diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
deleted file mode 100644
index 0037c93efb..0000000000
--- a/.github/CODEOWNERS
+++ /dev/null
@@ -1,2 +0,0 @@
-# Workflow definitions and their policy scripts are security-sensitive.
-/.github/ @1hyok
diff --git a/.github/scripts/awaiting-author-policy.test.mjs b/.github/scripts/awaiting-author-policy.test.mjs
deleted file mode 100644
index 1e4b7103e2..0000000000
--- a/.github/scripts/awaiting-author-policy.test.mjs
+++ /dev/null
@@ -1,176 +0,0 @@
-import assert from "node:assert/strict";
-import { readFile } from "node:fs/promises";
-import test from "node:test";
-
-import {
-    judgeAwaitingAuthor,
-    parseReviewGateExemptAuthors,
-    planAwaitingAuthorLabels,
-} from "./label-awaiting-author-prs.mjs";
-
-const guard = await readFile(new URL("../workflows/review-debt-guard.yml", import.meta.url), "utf8");
-const reconcile = await readFile(new URL("../workflows/conflict-label.yml", import.meta.url), "utf8");
-const script = await readFile(new URL("./label-awaiting-author-prs.mjs", import.meta.url), "utf8");
-const authorDebtCheck = await readFile(new URL("./check-author-debt.mjs", import.meta.url), "utf8");
-const exemptAuthors = parseReviewGateExemptAuthors(guard);
-
-test("가드는 작성자 무조치를 공통 판정 CLI 로 검사한다", () => {
-    // 라벨은 주기 리컨사일 결과라 입장 시점에 스테일할 수 있다. 가드는 live PR 목록을 읽는
-    // CLI 를 호출하고, CLI 는 라벨 리컨사일러와 같은 judgeAwaitingAuthor 를 재사용해야 한다.
-    assert.match(guard, /node \.github\/scripts\/check-author-debt\.mjs/);
-    assert.match(guard, /AUTHOR_DEBT_FILE="\$author_debt_file"/);
-    assert.match(authorDebtCheck, /findAuthorDebts/);
-    assert.match(script, /export function findAuthorDebts/);
-});
-
-test("라벨 판정은 입장 가드에 선언된 작성자 면제 목록을 직접 읽는다", () => {
-    assert.match(guard, /^\s*REVIEW_GATE_EXEMPT_AUTHORS:/m);
-    assert.match(guard, /\$REVIEW_GATE_EXEMPT_AUTHORS/);
-    assert.match(script, /new URL\("\.\.\/workflows\/review-debt-guard\.yml", import\.meta\.url\)/);
-    assert.doesNotMatch(script, /review-gate-policy\.json/);
-    const mainAt = script.indexOf("async function main()");
-    assert.ok(mainAt > 0);
-    const main = script.slice(mainAt);
-    assert.match(main, /parseReviewGateExemptAuthors\(/);
-    assert.match(main, /planAwaitingAuthorLabels\(\{[^}]*\bexemptAuthors\b/);
-});
-
-test("workflow 파일이 없는 가드 checkout에서도 작성자 빚 판정을 import할 수 있다", async () => {
-    // data URL 에는 상대 workflow 경로가 없다. 모듈을 불러오는 순간 목록을 읽으면
-    // scripts 만 checkout 하는 오래된 가드와 마찬가지로 import가 실패한다.
-    const module = await import(`data:text/javascript;base64,${Buffer.from(script).toString("base64")}`);
-
-    assert.equal(typeof module.findAuthorDebts, "function");
-    assert.equal(typeof module.judgeAwaitingAuthor, "function");
-});
-
-test("가드의 면제 목록에 있는 작성자는 라벨 계획에서도 빠진다", () => {
-    const pullRequests = exemptAuthors.map((login, index) => ({
-        number: index + 1,
-        isDraft: false,
-        author: { login: login.toUpperCase() },
-        labels: { nodes: [{ name: "awaiting-author" }] },
-        reviews: {
-            nodes: [{
-                state: "CHANGES_REQUESTED",
-                submittedAt: "2026-08-29T00:00:00Z",
-                authorCanPushToRepository: true,
-                author: { login: "reviewer" },
-            }],
-        },
-    }));
-    const plan = planAwaitingAuthorLabels({ pullRequests, exemptAuthors });
-
-    assert.deepEqual(plan.toLabel, []);
-    assert.deepEqual(plan.toUnlabel.map((entry) => entry.number), pullRequests.map(({ number }) => number));
-    assert.ok(plan.toUnlabel.every(({ reason }) => reason === "리뷰 게이트 면제 작성자"));
-});
-
-test("리뷰어 빚과 작성자 빚은 한 번의 안내와 종료로 합친다", () => {
-    // 두 경로가 각각 댓글·close 를 수행하면 같은 opened 이벤트에서 중복 코멘트와 경합이
-    // 생긴다. 두 TSV 를 모두 만든 뒤 한 번만 최종 결정을 내려야 한다.
-    assert.match(guard, /\[ ! -s "\$debt_file" \] && \[ ! -s "\$author_debt_file" \]/);
-    assert.equal((guard.match(/gh pr close/g) ?? []).length, 1);
-    assert.equal((guard.match(/> \/tmp\/debt-comment\.md/g) ?? []).length, 1);
-});
-
-test("두 판정은 «PR 전체의 최신 결정 리뷰» 라는 같은 축을 쓴다", () => {
-    // 한쪽만 리뷰어별로 묶으면, 승인으로 끝난 PR 에 더 오래된 변경요청 때문에 라벨이
-    // 붙거나 그 반대가 된다.
-    assert.match(guard, /sort_by\(\.t\) \| last/);
-    assert.doesNotMatch(guard, /group_by\(\.u/);
-    assert.match(script, /export function latestDecision/);
-    assert.doesNotMatch(script, /groupBy/);
-});
-
-test("두 판정 모두 병합 커밋을 작성자 반영으로 세지 않는다", () => {
-    // 병합 커밋의 diff 는 base 에서 들어온 변경을 통째로 담아 반영분과 구별되지 않는다.
-    assert.match(guard, /\(\.parents \| length\) < 2/);
-    assert.match(script, /parents\?\.totalCount \?\? 0\) >= 2/);
-});
-
-test("두 판정 모두 빈 커밋을 반영으로 세지 않는다", () => {
-    // 리뷰어가 미는 +0/-0 CI 재트리거 커밋이 «작성자가 반영했다» 가 되면, 방치된 PR 의
-    // 라벨이 조용히 떨어진다 (#1459).
-    assert.match(guard, /\(\.files \/\/ \[\]\) \| length/);
-    assert.match(guard, /\[ "\$changed" -gt 0 \] \|\| continue/);
-    assert.match(script, /changedFilesIfAvailable/);
-    assert.match(script, /changed === 0/);
-});
-
-test("두 판정 모두 커밋 작성자를 확인하고 이메일 폴백을 쓴다", () => {
-    // 누가 올렸는지를 보지 않으면 리뷰어 커밋이 작성자 반영으로 둔갑한다. 계정이 연결되지
-    // 않은 커밋은 login 이 비어 같은 PR 의 작성자 이메일로만 가릴 수 있다.
-    assert.match(guard, /\(\.author\.login \/\/ ""\)/);
-    assert.match(guard, /email in own/);
-    assert.match(script, /ownEmails/);
-});
-
-test("두 판정 모두 커밋과 함께 작성자의 응답을 본다", () => {
-    // 커밋만 세면 base 를 merge 로 끌어와 반영한 PR 이 «무조치» 가 된다 (#1316 → #1450).
-    assert.match(guard, /issues\/\$pn\/comments/);
-    assert.match(guard, /\[ "\$\{fixed:-0\}" -gt 0 \] \|\| \[ "\$responses" -gt 0 \]/);
-    assert.match(script, /export function countAuthorResponses/);
-    assert.match(script, /fixes > 0 \|\| responses > 0/);
-});
-
-test("두 판정 모두 변경요청 뒤 작성자의 PR 본문 편집을 조치로 본다", () => {
-    // CI Test Plan 처럼 PR 본문 자체가 리뷰 대상인 지적은 새 커밋 없이 해결된다. 일반
-    // updatedAt 이 아니라 편집자와 편집 시각이 남는 userContentEdits 를 사용해야 한다.
-    assert.match(guard, /userContentEdits/);
-    assert.match(script, /userContentEdits\(last: 50\)/);
-    assert.match(script, /export function countAuthorBodyEdits/);
-    assert.match(script, /bodyEdits > 0/);
-});
-
-test("두 판정 모두 draft·봇·fork 를 대상에서 뺀다", () => {
-    assert.match(guard, /\[ "\$HEAD_REPO" != "\$REPO" \]/);
-    assert.match(guard, /select\(\.draft == false\)/);
-    assert.match(guard, /봇 PR — 건너뜀/);
-
-    for (const [name, pullRequest] of [
-        ["draft", { isDraft: true }],
-        ["bot", { author: { login: "dependabot[bot]" } }],
-        ["fork", { headRepository: { nameWithOwner: "someone/fork" } }],
-    ]) {
-        const verdict = judgeAwaitingAuthor(
-            {
-                isDraft: false,
-                author: { login: "author" },
-                headRepository: { nameWithOwner: "Afternote/Afternote-FE" },
-                reviews: {
-                    nodes: [
-                        {
-                            state: "CHANGES_REQUESTED",
-                            submittedAt: "2026-08-29T00:00:00Z",
-                            authorCanPushToRepository: true,
-                            author: { login: "r" },
-                        },
-                    ],
-                },
-                commits: { nodes: [] },
-                comments: { nodes: [] },
-                ...pullRequest,
-            },
-            { repository: "Afternote/Afternote-FE" },
-        );
-        assert.equal(verdict.awaiting, false, `${name} 은 대상이 아니어야 한다`);
-    }
-});
-
-test("라벨은 리컨사일러로만 관리된다 — 붙이는 경로와 떼는 경로가 갈라지지 않는다", () => {
-    // 이벤트로 붙이고 다른 이벤트로 떼면 떼는 쪽이 새고 스테일 라벨이 남는다. 한 번의
-    // 차이 계산으로 양쪽을 처리하는 구조를 강제한다.
-    assert.match(script, /export function planAwaitingAuthorLabels/);
-    assert.match(script, /toUnlabel/);
-
-    // 전용 워크플로를 새로 세우지 않는다. 트리거·concurrency·quota 처리가 이미 허브에 있다.
-    assert.match(reconcile, /label-awaiting-author-prs\.test\.mjs/);
-    assert.match(reconcile, /node \.github\/scripts\/label-awaiting-author-prs\.mjs/);
-    assert.match(reconcile, /awaiting-author-policy\.test\.mjs/);
-});
-
-test("리컨사일러 실패가 다른 리컨사일러를 가리지 않는다", () => {
-    // 허브는 실패를 모아 마지막에 exit 한다. `&&` 로 이으면 앞이 죽을 때 뒤가 아예 돌지 않는다.
-    assert.match(reconcile, /node \.github\/scripts\/label-awaiting-author-prs\.mjs \|\| failures=1/);
-});
diff --git a/.github/scripts/check-author-debt.mjs b/.github/scripts/check-author-debt.mjs
deleted file mode 100644
index 954394d4da..0000000000
--- a/.github/scripts/check-author-debt.mjs
+++ /dev/null
@@ -1,77 +0,0 @@
-#!/usr/bin/env node
-
-// 새 PR 을 여는 사람이 변경요청을 받은 «자기가 담당하는» PR 을 방치하고 있는지 live 상태로
-// 검사한다. 담당은 어사인이고 어사인이 비면 작성자다(#1974) — AUTHOR 는 여는 사람의 로그인이지
-// «작성자 필터» 가 아니다.
-// 라벨은 스테일할 수 있으므로 입장 판정에 사용하지 않는다. 열린 PR 을 한 번 조회한 뒤
-// label-awaiting-author-prs.mjs 의 SSOT 판정을 재사용하고, 워크플로가 댓글과 close 를 한 번만
-// 처리할 수 있도록 결과만 TSV 로 넘긴다.
-
-import { writeFile } from "node:fs/promises";
-import path from "node:path";
-import process from "node:process";
-import { pathToFileURL } from "node:url";
-
-import {
-    createApi,
-    fetchOpenPullRequestsByAuthor,
-    findAuthorDebts,
-} from "./label-awaiting-author-prs.mjs";
-
-function requiredEnv(env, name) {
-    const value = env[name];
-    if (typeof value !== "string" || value.trim() === "") {
-        throw new Error(`${name} 가 필요합니다.`);
-    }
-    return value;
-}
-
-function safeTsvField(value) {
-    return String(value ?? "").replace(/[\u0000-\u001f\u007f]+/g, " ").trim();
-}
-
-export function renderAuthorDebtTsv(debts) {
-    if (!Array.isArray(debts)) {
-        throw new TypeError("debts 배열이 필요합니다.");
-    }
-
-    const lines = debts.map((debt) =>
-        [debt.number, debt.createdDate, debt.reviewer, debt.title]
-            .map(safeTsvField)
-            .join("\t"),
-    );
-    return lines.length > 0 ? `${lines.join("\n")}\n` : "";
-}
-
-export async function runAuthorDebtCheck({ env = process.env, api, logger = console } = {}) {
-    const token = requiredEnv(env, "GITHUB_TOKEN");
-    const repository = requiredEnv(env, "GITHUB_REPOSITORY");
-    const author = requiredEnv(env, "AUTHOR");
-    const currentPullRequestNumber = requiredEnv(env, "CURRENT_PULL_REQUEST_NUMBER");
-    const outputFile = requiredEnv(env, "AUTHOR_DEBT_FILE");
-
-    const pullRequests = await fetchOpenPullRequestsByAuthor(
-        api ?? createApi(token),
-        repository,
-        author,
-    );
-    const debts = findAuthorDebts({
-        pullRequests,
-        repository,
-        author,
-        currentPullRequestNumber,
-    });
-
-    // 빚이 없어도 파일을 새로 써서 이전 실행의 결과가 남지 않게 한다.
-    await writeFile(outputFile, renderAuthorDebtTsv(debts), "utf8");
-    logger.log(`작성자 미조치 PR ${debts.length}건`);
-    return debts;
-}
-
-const invokedPath = process.argv[1] ? pathToFileURL(path.resolve(process.argv[1])).href : "";
-if (import.meta.url === invokedPath) {
-    runAuthorDebtCheck().catch((error) => {
-        console.error(error.message);
-        process.exitCode = 1;
-    });
-}
diff --git a/.github/scripts/check-author-debt.test.mjs b/.github/scripts/check-author-debt.test.mjs
deleted file mode 100644
index 12e062a644..0000000000
--- a/.github/scripts/check-author-debt.test.mjs
+++ /dev/null
@@ -1,146 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdtemp, readFile, rm } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import test from "node:test";
-
-import { renderAuthorDebtTsv, runAuthorDebtCheck } from "./check-author-debt.mjs";
-
-const REPO = "Afternote/Afternote-FE";
-const silent = { log() {} };
-
-function changesRequested() {
-    return {
-        state: "CHANGES_REQUESTED",
-        submittedAt: "2026-08-29T00:00:00Z",
-        authorCanPushToRepository: true,
-        author: { login: "reviewer" },
-    };
-}
-
-function pullRequest(overrides = {}) {
-    return {
-        number: 10,
-        title: "fix(core): review debt",
-        isDraft: false,
-        createdAt: "2026-08-01T00:00:00Z",
-        author: { login: "author" },
-        headRepository: { nameWithOwner: REPO },
-        labels: { nodes: [] },
-        reviews: { pageInfo: { hasPreviousPage: false }, nodes: [changesRequested()] },
-        commits: { pageInfo: { hasPreviousPage: false }, nodes: [] },
-        comments: { pageInfo: { hasPreviousPage: false }, nodes: [] },
-        userContentEdits: { pageInfo: { hasPreviousPage: false }, nodes: [] },
-        ...overrides,
-    };
-}
-
-function graphqlApi(pullRequests) {
-    return async (apiPath, options = {}) => {
-        assert.equal(apiPath, "/graphql");
-        assert.equal(options.method, "POST");
-        // 담당은 어사인이 정본이고 어사인이 비면 작성자라 두 축을 모두 검색한다(#1974).
-        const query = options.body.variables.searchQuery;
-        assert.ok(
-            query === "repo:Afternote/Afternote-FE is:pr is:open assignee:author" ||
-                query === "repo:Afternote/Afternote-FE is:pr is:open author:author",
-            query,
-        );
-        if (query.endsWith("author:author")) {
-            return {
-                data: {
-                    search: { pageInfo: { hasNextPage: false, endCursor: null }, nodes: [] },
-                },
-            };
-        }
-        return {
-            data: {
-                search: {
-                    pageInfo: { hasNextPage: false, endCursor: null },
-                    nodes: pullRequests,
-                },
-            },
-        };
-    };
-}
-
-function environment(outputFile, overrides = {}) {
-    return {
-        GITHUB_TOKEN: "test-token",
-        GITHUB_REPOSITORY: REPO,
-        AUTHOR: "author",
-        CURRENT_PULL_REQUEST_NUMBER: "99",
-        AUTHOR_DEBT_FILE: outputFile,
-        ...overrides,
-    };
-}
-
-test("CLI 는 live GraphQL 결과를 판정해 안전한 4열 TSV 를 쓴다", async (t) => {
-    const root = await mkdtemp(path.join(os.tmpdir(), "author-debt-"));
-    t.after(() => rm(root, { recursive: true, force: true }));
-    const outputFile = path.join(root, "debt.tsv");
-
-    const debts = await runAuthorDebtCheck({
-        env: environment(outputFile),
-        api: graphqlApi([
-            pullRequest({ title: "fix(core): tab\tand\nnewline" }),
-            pullRequest({ number: 99, title: "현재 PR" }),
-        ]),
-        logger: silent,
-    });
-
-    assert.equal(debts.length, 1);
-    assert.equal(
-        await readFile(outputFile, "utf8"),
-        "10\t2026-08-01\treviewer\tfix(core): tab and newline\n",
-    );
-});
-
-test("CLI 는 빚이 없어도 빈 결과 파일을 새로 쓴다", async (t) => {
-    const root = await mkdtemp(path.join(os.tmpdir(), "author-debt-empty-"));
-    t.after(() => rm(root, { recursive: true, force: true }));
-    const outputFile = path.join(root, "debt.tsv");
-
-    await runAuthorDebtCheck({
-        env: environment(outputFile),
-        api: graphqlApi([]),
-        logger: silent,
-    });
-
-    assert.equal(await readFile(outputFile, "utf8"), "");
-});
-
-test("CLI 는 API 실패와 불완전한 GraphQL 응답을 빚 없음으로 통과시키지 않는다", async (t) => {
-    const root = await mkdtemp(path.join(os.tmpdir(), "author-debt-fail-"));
-    t.after(() => rm(root, { recursive: true, force: true }));
-    const outputFile = path.join(root, "debt.tsv");
-
-    await assert.rejects(
-        runAuthorDebtCheck({
-            env: environment(outputFile),
-            api: async () => {
-                throw new Error("API unavailable");
-            },
-            logger: silent,
-        }),
-        /API unavailable/,
-    );
-
-    await assert.rejects(
-        runAuthorDebtCheck({
-            env: environment(outputFile),
-            api: async () => ({ data: { search: null } }),
-            logger: silent,
-        }),
-        /작성자의 열린 PR 검색 결과가 없습니다/,
-    );
-});
-
-test("TSV 렌더러는 행과 열을 깨는 제어 문자를 제거한다", () => {
-    assert.equal(
-        renderAuthorDebtTsv([
-            { number: 7, createdDate: "2026-08-31", reviewer: "r\t1", title: "a\rb\nc" },
-        ]),
-        "7\t2026-08-31\tr 1\ta b c\n",
-    );
-});
diff --git a/.github/scripts/dependabot-pr-gate.mjs b/.github/scripts/dependabot-pr-gate.mjs
index 58b0e7a7b0..8fd2e24667 100644
--- a/.github/scripts/dependabot-pr-gate.mjs
+++ b/.github/scripts/dependabot-pr-gate.mjs
@@ -2,12 +2,22 @@
 //
 // 봇은 이슈를 만들지 못하고 본문에 CI Test Plan 도 쓰지 않아, 열리는 순간
 // Repository Quality 와 기기 잡이 구조적으로 실패한다(#1397·#1699·#2106). 사람이 매번
-// 손으로 하던 세 가지 — 대표 이슈 신설, 제목 끝 `(#N)`, 본문의 `Refs #N` + CI Test Plan —
-// 를 여기서 한다. mode 는 사람이 정하지 않는다. `ci-test-plan.mjs` 가 변경 파일로 판정한
+// 손으로 하던 세 가지 — 대표 이슈 신설, 제목 끝 `(#N)`, 본문의 `Closes #N` + CI Test Plan —
+// 를 여기서 한다. 손으로 할 때는 `Refs` 로 걸고 머지 뒤 이슈를 손으로 닫았는데(#1397·#2111), 게이트가
+// PR 마다 이슈를 새로 만들므로 `Closes` 로 걸어 머지가 이슈를 닫게 한다(#2274). mode 는 사람이 정하지 않는다. `ci-test-plan.mjs` 가 변경 파일로 판정한
 // 결과를 그대로 쓴다. 게이트 면제는 하지 않는다 — 봇 PR 도 워크플로 파일을 건드린다.
 //
-// 순수 함수(needsGate·buildPlan·buildIssue·applyGate)와 GitHub 호출(main)을 갈라 두어
-// 정책은 dependabot-pr-gate.test.mjs 가 잠근다.
+// 게이트는 GITHUB_TOKEN 으로 제목·본문을 고치므로 그 `edited` 는 다른 워크플로를 깨우지 못한다.
+// 같은 순간 열린 PR Validation·Managed Device 는 opened 시점 페이로드를 읽어 red 로 남았다(#2212).
+// 게이트가 검증을 다시 부르는 길은 막혀 있다. 같은 sha 에 dispatch 로 붙인 초록은 PR 롤업이 옛
+// `pull_request` 실패를 덮지 못하고(#1825), 재실행은 옛 페이로드를 그대로 쓰는 데다 기기 레인의
+// 1회차 인프라 복구를 잃으며, App 토큰은 이 브리지에 금지된 시크릿이 필요하다. 그래서 방향을
+// 뒤집었다. 검증이 `await` 명령으로 게이트가 채울 때까지 live PR 을 기다렸다가 그 값으로 판정한다.
+//
+// 순수 함수(needsGate·awaitsGate·buildPlan·buildIssue·applyGate)·대기(awaitGate)와 GitHub 호출
+// (fillGate·awaitMain)을 갈라 두어 정책은 dependabot-pr-gate.test.mjs 가 잠근다.
+
+import { readFile, writeFile } from "node:fs/promises";
 
 import { inspectAndroidTestImpact } from "./ci-test-plan.mjs";
 
@@ -53,6 +63,59 @@ export function buildPlan(changedPaths) {
     };
 }
 
+/** `await` 가 live PR 을 다시 조회하는 간격. 게이트는 job 시작 뒤 수 초 안에 끝난다(#2138 실측 7초). */
+export const AWAIT_POLL_INTERVAL_MS = 5_000;
+
+/**
+ * 검증이 아직 기다려야 하는 PR 인가. dependabot 이 연 열린 PR 인데 제목에 대표 이슈 번호가 없을 때만이다.
+ * 마커가 아니라 제목으로 가른다. 게이트가 경계 경로에서 멈춰 사람이 손으로 채운 PR 에는 마커가 없는데,
+ * 그 PR 까지 edited 마다 제한 시간을 꽉 채워 기다리게 하지 않는다. 게이트는 제목과 본문을 한 번의
+ * PATCH 로 바꾸므로 제목에 번호가 있으면 본문도 채워져 있다.
+ */
+export function awaitsGate(pullRequest) {
+    return (
+        pullRequest?.user?.login === DEPENDABOT_LOGIN &&
+        pullRequest?.state === "open" &&
+        !TITLE_ISSUE_PATTERN.test(String(pullRequest?.title ?? ""))
+    );
+}
+
+/**
+ * 게이트가 제목·본문을 채울 때까지 live PR 을 다시 읽는다(#2212). `initial`(이벤트 페이로드의 PR)이 이미
+ * 판정할 수 있는 상태면 API 를 부르지 않고 그대로 돌려준다. 게이트가 채운 뒤의 edited·synchronize 는
+ * 종전처럼 페이로드만으로 끝난다. 조회가 실패하면 제한 시간 안에서 다시 시도한다. 한 번도 읽지 못한 채
+ * 시간이 다하면 마지막 오류를 던지고, 읽은 적이 있으면 마지막 live 상태를 돌려준다. 판정은 호출한
+ * 검증의 몫이라, 게이트가 실패했으면 검증이 평소 오류 문구로 실패한다.
+ */
+export async function awaitGate({ loadPullRequest, initial, timeoutMs, intervalMs = AWAIT_POLL_INTERVAL_MS }) {
+    if (initial && !awaitsGate(initial)) {
+        return { pullRequest: initial, polls: 0, timedOut: false };
+    }
+    const deadline = Date.now() + timeoutMs;
+    let latest;
+    let lastError;
+    for (let polls = 1; ; polls += 1) {
+        try {
+            const pullRequest = await loadPullRequest();
+            if (!awaitsGate(pullRequest)) {
+                return { pullRequest, polls, timedOut: false };
+            }
+            latest = pullRequest;
+            lastError = undefined;
+        } catch (error) {
+            lastError = error;
+        }
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) {
+            if (latest === undefined) {
+                throw lastError;
+            }
+            return { pullRequest: latest, polls, timedOut: true, lastError };
+        }
+        await new Promise((resolve) => setTimeout(resolve, Math.min(intervalMs, remaining)));
+    }
+}
+
 /** 대표 이슈. `.github/ISSUE_TEMPLATE/issue.yml` 양식이라 reconcile-issue-metadata 가 어사인·라벨을 맞춘다. */
 export function buildIssue({ title, prNumber, changedPaths, plan }) {
     const summary = String(title ?? "").replace(/^chore\(deps\):\s*/i, "").trim() || `PR #${prNumber}`;
@@ -79,7 +142,7 @@ export function buildIssue({ title, prNumber, changedPaths, plan }) {
             "",
             `dependabot 이 올린 PR #${prNumber}(${summary})의 대표 이슈다. dependabot-pr-gate 워크플로가 만들었다(#2112).`,
             "",
-            "Repository Quality 가 모든 PR 에 제목 대표 이슈 번호와 본문 Refs 를 요구하는데 봇은 이슈를 만들지 못한다. 이 이슈로 연결해 수용한다.",
+            "Repository Quality 가 모든 PR 에 제목 대표 이슈 번호와 본문 연결을 요구하는데 봇은 이슈를 만들지 못한다. 이 이슈로 연결해 수용하고, PR 본문의 Closes 로 머지 때 함께 닫힌다.",
             "",
             `변경 파일 ${files.length}개:`,
             fileLines,
@@ -97,8 +160,12 @@ export function buildIssue({ title, prNumber, changedPaths, plan }) {
     };
 }
 
-/** 제목 끝에 `(#N)`, 본문 맨 위에 `Refs #N` 과 CI Test Plan 을 붙인다. 봇 본문은 그대로 아래 둔다. */
-export function applyGate({ title, body, issueNumber, plan }) {
+/**
+ * 제목 끝에 `(#N)`, 본문 맨 위에 `Closes #N` 과 CI Test Plan 을 붙인다. 봇 본문은 그대로 아래 둔다.
+ * 게이트가 만든 이슈는 이 PR 하나의 대표 이슈라 머지가 닫게 한다(#2274). 제목에 사람이 이미 붙인
+ * 번호를 재사용할 때(`reusedIssue`)는 여러 봇 PR 이 공유하는 이슈일 수 있어 `Refs` 로 둔다(#1748).
+ */
+export function applyGate({ title, body, issueNumber, plan, reusedIssue = false }) {
     const baseTitle = String(title ?? "").replace(TITLE_ISSUE_PATTERN, "").trim();
     const planJson = JSON.stringify(
         { androidTest: { mode: plan.mode, reason: plan.reason, tests: [] } },
@@ -108,7 +175,7 @@ export function applyGate({ title, body, issueNumber, plan }) {
     const original = String(body ?? "").replace(GATE_MARKER, "").trim();
     const nextBody = [
         GATE_MARKER,
-        `Refs #${issueNumber}`,
+        `${reusedIssue ? "Refs" : "Closes"} #${issueNumber}`,
         "",
         "## CI Test Plan",
         "",
@@ -153,7 +220,7 @@ async function listChangedPaths(apiUrl, repository, prNumber, token) {
     return paths;
 }
 
-async function main() {
+async function fillGate() {
     const token = process.env.GITHUB_TOKEN;
     const repository = process.env.GITHUB_REPOSITORY;
     const prNumber = Number(process.env.PR_NUMBER);
@@ -180,9 +247,11 @@ async function main() {
     const changedPaths = await listChangedPaths(apiUrl, repository, prNumber, token);
     const plan = buildPlan(changedPaths);
 
-    // 제목에 이슈 번호가 이미 있으면(사람이 붙였거나 앞선 실행이 본문 갱신 전에 끊겼거나) 재사용한다.
+    // 제목에 이슈 번호가 이미 있으면 사람이 붙인 것이다(게이트는 제목·본문을 한 번의 PATCH 로 바꾼다). 그 번호를
+    // 재사용하고, 여러 봇 PR 이 공유하는 이슈일 수 있어 Refs 로 건다(#1748).
     let issueNumber = Number(TITLE_ISSUE_PATTERN.exec(pullRequest.title ?? "")?.[1]);
-    if (!issueNumber) {
+    const reusedIssue = Boolean(issueNumber);
+    if (!reusedIssue) {
         const issue = buildIssue({ title: pullRequest.title, prNumber, changedPaths, plan });
         const created = await github(`${apiUrl}/repos/${repository}/issues`, token, {
             method: "POST",
@@ -192,16 +261,61 @@ async function main() {
         console.log(`대표 이슈 #${issueNumber} 생성`);
     }
 
-    const next = applyGate({ title: pullRequest.title, body: pullRequest.body, issueNumber, plan });
+    const next = applyGate({ title: pullRequest.title, body: pullRequest.body, issueNumber, plan, reusedIssue });
     await github(`${apiUrl}/repos/${repository}/pulls/${prNumber}`, token, {
         method: "PATCH",
         body: JSON.stringify(next),
     });
-    console.log(`#${prNumber} 제목·본문 갱신: Refs #${issueNumber}, androidTest mode=${plan.mode}`);
+    console.log(`#${prNumber} 제목·본문 갱신: ${reusedIssue ? "Refs" : "Closes"} #${issueNumber}, androidTest mode=${plan.mode}`);
+}
+
+/**
+ * `await <출력 경로>`: dependabot PR 의 `pull_request` 검증이 부른다. 게이트를 기다린 뒤 PR JSON 을 출력
+ * 경로에 쓴다. 이벤트 페이로드(GITHUB_EVENT_PATH)의 PR 이 이미 판정할 수 있는 상태면 그것을 그대로 쓴다.
+ * 제한 시간을 넘겨도 실패하지 않고 경고만 남긴다. 판정은 뒤따르는 검증이 한다.
+ */
+async function awaitMain(outputPath) {
+    const token = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
+    const repository = process.env.GITHUB_REPOSITORY;
+    const prNumber = Number(process.env.PR_NUMBER);
+    const timeoutSeconds = Number(process.env.AWAIT_TIMEOUT_SECONDS);
+    const apiUrl = process.env.GITHUB_API_URL ?? "https://api.github.com";
+    if (!outputPath || !token || !repository || !Number.isInteger(prNumber) || prNumber <= 0) {
+        throw new Error("await <출력 경로> 와 GITHUB_TOKEN(또는 GH_TOKEN), GITHUB_REPOSITORY, PR_NUMBER 가 필요합니다");
+    }
+    if (!Number.isInteger(timeoutSeconds) || timeoutSeconds < 0) {
+        throw new Error(`AWAIT_TIMEOUT_SECONDS 는 0 이상의 정수여야 합니다: ${process.env.AWAIT_TIMEOUT_SECONDS}`);
+    }
+
+    const eventPullRequest = process.env.GITHUB_EVENT_PATH
+        ? JSON.parse(await readFile(process.env.GITHUB_EVENT_PATH, "utf8")).pull_request
+        : undefined;
+    const { pullRequest, polls, timedOut, lastError } = await awaitGate({
+        loadPullRequest: () => github(`${apiUrl}/repos/${repository}/pulls/${prNumber}`, token),
+        initial: eventPullRequest?.number === prNumber ? eventPullRequest : undefined,
+        timeoutMs: timeoutSeconds * 1000,
+    });
+    await writeFile(outputPath, JSON.stringify(pullRequest));
+    if (timedOut) {
+        console.log(
+            `::warning::dependabot-pr-gate 가 ${timeoutSeconds}초 안에 #${prNumber} 의 제목·본문을 채우지 않았습니다. ` +
+                "그 워크플로 실행을 확인하세요. 지금 live 상태로 판정합니다." +
+                (lastError ? ` 마지막 조회 오류: ${lastError.message}` : ""),
+        );
+    } else if (polls > 1) {
+        console.log(`#${prNumber} 게이트가 채운 제목·본문을 ${polls}번째 조회에서 확인`);
+    }
 }
 
 if (import.meta.url === `file://${process.argv[1]}`) {
-    main().catch((error) => {
+    const [command, ...rest] = process.argv.slice(2);
+    const run =
+        command === undefined
+            ? fillGate
+            : command === "await"
+              ? () => awaitMain(rest[0])
+              : () => Promise.reject(new Error(`알 수 없는 명령: ${command}. 인자 없이(채우기) 또는 await 만 받습니다`));
+    run().catch((error) => {
         console.error(`::error::${error.message}`);
         process.exitCode = 1;
     });
diff --git a/.github/scripts/dependabot-pr-gate.test.mjs b/.github/scripts/dependabot-pr-gate.test.mjs
index 1a1aa9c31b..604e0a5937 100644
--- a/.github/scripts/dependabot-pr-gate.test.mjs
+++ b/.github/scripts/dependabot-pr-gate.test.mjs
@@ -1,6 +1,12 @@
 import assert from "node:assert/strict";
-import { readFile } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { createServer } from "node:http";
+import { tmpdir } from "node:os";
+import path from "node:path";
 import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
 
 import { inspectCiTestPlan } from "./ci-test-plan.mjs";
 import {
@@ -9,10 +15,16 @@ import {
     ISSUE_ASSIGNEES,
     ISSUE_LABELS,
     applyGate,
+    awaitGate,
+    awaitsGate,
     buildIssue,
     buildPlan,
     needsGate,
 } from "./dependabot-pr-gate.mjs";
+import { validatePullRequestIssueLink } from "./validate-pr-issue-link.mjs";
+
+const GATE_SCRIPT = fileURLToPath(new URL("./dependabot-pr-gate.mjs", import.meta.url));
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 
 const BOT_TITLE = "chore(deps): bump the github-actions-updates group with 3 updates";
 const BOT_BODY = "Bumps the github-actions-updates group with 3 updates: actions/setup-java ...";
@@ -63,13 +75,13 @@ test("대표 이슈는 issue.yml 양식이고 platform maintenance 로 1hyok 에
     assert.match(issue.body, /### 참고/);
 });
 
-test("제목은 (#N) 으로 정확히 한 번 끝나고 본문은 Refs 와 유효한 CI Test Plan 으로 시작한다", () => {
+test("제목은 (#N) 으로 정확히 한 번 끝나고 본문은 Closes 와 유효한 CI Test Plan 으로 시작한다", () => {
     const plan = buildPlan([".github/workflows/android-managed-device.yml"]);
     const next = applyGate({ title: BOT_TITLE, body: BOT_BODY, issueNumber: 2111, plan });
 
     assert.equal(next.title, `${BOT_TITLE} (#2111)`);
     assert.equal((next.title.match(/\(#\d+\)/g) ?? []).length, 1);
-    assert.ok(next.body.startsWith(`${GATE_MARKER}\nRefs #2111\n`));
+    assert.ok(next.body.startsWith(`${GATE_MARKER}\nCloses #2111\n`), "게이트가 만든 이슈는 머지가 닫는다 (#2274)");
     assert.ok(next.body.endsWith(BOT_BODY), "봇 본문은 그대로 아래에 남는다");
     assert.equal(needsGate(next), false, "한 번 적용한 결과는 다시 대상이 아니다");
 
@@ -78,12 +90,34 @@ test("제목은 (#N) 으로 정확히 한 번 끝나고 본문은 Refs 와 유
     assert.equal(inspected.plan?.androidTest?.mode ?? inspected.androidTest?.mode, "full");
 });
 
+test("게이트가 채운 봇 PR 은 Repository Quality 의 대표 이슈 연결 검증을 통과한다", async () => {
+    const plan = buildPlan([".github/workflows/codeql.yml"]);
+    for (const reusedIssue of [false, true]) {
+        const next = applyGate({ title: BOT_TITLE, body: BOT_BODY, issueNumber: 2111, plan, reusedIssue });
+        const result = await validatePullRequestIssueLink({
+            pullRequest: { number: 2106, ...next, user: { login: DEPENDABOT_LOGIN, type: "Bot" }, labels: [] },
+            repository: "Afternote/Afternote-FE",
+            loadIssue: async (number) => ({ number, state: "open", assignees: [{ login: "1hyok" }] }),
+        });
+        assert.deepEqual(result, { issues: [2111], rejected: [] }, `reusedIssue=${reusedIssue}`);
+    }
+});
+
+test("제목에 사람이 붙인 번호를 재사용하면 공유 이슈일 수 있어 Refs 로 건다 (#1748)", () => {
+    const plan = buildPlan([".github/workflows/codeql.yml"]);
+    const next = applyGate({ title: `${BOT_TITLE} (#1397)`, body: BOT_BODY, issueNumber: 1397, plan, reusedIssue: true });
+
+    assert.equal(next.title, `${BOT_TITLE} (#1397)`);
+    assert.ok(next.body.startsWith(`${GATE_MARKER}\nRefs #1397\n`));
+    assert.doesNotMatch(next.body, /Closes #1397/);
+});
+
 test("이미 (#N) 이 붙은 제목에 다시 적용해도 번호가 겹치지 않는다", () => {
     const plan = buildPlan([".github/workflows/codeql.yml"]);
     const once = applyGate({ title: BOT_TITLE, body: BOT_BODY, issueNumber: 2111, plan });
     const twice = applyGate({ title: once.title, body: once.body, issueNumber: 2111, plan });
     assert.equal(twice.title, once.title);
-    assert.equal((twice.body.match(/Refs #2111/g) ?? []).length, 2, "본문 재적용은 앞선 머리말을 봇 본문으로 취급한다");
+    assert.equal((twice.body.match(/Closes #2111/g) ?? []).length, 2, "본문 재적용은 앞선 머리말을 봇 본문으로 취급한다");
     assert.equal((twice.body.match(new RegExp(GATE_MARKER.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), "g")) ?? []).length, 1);
 });
 
@@ -100,5 +134,264 @@ test("워크플로는 봇 PR 에만 돌고 PR 코드를 체크아웃하지 않
     assert.match(source, /^permissions: \{\}/m);
     assert.match(source, /issues: write/);
     assert.match(source, /pull-requests: write/);
-    assert.match(source, /run: node \.github\/scripts\/dependabot-pr-gate\.mjs/);
+    assert.match(source, /run: node \.github\/scripts\/dependabot-pr-gate\.mjs$/m, "인자 없이 불러야 채우기다");
+});
+
+const FILLED = {
+    user: { login: DEPENDABOT_LOGIN },
+    state: "open",
+    title: `${BOT_TITLE} (#2139)`,
+    body: `${GATE_MARKER}\nCloses #2139\n\n${BOT_BODY}`,
+    head: { sha: "a".repeat(40) },
+    changed_files: 3,
+};
+const UNFILLED = { ...FILLED, title: BOT_TITLE, body: BOT_BODY };
+
+test("Closes 로 바꾸기 전 게이트가 Refs 로 채운 PR 도 처리된 PR 이다 (#2274)", () => {
+    const legacy = { ...FILLED, body: `${GATE_MARKER}\nRefs #2139\n\n${BOT_BODY}` };
+    assert.equal(needsGate(legacy), false, "열린 옛 봇 PR 을 다시 고치지 않는다");
+    assert.equal(awaitsGate(legacy), false, "검증도 옛 본문을 기다리지 않는다");
+});
+
+function sequence(...pullRequests) {
+    let calls = 0;
+    return {
+        load: async () => pullRequests[Math.min(calls++, pullRequests.length - 1)],
+        calls: () => calls,
+    };
+}
+
+test("await 는 게이트가 채운 뒤의 live PR 을 돌려준다 (#2212)", async () => {
+    const live = sequence(UNFILLED, UNFILLED, FILLED);
+    const result = await awaitGate({ loadPullRequest: live.load, timeoutMs: 5_000, intervalMs: 5 });
+
+    assert.equal(result.timedOut, false);
+    assert.equal(result.polls, 3);
+    assert.equal(result.pullRequest, FILLED);
+    assert.equal(needsGate(result.pullRequest), false);
+});
+
+test("await 는 기다릴 이유가 없으면 첫 조회로 끝난다", async () => {
+    const handFilled = { ...UNFILLED, title: `${BOT_TITLE} (#2139)`, body: "Refs #2139\n\n## CI Test Plan\n..." };
+    assert.equal(needsGate(handFilled), true, "마커가 없어 게이트는 다시 채우려 한다");
+    assert.equal(awaitsGate(handFilled), false, "검증은 사람이 채운 PR 을 기다리지 않는다");
+    for (const pullRequest of [
+        FILLED,
+        handFilled,
+        { ...UNFILLED, user: { login: "1hyok" } },
+        { ...UNFILLED, state: "closed" },
+    ]) {
+        const live = sequence(pullRequest);
+        const result = await awaitGate({ loadPullRequest: live.load, timeoutMs: 5_000, intervalMs: 5 });
+        assert.equal(live.calls(), 1, JSON.stringify(pullRequest.user));
+        assert.equal(result.timedOut, false);
+        assert.equal(result.pullRequest, pullRequest);
+    }
+});
+
+test("await 는 페이로드가 이미 판정할 수 있으면 API 를 부르지 않는다", async () => {
+    const live = sequence(UNFILLED);
+    const ready = await awaitGate({ loadPullRequest: live.load, initial: FILLED, timeoutMs: 5_000, intervalMs: 5 });
+    assert.equal(live.calls(), 0, "게이트가 채운 뒤의 edited·synchronize 는 종전처럼 페이로드로 끝난다");
+    assert.equal(ready.pullRequest, FILLED);
+    assert.equal(ready.polls, 0);
+
+    const stale = sequence(UNFILLED, FILLED);
+    const waited = await awaitGate({ loadPullRequest: stale.load, initial: UNFILLED, timeoutMs: 5_000, intervalMs: 5 });
+    assert.equal(stale.calls(), 2, "opened 페이로드는 옛 값이라 live 를 기다린다");
+    assert.equal(waited.pullRequest, FILLED);
+});
+
+test("await 는 조회 오류를 제한 시간 안에서 다시 시도하고, 한 번도 못 읽으면 오류를 던진다", async () => {
+    let calls = 0;
+    const flaky = async () => {
+        calls += 1;
+        if (calls === 1) throw new Error("GET pulls -> 502");
+        return calls === 2 ? UNFILLED : FILLED;
+    };
+    const recovered = await awaitGate({ loadPullRequest: flaky, timeoutMs: 5_000, intervalMs: 5 });
+    assert.equal(recovered.timedOut, false);
+    assert.equal(recovered.pullRequest, FILLED);
+    assert.equal(calls, 3);
+
+    const down = async () => {
+        throw new Error("GET pulls -> 403 rate limit");
+    };
+    await assert.rejects(awaitGate({ loadPullRequest: down, timeoutMs: 30, intervalMs: 5 }), /403 rate limit/);
+
+    let readOnce = 0;
+    const thenDown = async () => {
+        readOnce += 1;
+        if (readOnce === 1) return UNFILLED;
+        throw new Error("GET pulls -> 502");
+    };
+    const partial = await awaitGate({ loadPullRequest: thenDown, timeoutMs: 30, intervalMs: 5 });
+    assert.equal(partial.timedOut, true);
+    assert.equal(partial.pullRequest, UNFILLED, "읽은 적이 있으면 마지막 live 상태를 넘긴다");
+    assert.match(partial.lastError.message, /502/);
+});
+
+test("await 는 제한 시간이 지나면 기다림을 끝내고 마지막 live 상태를 넘긴다", async () => {
+    const live = sequence(UNFILLED);
+    const started = Date.now();
+    const result = await awaitGate({ loadPullRequest: live.load, timeoutMs: 60, intervalMs: 10 });
+
+    assert.equal(result.timedOut, true);
+    assert.equal(result.pullRequest, UNFILLED);
+    assert.ok(live.calls() >= 2, "제한 시간 안에서는 다시 조회한다");
+    assert.ok(Date.now() - started < 1_000, "무기한 대기하지 않는다");
+
+    const once = sequence(UNFILLED);
+    const immediate = await awaitGate({ loadPullRequest: once.load, timeoutMs: 0, intervalMs: 10 });
+    assert.equal(immediate.timedOut, true);
+    assert.equal(once.calls(), 1);
+});
+
+async function runGateCli(args, { env = {}, pullRequest } = {}) {
+    const requests = [];
+    const server = createServer((request, response) => {
+        requests.push(`${request.method} ${request.url}`);
+        response.setHeader("Content-Type", "application/json");
+        response.end(JSON.stringify(pullRequest ?? {}));
+    });
+    await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+    const { port } = server.address();
+    try {
+        const result = await promisify(execFile)(process.execPath, [GATE_SCRIPT, ...args], {
+            env: {
+                PATH: process.env.PATH,
+                GITHUB_API_URL: `http://127.0.0.1:${port}`,
+                GITHUB_REPOSITORY: "Afternote/Afternote-FE",
+                ...env,
+            },
+        }).then(
+            ({ stdout, stderr }) => ({ code: 0, stdout, stderr }),
+            (error) => ({ code: error.code, stdout: error.stdout, stderr: error.stderr }),
+        );
+        return { ...result, requests };
+    } finally {
+        server.close();
+    }
+}
+
+test("await 명령은 live PR JSON 을 파일에 쓰고, 제한 시간을 넘겨도 판정을 검증에 넘긴다", async () => {
+    const directory = await mkdtemp(path.join(tmpdir(), "dependabot-pr-gate-"));
+    try {
+        const filledPath = path.join(directory, "filled.json");
+        const filled = await runGateCli(["await", filledPath], {
+            env: { GH_TOKEN: "t", PR_NUMBER: "2138", AWAIT_TIMEOUT_SECONDS: "90" },
+            pullRequest: FILLED,
+        });
+        assert.equal(filled.code, 0, filled.stderr);
+        assert.deepEqual(filled.requests, ["GET /repos/Afternote/Afternote-FE/pulls/2138"]);
+        assert.deepEqual(JSON.parse(await readFile(filledPath, "utf8")), FILLED);
+
+        const unfilledPath = path.join(directory, "unfilled.json");
+        const unfilled = await runGateCli(["await", unfilledPath], {
+            env: { GH_TOKEN: "t", PR_NUMBER: "2138", AWAIT_TIMEOUT_SECONDS: "0" },
+            pullRequest: UNFILLED,
+        });
+        assert.equal(unfilled.code, 0, "시간 초과는 실패가 아니다. 검증이 평소 오류 문구로 판정한다");
+        assert.match(unfilled.stdout, /::warning::dependabot-pr-gate 가 0초 안에 #2138/);
+        assert.deepEqual(JSON.parse(await readFile(unfilledPath, "utf8")), UNFILLED);
+
+        const eventPath = path.join(directory, "event.json");
+        await writeFile(eventPath, JSON.stringify({ action: "synchronize", pull_request: { ...FILLED, number: 2138 } }));
+        const payloadPath = path.join(directory, "payload.json");
+        const fromPayload = await runGateCli(["await", payloadPath], {
+            env: { GH_TOKEN: "t", PR_NUMBER: "2138", AWAIT_TIMEOUT_SECONDS: "90", GITHUB_EVENT_PATH: eventPath },
+            pullRequest: UNFILLED,
+        });
+        assert.equal(fromPayload.code, 0, fromPayload.stderr);
+        assert.deepEqual(fromPayload.requests, [], "채워진 페이로드면 API 를 부르지 않는다");
+        assert.deepEqual(JSON.parse(await readFile(payloadPath, "utf8")), { ...FILLED, number: 2138 });
+
+        const otherPath = path.join(directory, "other.json");
+        const otherPullRequest = await runGateCli(["await", otherPath], {
+            env: { GH_TOKEN: "t", PR_NUMBER: "2140", AWAIT_TIMEOUT_SECONDS: "0", GITHUB_EVENT_PATH: eventPath },
+            pullRequest: FILLED,
+        });
+        assert.equal(otherPullRequest.code, 0, otherPullRequest.stderr);
+        assert.deepEqual(otherPullRequest.requests, ["GET /repos/Afternote/Afternote-FE/pulls/2140"], "다른 PR 의 페이로드는 쓰지 않는다");
+
+        const missing = await runGateCli(["await", path.join(directory, "x.json")], {
+            env: { GH_TOKEN: "t", PR_NUMBER: "2138" },
+        });
+        assert.equal(missing.code, 1);
+        assert.match(missing.stderr, /AWAIT_TIMEOUT_SECONDS/);
+        assert.deepEqual(missing.requests, [], "입력이 틀리면 API 를 부르지 않는다");
+    } finally {
+        await rm(directory, { recursive: true, force: true });
+    }
+});
+
+test("인자 없이 부르면 채우기다: live PR 을 읽고 봇 PR 이 아니면 아무것도 쓰지 않는다", async () => {
+    const result = await runGateCli([], {
+        env: { GITHUB_TOKEN: "t", PR_NUMBER: "2138" },
+        pullRequest: { user: { login: "1hyok" }, state: "open", title: "x", body: "" },
+    });
+    assert.equal(result.code, 0, result.stderr);
+    assert.deepEqual(result.requests, ["GET /repos/Afternote/Afternote-FE/pulls/2138"]);
+    assert.match(result.stdout, /작성자가 1hyok 이라 건너뜀/);
+});
+
+test("모르는 명령은 채우기로 떨어지지 않는다", async () => {
+    const result = await runGateCli(["wait"], { env: { GITHUB_TOKEN: "t", PR_NUMBER: "2138" } });
+    assert.equal(result.code, 1);
+    assert.match(result.stderr, /알 수 없는 명령: wait/);
+    assert.deepEqual(result.requests, [], "이슈 생성·PR 편집 요청이 나가지 않는다");
+});
+
+test("게이트는 검증을 다시 부르지 않고, 두 검증이 dependabot PR 에서 게이트를 기다린다 (#2212)", async () => {
+    const readWorkflow = (name) => readFile(new URL(`../workflows/${name}`, import.meta.url), "utf8");
+    const gate = await readWorkflow("dependabot-pr-gate.yml");
+    const repositoryQuality = await readWorkflow("repository-quality.yml");
+    const managedDevice = await readWorkflow("android-managed-device.yml");
+    const login = escapeRegExp(DEPENDABOT_LOGIN);
+
+    // 같은 sha 의 dispatch 는 PR 롤업의 옛 실패를 못 덮고(#1825), 재실행은 옛 페이로드를 쓴다.
+    assert.doesNotMatch(gate, /^\s+actions:/m, "게이트에 actions 권한을 주지 않는다");
+
+    // Repository Quality: pull_request 이면서 봇이 연 PR 만 live PR 을 기다렸다가 그 값으로 판정한다.
+    assert.match(repositoryQuality, /PR_AUTHOR: \$\{\{ github\.event\.pull_request\.user\.login \}\}/);
+    assert.match(
+        repositoryQuality,
+        new RegExp(
+            `elif \\[ "\\$GITHUB_EVENT_NAME" = "pull_request" \\] && \\[ "\\$PR_AUTHOR" = "${login}" \\]; then\\n` +
+                `(?:\\s+#.*\\n)*` +
+                `\\s+AWAIT_TIMEOUT_SECONDS=(\\d+) node \\.github/scripts/dependabot-pr-gate\\.mjs await "\\$pull_request_file"\\n` +
+                `\\s+CHANGED_FILES=\\$\\(jq -r '\\.changed_files' "\\$pull_request_file"\\)`,
+        ),
+    );
+    const awaitSeconds = Number(repositoryQuality.match(/AWAIT_TIMEOUT_SECONDS=(\d+) node/)[1]);
+    const quotaSeconds = Number(repositoryQuality.match(/ensure-api-quota\.mjs ensure --max-wait (\d+)/)[1]);
+    const jobMinutes = Number(repositoryQuality.match(/name: Repository Quality\n\s+runs-on: .+\n\s+timeout-minutes: (\d+)/)[1]);
+    assert.ok(
+        awaitSeconds + quotaSeconds + 30 <= jobMinutes * 60,
+        `게이트 대기 ${awaitSeconds}s + quota 대기 ${quotaSeconds}s 가 job timeout ${jobMinutes}분을 넘기면 판정 전에 취소된다`,
+    );
+
+    // Managed Device: 판정 재료는 신뢰 정책 사본으로 기다린 live PR 이다. PR 사본 스크립트를 부르지 않는다.
+    assert.match(
+        managedDevice,
+        /install -m 0644 \\\n\s+\.github\/scripts\/dependabot-pr-gate\.mjs \\\n\s+"\$policy_dir\/dependabot-pr-gate\.mjs"\n\s+dependabot_gate=trusted/,
+    );
+    // 신뢰 사본에 대기 명령이 있는지를 이 문자열로 가른다. 스크립트가 선언 모양을 바꾸면 기기 레인
+    // 대기가 조용히 꺼지므로, grep 문자열이 스크립트에 실제로 있는지 대조한다.
+    const probe = managedDevice.match(/grep -q '([^']+)' \.github\/scripts\/dependabot-pr-gate\.mjs/)?.[1];
+    assert.ok(probe, "스테이징 판별 grep 이 없다");
+    assert.ok((await readFile(GATE_SCRIPT, "utf8")).includes(probe), `dependabot-pr-gate.mjs 에 '${probe}' 가 없다`);
+    assert.equal((managedDevice.match(/dependabot_gate=unavailable/g) ?? []).length, 2, "도입 PR·bootstrap 은 페이로드를 읽는다");
+    assert.match(managedDevice, /EVENT_PR_AUTHOR: \$\{\{ github\.event\.pull_request\.user\.login \}\}/);
+    assert.match(managedDevice, /DEPENDABOT_GATE: \$\{\{ steps\.policy\.outputs\.dependabot_gate \}\}/);
+    assert.match(
+        managedDevice,
+        new RegExp(`if \\[\\[ "\\$EVENT_PR_AUTHOR" == "${login}" && "\\$DEPENDABOT_GATE" == "trusted" \\]\\]; then`),
+    );
+    assert.match(
+        managedDevice,
+        /AWAIT_TIMEOUT_SECONDS=\d+ \\\n\s+node "\$RUNNER_TEMP\/android-test-policy\/dependabot-pr-gate\.mjs" await "\$pull_request_file"/,
+    );
+    assert.match(managedDevice, /if \[\[ "\$live_head_sha" != "\$EVENT_PR_SHA" \]\]; then/);
+    assert.doesNotMatch(managedDevice, /node \.github\/scripts\/dependabot-pr-gate\.mjs/);
 });
diff --git a/.github/scripts/ensure-api-quota.mjs b/.github/scripts/ensure-api-quota.mjs
index 7cbec400e9..bb21575184 100644
--- a/.github/scripts/ensure-api-quota.mjs
+++ b/.github/scripts/ensure-api-quota.mjs
@@ -4,8 +4,7 @@
 // 구분한다 (#1465).
 //
 // 이 저장소의 게이트들은 잡마다 `gh api` 를 여러 번 부른다 — merge-order-guard 는 closing
-// 이슈마다 blocked_by 를, review-debt-guard 는 열린 PR 전수를, impact 분류는 PR 메타를
-// 조회한다. PR 수 × 잡 수 × 잡당 호출수가 곱해져 installation 한도를 넘기면, 저장소 전체의
+// 이슈마다 blocked_by 를, impact 분류는 PR 메타를 조회한다. PR 수 × 잡 수 × 잡당 호출수가 곱해져 installation 한도를 넘기면, 저장소 전체의
 // 게이트가 코드와 무관하게 빨갛게 된다. 그때 재실행은 남은 quota 를 더 태울 뿐이다.
 //
 // 명령:
@@ -18,8 +17,8 @@ import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import process from "node:process";
 
-// 게이트 한 번이 쓰는 호출 수의 상한을 여유 있게 잡은 값. merge-order-guard 8 · review-debt-guard 6
-// (열린 PR 전수를 도는 루프 포함) 를 감안한다.
+// 게이트 한 번이 쓰는 호출 수의 상한을 여유 있게 잡은 값. merge-order-guard 8 을
+// 감안한다.
 const DEFAULT_MIN_REMAINING = 200;
 // job timeout(대개 5분) 안에서 기다릴 수 있는 상한. 리셋이 이보다 멀면 기다리지 않고 실패한다.
 const DEFAULT_MAX_WAIT_SECONDS = 240;
diff --git a/.github/scripts/ensure-api-quota.test.mjs b/.github/scripts/ensure-api-quota.test.mjs
index 8d112266c1..4e5cf578cc 100644
--- a/.github/scripts/ensure-api-quota.test.mjs
+++ b/.github/scripts/ensure-api-quota.test.mjs
@@ -102,7 +102,7 @@ test("요약에 남은 호출과 리셋까지 남은 시간이 드러난다", ()
 });
 
 // 스크립트가 default branch 사본으로 도는 게이트. 판정 자체를 하는 자리라 PR 사본을 믿지 않는다.
-const TRUSTED_COPY_GATES = ["merge-order-guard.yml", "review-debt-guard.yml"];
+const TRUSTED_COPY_GATES = ["merge-order-guard.yml"];
 // PR 사본으로 도는 게이트. 이미 PR 사본의 분류·검증 스크립트를 실행하는 자리라 새 신뢰 경계가
 // 열리지 않고, quota 스텝은 관측·대기라 무력화해도 통과시킬 판정이 없다.
 const PULL_REQUEST_COPY_GATES = ["repository-quality.yml", "codeql.yml"];
@@ -128,16 +128,6 @@ test("게이트 워크플로가 quota 확인과 실패 분류를 모두 건다",
     }
 });
 
-test("GraphQL 을 사용하는 리뷰 적체 가드는 core 와 graphql 을 모두 예산·분류한다", async () => {
-    const source = await workflow("review-debt-guard.yml");
-    for (const resource of ["core", "graphql"]) {
-        assert.match(
-            source,
-            new RegExp(`ensure-api-quota\\.mjs ensure --resource ${resource} --max-wait 115`),
-        );
-        assert.match(source, new RegExp(`ensure-api-quota\\.mjs classify --resource ${resource}`));
-    }
-});
 
 test("default branch 사본으로 도는 게이트만 부트스트랩 예외를 갖는다", async () => {
     for (const name of TRUSTED_COPY_GATES) {
diff --git a/.github/scripts/find-viewed-auto-merge-targets.mjs b/.github/scripts/find-viewed-auto-merge-targets.mjs
new file mode 100644
index 0000000000..55b30a00f4
--- /dev/null
+++ b/.github/scripts/find-viewed-auto-merge-targets.mjs
@@ -0,0 +1,159 @@
+// Viewed 기반 자동 머지 대상 판정 (#2248)
+//
+// 지정한 한 사람(VIEWED_BY)이 PR 의 모든 파일을 Viewed 로 체크하면 «Merge when ready» 를 예약할 대상으로
+// 고른다. 리뷰 상태는 보지 않는다(#2277, 리뷰 폐지). 실제 머지는 GitHub 가 required check·승인 수·merge queue 를 통과시킨 뒤에만
+// 한다.
+//
+// viewerViewedState 는 토큰 주인 본인의 체크만 돌려준다. 그래서 VIEWED_BY 본인의 토큰(VIEWED_TOKEN)으로
+// 읽고, 토큰 주인이 VIEWED_BY 와 다르면 판정하지 않는다. 쓰기(예약)는 워크플로의 GITHUB_TOKEN 이 한다.
+// 체크한 뒤 바뀐 파일은 GitHub 가 DISMISSED 로 되돌리므로 새 커밋은 다시 봐야 대상이 된다.
+//
+// 반대 방향(예약 해제·큐에서 빼기)은 하지 않는다(#2252 폐지). Viewed 가 덜 찬 PR 도 사람이 직접 예약하거나 큐에 넣으면
+// 그대로 머지된다. Viewed 는 자동 예약의 조건일 뿐 머지를 막는 장치가 아니다.
+//
+// 이 규칙은 VIEWED_BY 개인의 운영 규칙이라 VIEWED_BY 본인이 작성한 PR 에만 적용한다(#2270). 팀원·봇 PR 은
+// 예약하지 않는다.
+import { appendFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+
+const PULL_REQUEST_FIELDS = `
+    number isDraft headRefOid isInMergeQueue changedFiles
+    author { login }
+    autoMergeRequest { enabledAt }
+    files(first: 100) { pageInfo { hasNextPage endCursor } nodes { path viewerViewedState } }
+`;
+
+/**
+ * 예약을 판정할 PR 인지 가른다. VIEWED_BY 본인이 작성한 PR 만 대상이다(대소문자 무시).
+ * 작성자를 알 수 없는 PR(탈퇴 계정 등)은 대상이 아니다.
+ *
+ * @param {object} pullRequest GraphQL PullRequest 노드
+ * @param {string} viewedBy Viewed 를 판정하는 사람의 로그인
+ * @returns {boolean}
+ */
+export function isAuthoredByViewer(pullRequest, viewedBy) {
+    const login = pullRequest.author?.login;
+    return typeof login === "string" && login.toLowerCase() === viewedBy.toLowerCase();
+}
+
+/**
+ * @param {object} pullRequest GraphQL PullRequest 노드
+ * @param {Array<{ path: string, viewerViewedState: string }>} files PR 의 전체 변경 파일
+ * @returns {{ enable: boolean, reason: string }}
+ */
+export function decideViewedAutoMerge(pullRequest, files) {
+    if (pullRequest.isDraft) return { enable: false, reason: "Draft PR" };
+    if (pullRequest.autoMergeRequest || pullRequest.isInMergeQueue) {
+        return { enable: false, reason: "이미 자동 머지 예약 또는 merge queue 에 있다" };
+    }
+    // 파일 목록을 다 못 읽었으면 «다 봤다» 고 단정하지 않는다.
+    if (files.length === 0 || files.length !== pullRequest.changedFiles) {
+        return { enable: false, reason: `파일 ${files.length}/${pullRequest.changedFiles} 만 읽었다` };
+    }
+    const unviewed = files.filter((file) => file.viewerViewedState !== "VIEWED");
+    if (unviewed.length > 0) {
+        return { enable: false, reason: `Viewed 안 된 파일 ${unviewed.length}/${files.length}` };
+    }
+    return { enable: true, reason: `모든 파일 Viewed — 자동 머지 예약` };
+}
+
+async function graphql(token, apiUrl, query, variables) {
+    const response = await fetch(`${apiUrl}/graphql`, {
+        method: "POST",
+        headers: { authorization: `bearer ${token}`, "content-type": "application/json" },
+        body: JSON.stringify({ query, variables }),
+    });
+    const payload = await response.json();
+    if (!response.ok || payload.errors) {
+        throw new Error(`GraphQL 실패 (${response.status}): ${JSON.stringify(payload.errors ?? payload)}`);
+    }
+    return payload.data;
+}
+
+async function readAllFiles(request, owner, name, pullRequest) {
+    const files = [...pullRequest.files.nodes];
+    let { hasNextPage, endCursor } = pullRequest.files.pageInfo;
+    while (hasNextPage) {
+        const data = await request(
+            `query($owner: String!, $name: String!, $number: Int!, $after: String) {
+                repository(owner: $owner, name: $name) {
+                    pullRequest(number: $number) {
+                        files(first: 100, after: $after) { pageInfo { hasNextPage endCursor } nodes { path viewerViewedState } }
+                    }
+                }
+            }`,
+            { owner, name, number: pullRequest.number, after: endCursor },
+        );
+        const page = data.repository.pullRequest.files;
+        files.push(...page.nodes);
+        ({ hasNextPage, endCursor } = page.pageInfo);
+    }
+    return files;
+}
+
+/**
+ * 열린 PR 마다 예약을 판정한다. VIEWED_BY 본인 PR 이 아니면 파일도 읽지 않고 건너뛴다.
+ *
+ * @returns {Promise<{ targets: Array<object> }>}
+ */
+export async function collectViewedAutoMergeActions(request, owner, name, viewedBy, pullRequests) {
+    const targets = [];
+    for (const pullRequest of pullRequests) {
+        if (!isAuthoredByViewer(pullRequest, viewedBy)) {
+            console.log(`#${pullRequest.number}: 작성자 ${pullRequest.author?.login ?? "없음"} — ${viewedBy} 의 PR 이 아니라 건드리지 않는다`);
+            continue;
+        }
+        const files = await readAllFiles(request, owner, name, pullRequest);
+        const decision = decideViewedAutoMerge(pullRequest, files);
+        console.log(`#${pullRequest.number}: ${decision.reason}`);
+        if (decision.enable) targets.push({ number: pullRequest.number, headSha: pullRequest.headRefOid });
+    }
+    return { targets };
+}
+
+async function main() {
+    const token = process.env.VIEWED_TOKEN;
+    const viewedBy = process.env.VIEWED_BY;
+    const baseBranch = process.env.BASE_BRANCH;
+    const [owner, name] = (process.env.GITHUB_REPOSITORY ?? "").split("/");
+    if (!token || !viewedBy || !baseBranch || !owner || !name) {
+        throw new Error("VIEWED_TOKEN·VIEWED_BY·BASE_BRANCH·GITHUB_REPOSITORY 가 필요합니다.");
+    }
+    const request = (query, variables) =>
+        graphql(token, process.env.GITHUB_API_URL ?? "https://api.github.com", query, variables);
+
+    const data = await request(
+        `query($owner: String!, $name: String!, $base: String!) {
+            viewer { login }
+            repository(owner: $owner, name: $name) {
+                pullRequests(states: OPEN, baseRefName: $base, first: 50) { nodes { ${PULL_REQUEST_FIELDS} } }
+            }
+        }`,
+        { owner, name, base: baseBranch },
+    );
+    if (data.viewer.login.toLowerCase() !== viewedBy.toLowerCase()) {
+        throw new Error(`VIEWED_TOKEN 주인이 ${data.viewer.login} 입니다 — ${viewedBy} 의 토큰이어야 합니다.`);
+    }
+
+    const { targets } = await collectViewedAutoMergeActions(
+        request, owner, name, viewedBy, data.repository.pullRequests.nodes,
+    );
+    if (process.env.GITHUB_OUTPUT) {
+        appendFileSync(
+            process.env.GITHUB_OUTPUT,
+            `targets=${JSON.stringify(targets)}\n`,
+        );
+    }
+}
+
+const isDirectExecution = process.argv[1]
+    && import.meta.url === pathToFileURL(process.argv[1]).href;
+
+if (isDirectExecution) {
+    try {
+        await main();
+    } catch (error) {
+        console.error(`::error::${error.message}`);
+        process.exitCode = 1;
+    }
+}
diff --git a/.github/scripts/find-viewed-auto-merge-targets.test.mjs b/.github/scripts/find-viewed-auto-merge-targets.test.mjs
new file mode 100644
index 0000000000..19ce8a0302
--- /dev/null
+++ b/.github/scripts/find-viewed-auto-merge-targets.test.mjs
@@ -0,0 +1,134 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import test from "node:test";
+
+import {
+    collectViewedAutoMergeActions,
+    decideViewedAutoMerge,
+    isAuthoredByViewer,
+} from "./find-viewed-auto-merge-targets.mjs";
+
+const viewed = (path) => ({ path, viewerViewedState: "VIEWED" });
+
+function pullRequest(overrides = {}) {
+    return {
+        number: 1,
+        isDraft: false,
+        headRefOid: "0123456789abcdef0123456789abcdef01234567",
+        isInMergeQueue: false,
+        autoMergeRequest: null,
+        changedFiles: 2,
+        ...overrides,
+    };
+}
+
+test("모든 파일이 Viewed 이고 승인 상태면 예약한다", () => {
+    assert.equal(decideViewedAutoMerge(pullRequest(), [viewed("a.kt"), viewed("b.kt")]).enable, true);
+});
+
+test("하나라도 Viewed 가 아니면 예약하지 않는다 — 체크 뒤 바뀐 파일(DISMISSED) 포함", () => {
+    for (const state of ["UNVIEWED", "DISMISSED"]) {
+        const files = [viewed("a.kt"), { path: "b.kt", viewerViewedState: state }];
+        assert.equal(decideViewedAutoMerge(pullRequest(), files).enable, false, state);
+    }
+});
+
+test("리뷰 상태와 무관하게 Viewed 만으로 예약한다", () => {
+    for (const reviewDecision of [null, "APPROVED", "CHANGES_REQUESTED", "REVIEW_REQUIRED"]) {
+        const decision = decideViewedAutoMerge(pullRequest({ reviewDecision }), [viewed("a.kt"), viewed("b.kt")]);
+        assert.equal(decision.enable, true, String(reviewDecision));
+    }
+});
+
+test("파일 목록을 다 못 읽었으면 다 봤다고 단정하지 않는다", () => {
+    assert.equal(decideViewedAutoMerge(pullRequest({ changedFiles: 3 }), [viewed("a.kt"), viewed("b.kt")]).enable, false);
+    assert.equal(decideViewedAutoMerge(pullRequest({ changedFiles: 0 }), []).enable, false);
+});
+
+test("Draft·이미 예약·큐에 있는 PR 은 건드리지 않는다", () => {
+    const files = [viewed("a.kt"), viewed("b.kt")];
+    assert.equal(decideViewedAutoMerge(pullRequest({ isDraft: true }), files).enable, false);
+    assert.equal(decideViewedAutoMerge(pullRequest({ autoMergeRequest: { enabledAt: "2026-10-04T00:00:00Z" } }), files).enable, false);
+    assert.equal(decideViewedAutoMerge(pullRequest({ isInMergeQueue: true }), files).enable, false);
+});
+
+const scheduled = { autoMergeRequest: { enabledAt: "2026-10-04T00:00:00Z" } };
+
+test("VIEWED_BY 본인이 작성한 PR 만 대상이다 — 대소문자 무시, 작성자 없음은 제외", () => {
+    assert.equal(isAuthoredByViewer({ author: { login: "1hyok" } }, "1hyok"), true);
+    assert.equal(isAuthoredByViewer({ author: { login: "1Hyok" } }, "1hyok"), true);
+    for (const author of [{ login: "koongmai" }, { login: "Sadturtleman" }, { login: "dependabot" }, null, undefined]) {
+        assert.equal(isAuthoredByViewer({ author }, "1hyok"), false, JSON.stringify(author));
+    }
+});
+
+// 파일이 한 페이지에 다 들어 있어 추가 조회가 없다. 작성자가 아니면 파일을 읽지도 않는다.
+function listedPullRequest(number, login, overrides = {}, states = ["VIEWED", "VIEWED"]) {
+    const nodes = states.map((viewerViewedState, index) => ({ path: `f${index}.kt`, viewerViewedState }));
+    return pullRequest({
+        number,
+        id: `PR_${number}`,
+        author: login === null ? null : { login },
+        changedFiles: nodes.length,
+        files: { pageInfo: { hasNextPage: false, endCursor: null }, nodes },
+        ...overrides,
+    });
+}
+
+const noRequest = async () => {
+    throw new Error("파일 추가 조회는 없어야 한다");
+};
+
+test("팀원·봇 PR 은 Viewed 가 다 차도 예약하지 않는다", async () => {
+    const pullRequests = [
+        listedPullRequest(2262, "dependabot", { isInMergeQueue: true }, ["UNVIEWED", "UNVIEWED"]),
+        listedPullRequest(2300, "Sadturtleman", { isInMergeQueue: true, changedFiles: 0 }, []),
+        listedPullRequest(2301, null),
+        listedPullRequest(2302, "koongmai"),
+    ];
+    const actions = await collectViewedAutoMergeActions(noRequest, "Afternote", "Afternote-FE", "1hyok", pullRequests);
+    assert.deepEqual(actions, { targets: [] });
+});
+
+test("본인 PR 은 Viewed 가 다 차면 예약하고, 덜 찬 채 예약·큐에 있어도 빼지 않는다", async () => {
+    const pullRequests = [
+        listedPullRequest(10, "1hyok", { isInMergeQueue: true }, ["UNVIEWED", "UNVIEWED"]),
+        listedPullRequest(11, "1Hyok", scheduled, ["VIEWED", "DISMISSED"]),
+        listedPullRequest(12, "1hyok"),
+        listedPullRequest(13, "dependabot", { isInMergeQueue: true }, ["UNVIEWED", "UNVIEWED"]),
+    ];
+    const actions = await collectViewedAutoMergeActions(noRequest, "Afternote", "Afternote-FE", "1hyok", pullRequests);
+    assert.deepEqual(actions, { targets: [{ number: 12, headSha: pullRequest().headRefOid }] });
+});
+
+test("GraphQL 조회가 작성자를 가져온다", async () => {
+    const script = await readFile(new URL("./find-viewed-auto-merge-targets.mjs", import.meta.url), "utf8");
+    const fields = script.slice(script.indexOf("const PULL_REQUEST_FIELDS"), script.indexOf("`;", script.indexOf("const PULL_REQUEST_FIELDS")));
+    assert.match(fields, /author \{ login \}/);
+});
+
+test("워크플로는 예약을 끄거나 큐에서 빼지 않는다 — Viewed 는 머지를 막지 않는다", async () => {
+    const workflow = await readFile(new URL("../workflows/viewed-auto-merge.yml", import.meta.url), "utf8");
+    assert.doesNotMatch(workflow, /--disable-auto/);
+    assert.doesNotMatch(workflow, /dequeuePullRequest/);
+    assert.doesNotMatch(workflow, /cancels/);
+    assert.doesNotMatch(workflow, /pull-requests: write|contents: write/);
+});
+
+test("워크플로는 본인 토큰으로 읽고 사람 토큰으로 승인한 HEAD 만 예약한다", async () => {
+    const workflow = await readFile(new URL("../workflows/viewed-auto-merge.yml", import.meta.url), "utf8");
+    assert.match(workflow, /^permissions: \{\}$/m);
+    assert.match(workflow, /VIEWED_TOKEN: \$\{\{ secrets\.VIEWED_TOKEN \}\}/);
+    assert.match(workflow, /ref: \$\{\{ github\.event\.repository\.default_branch \}\}/);
+    assert.match(workflow, /persist-credentials: false/);
+    // GITHUB_TOKEN 으로 예약·투입하면 merge_group CI 가 뜨지 않아 큐가 60분 막힌다(1005 #2208).
+    const enableStep = workflow.slice(workflow.indexOf("- name: Enable auto-merge"));
+    assert.match(enableStep, /GH_TOKEN: \$\{\{ secrets\.MERGE_QUEUE_TOKEN \}\}/);
+    assert.doesNotMatch(enableStep, /GH_TOKEN: \$\{\{ github\.token \}\}/);
+    assert.match(enableStep, /if \[ -z "\$GH_TOKEN" \]; then[\s\S]*?exit 0/);
+    assert.match(workflow, /--match-head-commit "\$head_sha"/);
+    // 우회 머지 금지. merge queue 와 required check 를 그대로 탄다.
+    assert.doesNotMatch(workflow, /--admin/);
+    // PR 코드를 체크아웃하지 않는다.
+    assert.doesNotMatch(workflow, /github\.event\.pull_request\.head|refs\/pull/);
+});
diff --git a/.github/scripts/handle-merge-queue-dequeue.mjs b/.github/scripts/handle-merge-queue-dequeue.mjs
index 1ff578ce31..c05e6be0ad 100644
--- a/.github/scripts/handle-merge-queue-dequeue.mjs
+++ b/.github/scripts/handle-merge-queue-dequeue.mjs
@@ -10,9 +10,27 @@
 //   한 번만 재투입한다. 0902 에 감시 루프가 90초마다 맹목 재투입해 30분을 헛돈 사고(#1638·#1639)가
 //   «한 번까지» 규칙의 근거다. 횟수는 이 스크립트가 남기는 마커 코멘트로 센다.
 //
+// 예외는 증명된 인프라 실패다(#2250). GMD 분류기(classify-android-managed-device-failure.mjs)가 테스트가 돌기 전에
+// 죽었다고 판정하면 그 run 에 재시도 마커 아티팩트를 남긴다. 실패 job 이 전부 그런 job 이면 PR 코드가 실행되기
+// 전에 끝난 것이므로 조용한 방출과 같이 같은 head 당 한 번 재투입한다. 머지 큐는 실패한 필수 체크로 바로 방출하므로
+// job 재실행(android-managed-device-retry.yml)으로는 복구되지 않고 재투입만이 수단이다.
+//
 // 판정 순서는 «실패 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 에는 마커 없는 안내 코멘트만 남긴다.
+//
+// 재투입은 이 job 이 직접 하지 않고 merge-queue-requeue.yml 에 넘긴다(#2254). GITHUB_TOKEN 으로 큐에 넣으면 GitHub 이
+// 그 이벤트로 워크플로를 띄우지 않아 merge_group CI 가 하나도 돌지 않고, 큐 맨 앞을 60분(check timeout) 붙잡은 뒤
+// CI_TIMEOUT 으로 다시 빠지면서 뒤의 PR 들까지 다시 검증하게 만든다(1005 #2208 실측: 봇이 넣은 그룹만 체크 0개).
+// 투입에는 사람 토큰(MERGE_QUEUE_TOKEN)이 필요한데 이 워크플로는 pull_request_target 브리지라 시크릿을 쓰지 않는다.
+// workflow_dispatch 는 GITHUB_TOKEN 으로 보내도 실행되는 예외라서, 판정과 마커는 여기서 끝내고 투입만 dispatch 로 넘긴다.
 
 import { readFile } from "node:fs/promises";
 import path from "node:path";
@@ -24,6 +42,12 @@ 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;
+// 재시도 마커 아티팩트 이름의 device → 그 마커가 증명하는 job 이름. android-managed-device-retry.yml 과 같은 표다.
+export const MANAGED_DEVICE_RETRY_JOBS = new Map([
+    ["api30", "Pixel 2 API 30 androidTest"],
+    ["api34", "Pixel 2 API 34 accessibility smoke"],
+]);
+const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
 export function queueBranchPrefix(baseRef, number) {
     return `gh-readonly-queue/${baseRef}/pr-${number}-`;
@@ -35,15 +59,17 @@ export function queueBranchPrefix(baseRef, number) {
  * [since] 는 마지막 큐 투입 시각이다 — 큐 브랜치 이름은 head 가 아니라 base SHA 를 달고 있어 며칠 전
  * 투입의 실패 run 도 같은 접두어로 잡힌다(0904 #1582 실측). 그 이전 run 은 이번 방출과 무관하다.
  */
-export function collectFailedJobs({ runs, jobsByRunId, baseRef, number, since }) {
+export function collectFailedJobs({ runs, jobsByRunId, artifactsByRunId = new Map(), baseRef, number, since }) {
     const prefix = queueBranchPrefix(baseRef, number);
     const failed = [];
     for (const run of runs) {
         if (typeof run.head_branch !== "string" || !run.head_branch.startsWith(prefix)) continue;
         if (since && typeof run.created_at === "string" && run.created_at < since) continue;
+        const provenJobNames = provenInfrastructureJobNames(run, artifactsByRunId.get(run.id) ?? []);
         for (const job of jobsByRunId.get(run.id) ?? []) {
             if (!FAILED_JOB_CONCLUSIONS.has(job.conclusion)) continue;
             failed.push({
+                infrastructure: provenJobNames.has(job.name),
                 runName: run.name,
                 runUrl: run.html_url,
                 jobName: job.name,
@@ -55,6 +81,24 @@ export function collectFailedJobs({ runs, jobsByRunId, baseRef, number, since })
     return failed;
 }
 
+/**
+ * run 의 재시도 마커 아티팩트가 증명하는 job 이름들. 마커는 분류기가 retryable 로 판정했을 때만 올라가고
+ * 이름에 run id·attempt 가 박혀 있어, 같은 run·attempt 의 이름만 받는다.
+ */
+export function provenInfrastructureJobNames(run, artifacts) {
+    const names = new Set();
+    for (const [device, jobName] of MANAGED_DEVICE_RETRY_JOBS) {
+        const expected = `android-managed-device-retry-${device}-${run.id}-${run.run_attempt ?? 1}`;
+        if (artifacts.some((artifact) => artifact.name === expected && !artifact.expired)) names.add(jobName);
+    }
+    return names;
+}
+
+/** 실패 job 이 하나 이상이고 전부 증명된 인프라 실패인가. */
+export function onlyInfrastructureFailures(failedJobs) {
+    return failedJobs.length > 0 && failedJobs.every((job) => job.infrastructure === true);
+}
+
 export function requeueMarker(headSha) {
     return `${REQUEUE_MARKER_PREFIX}${headSha} -->`;
 }
@@ -67,22 +111,32 @@ export function countRequeuesForHead(comments, headSha) {
 
 /**
  * 판정표.
- * 1. 실패 job 이 있다 → comment-failure (재투입 없음)
+ * 1. 실패 job 이 있고 그중 하나라도 인프라로 증명되지 않았다 → comment-failure (재투입 없음)
  * 2. reason 이 MANUAL·ALREADY_MERGED·MERGE → none
- * 3. 같은 head 에서 이미 재투입했다 → comment-give-up
- * 4. 그 밖 → requeue
+ * 3. 실패 job 이 전부 증명된 인프라 실패다 → 같은 head 첫 번째면 requeue, 이미 재투입했으면 comment-failure
+ * 4. 같은 head 에서 이미 재투입했다 → comment-give-up
+ * 5. 그 밖 → requeue
  */
 export function decide({ reason, failedJobs, requeueCount }) {
-    if (failedJobs.length > 0) return "comment-failure";
+    if (failedJobs.length > 0 && !onlyInfrastructureFailures(failedJobs)) return "comment-failure";
     if (NO_ACTION_REASONS.has(String(reason ?? "").toUpperCase())) return "none";
+    if (failedJobs.length > 0) return requeueCount >= 1 ? "comment-failure" : "requeue";
     if (requeueCount >= 1) return "comment-give-up";
     return "requeue";
 }
 
 const shortSha = (sha) => sha.slice(0, 7);
 
-export function renderFailureComment({ reason, headSha, failedJobs, repository, number }) {
-    const lines = failedJobs.map((job) => `- [${job.runName} / ${job.jobName}](${job.jobUrl}) — ${job.conclusion}`);
+/**
+ * 스택 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}${job.infrastructure ? " (인프라 실패로 분류됨)" : ""}`);
     return [
         "### merge queue 방출 — merge group CI 실패",
         "",
@@ -91,26 +145,41 @@ export function renderFailureComment({ reason, headSha, failedJobs, repository,
         "실패한 job:",
         ...lines,
         "",
-        `고친 뒤 \`gh pr merge ${number} --repo ${repository}\` 로 다시 투입한다.`,
+        `고친 뒤 \`${manualEnqueueCommand({ repository, number, stack })}\` 로 다시 투입한다.`,
     ].join("\n");
 }
 
-export function renderRequeueComment({ reason, headSha }) {
+export function renderRequeueComment({ reason, headSha, failedJobs = [] }) {
+    const why = failedJobs.length > 0
+        ? "merge group 실패 job 이 전부 테스트 전 인프라 실패로 분류됨 → 한 번 재투입했다."
+        : "merge group 실패 job 없음 → 조용한 방출로 보고 한 번 재투입했다.";
     return [
         requeueMarker(headSha),
         "### merge queue 방출 — 재투입했다",
         "",
-        `사유 \`${reason}\` · head \`${shortSha(headSha)}\` · merge group 실패 job 없음 → 조용한 방출로 보고 한 번 재투입했다.`,
+        `사유 \`${reason}\` · head \`${shortSha(headSha)}\` · ${why}`,
+        ...failedJobs.map((job) => `- [${job.runName} / ${job.jobName}](${job.jobUrl}) — ${job.conclusion}`),
         "같은 head 에서 또 방출되면 재투입하지 않고 여기에 남긴다.",
     ].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 +229,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 +241,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);
@@ -185,11 +265,19 @@ export async function fetchQueueFailedJobs(api, repository, { baseRef, number, s
         .filter((run) => !since || typeof run.created_at !== "string" || run.created_at >= since)
         .slice(0, QUEUE_RUNS_TO_INSPECT);
     const jobsByRunId = new Map();
+    const artifactsByRunId = new Map();
     for (const run of runs) {
         const jobs = await api(`/repos/${repository}/actions/runs/${run.id}/jobs?per_page=100`);
         jobsByRunId.set(run.id, jobs.jobs ?? []);
+        // 마커를 남길 수 있는 run 만 아티팩트를 본다 — 실패한 GMD job 이 없으면 볼 필요가 없다.
+        const hasFailedManagedDeviceJob = (jobs.jobs ?? []).some((job) =>
+            FAILED_JOB_CONCLUSIONS.has(job.conclusion) && [...MANAGED_DEVICE_RETRY_JOBS.values()].includes(job.name));
+        if (hasFailedManagedDeviceJob) {
+            const artifacts = await api(`/repos/${repository}/actions/runs/${run.id}/artifacts?per_page=100`);
+            artifactsByRunId.set(run.id, artifacts.artifacts ?? []);
+        }
     }
-    return collectFailedJobs({ runs, jobsByRunId, baseRef, number, since });
+    return collectFailedJobs({ runs, jobsByRunId, artifactsByRunId, baseRef, number, since });
 }
 
 export async function fetchComments(api, repository, number) {
@@ -219,39 +307,167 @@ 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 const REQUEUE_WORKFLOW_FILE = "merge-queue-requeue.yml";
+
+/** 재투입 워크플로를 띄운다. 입력의 head 로 고정해 그사이 새 커밋이 올라오면 그쪽이 투입하지 않는다. */
+export async function dispatchRequeue(api, repository, { number, headSha, ref }) {
+    await api(`/repos/${repository}/actions/workflows/${REQUEUE_WORKFLOW_FILE}/dispatches`, {
+        method: "POST",
+        body: { ref, inputs: { pull_request_number: String(number), head_sha: headSha } },
+    });
+}
+
+/** 큐 투입 자체. 스택 PR 은 merge-async, 나머지는 GraphQL 이다(#2177). [api] 의 토큰 주인이 투입 주체가 된다. */
+export async function performRequeue({ api, repository, number, live, logger = console, sleep = defaultSleep }) {
+    const headSha = live.headRefOid;
+    if (isStackMember(live)) {
+        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());
+        }
+        return "merge-async";
+    }
+    const entry = await enqueue(api, live.id);
+    logger.log(`#${number} 재투입 → ${entry?.state ?? "?"} position=${entry?.position ?? "?"}`);
+    return "graphql";
+}
+
+/**
+ * merge-queue-requeue.yml 쪽. dispatch 를 받은 뒤 live 상태를 다시 보고, 판정한 head 그대로 열려 있고 큐 밖일 때만 넣는다.
+ * 판정·마커는 방출 처리 job 이 이미 끝냈으므로 여기서는 코멘트를 쓰지 않는다.
+ */
+export async function requeueDispatched({ api, repository, number, headSha, logger = console, sleep = defaultSleep }) {
+    const live = await fetchLivePullRequest(api, repository, number);
+    if (!live) throw new Error(`#${number} 를 찾을 수 없습니다`);
+    let skip = null;
+    if (live.state !== "OPEN") skip = live.state;
+    else if (live.mergeQueueEntry) skip = "already-queued";
+    else if (live.headRefOid !== headSha) skip = "head-changed";
+    else if (isStackMember(live) && !isStackBottom(live)) skip = "stack-upper";
+    if (skip) {
+        logger.log(`#${number} 재투입 생략(${skip}) — 판정 head ${shortSha(headSha)}, 지금 head ${shortSha(live.headRefOid ?? "")}`);
+        return { action: "none", why: skip };
+    }
+    const enqueueMethod = await performRequeue({ api, repository, number, live, logger, sleep });
+    return { action: "requeue", enqueueMethod };
+}
+
+export function renderMissingQueueTokenComment({ headSha, repository, number, stack = false }) {
+    return [
+        "### merge queue 방출: 재투입하지 못했다",
+        "",
+        `head \`${shortSha(headSha)}\`. \`MERGE_QUEUE_TOKEN\` 시크릿이 없다.`,
+        "GITHUB_TOKEN 으로 넣으면 merge_group CI 가 돌지 않아 60분 뒤 CI_TIMEOUT 으로 다시 빠지므로 넣지 않았다.",
+        `\`${manualEnqueueCommand({ repository, number, stack })}\` 로 직접 투입한다.`,
+    ].join("\n");
+}
+
+export async function handleDequeue({
+    api,
+    repository,
+    number,
+    reason,
+    dryRun = false,
+    logger = console,
+    sleep = defaultSleep,
+    requeue = null,
+}) {
     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 ?? "?"}`);
+        await postComment(api, repository, number, renderRequeueComment({ reason, headSha, failedJobs }));
+        result.enqueueMethod = requeue
+            ? await requeue({ number, headSha, live })
+            : await performRequeue({ api, repository, number, live, logger, sleep });
+    }
+    return result;
+}
+
+function requiredEnv(name) {
+    const value = process.env[name];
+    if (!value) throw new Error(`${name} 가 필요합니다.`);
+    return value;
+}
+
+async function requeueMain(repository) {
+    const commentApi = createApi(requiredEnv("GITHUB_TOKEN"));
+    const number = Number(process.env.PULL_REQUEST_NUMBER);
+    const headSha = requiredEnv("HEAD_SHA");
+    if (!Number.isInteger(number) || number <= 0) {
+        throw new Error("PULL_REQUEST_NUMBER 가 양의 정수여야 합니다.");
+    }
+    const queueToken = process.env.MERGE_QUEUE_TOKEN;
+    if (!queueToken) {
+        const live = await fetchLivePullRequest(commentApi, repository, number);
+        await postComment(commentApi, repository, number, renderMissingQueueTokenComment({ headSha, repository, number, stack: isStackMember(live) }));
+        throw new Error("MERGE_QUEUE_TOKEN 시크릿이 없어 재투입하지 못했다.");
     }
-    return { action, failedJobs, requeueCount };
+    const result = await requeueDispatched({ api: createApi(queueToken), repository, number, headSha });
+    console.log(`merge-queue-requeue: #${number} head=${shortSha(headSha)} → ${result.action}${result.why ? ` (${result.why})` : ""}${result.enqueueMethod ? ` (${result.enqueueMethod})` : ""}`);
 }
 
 async function main() {
@@ -260,6 +476,10 @@ async function main() {
     if (!token || !repository) {
         throw new Error("GITHUB_TOKEN·GITHUB_REPOSITORY 가 필요합니다.");
     }
+    if (process.env.MODE === "requeue") {
+        await requeueMain(repository);
+        return;
+    }
     let number = Number(process.env.PULL_REQUEST_NUMBER);
     let reason = process.env.DEQUEUE_REASON;
     if ((!Number.isInteger(number) || number <= 0 || !reason) && process.env.GITHUB_EVENT_PATH) {
@@ -273,8 +493,13 @@ async function main() {
     reason = reason || "UNKNOWN";
 
     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 ref = requiredEnv("DEFAULT_BRANCH");
+    const requeue = async ({ headSha }) => {
+        await dispatchRequeue(api, repository, { number, headSha, ref });
+        return "dispatch";
+    };
+    const result = await handleDequeue({ api, repository, number, reason, dryRun: process.env.DRY_RUN === "true", requeue });
+    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 f09f58d9a2..f75dabb935 100644
--- a/.github/scripts/handle-merge-queue-dequeue.test.mjs
+++ b/.github/scripts/handle-merge-queue-dequeue.test.mjs
@@ -7,10 +7,20 @@ import {
     collectFailedJobs,
     countRequeuesForHead,
     decide,
+    dispatchRequeue,
+    provenInfrastructureJobNames,
+    enqueueStacked,
     handleDequeue,
+    renderMissingQueueTokenComment,
+    requeueDispatched,
+    REQUEUE_WORKFLOW_FILE,
+    isStackBottom,
+    isStackMember,
     lastEnqueuedAt,
+    manualEnqueueCommand,
     queueBranchPrefix,
     renderFailureComment,
+    renderGiveUpComment,
     renderRequeueComment,
     requeueMarker,
 } from "./handle-merge-queue-dequeue.mjs";
@@ -18,6 +28,7 @@ import {
 const REPO = "Afternote/Afternote-FE";
 const HEAD = "0123456789abcdef0123456789abcdef01234567";
 const silent = { log() {} };
+const immediateSleep = async () => {};
 
 // ---- 판정표 (#1892) ----
 
@@ -41,6 +52,24 @@ test("실패 job 없는 방출은 같은 head 에서 한 번만 재투입하고,
     assert.equal(decide({ reason: "ROLL_BACK", failedJobs: [], requeueCount: 3 }), "comment-give-up");
 });
 
+test("실패 job 이 전부 증명된 인프라 실패면 같은 head 에서 한 번 재투입하고, 두 번째는 링크만 남긴다", () => {
+    const infra = [{ jobName: "Pixel 2 API 30 androidTest", conclusion: "failure", infrastructure: true }];
+    assert.equal(decide({ reason: "CI_FAILURE", failedJobs: infra, requeueCount: 0 }), "requeue");
+    assert.equal(decide({ reason: "CI_FAILURE", failedJobs: infra, requeueCount: 1 }), "comment-failure");
+    assert.equal(decide({ reason: "MANUAL", failedJobs: infra, requeueCount: 0 }), "none");
+    const mixed = [...infra, { jobName: "Run Unit Tests", conclusion: "failure", infrastructure: false }];
+    assert.equal(decide({ reason: "CI_FAILURE", failedJobs: mixed, requeueCount: 0 }), "comment-failure");
+});
+
+test("재시도 마커는 같은 run·attempt 이름만 인정한다 — 다른 run·만료·모르는 device 는 증명이 아니다", () => {
+    const run = { id: 37178469871, run_attempt: 1 };
+    assert.deepEqual([...provenInfrastructureJobNames(run, [{ name: "android-managed-device-retry-api30-37178469871-1" }])], ["Pixel 2 API 30 androidTest"]);
+    assert.equal(provenInfrastructureJobNames(run, [{ name: "android-managed-device-retry-api30-37178469871-2" }]).size, 0);
+    assert.equal(provenInfrastructureJobNames(run, [{ name: "android-managed-device-retry-api30-1-1" }]).size, 0);
+    assert.equal(provenInfrastructureJobNames(run, [{ name: "android-managed-device-retry-api30-37178469871-1", expired: true }]).size, 0);
+    assert.equal(provenInfrastructureJobNames(run, [{ name: "android-managed-device-retry-api26-37178469871-1" }]).size, 0);
+});
+
 // ---- 실패 job 수집 ----
 
 test("이 PR 의 큐 브랜치 run 에서 failure·timed_out job 만 모은다 — 다른 PR 의 run, cancelled job 은 뺀다", () => {
@@ -109,10 +138,77 @@ 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 = {},
+    artifacts = {},
+    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,38 +216,64 @@ 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 artifactsMatch = /\/actions\/runs\/(\d+)\/artifacts/.exec(apiPath);
+        if (artifactsMatch) return { artifacts: artifacts[artifactsMatch[1]] ?? [] };
         const jobsMatch = /\/actions\/runs\/(\d+)\/jobs/.exec(apiPath);
         if (jobsMatch) return { jobs: jobs[jobsMatch[1]] ?? [] };
         if (apiPath.includes("/comments") && (options.method ?? "GET") === "GET") return comments;
         if (apiPath.includes("/comments") && options.method === "POST") return { id: 1 };
+        if (apiPath.endsWith("/dispatches") && options.method === "POST") return null;
         throw new Error(`unexpected ${apiPath}`);
     };
     api.calls = calls;
     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 +282,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 +537,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 +551,51 @@ 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 });
+test("GMD 인프라 실패만으로 방출되면 마커 코멘트 뒤 재투입한다 — 마커 없는 같은 job 은 실패 코멘트만", async () => {
+    const runs = [{ id: 9, run_attempt: 1, name: "Android Managed Device Test", html_url: "https://x/runs/9", head_branch: queueBranchPrefix("develop", 1509) + "abc", created_at: "2026-09-04T08:05:00Z" }];
+    const jobs = { 9: [
+        { name: "Pixel 2 API 30 androidTest", conclusion: "failure", html_url: "https://x/jobs/91" },
+        { name: "Pixel 2 API 34 accessibility smoke", conclusion: "success", html_url: "https://x/jobs/92" },
+    ] };
+    const proven = fakeApi({ live: openLive, runs, jobs, artifacts: { 9: [{ name: "android-managed-device-retry-api30-9-1" }] } });
+    const result = await handleDequeue({ api: proven, repository: REPO, number: 1509, reason: "CI_FAILURE", 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")));
+    assert.equal(enqueueMutations(proven).length, 1);
+    const comment = commentPosts(proven)[0].body.body;
+    assert.ok(comment.startsWith(requeueMarker(HEAD)));
+    assert.match(comment, /인프라 실패로 분류됨/);
+    assert.match(comment, /https:\/\/x\/jobs\/91/);
+    const writes = proven.calls.filter((call) => call.method === "POST");
+    assert.ok(writes.findIndex((call) => call.apiPath.endsWith("/comments")) < writes.findIndex((call) => call.body?.query?.includes("enqueuePullRequest")));
+
+    const unproven = fakeApi({ live: openLive, runs, jobs });
+    const failed = await handleDequeue({ api: unproven, repository: REPO, number: 1509, reason: "CI_FAILURE", logger: silent });
+    assert.equal(failed.action, "comment-failure");
+    assert.equal(enqueueMutations(unproven).length, 0);
+
+    const second = fakeApi({
+        live: openLive, runs, jobs,
+        artifacts: { 9: [{ name: "android-managed-device-retry-api30-9-1" }] },
+        comments: [{ body: renderRequeueComment({ reason: "CI_FAILURE", headSha: HEAD }) }],
+    });
+    const again = await handleDequeue({ api: second, repository: REPO, number: 1509, reason: "CI_FAILURE", logger: silent });
+    assert.equal(again.action, "comment-failure");
+    assert.equal(enqueueMutations(second).length, 0);
+});
+
+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);
+    }
 });
 
 // ---- 워크플로 정책 ----
@@ -206,3 +610,105 @@ test("워크플로는 default branch 정의로 dequeued 에만 반응하고, 테
     assert.match(source, /DEQUEUE_REASON: \$\{\{ github\.event\.reason \}\}/);
     assert.match(source, /cancel-in-progress: false/);
 });
+
+// ---- 재투입은 사람 토큰을 가진 워크플로가 한다 (1005 #2208) ----
+// GITHUB_TOKEN 으로 넣은 큐 항목은 merge_group CI 를 띄우지 못해 60분 뒤 CI_TIMEOUT 으로 빠진다.
+
+const dispatches = (api) => api.calls.filter((call) => call.apiPath.endsWith("/dispatches"));
+
+test("방출 처리에 재투입 위임을 주면 마커를 먼저 남기고 직접 넣지 않는다", async () => {
+    for (const live of [openLive, stackedLive]) {
+        const api = fakeApi({ live });
+        const delegated = [];
+        const result = await handleDequeue({
+            api, repository: REPO, number: 1509, reason: "CI_TIMEOUT", logger: silent,
+            requeue: async (request) => {
+                delegated.push(request);
+                assert.equal(commentPosts(api).length, 1, "마커 코멘트가 위임보다 먼저다");
+                return "dispatch";
+            },
+        });
+        assert.equal(result.action, "requeue");
+        assert.equal(result.enqueueMethod, "dispatch");
+        assert.equal(delegated.length, 1);
+        assert.equal(delegated[0].number, 1509);
+        assert.equal(delegated[0].headSha, HEAD);
+        assert.ok(commentPosts(api)[0].body.body.startsWith(requeueMarker(HEAD)));
+        assert.equal(enqueueMutations(api).length, 0);
+        assert.equal(mergeAsyncCalls(api).length, 0);
+    }
+});
+
+test("재투입 위임은 재투입 판정일 때만 부른다", async () => {
+    const runs = [{ id: 7, name: "Unit Test", html_url: "https://x/runs/7", head_branch: queueBranchPrefix("develop", 1509) + "abc", created_at: "2026-09-04T08:05:00Z" }];
+    const jobs = { 7: [{ name: "Run Unit Tests", conclusion: "failure", html_url: "https://x/jobs/71" }] };
+    const cases = [
+        fakeApi({ live: openLive, runs, jobs }),
+        fakeApi({ live: openLive, comments: [{ body: renderRequeueComment({ reason: "X", headSha: HEAD }) }] }),
+        fakeApi({ live: { ...openLive, state: "MERGED" } }),
+    ];
+    for (const api of cases) {
+        await handleDequeue({
+            api, repository: REPO, number: 1509, reason: "CI_TIMEOUT", logger: silent,
+            requeue: async () => assert.fail("재투입 판정이 아니면 위임하지 않는다"),
+        });
+    }
+});
+
+test("dispatchRequeue 는 판정한 head 를 입력으로 재투입 워크플로를 띄운다", async () => {
+    const api = fakeApi({ live: openLive });
+    await dispatchRequeue(api, REPO, { number: 2208, headSha: HEAD, ref: "develop" });
+    assert.deepEqual(dispatches(api).map(({ apiPath, method, body }) => ({ apiPath, method, body })), [{
+        apiPath: `/repos/${REPO}/actions/workflows/${REQUEUE_WORKFLOW_FILE}/dispatches`,
+        method: "POST",
+        body: { ref: "develop", inputs: { pull_request_number: "2208", head_sha: HEAD } },
+    }]);
+});
+
+test("requeueDispatched 는 판정한 head 그대로 열려 있고 큐 밖일 때만 넣는다", async () => {
+    const plain = fakeApi({ live: openLive });
+    assert.deepEqual(await requeueDispatched({ api: plain, repository: REPO, number: 2208, headSha: HEAD, logger: silent }), { action: "requeue", enqueueMethod: "graphql" });
+    assert.equal(enqueueMutations(plain).length, 1);
+
+    const stacked = fakeApi({ live: stackedLive });
+    const stackedResult = await requeueDispatched({ api: stacked, repository: REPO, number: 2123, headSha: HEAD, logger: silent, sleep: immediateSleep });
+    assert.equal(stackedResult.enqueueMethod, "merge-async");
+    assert.equal(enqueueMutations(stacked).length, 0);
+
+    for (const [live, why] of [
+        [{ ...openLive, state: "MERGED" }, "MERGED"],
+        [{ ...openLive, mergeQueueEntry: { state: "QUEUED", position: 1 } }, "already-queued"],
+        [{ ...openLive, headRefOid: "f".repeat(40) }, "head-changed"],
+        [stackUpperLive, "stack-upper"],
+    ]) {
+        const api = fakeApi({ live });
+        assert.deepEqual(await requeueDispatched({ api, repository: REPO, number: 2208, headSha: HEAD, logger: silent }), { action: "none", why });
+        assert.equal(enqueueMutations(api).length, 0, why);
+        assert.equal(mergeAsyncCalls(api).length, 0, why);
+        assert.equal(commentPosts(api).length, 0, "판정·코멘트는 방출 처리 job 몫이다");
+    }
+});
+
+test("사람 토큰이 없으면 GITHUB_TOKEN 으로 넣지 않고 직접 투입 명령을 안내한다", () => {
+    const body = renderMissingQueueTokenComment({ headSha: HEAD, repository: REPO, number: 2208 });
+    assert.match(body, /MERGE_QUEUE_TOKEN/);
+    assert.match(body, /CI_TIMEOUT/);
+    assert.match(body, /gh pr merge 2208 --repo Afternote\/Afternote-FE/);
+    assert.ok(!body.includes("<!-- merge-queue-dequeue:requeued"));
+});
+
+test("워크플로: 방출 처리는 시크릿 없이 dispatch 만 하고, 재투입은 workflow_dispatch 로만 사람 토큰을 쓴다", () => {
+    const dequeue = readFileSync(new URL("../workflows/merge-queue-dequeue.yml", import.meta.url), "utf8");
+    assert.doesNotMatch(dequeue, /\bsecrets(?:\.|\[)/);
+    assert.match(dequeue, /actions: write/);
+    assert.match(dequeue, /DEFAULT_BRANCH: \$\{\{ github\.event\.repository\.default_branch \}\}/);
+
+    const requeue = readFileSync(new URL(`../workflows/${REQUEUE_WORKFLOW_FILE}`, import.meta.url), "utf8");
+    assert.match(requeue, /^on:\n  workflow_dispatch:\n/m);
+    assert.doesNotMatch(requeue, /^  (pull_request|pull_request_target|merge_group|schedule|push):/m);
+    assert.match(requeue, /^permissions: \{\}$/m);
+    assert.match(requeue, /MERGE_QUEUE_TOKEN: \$\{\{ secrets\.MERGE_QUEUE_TOKEN \}\}/);
+    assert.match(requeue, /MODE: requeue/);
+    assert.match(requeue, /ref: \$\{\{ github\.event\.repository\.default_branch \}\}/);
+    assert.match(requeue, /persist-credentials: false/);
+});
diff --git a/.github/scripts/ktlint-coverage.mjs b/.github/scripts/ktlint-coverage.mjs
index 0b26d4537e..1d4ae62d04 100644
--- a/.github/scripts/ktlint-coverage.mjs
+++ b/.github/scripts/ktlint-coverage.mjs
@@ -8,8 +8,8 @@
 // 「.kt 를 가진 모듈」이 아니라 **등록된 모듈 전부**다.
 //
 // ktlint 는 두 경로로 붙는다 — 모듈이 직접 적용하거나, ktlint 를 적용하는 컨벤션 플러그인을
-// 타거나. 컨벤션은 서로를 apply 하며 사슬을 이루므로(android.feature → android.library.compose →
-// android.library → android.lint) 여기서 그 사슬의 전이 폐포를 계산한다. 컨벤션이 새로 생겨도
+// 타거나. 컨벤션은 서로를 apply 하며 사슬을 이루므로(android.library.compose → android.library →
+// android.lint) 여기서 그 사슬의 전이 폐포를 계산한다. 컨벤션이 새로 생겨도
 // 목록을 손으로 고칠 필요가 없다.
 
 import fs from "node:fs/promises";
diff --git a/.github/scripts/label-awaiting-author-prs.mjs b/.github/scripts/label-awaiting-author-prs.mjs
deleted file mode 100644
index 05aaac2785..0000000000
--- a/.github/scripts/label-awaiting-author-prs.mjs
+++ /dev/null
@@ -1,787 +0,0 @@
-#!/usr/bin/env node
-
-// 변경요청을 받은 뒤 작성자가 아무 조치도 하지 않은 PR 에 라벨을 붙인다 (#1552).
-//
-// `review-debt-guard.yml` 은 리뷰어의 빚과 작성자의 빚을 서로 다른 입장 조건으로 다룬다.
-// 리뷰어 빚 판정에서는 "재요청이 없거나 최신 변경요청 뒤 작성자 조치가 없으면 리뷰어 빚이
-// 아니다"(#1136)를 유지한다. 대신 `check-author-debt.mjs` 가 이 파일의 같은 판정을 재사용해,
-// 공이 작성자에게 남은 자기 PR 이 있으면 새 PR 을 닫는다. 라벨 리컨사일러는 현재 상태를 열린
-// PR 목록에서 바로 볼 수 있게 만드는 관찰 가능성 경로이고, check CLI 는 새 PR 입장 게이트다.
-//
-// 8/30 실측: 열린 non-draft 29건 중 최신 판정이 CHANGES_REQUESTED 인 9건이 9건 모두 작성자
-// 무조치였고, 그중 #440 은 49일 · #767·#771 은 22일째였다. 오래 열려 있을수록 develop 이
-// 전진해 충돌 비용이 커진다.
-//
-// 이벤트가 아니라 리컨사일러인 이유. 붙이는 경로와 떼는 경로를 따로 만들면 떼는 쪽이 새고
-// 스테일 라벨이 남아 신호가 죽는다. 여기서는 매 실행이 «지금 무조치인 PR 집합» 을 다시 계산해
-// 차이만 쓰므로 붙이기와 떼기가 갈라질 수 없다. 호출도 PR 수만큼 곱해지지 않는다 (#1465).
-//
-// 판정 기준은 `review-debt-guard.yml` 과 같아야 한다. 한쪽만 바뀌면 가드가 «작성자 몫» 이라고
-// 판단한 PR 에 라벨이 없거나, 반대로 리뷰어 몫인 PR 에 라벨이 붙는다. 커밋·응답·본문 편집을
-// 포함해 두 판정이 공유하는 술어는 `awaiting-author-policy.test.mjs` 가 잠근다.
-
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import process from "node:process";
-import { pathToFileURL } from "node:url";
-
-export const DEFAULT_LABEL = "awaiting-author";
-
-const LABEL_COLOR = "FBCA04";
-const LABEL_DESCRIPTION = "변경요청 뒤 작성자 조치 없음 — 공은 작성자에게 있다";
-// 25건 × (리뷰·커밋·코멘트·본문 편집 100) 를 한 번에 물으면 GraphQL 이 시간 안에 못 돌려
-// 504 를 낸다
-// (8/30 실측). 페이지를 잘게 끊고, 하위 컬렉션도 «판정 이후» 를 덮을 만큼만 가져온다. 모두
-// `last` 인 것은 필요한 쪽이 최근이기 때문이다 — 판정은 최신 결정 리뷰이고, 반영·응답은 그
-// 시각 이후만 센다. `first` 로 앞부분을 가져오면 정작 볼 구간이 잘린다.
-const PULL_REQUEST_PAGE_SIZE = 10;
-
-const OPEN_PULL_REQUESTS_QUERY = `
-query($owner: String!, $name: String!, $cursor: String, $pageSize: Int!) {
-    repository(owner: $owner, name: $name) {
-        pullRequests(states: OPEN, first: $pageSize, after: $cursor) {
-            pageInfo { hasNextPage endCursor }
-            nodes {
-                number
-                title
-                isDraft
-                createdAt
-                author { login }
-                assignees(first: 10) { nodes { login } }
-                headRepository { nameWithOwner }
-                labels(first: 50) { nodes { name } }
-                reviews(last: 50) {
-                    pageInfo { hasPreviousPage }
-                    nodes {
-                        state
-                        submittedAt
-                        authorCanPushToRepository
-                        author { login }
-                    }
-                }
-                commits(last: 50) {
-                    pageInfo { hasPreviousPage }
-                    nodes {
-                        commit {
-                            committedDate
-                            changedFilesIfAvailable
-                            parents(first: 2) { totalCount }
-                            author { email user { login } }
-                        }
-                    }
-                }
-                comments(last: 50) {
-                    pageInfo { hasPreviousPage }
-                    nodes {
-                        createdAt
-                        author { login }
-                    }
-                }
-                userContentEdits(last: 50) {
-                    pageInfo { hasPreviousPage }
-                    nodes {
-                        editedAt
-                        editor { login }
-                    }
-                }
-            }
-        }
-    }
-}`;
-
-const OPEN_PULL_REQUESTS_BY_AUTHOR_QUERY = `
-query($searchQuery: String!, $cursor: String, $pageSize: Int!) {
-    search(query: $searchQuery, type: ISSUE, first: $pageSize, after: $cursor) {
-        pageInfo { hasNextPage endCursor }
-        nodes {
-            ... on PullRequest {
-                number
-                title
-                isDraft
-                createdAt
-                author { login }
-                assignees(first: 10) { nodes { login } }
-                headRepository { nameWithOwner }
-                labels(first: 50) { nodes { name } }
-                reviews(last: 50) {
-                    pageInfo { hasPreviousPage }
-                    nodes {
-                        state
-                        submittedAt
-                        authorCanPushToRepository
-                        author { login }
-                    }
-                }
-                commits(last: 50) {
-                    pageInfo { hasPreviousPage }
-                    nodes {
-                        commit {
-                            committedDate
-                            changedFilesIfAvailable
-                            parents(first: 2) { totalCount }
-                            author { email user { login } }
-                        }
-                    }
-                }
-                comments(last: 50) {
-                    pageInfo { hasPreviousPage }
-                    nodes {
-                        createdAt
-                        author { login }
-                    }
-                }
-                userContentEdits(last: 50) {
-                    pageInfo { hasPreviousPage }
-                    nodes {
-                        editedAt
-                        editor { login }
-                    }
-                }
-            }
-        }
-    }
-}`;
-
-// 판정 함수가 각 connection 에서 읽는 시각 필드. reviews 는 판정 기준 시각 자체를 구하는
-// 근거라 여기 넣지 않는다.
-const ACTIVITY_TIMESTAMP_BY_CONNECTION = Object.freeze({
-    commits: (node) => node?.commit?.committedDate,
-    comments: (node) => node?.createdAt,
-    userContentEdits: (node) => node?.editedAt,
-});
-
-function sameLogin(a, b) {
-    return typeof a === "string" && typeof b === "string" && a.toLowerCase() === b.toLowerCase();
-}
-
-function isOneOf(login, owners) {
-    return (owners ?? []).some((owner) => sameLogin(login, owner));
-}
-
-function toOwners(author) {
-    return Array.isArray(author) ? author : [author];
-}
-
-/**
- * PR 의 담당자 로그인 목록.
- *
- * PR 의 공은 «올린 사람» 이 아니라 «어사인된 사람» 에게 있다(#1974 결정, #1980). 변경요청에
- * 응답할 의무도, 그 미응답이 막는 «새 PR 열기» 도 담당자의 몫이다. 어사인이 비어 있는 동안만
- * 작성자가 담당자다 — pr-assign-author 가 빈 어사인에 작성자를 걸므로 잠깐 비는 창에서도
- * 결과가 같다.
- */
-export function responsibleLogins(pullRequest) {
-    const assignees = (pullRequest?.assignees?.nodes ?? [])
-        .map((node) => node?.login)
-        .filter((login) => typeof login === "string" && login !== "");
-    if (assignees.length > 0) {
-        return assignees;
-    }
-    const author = pullRequest?.author?.login;
-    return typeof author === "string" && author !== "" ? [author] : [];
-}
-
-/**
- * PR 전체에서 «최신 결정 리뷰» 를 고른다.
- *
- * 쓰기 권한이 있는 팀원의 판정만 인정하고 리뷰어별로 묶지 않는다. 외부인의 변경요청으로 팀원의
- * 새 PR 을 막거나, 외부인의 승인으로 팀 변경요청을 지울 수 없다. 팀에서 한 사람이 더 늦은 판정을
- * 내렸다면 그것이 PR 의 현재 상태이고, 더 오래된 다른 팀원의 변경요청을 다시 살리지 않는다.
- */
-export function latestDecision(reviews) {
-    const decisions = (reviews ?? [])
-        .filter((review) => review?.state === "APPROVED" || review?.state === "CHANGES_REQUESTED")
-        .filter((review) => review?.authorCanPushToRepository === true)
-        .filter((review) => typeof review.submittedAt === "string")
-        .sort((a, b) => (a.submittedAt < b.submittedAt ? -1 : a.submittedAt > b.submittedAt ? 1 : 0));
-
-    return decisions.length > 0 ? decisions[decisions.length - 1] : null;
-}
-
-/**
- * `last: 50` 이 판정에 필요한 범위를 덮는지 본다.
- *
- * 판정은 최신 결정 시각 이후 항목만 세므로, 가져온 것 중 가장 오래된 항목이 그 시각보다 앞서면
- * 그 이후는 전부 들어와 있다. `reviews` 는 그 시각 자체를 구하는 근거라 여기서 제외한다.
- */
-export function isCoveredSinceDecision(connectionName, nodes, since) {
-    const readTimestamp = ACTIVITY_TIMESTAMP_BY_CONNECTION[connectionName];
-    if (!readTimestamp) {
-        return false;
-    }
-    // 최신 결정이 없거나 변경요청이 아니면 judgeAwaitingAuthor 가 이 connection 을 읽지 않는다.
-    if (since === null || since === undefined) {
-        return true;
-    }
-    if (!Array.isArray(nodes) || nodes.length === 0) {
-        return false;
-    }
-    const oldest = readTimestamp(nodes[0]);
-    return typeof oldest === "string" && oldest <= since;
-}
-
-/**
- * 판정 시각 이후 작성자가 올린 «실질» 커밋 수를 센다.
- *
- * 병합 커밋은 빼고(base 를 끌어온 변경이 반영분과 구별되지 않는다), 바뀐 파일이 0건인 커밋도
- * 뺀다. 누가 올렸는지를 보지 않으면 리뷰어가 미는 CI 재트리거 빈 커밋이 «작성자가 반영했다» 가
- * 되어 가짜 판정이 된다 — 8/28 에 그 한 건으로 PR 3건이 빚으로 잡혔다 (#1459).
- *
- * 계정이 연결되지 않은 커밋은 login 이 비어 가릴 수 없다. 같은 PR 에서 작성자 것으로 확인된
- * 커밋의 이메일을 폴백 신원으로 쓴다.
- *
- * 변경 파일 수를 알 수 없으면(`changedFilesIfAvailable` 가 null) 반영으로 센다. 조회 공백을
- * «빈 커밋» 으로 접으면 라벨이 없는 근거로 둔갑한다 — 놓치는 쪽이 잘못 붙이는 쪽보다 안전하다.
- */
-export function countAuthorFixes({ commits, author, since }) {
-    const owners = toOwners(author);
-    const nodes = (commits ?? []).map((node) => node?.commit).filter(Boolean);
-
-    const ownEmails = new Set();
-    for (const commit of nodes) {
-        if (isOneOf(commit.author?.user?.login, owners) && commit.author?.email) {
-            ownEmails.add(commit.author.email.toLowerCase());
-        }
-    }
-
-    let fixes = 0;
-    for (const commit of nodes) {
-        if ((commit.parents?.totalCount ?? 0) >= 2) {
-            continue;
-        }
-        if (!(typeof commit.committedDate === "string" && commit.committedDate > since)) {
-            continue;
-        }
-
-        const login = commit.author?.user?.login;
-        const email = commit.author?.email?.toLowerCase();
-        const isAuthor = login ? isOneOf(login, owners) : Boolean(email && ownEmails.has(email));
-        if (!isAuthor) {
-            continue;
-        }
-
-        const changed = commit.changedFilesIfAvailable;
-        if (changed === 0) {
-            continue;
-        }
-        fixes += 1;
-    }
-
-    return fixes;
-}
-
-/**
- * 판정 시각 이후 작성자가 남긴 응답 수를 센다.
- *
- * 커밋만 세면 base 를 merge 로 끌어와 반영한 PR 이 «무조치» 가 된다 — #1316 은 리뷰가 지목한
- * 파일이 실제로 바뀌고 응답 코멘트도 2건 달린 채 빚에서 빠져 있었다 (#1450).
- *
- * 라인 코멘트는 따로 조회하지 않는다. 작성자가 라인 코멘트를 남기면 그 코멘트를 담은 리뷰가
- * 함께 제출되므로 `reviews` 에서 잡힌다. PR 본문 편집은 별도 이력이므로 아래
- * `countAuthorBodyEdits` 에서 센다.
- */
-export function countAuthorResponses({ comments, reviews, author, since }) {
-    const owners = toOwners(author);
-    const issueComments = (comments ?? []).filter(
-        (comment) =>
-            isOneOf(comment?.author?.login, owners) &&
-            typeof comment?.createdAt === "string" &&
-            comment.createdAt > since,
-    ).length;
-
-    const authorReviews = (reviews ?? []).filter(
-        (review) =>
-            isOneOf(review?.author?.login, owners) &&
-            typeof review?.submittedAt === "string" &&
-            review.submittedAt > since,
-    ).length;
-
-    return issueComments + authorReviews;
-}
-
-/**
- * 판정 시각 이후 PR 작성자가 직접 고친 본문 편집 수를 센다.
- *
- * PR 본문의 CI Test Plan 같이 커밋 밖에 있는 리뷰 지적은 본문 편집만으로 반영될 수 있다.
- * `updatedAt` 은 라벨·리뷰어 등 다른 메타데이터 변경도 섞이므로 쓰지 않고, GitHub 가 남기는
- * `userContentEdits` 의 실제 편집자와 시각만 본다. 리뷰어의 대리 편집이나 편집자 정보가 사라진
- * 기록은 작성자 조치로 추정하지 않는다.
- */
-export function countAuthorBodyEdits({ userContentEdits, author, since }) {
-    const owners = toOwners(author);
-    return (userContentEdits ?? []).filter(
-        (edit) =>
-            isOneOf(edit?.editor?.login, owners) &&
-            typeof edit?.editedAt === "string" &&
-            edit.editedAt > since,
-    ).length;
-}
-
-/**
- * PR 한 건이 «변경요청 뒤 작성자 무조치» 인지 판정한다.
- *
- * 제외 축은 가드와 같다. draft 는 리뷰를 받을 상태가 아니고, 봇 PR 은 사람이 반영할 주체가
- * 없으며, fork PR 은 팀 리뷰 적체와 무관하다.
- */
-export function judgeAwaitingAuthor(pullRequest, { repository } = {}) {
-    const author = pullRequest?.author?.login ?? "";
-    // 조치 주체는 담당자다. 어사인이 비어 있으면 작성자로 폴백한다.
-    const owners = responsibleLogins(pullRequest);
-
-    if (pullRequest?.isDraft) {
-        return { awaiting: false, reason: "draft" };
-    }
-    if (!author || owners.length === 0) {
-        return { awaiting: false, reason: "작성자 없음" };
-    }
-    if (/\[bot\]$/i.test(author) || author === "dependabot" || author === "github-actions") {
-        return { awaiting: false, reason: "봇 PR" };
-    }
-
-    const headRepository = pullRequest?.headRepository?.nameWithOwner;
-    if (repository && headRepository && headRepository !== repository) {
-        return { awaiting: false, reason: `fork PR(${headRepository})` };
-    }
-
-    const decision = latestDecision(pullRequest?.reviews?.nodes);
-    if (!decision) {
-        return { awaiting: false, reason: "결정 리뷰 없음" };
-    }
-    if (decision.state !== "CHANGES_REQUESTED") {
-        return { awaiting: false, reason: "최신 판정이 변경요청이 아님" };
-    }
-
-    const since = decision.submittedAt;
-    const fixes = countAuthorFixes({
-        commits: pullRequest?.commits?.nodes,
-        author: owners,
-        since,
-    });
-    const responses = countAuthorResponses({
-        comments: pullRequest?.comments?.nodes,
-        reviews: pullRequest?.reviews?.nodes,
-        author: owners,
-        since,
-    });
-    const bodyEdits = countAuthorBodyEdits({
-        userContentEdits: pullRequest?.userContentEdits?.nodes,
-        author: owners,
-        since,
-    });
-
-    if (fixes > 0 || responses > 0 || bodyEdits > 0) {
-        return {
-            awaiting: false,
-            reason: `담당자 조치 있음(${fixes}커밋 · 응답 ${responses}건 · 본문 편집 ${bodyEdits}건)`,
-            decidedAt: since,
-            owners,
-        };
-    }
-
-    return {
-        awaiting: true,
-        reason: "변경요청 뒤 담당자 조치 없음",
-        decidedAt: since,
-        reviewer: decision.author?.login ?? "",
-        owners,
-    };
-}
-
-/**
- * 새 PR 작성자가 먼저 처리해야 할 다른 열린 PR 을 고른다.
- *
- * 열린 PR 목록은 호출자가 한 번 live 조회해 넘긴다. 현재 PR 은 이벤트 직후 그 목록에 이미
- * 포함되므로 번호로 명시적으로 제외한다. «자기 PR» 은 작성자가 아니라 담당자(어사인, 비어
- * 있으면 작성자)로 가른다. login 은 GitHub 의 대소문자 비구분 규약에 맞춰 비교하고, 실제
- * 무조치 여부는 라벨이 아니라 `judgeAwaitingAuthor` 로 매번 다시 판정한다.
- */
-export function findAuthorDebts({ pullRequests, repository, author, currentPullRequestNumber }) {
-    if (!Array.isArray(pullRequests)) {
-        throw new TypeError("pullRequests 배열이 필요합니다.");
-    }
-    if (typeof author !== "string" || author.trim() === "") {
-        throw new TypeError("author 가 필요합니다.");
-    }
-
-    const currentNumber = Number(currentPullRequestNumber);
-    if (!Number.isSafeInteger(currentNumber) || currentNumber <= 0) {
-        throw new TypeError("currentPullRequestNumber 는 양의 정수여야 합니다.");
-    }
-
-    const debts = [];
-    for (const pullRequest of pullRequests) {
-        if (Number(pullRequest?.number) === currentNumber) {
-            continue;
-        }
-        // 빚의 주인은 담당자다. 남이 올렸어도 내가 어사인된 PR 이면 내 빚이고, 내가 올렸어도
-        // 남에게 어사인된 PR 이면 내 빚이 아니다.
-        if (!isOneOf(author, responsibleLogins(pullRequest))) {
-            continue;
-        }
-
-        const verdict = judgeAwaitingAuthor(pullRequest, { repository });
-        if (!verdict.awaiting) {
-            continue;
-        }
-
-        debts.push({
-            number: pullRequest.number,
-            createdDate:
-                typeof pullRequest.createdAt === "string" ? pullRequest.createdAt.slice(0, 10) : "",
-            reviewer: verdict.reviewer ?? "",
-            title: pullRequest.title ?? "",
-        });
-    }
-
-    return debts;
-}
-
-/**
- * 라벨을 붙일 PR 과 뗄 PR 을 한 번에 계산한다.
- *
- * 매 실행이 현재 집합을 다시 세우고 차이만 쓴다. 조치가 들어오면 다음 실행에서 라벨이 떨어지므로
- * 스테일 라벨이 남지 않는다.
- */
-export function planAwaitingAuthorLabels({ pullRequests, repository, label = DEFAULT_LABEL, exemptAuthors = [] }) {
-    const toLabel = [];
-    const toUnlabel = [];
-    const unchanged = [];
-
-    for (const pullRequest of pullRequests ?? []) {
-        const labels = (pullRequest?.labels?.nodes ?? []).map((node) => node?.name);
-        const labeled = labels.includes(label);
-        // 면제는 담당자 기준이다. 담당자 전원이 면제 목록에 있을 때만 뺀다 — 면제자와 비면제자가
-        // 함께 어사인된 PR 은 비면제자의 몫이 남아 있다.
-        const owners = responsibleLogins(pullRequest);
-        const exempt = owners.length > 0 && owners.every((login) => isOneOf(login, exemptAuthors));
-        const verdict = exempt
-            ? { awaiting: false, reason: "리뷰 게이트 면제 작성자" }
-            : judgeAwaitingAuthor(pullRequest, { repository });
-        const entry = {
-            number: pullRequest.number,
-            title: pullRequest.title,
-            author: owners.join(","),
-            reason: verdict.reason,
-            decidedAt: verdict.decidedAt,
-            reviewer: verdict.reviewer,
-        };
-
-        if (verdict.awaiting && !labeled) {
-            toLabel.push(entry);
-        } else if (!verdict.awaiting && labeled) {
-            toUnlabel.push(entry);
-        } else {
-            unchanged.push({ ...entry, labeled });
-        }
-    }
-
-    return { toLabel, toUnlabel, unchanged };
-}
-
-export function renderSummary({ plan, dryRun, label = DEFAULT_LABEL }) {
-    const lines = [`## \`${label}\` 리컨사일`];
-    if (dryRun) {
-        lines.push("", "> DRY_RUN — 라벨을 쓰지 않고 계획만 출력합니다.");
-    }
-
-    lines.push("", `- 붙임 ${plan.toLabel.length}건 · 뗌 ${plan.toUnlabel.length}건`);
-
-    if (plan.toLabel.length > 0) {
-        lines.push("", "| PR | 담당자 | 변경요청 | 리뷰어 |", "|---|---|---|---|");
-        for (const entry of plan.toLabel) {
-            lines.push(
-                `| #${entry.number} | @${entry.author} | ${entry.decidedAt?.slice(0, 10) ?? "-"} | @${entry.reviewer || "-"} |`,
-            );
-        }
-    }
-
-    if (plan.toUnlabel.length > 0) {
-        lines.push("", "**뗀 PR**", "");
-        for (const entry of plan.toUnlabel) {
-            lines.push(`- #${entry.number} — ${entry.reason}`);
-        }
-    }
-
-    return lines.join("\n");
-}
-
-export function createApi(token, { fetchImpl = globalThis.fetch } = {}) {
-    if (typeof fetchImpl !== "function") {
-        throw new TypeError("fetch 구현이 필요합니다.");
-    }
-
-    return async function api(apiPath, { method = "GET", body, allowNotFound = false } = {}) {
-        const response = await fetchImpl(`https://api.github.com${apiPath}`, {
-            method,
-            headers: {
-                accept: "application/vnd.github+json",
-                authorization: `Bearer ${token}`,
-                "content-type": "application/json",
-                "x-github-api-version": "2022-11-28",
-            },
-            body: body === undefined ? undefined : JSON.stringify(body),
-        });
-
-        if (allowNotFound && response.status === 404) {
-            return null;
-        }
-        if (!response.ok) {
-            const detail = await response.text();
-            throw new Error(`GitHub API ${method} ${apiPath} 실패: ${response.status} ${detail}`);
-        }
-        if (response.status === 204) {
-            return null;
-        }
-        return response.json();
-    };
-}
-
-async function graphql(api, query, variables) {
-    const payload = await api("/graphql", { method: "POST", body: { query, variables } });
-    if (payload?.errors?.length) {
-        throw new Error(`GraphQL 실패: ${JSON.stringify(payload.errors)}`);
-    }
-    return payload.data;
-}
-
-export async function fetchOpenPullRequests(api, repository) {
-    const [owner, name] = repository.split("/");
-    if (!owner || !name || repository.split("/").length !== 2) {
-        throw new TypeError("repository 는 owner/name 형식이어야 합니다.");
-    }
-
-    const pullRequests = [];
-    let cursor = null;
-
-    for (;;) {
-        const data = await graphql(api, OPEN_PULL_REQUESTS_QUERY, {
-            owner,
-            name,
-            cursor,
-            pageSize: PULL_REQUEST_PAGE_SIZE,
-        });
-        const page = data?.repository?.pullRequests;
-        if (!page) {
-            throw new Error("GraphQL 응답에 열린 PR 목록이 없습니다.");
-        }
-        if (!Array.isArray(page.nodes)) {
-            throw new Error("GraphQL 열린 PR nodes 가 배열이 아닙니다.");
-        }
-        pullRequests.push(...(page.nodes ?? []).filter(Boolean));
-        if (!page.pageInfo?.hasNextPage) {
-            break;
-        }
-        cursor = page.pageInfo.endCursor;
-        if (!cursor) {
-            throw new Error("GraphQL 다음 페이지 cursor 가 없습니다.");
-        }
-    }
-
-    return pullRequests;
-}
-
-/**
- * 입장 게이트용으로 한 사람이 담당하는 열린 PR 만 조회한다.
- *
- * 라벨 리컨사일러는 전체 열린 PR 이 필요하지만, 새 PR 입장마다 그 전체의 하위 리뷰·커밋·
- * 코멘트를 다시 읽을 필요는 없다. GitHub search 로 서버에서 먼저 제한한다. 담당은 어사인이
- * 정본이고 어사인이 비면 작성자이므로 `assignee:` 와 `author:` 두 검색을 합친다. 남에게
- * 어사인된 자기 작성 PR 은 `findAuthorDebts` 가 담당자 기준으로 걸러낸다.
- */
-export async function fetchOpenPullRequestsByAuthor(api, repository, author) {
-    const [owner, name] = repository.split("/");
-    if (!owner || !name || repository.split("/").length !== 2) {
-        throw new TypeError("repository 는 owner/name 형식이어야 합니다.");
-    }
-    if (typeof author !== "string" || author.trim() === "") {
-        throw new TypeError("author 가 필요합니다.");
-    }
-
-    const pullRequests = [];
-    const seen = new Set();
-
-    for (const qualifier of ["assignee", "author"]) {
-    let cursor = null;
-
-    for (;;) {
-        const data = await graphql(api, OPEN_PULL_REQUESTS_BY_AUTHOR_QUERY, {
-            searchQuery: `repo:${owner}/${name} is:pr is:open ${qualifier}:${author}`,
-            cursor,
-            pageSize: PULL_REQUEST_PAGE_SIZE,
-        });
-        const page = data?.search;
-        if (!page) {
-            throw new Error("GraphQL 응답에 작성자의 열린 PR 검색 결과가 없습니다.");
-        }
-        if (!Array.isArray(page.nodes)) {
-            throw new Error("GraphQL 작성자 PR nodes 가 배열이 아닙니다.");
-        }
-
-        for (const pullRequest of page.nodes) {
-            if (!pullRequest || !Number.isSafeInteger(pullRequest.number)) {
-                throw new Error("GraphQL 작성자 PR 검색 결과가 불완전합니다.");
-            }
-            if (seen.has(pullRequest.number)) {
-                continue;
-            }
-            seen.add(pullRequest.number);
-
-            // `last: 50` 앞에 더 많은 항목이 있으면 최신 결정 시각 이후의 작성자 이메일·응답·
-            // 본문 편집을 완전하게 판정할 수 없다. 라벨은 다음 리컨사일에서 복구할 수 있지만,
-            // 입장 가드가 불완전한 근거로 PR 을 닫는 것은 되돌리기 비용이 있으므로 판정 자체를
-            // 중단한다.
-            //
-            // 다만 완전성의 기준은 «전체 이력» 이 아니라 «판정이 실제로 읽는 범위» 다. 세 판정
-            // 함수는 모두 최신 결정 시각(since) 이후 항목만 세고, judgeAwaitingAuthor 는 최신
-            // 결정이 없거나 변경요청이 아니면 그 셋을 아예 부르지 않는다. `last: 50` 은 최신
-            // 50건이므로 가져온 것 중 가장 오래된 항목이 since 보다 앞서면 since 이후는 전부
-            // 확보한 것이고 판정은 완전하다 — 커밋이 몇백 건이든 상관없다. 이 구분이 없어서
-            // 커밋 403건짜리 릴리스 PR(develop → main) 하나가 그 작성자의 새 PR 을 전부 막았다
-            // (#1787). reviews 는 since 를 구하는 근거라 시각으로 대체 판정할 수 없어 그대로 둔다.
-            const decision = latestDecision(pullRequest.reviews?.nodes);
-            const since = decision?.state === "CHANGES_REQUESTED" ? decision.submittedAt : null;
-            for (const connectionName of ["reviews", "commits", "comments", "userContentEdits"]) {
-                const connection = pullRequest[connectionName];
-                if (!connection || !Array.isArray(connection.nodes)) {
-                    throw new Error(`GraphQL 작성자 PR ${connectionName} 응답이 불완전합니다.`);
-                }
-                if (connection.pageInfo?.hasPreviousPage === false) {
-                    continue;
-                }
-                if (isCoveredSinceDecision(connectionName, connection.nodes, since)) {
-                    continue;
-                }
-                throw new Error(
-                    `GraphQL 작성자 PR ${connectionName} 최근 50건이 완전하지 않습니다.`,
-                );
-            }
-            pullRequests.push(pullRequest);
-        }
-
-        if (!page.pageInfo?.hasNextPage) {
-            break;
-        }
-        cursor = page.pageInfo.endCursor;
-        if (!cursor) {
-            throw new Error("GraphQL 작성자 PR 다음 페이지 cursor 가 없습니다.");
-        }
-    }
-    }
-
-    return pullRequests;
-}
-
-export async function ensureLabelExists(api, repository, label = DEFAULT_LABEL) {
-    const existing = await api(`/repos/${repository}/labels/${encodeURIComponent(label)}`, {
-        allowNotFound: true,
-    });
-    if (existing) {
-        return;
-    }
-    await api(`/repos/${repository}/labels`, {
-        method: "POST",
-        body: { name: label, color: LABEL_COLOR, description: LABEL_DESCRIPTION },
-    });
-}
-
-export async function applyPlan(api, repository, plan, { dryRun = false, label = DEFAULT_LABEL, logger = console } = {}) {
-    const failures = [];
-
-    for (const entry of plan.toLabel) {
-        if (dryRun) {
-            logger.log(`(dry-run) #${entry.number} ${label} 부착`);
-            continue;
-        }
-        try {
-            await api(`/repos/${repository}/issues/${entry.number}/labels`, {
-                method: "POST",
-                body: { labels: [label] },
-            });
-            logger.log(`#${entry.number} ${label} 부착 — ${entry.reason}`);
-        } catch (error) {
-            failures.push(`#${entry.number} 라벨 부착 실패: ${error.message}`);
-        }
-    }
-
-    for (const entry of plan.toUnlabel) {
-        if (dryRun) {
-            logger.log(`(dry-run) #${entry.number} ${label} 제거`);
-            continue;
-        }
-        try {
-            await api(
-                `/repos/${repository}/issues/${entry.number}/labels/${encodeURIComponent(label)}`,
-                { method: "DELETE", allowNotFound: true },
-            );
-            logger.log(`#${entry.number} ${label} 제거 — ${entry.reason}`);
-        } catch (error) {
-            failures.push(`#${entry.number} 라벨 제거 실패: ${error.message}`);
-        }
-    }
-
-    return failures;
-}
-
-/** 가드의 한 줄 환경변수 선언을 읽는다. 형식이 달라지면 빈 면제 목록으로 숨기지 않는다. */
-export function parseReviewGateExemptAuthors(workflow) {
-    const lines = workflow.split(/\r?\n/);
-    const declarations = lines.flatMap((line, index) => {
-        const match = /^([ \t]+)REVIEW_GATE_EXEMPT_AUTHORS:[ \t]*(.*)$/.exec(line);
-        return match ? [{ index, indent: match[1].length, value: match[2].trim() }] : [];
-    });
-    if (declarations.length !== 1) {
-        throw new Error("REVIEW_GATE_EXEMPT_AUTHORS 선언이 정확히 한 개 필요합니다.");
-    }
-    const { index, indent, value } = declarations[0];
-    const nextLine = lines.slice(index + 1).find((line) => line.trim() && !line.trimStart().startsWith("#"));
-    const continued = nextLine && /^[ \t]*/.exec(nextLine)[0].length > indent;
-    if (continued || !/^[a-zA-Z0-9-]+(?:[ \t]+[a-zA-Z0-9-]+)*$/.test(value)) {
-        throw new Error("REVIEW_GATE_EXEMPT_AUTHORS는 인용·주석 없는 한 줄의 공백 구분 로그인 목록이어야 합니다.");
-    }
-    return value.split(/\s+/).map((login) => login.toLowerCase());
-}
-
-async function main() {
-    const token = process.env.GITHUB_TOKEN;
-    const repository = process.env.GITHUB_REPOSITORY;
-    if (!token || !repository) {
-        throw new Error("GITHUB_TOKEN·GITHUB_REPOSITORY 가 필요합니다.");
-    }
-
-    const label = process.env.AWAITING_AUTHOR_LABEL ?? DEFAULT_LABEL;
-    const dryRun = process.env.DRY_RUN === "true";
-    const api = createApi(token);
-
-    // 전체 checkout을 쓰는 라벨 CLI에서만 읽는다. 가드의 scripts-only checkout에서도
-    // 상태 판정 함수를 import할 수 있어야 한다. 면제 목록의 정본은 기존 가드 선언이다.
-    const exemptAuthors = parseReviewGateExemptAuthors(
-        await readFile(new URL("../workflows/review-debt-guard.yml", import.meta.url), "utf8"),
-    );
-    const pullRequests = await fetchOpenPullRequests(api, repository);
-    const plan = planAwaitingAuthorLabels({ pullRequests, repository, label, exemptAuthors });
-
-    if (!dryRun && plan.toLabel.length > 0) {
-        await ensureLabelExists(api, repository, label);
-    }
-
-    const failures = await applyPlan(api, repository, plan, { dryRun, label });
-    const summary = renderSummary({ plan, dryRun, label });
-    console.log(summary);
-
-    if (process.env.GITHUB_STEP_SUMMARY) {
-        const { appendFile } = await import("node:fs/promises");
-        await appendFile(process.env.GITHUB_STEP_SUMMARY, `${summary}\n`);
-    }
-
-    if (failures.length > 0) {
-        throw new Error(failures.join("\n"));
-    }
-}
-
-const invokedPath = process.argv[1] ? pathToFileURL(path.resolve(process.argv[1])).href : "";
-if (import.meta.url === invokedPath) {
-    main().catch((error) => {
-        console.error(error.message);
-        process.exitCode = 1;
-    });
-}
diff --git a/.github/scripts/label-awaiting-author-prs.test.mjs b/.github/scripts/label-awaiting-author-prs.test.mjs
deleted file mode 100644
index 10b4e9b437..0000000000
--- a/.github/scripts/label-awaiting-author-prs.test.mjs
+++ /dev/null
@@ -1,939 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import {
-    applyPlan,
-    countAuthorBodyEdits,
-    countAuthorFixes,
-    countAuthorResponses,
-    DEFAULT_LABEL,
-    ensureLabelExists,
-    fetchOpenPullRequests,
-    fetchOpenPullRequestsByAuthor,
-    findAuthorDebts,
-    judgeAwaitingAuthor,
-    latestDecision,
-    parseReviewGateExemptAuthors,
-    planAwaitingAuthorLabels,
-    renderSummary,
-    responsibleLogins,
-} from "./label-awaiting-author-prs.mjs";
-
-const REPO = "Afternote/Afternote-FE";
-
-/** 테스트 출력이 CI 로그에서 실제 조작처럼 보이지 않도록 삼킨다. */
-const silent = { log() {} };
-
-test("게이트 면제 목록은 공백을 나누고 로그인 대소문자를 정규화한다", () => {
-    const workflow = [
-        "jobs:",
-        "  check:",
-        "    env:",
-        "      REPO: Afternote/Afternote-FE",
-        "      REVIEW_GATE_EXEMPT_AUTHORS:   KoOnGmAi   Example-User  ",
-        "    run: echo check",
-    ].join("\r\n");
-
-    assert.deepEqual(parseReviewGateExemptAuthors(workflow), ["koongmai", "example-user"]);
-});
-
-test("게이트 면제 목록이 없거나 두 번 선언되면 빈 목록으로 넘기지 않는다", () => {
-    for (const workflow of [
-        "env:\n  REPO: Afternote/Afternote-FE\n",
-        "# REVIEW_GATE_EXEMPT_AUTHORS: koongmai\n",
-        "env:\n  REVIEW_GATE_EXEMPT_AUTHORS: koongmai\n  REVIEW_GATE_EXEMPT_AUTHORS: other\n",
-    ]) {
-        assert.throws(() => parseReviewGateExemptAuthors(workflow), undefined, workflow);
-    }
-});
-
-test("게이트 면제 목록은 따옴표·주석·배열·여러 줄과 잘못된 로그인 형식을 거부한다", () => {
-    for (const value of [
-        "",
-        '"koongmai"',
-        "'koongmai'",
-        "koongmai # comment",
-        "[koongmai]",
-        "|\n    koongmai",
-        ">\n    koongmai",
-        "\n    koongmai",
-        "koongmai\n    other",
-        "koongmai,other",
-        "invalid_login",
-    ]) {
-        const workflow = `env:\n  REVIEW_GATE_EXEMPT_AUTHORS: ${value}\n`;
-        assert.throws(() => parseReviewGateExemptAuthors(workflow), undefined, value);
-    }
-});
-
-function fakeApi({ responses = {}, failOn = null } = {}) {
-    const calls = [];
-    const api = async (apiPath, options = {}) => {
-        calls.push({ apiPath, method: options.method ?? "GET", body: options.body });
-        if (failOn && failOn(apiPath, options)) {
-            throw new Error("boom");
-        }
-        for (const [pattern, value] of Object.entries(responses)) {
-            if (apiPath.startsWith(pattern)) {
-                return typeof value === "function" ? value(apiPath, options) : value;
-            }
-        }
-        return options.allowNotFound ? null : {};
-    };
-    api.calls = calls;
-    return api;
-}
-
-function commit({ login = "author", email = "author@example.com", date = "2026-08-30T00:00:00Z", changed = 3, parents = 1 } = {}) {
-    return {
-        commit: {
-            committedDate: date,
-            changedFilesIfAvailable: changed,
-            parents: { totalCount: parents },
-            author: { email, user: login === null ? null : { login } },
-        },
-    };
-}
-
-function pullRequest(overrides = {}) {
-    return {
-        number: 1,
-        title: "fix(core): 무언가",
-        isDraft: false,
-        createdAt: "2026-08-01T00:00:00Z",
-        author: { login: "author" },
-        headRepository: { nameWithOwner: REPO },
-        labels: { nodes: [] },
-        reviews: { pageInfo: { hasPreviousPage: false }, nodes: [] },
-        commits: { pageInfo: { hasPreviousPage: false }, nodes: [] },
-        comments: { pageInfo: { hasPreviousPage: false }, nodes: [] },
-        userContentEdits: { pageInfo: { hasPreviousPage: false }, nodes: [] },
-        ...overrides,
-    };
-}
-
-function changesRequested(
-    at = "2026-08-29T00:00:00Z",
-    reviewer = "reviewer",
-    authorCanPushToRepository = true,
-) {
-    return {
-        state: "CHANGES_REQUESTED",
-        submittedAt: at,
-        authorCanPushToRepository,
-        author: { login: reviewer },
-    };
-}
-
-test("최신 결정 리뷰는 리뷰어별로 묶지 않고 PR 전체에서 하나만 고른다", () => {
-    // 팀에서 한 사람이 더 늦은 판정을 내리면 그것이 PR 의 현재 상태다. 더 오래된 다른
-    // 리뷰어의 변경요청을 다시 살리면 승인된 PR 에까지 라벨이 붙는다.
-    const decision = latestDecision([
-        {
-            state: "CHANGES_REQUESTED",
-            submittedAt: "2026-08-01T00:00:00Z",
-            authorCanPushToRepository: true,
-            author: { login: "a" },
-        },
-        {
-            state: "APPROVED",
-            submittedAt: "2026-08-05T00:00:00Z",
-            authorCanPushToRepository: true,
-            author: { login: "b" },
-        },
-    ]);
-    assert.equal(decision.state, "APPROVED");
-
-    // COMMENTED 는 판정이 아니다.
-    const onlyComments = latestDecision([
-        { state: "COMMENTED", submittedAt: "2026-08-09T00:00:00Z", author: { login: "a" } },
-    ]);
-    assert.equal(onlyComments, null);
-});
-
-test("변경요청 뒤 작성자가 아무것도 하지 않으면 대상이다", () => {
-    const verdict = judgeAwaitingAuthor(
-        pullRequest({ reviews: { nodes: [changesRequested()] } }),
-        { repository: REPO },
-    );
-    assert.equal(verdict.awaiting, true);
-    assert.equal(verdict.reviewer, "reviewer");
-    assert.equal(verdict.decidedAt, "2026-08-29T00:00:00Z");
-});
-
-test("리뷰 게이트 면제 작성자는 대소문자와 무관하게 무조치 라벨 대상에서 빠진다", () => {
-    for (const login of ["koongmai", "KoOnGmAi"]) {
-        const plan = planAwaitingAuthorLabels({
-            repository: REPO,
-            exemptAuthors: ["koongmai"],
-            pullRequests: [pullRequest({
-                author: { login },
-                reviews: { nodes: [changesRequested()] },
-            })],
-        });
-
-        assert.deepEqual(plan.toLabel, [], login);
-        assert.equal(plan.unchanged[0].reason, "리뷰 게이트 면제 작성자");
-    }
-});
-
-test("면제 계정과 일부만 같은 작성자는 여전히 무조치 라벨 대상이다", () => {
-    const plan = planAwaitingAuthorLabels({
-        repository: REPO,
-        exemptAuthors: ["koongmai"],
-        pullRequests: [pullRequest({
-            author: { login: "koongmai-other" },
-            reviews: { nodes: [changesRequested()] },
-        })],
-    });
-
-    assert.deepEqual(plan.toLabel.map((entry) => entry.number), [1]);
-});
-
-test("변경요청 리뷰어가 면제 계정이어도 다른 작성자의 무조치 라벨은 유지한다", () => {
-    const plan = planAwaitingAuthorLabels({
-        repository: REPO,
-        exemptAuthors: ["koongmai"],
-        pullRequests: [pullRequest({
-            reviews: { nodes: [changesRequested("2026-08-29T00:00:00Z", "koongmai")] },
-        })],
-    });
-
-    assert.deepEqual(plan.toLabel.map((entry) => entry.number), [1]);
-    assert.equal(plan.toLabel[0].reviewer, "koongmai");
-});
-
-test("쓰기 권한이 없는 외부인의 변경요청은 작성자 빚을 만들지 못한다", () => {
-    const verdict = judgeAwaitingAuthor(
-        pullRequest({
-            reviews: {
-                nodes: [changesRequested("2026-08-29T00:00:00Z", "outsider", false)],
-            },
-        }),
-        { repository: REPO },
-    );
-
-    assert.equal(verdict.awaiting, false);
-    assert.equal(verdict.reason, "결정 리뷰 없음");
-});
-
-test("쓰기 권한이 없는 외부인의 승인은 팀 변경요청을 지우지 못한다", () => {
-    const verdict = judgeAwaitingAuthor(
-        pullRequest({
-            reviews: {
-                nodes: [
-                    changesRequested("2026-08-28T00:00:00Z", "team-reviewer"),
-                    {
-                        state: "APPROVED",
-                        submittedAt: "2026-08-29T00:00:00Z",
-                        authorCanPushToRepository: false,
-                        author: { login: "outsider" },
-                    },
-                ],
-            },
-        }),
-        { repository: REPO },
-    );
-
-    assert.equal(verdict.awaiting, true);
-    assert.equal(verdict.reviewer, "team-reviewer");
-    assert.equal(verdict.decidedAt, "2026-08-28T00:00:00Z");
-});
-
-test("작성자 빚은 같은 작성자의 다른 열린 PR 중 현재 무조치인 것만 고른다", () => {
-    const debts = findAuthorDebts({
-        repository: REPO,
-        author: "AuThOr",
-        currentPullRequestNumber: "20",
-        pullRequests: [
-            // 현재 PR 자체는 아직 변경요청 상태여도 명시적으로 제외한다.
-            pullRequest({ number: 20, reviews: { nodes: [changesRequested()] } }),
-            // login 대소문자가 달라도 같은 작성자다.
-            pullRequest({
-                number: 21,
-                title: "fix(core): 기존 지적 반영",
-                author: { login: "AUTHOR" },
-                createdAt: "2026-08-17T10:00:00Z",
-                reviews: { nodes: [changesRequested("2026-08-29T00:00:00Z", "reviewer-1")] },
-            }),
-            // 작성자가 이미 조치한 PR 은 입장 빚이 아니다.
-            pullRequest({
-                number: 22,
-                reviews: { nodes: [changesRequested()] },
-                commits: { nodes: [commit({ date: "2026-08-29T12:00:00Z" })] },
-            }),
-            // 다른 작성자의 무조치 PR 은 이 작성자를 막지 않는다.
-            pullRequest({
-                number: 23,
-                author: { login: "someone-else" },
-                reviews: { nodes: [changesRequested()] },
-            }),
-            // 남이 올렸어도 내게 어사인된 PR 은 내 빚이다(#1974).
-            pullRequest({
-                number: 24,
-                title: "fix(home): 인계받은 PR",
-                author: { login: "someone-else" },
-                assignees: { nodes: [{ login: "author" }] },
-                createdAt: "2026-08-18T10:00:00Z",
-                reviews: { nodes: [changesRequested("2026-08-29T00:00:00Z", "reviewer-2")] },
-            }),
-            // 내가 올렸어도 남에게 어사인된 PR 은 내 빚이 아니다.
-            pullRequest({
-                number: 25,
-                assignees: { nodes: [{ login: "someone-else" }] },
-                reviews: { nodes: [changesRequested()] },
-            }),
-        ],
-    });
-
-    assert.deepEqual(debts, [
-        {
-            number: 21,
-            createdDate: "2026-08-17",
-            reviewer: "reviewer-1",
-            title: "fix(core): 기존 지적 반영",
-        },
-        {
-            number: 24,
-            createdDate: "2026-08-18",
-            reviewer: "reviewer-2",
-            title: "fix(home): 인계받은 PR",
-        },
-    ]);
-});
-
-test("담당자는 어사인이고, 어사인이 비어 있을 때만 작성자다", () => {
-    assert.deepEqual(responsibleLogins(pullRequest()), ["author"]);
-    assert.deepEqual(
-        responsibleLogins(pullRequest({ assignees: { nodes: [{ login: "a" }, { login: "b" }] } })),
-        ["a", "b"],
-    );
-    assert.deepEqual(responsibleLogins(pullRequest({ assignees: { nodes: [] } })), ["author"]);
-});
-
-test("변경요청 뒤 조치는 작성자가 아니라 담당자의 것만 센다", () => {
-    const base = {
-        assignees: { nodes: [{ login: "Assignee" }] },
-        reviews: { nodes: [changesRequested()] },
-    };
-    // 작성자의 커밋·코멘트는 담당자가 따로 있으면 조치가 아니다.
-    const authorOnly = judgeAwaitingAuthor(
-        pullRequest({
-            ...base,
-            commits: { nodes: [commit({ date: "2026-08-29T12:00:00Z", login: "author" })] },
-            comments: { nodes: [{ createdAt: "2026-08-29T12:00:00Z", author: { login: "author" } }] },
-        }),
-        { repository: REPO },
-    );
-    assert.equal(authorOnly.awaiting, true);
-    assert.deepEqual(authorOnly.owners, ["Assignee"]);
-
-    // 담당자의 코멘트 하나면 풀린다. 대소문자는 가리지 않는다.
-    const assigneeAnswered = judgeAwaitingAuthor(
-        pullRequest({
-            ...base,
-            comments: { nodes: [{ createdAt: "2026-08-29T12:00:00Z", author: { login: "assignee" } }] },
-        }),
-        { repository: REPO },
-    );
-    assert.equal(assigneeAnswered.awaiting, false);
-});
-
-test("면제는 담당자 전원이 면제일 때만 적용된다", () => {
-    const plan = planAwaitingAuthorLabels({
-        repository: REPO,
-        exemptAuthors: ["exempt"],
-        pullRequests: [
-            // 면제 작성자가 올렸어도 비면제자에게 어사인됐으면 그 사람의 몫이다.
-            pullRequest({
-                number: 40,
-                author: { login: "exempt" },
-                assignees: { nodes: [{ login: "someone" }] },
-                reviews: { nodes: [changesRequested()] },
-            }),
-            // 비면제 작성자가 올렸어도 면제자에게 어사인됐으면 뺀다.
-            pullRequest({
-                number: 41,
-                assignees: { nodes: [{ login: "EXEMPT" }] },
-                reviews: { nodes: [changesRequested()] },
-            }),
-            // 면제자와 비면제자가 함께 어사인되면 비면제자의 몫이 남는다.
-            pullRequest({
-                number: 42,
-                assignees: { nodes: [{ login: "exempt" }, { login: "someone" }] },
-                reviews: { nodes: [changesRequested()] },
-            }),
-        ],
-    });
-    assert.deepEqual(plan.toLabel.map((entry) => entry.number), [40, 42]);
-    assert.equal(plan.unchanged.find((entry) => entry.number === 41)?.reason, "리뷰 게이트 면제 작성자");
-});
-
-test("작성자 빚 판정은 현재 PR 번호가 없거나 잘못되면 통과시키지 않는다", () => {
-    assert.throws(
-        () => findAuthorDebts({ pullRequests: [], repository: REPO, author: "author" }),
-        /양의 정수/,
-    );
-});
-
-test("입장 게이트 조회는 GraphQL search 로 어사인·작성자 두 축의 열린 PR 을 페이지 처리하고 합친다", async () => {
-    const calls = [];
-    const api = async (apiPath, options) => {
-        assert.equal(apiPath, "/graphql");
-        assert.match(options.body.query, /search\(query: \$searchQuery/);
-        const { searchQuery, cursor } = options.body.variables;
-        calls.push([searchQuery, cursor]);
-        const byAssignee = searchQuery.endsWith("assignee:AuThOr");
-        if (!byAssignee) {
-            assert.equal(searchQuery, "repo:Afternote/Afternote-FE is:pr is:open author:AuThOr");
-            // 작성자 검색은 어사인 검색과 겹치는 30 을 다시 내려 준다 — 한 번만 남아야 한다.
-            return {
-                data: {
-                    search: {
-                        pageInfo: { hasNextPage: false, endCursor: null },
-                        nodes: [pullRequest({ number: 30 }), pullRequest({ number: 32 })],
-                    },
-                },
-            };
-        }
-        assert.equal(searchQuery, "repo:Afternote/Afternote-FE is:pr is:open assignee:AuThOr");
-        return {
-            data: {
-                search: {
-                    pageInfo:
-                        cursor === null
-                            ? { hasNextPage: true, endCursor: "next" }
-                            : { hasNextPage: false, endCursor: null },
-                    nodes: [pullRequest({ number: cursor === null ? 30 : 31 })],
-                },
-            },
-        };
-    };
-
-    const pullRequests = await fetchOpenPullRequestsByAuthor(api, REPO, "AuThOr");
-
-    assert.deepEqual(calls, [
-        ["repo:Afternote/Afternote-FE is:pr is:open assignee:AuThOr", null],
-        ["repo:Afternote/Afternote-FE is:pr is:open assignee:AuThOr", "next"],
-        ["repo:Afternote/Afternote-FE is:pr is:open author:AuThOr", null],
-    ]);
-    assert.deepEqual(pullRequests.map((pullRequest) => pullRequest.number), [30, 31, 32]);
-});
-
-test("입장 게이트 조회는 불완전한 search 결과를 빈 목록으로 접지 않는다", async () => {
-    await assert.rejects(
-        fetchOpenPullRequestsByAuthor(
-            async () => ({ data: { search: { pageInfo: { hasNextPage: false }, nodes: [{}] } } }),
-            REPO,
-            "author",
-        ),
-        /검색 결과가 불완전합니다/,
-    );
-});
-
-test("두 GraphQL 조회는 결정 리뷰 권한과 하위 connection 절단 여부를 함께 요청한다", async () => {
-    const queries = [];
-    const api = async (_apiPath, options) => {
-        queries.push(options.body.query);
-        if (options.body.variables.searchQuery) {
-            return {
-                data: {
-                    search: {
-                        pageInfo: { hasNextPage: false, endCursor: null },
-                        nodes: [],
-                    },
-                },
-            };
-        }
-        return {
-            data: {
-                repository: {
-                    pullRequests: {
-                        pageInfo: { hasNextPage: false, endCursor: null },
-                        nodes: [],
-                    },
-                },
-            },
-        };
-    };
-
-    await fetchOpenPullRequests(api, REPO);
-    await fetchOpenPullRequestsByAuthor(api, REPO, "author");
-
-    // 전체 조회 1 + 입장 조회(assignee·author) 2
-    assert.equal(queries.length, 3);
-    for (const query of queries) {
-        assert.match(query, /authorCanPushToRepository/);
-        // 담당자 판정에 어사인이 필요하다.
-        assert.match(query, /assignees\(first: 10\) \{ nodes \{ login \} \}/);
-        for (const connection of ["reviews", "commits", "comments", "userContentEdits"]) {
-            assert.match(
-                query,
-                new RegExp(`${connection}\\(last: 50\\) \\{\\s+pageInfo \\{ hasPreviousPage \\}`),
-            );
-        }
-    }
-});
-
-test("입장 게이트 조회는 잘린·누락된 하위 connection으로 판정하지 않는다", async () => {
-    const cases = [
-        [
-            "reviews",
-            { pageInfo: { hasPreviousPage: true }, nodes: [changesRequested()] },
-            /reviews 최근 50건이 완전하지 않습니다/,
-        ],
-        ["commits", { pageInfo: {}, nodes: [] }, /commits 최근 50건이 완전하지 않습니다/],
-        ["comments", { pageInfo: { hasPreviousPage: false } }, /comments 응답이 불완전합니다/],
-        [
-            "userContentEdits",
-            { pageInfo: { hasPreviousPage: true }, nodes: [] },
-            /userContentEdits 최근 50건이 완전하지 않습니다/,
-        ],
-    ];
-
-    for (const [connection, value, expected] of cases) {
-        // 최신 판정이 변경요청이어야 판정이 이 connection 들을 실제로 읽는다. 그 상태에서만
-        // 「잘린 데이터로 판정하지 않는다」 가 의미를 갖는다.
-        const candidate = pullRequest({
-            number: 40,
-            reviews: { pageInfo: { hasPreviousPage: false }, nodes: [changesRequested()] },
-        });
-        candidate[connection] = value;
-
-        await assert.rejects(
-            fetchOpenPullRequestsByAuthor(
-                async () => ({
-                    data: {
-                        search: {
-                            pageInfo: { hasNextPage: false, endCursor: null },
-                            nodes: [candidate],
-                        },
-                    },
-                }),
-                REPO,
-                "author",
-            ),
-            expected,
-        );
-    }
-});
-
-test("판정이 읽지 않는 connection 은 잘려 있어도 입장을 막지 않는다", async () => {
-    // 릴리스 PR(develop → main)은 커밋이 수백 건이라 commits(last: 50) 이 항상 잘린다.
-    // 그런데 리뷰 판정이 없으면 judgeAwaitingAuthor 는 커밋을 읽지도 않는다. 이 구분이 없어
-    // 커밋 403건짜리 PR 하나가 그 작성자의 새 PR 을 전부 막았다 (#1787).
-    const releasePullRequest = pullRequest({
-        number: 1778,
-        reviews: { pageInfo: { hasPreviousPage: false }, nodes: [] },
-        commits: { pageInfo: { hasPreviousPage: true }, nodes: [] },
-    });
-
-    const fetched = await fetchOpenPullRequestsByAuthor(
-        async () => ({
-            data: {
-                search: {
-                    pageInfo: { hasNextPage: false, endCursor: null },
-                    nodes: [releasePullRequest],
-                },
-            },
-        }),
-        REPO,
-        "author",
-    );
-
-    assert.equal(fetched.length, 1);
-    assert.equal(fetched[0].number, 1778);
-});
-
-test("판정 시각 이후가 최근 50건 안에 다 들어오면 잘려 있어도 완전하다", async () => {
-    // last: 50 은 최신 50건이다. 가져온 것 중 가장 오래된 커밋이 판정 시각보다 앞서면
-    // 그 이후 커밋은 전부 확보한 것이므로 판정에 공백이 없다.
-    const candidate = pullRequest({
-        number: 41,
-        reviews: {
-            pageInfo: { hasPreviousPage: false },
-            nodes: [changesRequested("2026-08-29T00:00:00Z")],
-        },
-        commits: {
-            pageInfo: { hasPreviousPage: true },
-            nodes: [
-                { commit: { committedDate: "2026-08-28T00:00:00Z" } },
-                { commit: { committedDate: "2026-08-30T00:00:00Z" } },
-            ],
-        },
-    });
-
-    const fetched = await fetchOpenPullRequestsByAuthor(
-        async () => ({
-            data: {
-                search: {
-                    pageInfo: { hasNextPage: false, endCursor: null },
-                    nodes: [candidate],
-                },
-            },
-        }),
-        REPO,
-        "author",
-    );
-
-    assert.equal(fetched.length, 1);
-});
-
-test("판정 시각 이후가 최근 50건을 넘치면 여전히 중단한다", async () => {
-    // 가장 오래된 커밋조차 판정 시각 뒤라면 그 사이에 못 본 커밋이 있을 수 있다.
-    // 이때는 불완전한 근거로 PR 을 닫지 않도록 판정을 멈춘다.
-    const candidate = pullRequest({
-        number: 42,
-        reviews: {
-            pageInfo: { hasPreviousPage: false },
-            nodes: [changesRequested("2026-08-29T00:00:00Z")],
-        },
-        commits: {
-            pageInfo: { hasPreviousPage: true },
-            nodes: [
-                { commit: { committedDate: "2026-08-30T00:00:00Z" } },
-                { commit: { committedDate: "2026-08-31T00:00:00Z" } },
-            ],
-        },
-    });
-
-    await assert.rejects(
-        fetchOpenPullRequestsByAuthor(
-            async () => ({
-                data: {
-                    search: {
-                        pageInfo: { hasNextPage: false, endCursor: null },
-                        nodes: [candidate],
-                    },
-                },
-            }),
-            REPO,
-            "author",
-        ),
-        /commits 최근 50건이 완전하지 않습니다/,
-    );
-});
-
-test("최신 판정이 승인이면 대상이 아니다", () => {
-    // 승인 뒤 작성자가 손보는 것은 작성자 몫이지만, 그것은 «머지 가능한 상태» 이지
-    // «지적을 방치한 상태» 가 아니다.
-    const verdict = judgeAwaitingAuthor(
-        pullRequest({
-            reviews: {
-                nodes: [
-                    changesRequested("2026-08-01T00:00:00Z"),
-                    {
-                        state: "APPROVED",
-                        submittedAt: "2026-08-02T00:00:00Z",
-                        authorCanPushToRepository: true,
-                        author: { login: "reviewer" },
-                    },
-                ],
-            },
-            userContentEdits: {
-                nodes: [
-                    {
-                        editedAt: "2026-08-03T00:00:00Z",
-                        editor: { login: "author" },
-                    },
-                ],
-            },
-        }),
-        { repository: REPO },
-    );
-    assert.equal(verdict.awaiting, false);
-    assert.equal(verdict.reason, "최신 판정이 변경요청이 아님");
-});
-
-test("변경요청 뒤 작성자가 PR 본문을 고치면 조치로 센다", () => {
-    const verdict = judgeAwaitingAuthor(
-        pullRequest({
-            reviews: { nodes: [changesRequested("2026-08-29T00:00:00Z")] },
-            userContentEdits: {
-                nodes: [
-                    {
-                        editedAt: "2026-08-29T00:00:01Z",
-                        editor: { login: "AUTHOR" },
-                    },
-                ],
-            },
-        }),
-        { repository: REPO },
-    );
-
-    assert.equal(verdict.awaiting, false);
-    assert.match(verdict.reason, /본문 편집 1건/);
-});
-
-test("판정 전·다른 사람·편집자 없는 본문 편집은 작성자 조치가 아니다", () => {
-    const edits = [
-        { editedAt: "2026-08-28T23:59:59Z", editor: { login: "author" } },
-        { editedAt: "2026-08-29T00:00:00Z", editor: { login: "author" } },
-        { editedAt: "2026-08-29T00:00:01Z", editor: { login: "reviewer" } },
-        { editedAt: "2026-08-29T00:00:02Z", editor: null },
-    ];
-
-    assert.equal(
-        countAuthorBodyEdits({
-            userContentEdits: edits,
-            author: "author",
-            since: "2026-08-29T00:00:00Z",
-        }),
-        0,
-    );
-
-    const verdict = judgeAwaitingAuthor(
-        pullRequest({
-            reviews: { nodes: [changesRequested("2026-08-29T00:00:00Z")] },
-            userContentEdits: { nodes: edits },
-        }),
-        { repository: REPO },
-    );
-    assert.equal(verdict.awaiting, true);
-});
-
-test("리뷰어가 미는 빈 CI 재트리거 커밋은 작성자 조치가 아니다", () => {
-    // 8/28 에 리뷰어가 건 +0/-0 커밋 하나로 PR 3건(#1379·#1365·#882)이 전부 가짜 빚이
-    // 됐다 (#1459). 여기서 같은 실수를 하면 방치된 PR 의 라벨이 조용히 떨어진다.
-    const withReviewerEmptyCommit = pullRequest({
-        reviews: { nodes: [changesRequested()] },
-        commits: { nodes: [commit({ login: "reviewer", email: "reviewer@example.com", changed: 0 })] },
-    });
-    assert.equal(judgeAwaitingAuthor(withReviewerEmptyCommit, { repository: REPO }).awaiting, true);
-
-    // 작성자가 올린 커밋이라도 바뀐 파일이 0건이면 반영이 아니다.
-    const ownEmptyCommit = pullRequest({
-        reviews: { nodes: [changesRequested()] },
-        commits: { nodes: [commit({ changed: 0 })] },
-    });
-    assert.equal(judgeAwaitingAuthor(ownEmptyCommit, { repository: REPO }).awaiting, true);
-});
-
-test("작성자의 실질 커밋이 하나라도 있으면 대상에서 빠진다", () => {
-    const verdict = judgeAwaitingAuthor(
-        pullRequest({
-            reviews: { nodes: [changesRequested()] },
-            commits: { nodes: [commit({ date: "2026-08-29T12:00:00Z" })] },
-        }),
-        { repository: REPO },
-    );
-    assert.equal(verdict.awaiting, false);
-    assert.match(verdict.reason, /1커밋/);
-});
-
-test("판정 이전 커밋은 반영으로 세지 않는다", () => {
-    const verdict = judgeAwaitingAuthor(
-        pullRequest({
-            reviews: { nodes: [changesRequested("2026-08-29T00:00:00Z")] },
-            commits: { nodes: [commit({ date: "2026-08-28T00:00:00Z" })] },
-        }),
-        { repository: REPO },
-    );
-    assert.equal(verdict.awaiting, true);
-});
-
-test("병합으로 반영하고 코멘트를 남긴 PR 은 대상이 아니다", () => {
-    // 비병합 커밋만 세면 base 를 끌어와 충돌을 풀며 반영한 PR 이 «무조치» 가 된다.
-    // #1316 은 리뷰가 지목한 파일이 실제로 바뀌고 응답도 2건 달린 채 빚에서 빠져
-    // 있었다 (#1450). 커밋과 함께 작성자의 응답을 본다.
-    const verdict = judgeAwaitingAuthor(
-        pullRequest({
-            reviews: { nodes: [changesRequested()] },
-            commits: { nodes: [commit({ date: "2026-08-29T10:00:00Z", parents: 2 })] },
-            comments: { nodes: [{ createdAt: "2026-08-29T11:00:00Z", author: { login: "author" } }] },
-        }),
-        { repository: REPO },
-    );
-    assert.equal(verdict.awaiting, false);
-    assert.match(verdict.reason, /응답 1건/);
-});
-
-test("작성자가 제출한 리뷰도 응답으로 센다", () => {
-    // 라인 코멘트를 남기면 그것을 담은 리뷰가 함께 제출된다. 별도 조회 없이 잡힌다.
-    const responses = countAuthorResponses({
-        comments: [],
-        reviews: [
-            changesRequested(),
-            { state: "COMMENTED", submittedAt: "2026-08-29T05:00:00Z", author: { login: "author" } },
-        ],
-        author: "author",
-        since: "2026-08-29T00:00:00Z",
-    });
-    assert.equal(responses, 1);
-});
-
-test("변경 파일 수를 알 수 없는 커밋은 반영으로 센다", () => {
-    // 조회 공백을 «빈 커밋» 으로 접으면 라벨이 없는 근거로 둔갑한다. 놓치는 쪽이
-    // 잘못 붙이는 쪽보다 안전하다.
-    const fixes = countAuthorFixes({
-        commits: [commit({ date: "2026-08-29T10:00:00Z", changed: null })],
-        author: "author",
-        since: "2026-08-29T00:00:00Z",
-    });
-    assert.equal(fixes, 1);
-});
-
-test("계정이 연결되지 않은 커밋은 같은 PR 의 작성자 이메일로 가린다", () => {
-    const fixes = countAuthorFixes({
-        commits: [
-            commit({ date: "2026-08-29T10:00:00Z" }),
-            commit({ login: null, email: "AUTHOR@example.com", date: "2026-08-29T11:00:00Z" }),
-        ],
-        author: "author",
-        since: "2026-08-29T00:00:00Z",
-    });
-    assert.equal(fixes, 2);
-
-    // 남의 이메일까지 주우면 리뷰어 커밋이 작성자 것이 된다.
-    const strangers = countAuthorFixes({
-        commits: [commit({ login: null, email: "someone@example.com", date: "2026-08-29T11:00:00Z" })],
-        author: "author",
-        since: "2026-08-29T00:00:00Z",
-    });
-    assert.equal(strangers, 0);
-});
-
-test("draft·봇·fork 는 판정 대상이 아니다", () => {
-    const draft = pullRequest({ isDraft: true, reviews: { nodes: [changesRequested()] } });
-    assert.equal(judgeAwaitingAuthor(draft, { repository: REPO }).awaiting, false);
-
-    const bot = pullRequest({ author: { login: "dependabot[bot]" }, reviews: { nodes: [changesRequested()] } });
-    assert.equal(judgeAwaitingAuthor(bot, { repository: REPO }).awaiting, false);
-
-    const fork = pullRequest({
-        headRepository: { nameWithOwner: "someone/Afternote-FE" },
-        reviews: { nodes: [changesRequested()] },
-    });
-    assert.equal(judgeAwaitingAuthor(fork, { repository: REPO }).awaiting, false);
-});
-
-test("계획은 붙일 것과 뗄 것을 한 번에 낸다", () => {
-    const plan = planAwaitingAuthorLabels({
-        repository: REPO,
-        pullRequests: [
-            // 무조치 · 라벨 없음 → 붙인다
-            pullRequest({ number: 10, reviews: { nodes: [changesRequested()] } }),
-            // 조치함 · 라벨 있음 → 뗀다
-            pullRequest({
-                number: 11,
-                labels: { nodes: [{ name: DEFAULT_LABEL }] },
-                reviews: { nodes: [changesRequested()] },
-                commits: { nodes: [commit({ date: "2026-08-29T10:00:00Z" })] },
-            }),
-            // 무조치 · 라벨 있음 → 그대로
-            pullRequest({
-                number: 12,
-                labels: { nodes: [{ name: DEFAULT_LABEL }] },
-                reviews: { nodes: [changesRequested()] },
-            }),
-            // 승인 · 라벨 없음 → 그대로
-            pullRequest({ number: 13 }),
-        ],
-    });
-
-    assert.deepEqual(plan.toLabel.map((entry) => entry.number), [10]);
-    assert.deepEqual(plan.toUnlabel.map((entry) => entry.number), [11]);
-    assert.deepEqual(plan.unchanged.map((entry) => entry.number), [12, 13]);
-});
-
-test("면제 작성자의 기존 라벨을 제거하고 다음 리컨사일에서도 다시 붙이지 않는다", () => {
-    const pullRequests = [
-        pullRequest({
-            number: 40,
-            author: { login: "KoOnGmAi" },
-            labels: { nodes: [{ name: DEFAULT_LABEL }] },
-            reviews: { nodes: [changesRequested()] },
-        }),
-        pullRequest({
-            number: 41,
-            author: { login: "koongmai" },
-            reviews: { nodes: [changesRequested()] },
-        }),
-        pullRequest({
-            number: 42,
-            labels: { nodes: [{ name: DEFAULT_LABEL }] },
-            reviews: { nodes: [changesRequested()] },
-        }),
-        pullRequest({ number: 43, reviews: { nodes: [changesRequested()] } }),
-    ];
-
-    const plan = planAwaitingAuthorLabels({ repository: REPO, pullRequests, exemptAuthors: ["koongmai"] });
-
-    assert.deepEqual(plan.toUnlabel.map((entry) => entry.number), [40]);
-    assert.equal(plan.toUnlabel[0].reason, "리뷰 게이트 면제 작성자");
-    assert.deepEqual(plan.toLabel.map((entry) => entry.number), [43]);
-    assert.deepEqual(plan.unchanged.map((entry) => entry.number), [41, 42]);
-
-    // 첫 계획을 적용한 다음에도 면제 작성자의 무조치 상태는 그대로 남아 있다.
-    pullRequests[0].labels.nodes = [];
-    pullRequests[3].labels.nodes = [{ name: DEFAULT_LABEL }];
-    const nextPlan = planAwaitingAuthorLabels({ repository: REPO, pullRequests, exemptAuthors: ["koongmai"] });
-
-    assert.deepEqual(nextPlan.toLabel, []);
-    assert.deepEqual(nextPlan.toUnlabel, []);
-    assert.deepEqual(
-        nextPlan.unchanged.map(({ number, labeled }) => ({ number, labeled })),
-        [
-            { number: 40, labeled: false },
-            { number: 41, labeled: false },
-            { number: 42, labeled: true },
-            { number: 43, labeled: true },
-        ],
-    );
-});
-
-test("적용은 실패한 PR 만 보고하고 나머지를 계속 처리한다", async () => {
-    const api = fakeApi({ failOn: (apiPath) => apiPath.includes("/issues/10/") });
-    const plan = {
-        toLabel: [
-            { number: 10, reason: "변경요청 뒤 작성자 조치 없음" },
-            { number: 11, reason: "변경요청 뒤 작성자 조치 없음" },
-        ],
-        toUnlabel: [{ number: 12, reason: "작성자 조치 있음(1커밋 · 응답 0건)" }],
-    };
-
-    const failures = await applyPlan(api, REPO, plan, { logger: silent });
-
-    assert.equal(failures.length, 1);
-    assert.match(failures[0], /#10/);
-    assert.ok(api.calls.some((call) => call.apiPath === `/repos/${REPO}/issues/11/labels` && call.method === "POST"));
-    assert.ok(
-        api.calls.some(
-            (call) => call.apiPath === `/repos/${REPO}/issues/12/labels/${DEFAULT_LABEL}` && call.method === "DELETE",
-        ),
-    );
-});
-
-test("dry-run 은 아무것도 쓰지 않는다", async () => {
-    const api = fakeApi();
-    const plan = { toLabel: [{ number: 10, reason: "r" }], toUnlabel: [{ number: 11, reason: "r" }] };
-
-    await applyPlan(api, REPO, plan, { dryRun: true, logger: silent });
-
-    assert.equal(api.calls.filter((call) => call.method !== "GET").length, 0);
-});
-
-test("이미 있는 라벨은 다시 만들지 않는다", async () => {
-    const existing = fakeApi({ responses: { [`/repos/${REPO}/labels/${DEFAULT_LABEL}`]: { name: DEFAULT_LABEL } } });
-    await ensureLabelExists(existing, REPO);
-    assert.equal(existing.calls.filter((call) => call.method === "POST").length, 0);
-
-    const missing = fakeApi({ responses: { [`/repos/${REPO}/labels/${DEFAULT_LABEL}`]: () => null } });
-    await ensureLabelExists(missing, REPO);
-    assert.ok(missing.calls.some((call) => call.apiPath === `/repos/${REPO}/labels` && call.method === "POST"));
-});
-
-test("요약에는 붙인 PR 의 근거가 남는다", () => {
-    const summary = renderSummary({
-        plan: {
-            toLabel: [{ number: 440, author: "koongmai", decidedAt: "2026-08-29T00:00:00Z", reviewer: "Sadturtleman" }],
-            toUnlabel: [{ number: 11, reason: "작성자 조치 있음(1커밋 · 응답 0건)" }],
-        },
-        dryRun: false,
-    });
-
-    assert.match(summary, /#440/);
-    assert.match(summary, /@koongmai/);
-    assert.match(summary, /2026-08-29/);
-    assert.match(summary, /#11 — 작성자 조치 있음/);
-});
diff --git a/.github/scripts/latest-review-decision-policy.test.mjs b/.github/scripts/latest-review-decision-policy.test.mjs
deleted file mode 100644
index 646187f25d..0000000000
--- a/.github/scripts/latest-review-decision-policy.test.mjs
+++ /dev/null
@@ -1,49 +0,0 @@
-import assert from "node:assert/strict";
-import { readFile } from "node:fs/promises";
-import test from "node:test";
-
-const signal = await readFile(
-    new URL("../workflows/latest-review-decision-event.yml", import.meta.url),
-    "utf8",
-);
-const reconcile = await readFile(
-    new URL("../workflows/latest-review-decision-reconcile.yml", import.meta.url),
-    "utf8",
-);
-const readme = await readFile(new URL("../../README.md", import.meta.url), "utf8");
-
-test("the review event workflow is an unprivileged signal only", () => {
-    assert.match(signal, /^\s{2}pull_request_review:\n\s{4}types: \[submitted\]/m);
-    assert.match(signal, /^permissions: \{\}$/m);
-    assert.doesNotMatch(signal, /actions\/checkout@/);
-    assert.doesNotMatch(signal, /GITHUB_TOKEN|GH_TOKEN|gh api|pull-requests:\s*write/);
-});
-
-test("the trusted workflow reconciles from the default branch with minimal write access", () => {
-    assert.match(reconcile, /^\s{2}workflow_run:/m);
-    assert.match(reconcile, /workflows: \[Latest Review Decision Event\]/);
-    assert.match(reconcile, /^\s{2}workflow_dispatch:/m);
-    assert.match(reconcile, /^permissions: \{\}$/m);
-    assert.match(reconcile, /^\s{6}contents: read$/m);
-    assert.match(reconcile, /^\s{6}pull-requests: write$/m);
-    assert.match(reconcile, /ref: \$\{\{ github\.event\.repository\.default_branch \}\}/);
-    assert.match(reconcile, /persist-credentials: false/);
-    assert.match(reconcile, /reconcile-latest-review-decision\.mjs/);
-    assert.doesNotMatch(reconcile, /github\.event\.pull_request\.head|refs\/pull/);
-});
-
-test("automatic reconciliation is serialized and historical PRs can be swept manually", () => {
-    assert.match(reconcile, /cancel-in-progress: false/);
-    assert.match(reconcile, /inputs\.pull_number/);
-    assert.match(reconcile, /github\.event\.workflow_run\.pull_requests\[0\]\.number/);
-    assert.match(reconcile, /github\.event\.workflow_run\.conclusion == 'success'/);
-    assert.match(reconcile, /github\.event\.workflow_run\.event == 'pull_request_review'/);
-});
-
-test("the README documents the latest write-access review as the final decision", () => {
-    assert.match(
-        readme,
-        /쓰기 권한이 있는 리뷰어별 최신 `APPROVED`·`CHANGES_REQUESTED` 가운데 PR 전체에서 가장 늦은 판정을 최종 판정으로 사용한다/,
-    );
-    assert.doesNotMatch(readme, /\/review-response/);
-});
diff --git a/.github/scripts/merge-order-guard-policy.test.mjs b/.github/scripts/merge-order-guard-policy.test.mjs
index 6aa57dae00..4b91502907 100644
--- a/.github/scripts/merge-order-guard-policy.test.mjs
+++ b/.github/scripts/merge-order-guard-policy.test.mjs
@@ -8,7 +8,6 @@ import test from "node:test";
 
 const guard = await readFile(new URL("../workflows/merge-order-guard.yml", import.meta.url), "utf8");
 const stackNotify = await readFile(new URL("../workflows/stack-integrity-notify.yml", import.meta.url), "utf8");
-const codeowners = await readFile(new URL("../CODEOWNERS", import.meta.url), "utf8");
 
 function issueParser() {
     const match = /refs=\$\(\n\s+PR_JSON="\$pr_json" node <<'NODE'\n([\s\S]*?)\n[ \t]*NODE\n\s+\)/.exec(guard);
@@ -257,10 +256,6 @@ test("close notifier executes only trusted default-branch policy", () => {
     assert.doesNotMatch(stackNotify, /actions\/checkout[\s\S]*github\.event\.pull_request\.head/);
 });
 
-test("declares the repository code owner for GitHub automation and policy changes", () => {
-    assert.match(codeowners, /^\/\.github\/ @1hyok$/m);
-});
-
 test("live CLOSED warns upper PRs while OPEN or MERGED resolves the same bot comment", () => {
     assert.match(stackNotify, /issues: write/);
     // 코멘트 대상이 PR 이면 GitHub 은 pull-requests 쓰기를 요구한다. 이 칸이 read 로
diff --git a/.github/scripts/pr-gate-policy.test.mjs b/.github/scripts/pr-gate-policy.test.mjs
index 51c8988473..a83fb663c5 100644
--- a/.github/scripts/pr-gate-policy.test.mjs
+++ b/.github/scripts/pr-gate-policy.test.mjs
@@ -4,10 +4,15 @@ import test from "node:test";
 
 const workflowDirectory = new URL("../workflows/", import.meta.url);
 const ENTRY_WORKFLOW = "pr-validation.yml";
-const VALIDATION_WORKFLOWS = ["lint.yml", "unit-test.yml", "screenshot.yml", "repository-quality.yml"];
+const VALIDATION_WORKFLOWS = ["lint.yml", "unit-test.yml", "screenshot.yml", "repository-quality.yml", "dependency-review.yml"];
 const HEAVY_VALIDATION_WORKFLOWS = ["lint.yml", "unit-test.yml", "screenshot.yml"];
+// repository-quality 의 분류 결과를 받아 범위를 줄이는 lane. 분류 실패는 전부 실행으로 닫힌다.
+const IMPACT_SCOPED_WORKFLOWS = [...HEAVY_VALIDATION_WORKFLOWS, "dependency-review.yml"];
+// PR 번호로 PR 을 다시 조회하는 lane. dependency-review 는 이벤트의 PR 을 쓰므로 번호를 받지 않는다.
+const PR_NUMBER_WORKFLOWS = ["lint.yml", "unit-test.yml", "screenshot.yml", "repository-quality.yml"];
 // Repository ruleset 20911039 의 required context 와 함께 바꿔야 하는 외부 계약이다.
 const REQUIRED_VALIDATION_CONTEXTS = [
+    "Dependency Review / Review dependency changes",
     "Repository Quality / Repository Quality",
     "Screenshot / Validate Compose Preview Screenshots",
     "Static Analysis / Check Code Quality (Ktlint)",
@@ -130,7 +135,7 @@ test("token-authored commits preserve the pull request context on manual dispatc
                 /pull_request_number: \$\{\{ fromJSON\(inputs\.pull_request_number \|\| '0'\) \|\| github\.event\.pull_request\.number \|\| 0 \}\}/g,
             ) ?? []
         ).length,
-        VALIDATION_WORKFLOWS.length,
+        PR_NUMBER_WORKFLOWS.length,
     );
     assert.equal(
         (entry.match(/pull_request_number: \$\{\{ inputs\.pull_request_number/g) ?? []).length,
@@ -158,7 +163,7 @@ test("merge group validation falls back to the full suite without a pull request
 
     assert.equal(
         (entry.match(/\|\| github\.event\.pull_request\.number \|\| 0 \}\}/g) ?? []).length,
-        VALIDATION_WORKFLOWS.length,
+        PR_NUMBER_WORKFLOWS.length,
     );
     for (const gate of ["Require linked Issue", "Require module owner", "Validate CI Test Plan", "Reject test-only production declarations"]) {
         assert.match(
@@ -194,13 +199,19 @@ test("the entry point keeps no pull_request branch or path filter", async () =>
 test("impact outputs scope each heavy lane and classification failure runs full validation", async () => {
     const entry = await readWorkflow(ENTRY_WORKFLOW);
 
-    assert.equal((entry.match(/^ {4}needs: repository-quality$/gm) ?? []).length, HEAVY_VALIDATION_WORKFLOWS.length);
+    assert.equal((entry.match(/^ {4}needs: repository-quality$/gm) ?? []).length, IMPACT_SCOPED_WORKFLOWS.length);
     assert.equal(
         (entry.match(/^ {4}if: \$\{\{ !cancelled\(\) \}\}$/gm) ?? []).length,
-        HEAVY_VALIDATION_WORKFLOWS.length,
+        IMPACT_SCOPED_WORKFLOWS.length,
         "quality failures must fan out to full validation without reviving a cancelled stale run",
     );
-    for (const output of ["ktlint_required", "android_lint_required", "unit_test_required", "screenshot_required"]) {
+    for (const output of [
+        "ktlint_required",
+        "android_lint_required",
+        "unit_test_required",
+        "screenshot_required",
+        "dependency_review_required",
+    ]) {
         assert.match(
             entry,
             new RegExp(`needs\\.repository-quality\\.result != 'success' \\|\\| needs\\.repository-quality\\.outputs\\.${output} != 'false'`),
@@ -237,6 +248,38 @@ test("heavy reusable workflows default to full validation and preserve every req
     assert.match(lint, /^ {4}if: inputs\.run_android_lint$/m);
 });
 
+test("dependency review keeps one required context and skips only its check step", async () => {
+    // #2258: job 자체를 if 로 건너뛰면 분류 job 실패와 «검사 불필요» 가 같은 skipped 로 보인다.
+    // job 은 늘 돌고, 검사 스텝만 PR 이벤트 + 의존성 입력 변경일 때 실행한다. 그 밖의 이벤트에서
+    // 의존성 입력이 바뀌었으면 merge group 만 건너뛰고 나머지는 실패한다.
+    const source = await readWorkflow("dependency-review.yml");
+    const jobs = jobNames(source);
+
+    assert.deepEqual(jobs, ["dependency-review"]);
+    assert.doesNotMatch(source, /^ {4}if:/m);
+    assert.match(source, /^ {6}run_review:\n(?: {8}.+\n)*? {8}default: true\n {8}type: boolean$/m);
+    assert.match(
+        source,
+        /- name: Fail on newly introduced high-severity vulnerabilities\n\s+if: \$\{\{ inputs\.run_review && github\.event_name == 'pull_request' \}\}\n\s+uses: actions\/dependency-review-action@/,
+    );
+    assert.match(source, /- name: Skip unchanged dependency graph inputs\n\s+if: \$\{\{ !inputs\.run_review \}\}/);
+    assert.match(
+        source,
+        /- name: Skip merge group revalidation\n\s+if: \$\{\{ inputs\.run_review && github\.event_name == 'merge_group' \}\}/,
+    );
+    // bridge dispatch 커밋은 PR 스냅샷이 없다. 건너뛰면 이전 head 의 실패를 검사 없는 초록이 덮는다.
+    const rejectStart = source.indexOf("- name: Reject dependency changes without a pull request snapshot\n");
+    assert.ok(rejectStart >= 0, "dispatch rejection step is missing");
+    const rejectEnd = source.indexOf("\n      - name:", rejectStart + 1);
+    const rejectStep = source.slice(rejectStart, rejectEnd < 0 ? undefined : rejectEnd);
+    assert.ok(
+        rejectStep.includes(
+            "if: ${{ inputs.run_review && github.event_name != 'pull_request' && github.event_name != 'merge_group' }}\n",
+        ),
+    );
+    assert.match(rejectStep, /^ {10}exit 1$/m);
+});
+
 test("repository quality owns fail-closed paginated impact classification and PR gates", async () => {
     const repositoryQuality = await readWorkflow("repository-quality.yml");
     const unitTest = await readWorkflow("unit-test.yml");
diff --git a/.github/scripts/pr-issue-link-policy.test.mjs b/.github/scripts/pr-issue-link-policy.test.mjs
index 16841abde3..bac8020459 100644
--- a/.github/scripts/pr-issue-link-policy.test.mjs
+++ b/.github/scripts/pr-issue-link-policy.test.mjs
@@ -205,8 +205,20 @@ test("keeps Refs for Issues the PR touches but does not close, and checks the as
 });
 
 test("exempts bot authors from the assignee check and the closing keyword but keeps the Issue link requirement", async () => {
-    // 봇 PR 은 사람이 나중에 링크를 붙이는 구조라 대표 Issue 를 Refs 로 거는 현행을 유지한다 (#1748).
+    // 봇 PR 은 closing 키워드를 면제할 뿐 금지하지 않는다. 사람이 붙인 공유 Issue 는 Refs 로(#1748),
+    // dependabot-pr-gate 가 PR 마다 만든 Issue 는 Closes 로 건다(#2274). 둘 다 통과해야 한다.
     const loadIssue = issueLoader(new Map([[12, assignedIssue(12, { assignees: [] })]]));
+    const closing = await validatePullRequestIssueLink({
+        pullRequest: pullRequest({
+            title: "chore(deps): bump upload-artifact (#12)",
+            body: "<!-- dependabot-pr-gate:v1 -->\nCloses #12",
+            user: { login: "dependabot[bot]", type: "Bot" },
+        }),
+        repository: "Afternote/Afternote-FE",
+        loadIssue,
+    });
+    assert.deepEqual(closing, { issues: [12], rejected: [] });
+
     const result = await validatePullRequestIssueLink({
         pullRequest: pullRequest({
             title: "chore(deps): bump upload-artifact (#12)",
diff --git a/.github/scripts/qa-distribution-decision.mjs b/.github/scripts/qa-distribution-decision.mjs
index 88f41ea71e..bf6f466bc9 100644
--- a/.github/scripts/qa-distribution-decision.mjs
+++ b/.github/scripts/qa-distribution-decision.mjs
@@ -137,9 +137,24 @@ export async function collectQaDistributionContext({ repository, headSha, api =
     }
     git(["cat-file", "-e", `${headSha}^{commit}`]);
     const root = `repos/${repository}`;
-    const runs = pages(await api(`${root}/actions/workflows/release-distribution.yml/runs?status=success&branch=main&event=push&per_page=100`, true), "workflow_runs");
-    const latest = sortDistributionRuns(runs.filter((run) => run.conclusion === "success" && run.head_branch === "main" && run.event === "push"))[0];
+    const runsEndpoint = `${root}/actions/workflows/release-distribution.yml/runs?branch=main&event=push&per_page=100`;
+    const successfulRuns = async (endpoint) => sortDistributionRuns(pages(await api(endpoint, true), "workflow_runs")
+        .filter((run) => run.conclusion === "success" && run.head_branch === "main" && run.event === "push"));
+    // status=success 필터 응답은 최근 실행이 통째로 빠진 채 올 때가 있다(#2269 머지 뒤 판정이 8/14 배포를 기준으로 잡음). 결론은 직접 거른다.
+    let latest = (await successfulRuns(runsEndpoint))[0];
     if (!latest) throw new CollectionError("No successful main Firebase distribution baseline");
+    // 목록에서 빠진 더 새 배포가 있는지 main 의 뒤 커밋마다 head_sha 로 다시 묻는다. main tip 이 곧 배포 커밋이면 호출이 없다.
+    const newerMainCommits = SHA.test(latest.head_sha ?? "")
+        ? git(["rev-list", "--first-parent", `${latest.head_sha}..refs/remotes/origin/main`]).split("\n").filter(Boolean)
+        : [];
+    for (const sha of newerMainCommits) {
+        if (!SHA.test(sha)) throw new CollectionError("Invalid commit in main history");
+        const newer = (await successfulRuns(`${runsEndpoint}&head_sha=${sha}`))[0];
+        if (newer) {
+            latest = newer;
+            break;
+        }
+    }
     const associated = pages(await api(`${root}/commits/${latest.head_sha}/pulls?per_page=100`, true));
     const sourceSha = sourceShaForDistributionRun(latest, associated);
     if (!SHA.test(sourceSha ?? "")) throw new CollectionError("Successful distribution has no develop release PR source SHA");
diff --git a/.github/scripts/qa-distribution-decision.test.mjs b/.github/scripts/qa-distribution-decision.test.mjs
index c63f8b80ac..bea4cd109c 100644
--- a/.github/scripts/qa-distribution-decision.test.mjs
+++ b/.github/scripts/qa-distribution-decision.test.mjs
@@ -72,6 +72,7 @@ function collectorFixture(count = 1, netPaths = [APP]) {
         return [pulls.slice(0, 50), pulls.slice(50)];
     }
     function git(args) {
+        if (args[0] === "rev-list" && args.at(-1).endsWith("..refs/remotes/origin/main")) return "";
         if (args[0] === "rev-list") return [...commits].reverse().concat(sourceSha).join("\n");
         if (args.includes("--raw")) {
             const index = commits.indexOf(args.at(-2));
@@ -94,6 +95,33 @@ test("maps a successful main deployment to its develop source and collects over
     assert.equal(decideQaDistribution(collected, NOW).decision, "deploy");
 });
 
+test("a run list that omits newer main deployments still resolves the newest baseline", async () => {
+    const fixture = collectorFixture();
+    const [staleMain, failedMain, deployedMain] = ["d", "e", "f"].map((c) => c.repeat(40));
+    const staleSource = "9".repeat(40);
+    const run = (id, sha, conclusion) => ({ id, head_sha: sha, head_branch: "main", event: "push", conclusion, updated_at: `2026-09-0${id}T00:00:00Z`, html_url: `https://example.com/${id}` });
+    const api = fixture.api;
+    fixture.api = async (endpoint, paginate) => {
+        if (endpoint.includes("/actions/")) {
+            fixture.calls.push(endpoint);
+            if (endpoint.endsWith(`head_sha=${failedMain}`)) return [{ workflow_runs: [run(3, failedMain, "failure")] }];
+            if (endpoint.endsWith(`head_sha=${deployedMain}`)) return [{ workflow_runs: [run(2, deployedMain, "success")] }];
+            return [{ workflow_runs: [run(1, staleMain, "success")] }];
+        }
+        if (endpoint.includes(`/commits/${staleMain}/`)) return [[{ merged_at: "2026-09-01T00:00:00Z", base: { ref: "main" }, head: { ref: "develop", sha: staleSource } }]];
+        return api(endpoint, paginate);
+    };
+    const git = fixture.git;
+    fixture.git = (args) => {
+        if (args[0] === "rev-list" && args.at(-1) === `${staleMain}..refs/remotes/origin/main`) return [failedMain, deployedMain].join("\n");
+        return git(args);
+    };
+    const collected = await collectQaDistributionContext(fixture);
+    assert.equal(collected.baseline.runId, 2);
+    assert.equal(collected.baseline.sourceSha, sourceSha);
+    assert.ok(fixture.calls.every((endpoint) => !endpoint.includes("status=")));
+});
+
 test("a fully reverted runtime batch has no remaining APK change", async () => {
     const fixture = collectorFixture(75, []);
     const collected = await collectQaDistributionContext(fixture);
diff --git a/.github/scripts/reconcile-latest-review-decision.mjs b/.github/scripts/reconcile-latest-review-decision.mjs
deleted file mode 100644
index 32c076fdeb..0000000000
--- a/.github/scripts/reconcile-latest-review-decision.mjs
+++ /dev/null
@@ -1,308 +0,0 @@
-import { pathToFileURL } from "node:url";
-
-export const DECISIVE_REVIEW_STATES = new Set(["APPROVED", "CHANGES_REQUESTED"]);
-
-const WRITE_PERMISSIONS = new Set(["admin", "maintain", "write"]);
-const NON_WRITE_PERMISSIONS = new Set(["triage", "read", "none"]);
-
-function requiredString(value, name) {
-    if (typeof value !== "string" || value.trim() === "") {
-        throw new Error(`${name} 값이 없습니다.`);
-    }
-    return value.trim();
-}
-
-function requiredPositiveInteger(value, name) {
-    const number = typeof value === "number" ? value : Number(value);
-    if (!Number.isSafeInteger(number) || number <= 0) {
-        throw new Error(`${name} 값이 양의 정수가 아닙니다: ${value}`);
-    }
-    return number;
-}
-
-function normalizeReviewState(value) {
-    return requiredString(value, "review.state").toUpperCase();
-}
-
-function normalizeRepository(repository) {
-    const value = requiredString(repository, "repository");
-    if (!/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(value)) {
-        throw new Error(`repository 형식이 owner/name 이 아닙니다: ${value}`);
-    }
-    return value;
-}
-
-function normalizeDecisiveReview(review) {
-    const state = normalizeReviewState(review?.state);
-    if (!DECISIVE_REVIEW_STATES.has(state)) {
-        return null;
-    }
-
-    const id = requiredPositiveInteger(review?.id, "review.id");
-    const reviewer = requiredString(
-        review?.user?.login ?? review?.reviewer,
-        "review.user.login",
-    ).toLowerCase();
-    const submittedAt = requiredString(
-        review?.submitted_at ?? review?.submittedAt,
-        "review.submitted_at",
-    );
-    const submittedTimestamp = Date.parse(submittedAt);
-    if (!Number.isFinite(submittedTimestamp)) {
-        throw new Error(`review.submitted_at 값이 올바른 시각이 아닙니다: ${submittedAt}`);
-    }
-
-    return { id, reviewer, state, submittedAt, submittedTimestamp };
-}
-
-function compareDecisiveReviews(left, right) {
-    return left.submittedTimestamp - right.submittedTimestamp || left.id - right.id;
-}
-
-export function classifyRepositoryPermission(permission) {
-    const value = requiredString(permission, "repository permission").toLowerCase();
-    if (WRITE_PERMISSIONS.has(value)) {
-        return "write";
-    }
-    if (NON_WRITE_PERMISSIONS.has(value)) {
-        return "read";
-    }
-    throw new Error(`알 수 없는 repository permission 입니다: ${permission}`);
-}
-
-export function selectLatestDecisiveReviewsByReviewer(reviews) {
-    if (!Array.isArray(reviews)) {
-        throw new Error("리뷰 목록 응답이 배열이 아닙니다.");
-    }
-
-    const latestByReviewer = new Map();
-    for (const rawReview of reviews) {
-        const review = normalizeDecisiveReview(rawReview);
-        if (!review) {
-            continue;
-        }
-        const previous = latestByReviewer.get(review.reviewer);
-        if (!previous || compareDecisiveReviews(previous, review) <= 0) {
-            latestByReviewer.set(review.reviewer, review);
-        }
-    }
-
-    return [...latestByReviewer.values()].sort(compareDecisiveReviews);
-}
-
-export function buildDismissalPlan(reviews, permissionByReviewer) {
-    if (!(permissionByReviewer instanceof Map)) {
-        throw new Error("permissionByReviewer 는 Map 이어야 합니다.");
-    }
-
-    const latestByReviewer = selectLatestDecisiveReviewsByReviewer(reviews);
-    const writeReviews = latestByReviewer.filter((review) => {
-        if (!permissionByReviewer.has(review.reviewer)) {
-            throw new Error(`@${review.reviewer}의 repository permission 이 없습니다.`);
-        }
-        return classifyRepositoryPermission(permissionByReviewer.get(review.reviewer)) === "write";
-    });
-
-    if (writeReviews.length === 0) {
-        return { status: "no-write-review", latestReview: null, blockingReviews: [] };
-    }
-
-    const latestReview = writeReviews.at(-1);
-    if (latestReview.state !== "APPROVED") {
-        return { status: "latest-changes-requested", latestReview, blockingReviews: [] };
-    }
-
-    const blockingReviews = writeReviews.filter((review) => review.state === "CHANGES_REQUESTED");
-    if (blockingReviews.length === 0) {
-        return { status: "already-approved", latestReview, blockingReviews: [] };
-    }
-
-    return { status: "dismiss", latestReview, blockingReviews };
-}
-
-export class GitHubClient {
-    constructor({ token, apiUrl = "https://api.github.com", fetchImpl = globalThis.fetch }) {
-        this.token = requiredString(token, "GITHUB_TOKEN");
-        this.apiUrl = requiredString(apiUrl, "GITHUB_API_URL").replace(/\/+$/, "");
-        if (typeof fetchImpl !== "function") {
-            throw new Error("fetch 구현이 없습니다.");
-        }
-        this.fetchImpl = fetchImpl;
-    }
-
-    async request(path, { method = "GET", body } = {}) {
-        if (typeof path !== "string" || !path.startsWith("/")) {
-            throw new Error(`GitHub API path가 올바르지 않습니다: ${path}`);
-        }
-
-        const response = await this.fetchImpl(`${this.apiUrl}${path}`, {
-            method,
-            headers: {
-                Accept: "application/vnd.github+json",
-                Authorization: `Bearer ${this.token}`,
-                "Content-Type": "application/json",
-                "X-GitHub-Api-Version": "2022-11-28",
-            },
-            body: body === undefined ? undefined : JSON.stringify(body),
-        });
-        const responseText = await response.text();
-        let data = null;
-        if (responseText !== "") {
-            try {
-                data = JSON.parse(responseText);
-            } catch {
-                throw new Error(`GitHub API가 JSON이 아닌 응답을 반환했습니다: ${response.status}`);
-            }
-        }
-        if (!response.ok) {
-            const detail = typeof data?.message === "string" ? data.message : responseText.slice(0, 500);
-            throw new Error(`GitHub API ${method} ${path} 실패: HTTP ${response.status} ${detail}`);
-        }
-        return data;
-    }
-
-    async paginate(path) {
-        const items = [];
-        for (let page = 1; ; page += 1) {
-            const separator = path.includes("?") ? "&" : "?";
-            const response = await this.request(`${path}${separator}per_page=100&page=${page}`);
-            if (!Array.isArray(response)) {
-                throw new Error(`GitHub API pagination 응답이 배열이 아닙니다: ${path}`);
-            }
-            items.push(...response);
-            if (response.length < 100) {
-                return items;
-            }
-        }
-    }
-}
-
-export async function planPullRequest(client, repository, pullNumber) {
-    const normalizedRepository = normalizeRepository(repository);
-    const normalizedPullNumber = requiredPositiveInteger(pullNumber, "pull number");
-    const reviews = await client.paginate(
-        `/repos/${normalizedRepository}/pulls/${normalizedPullNumber}/reviews`,
-    );
-    const latestByReviewer = selectLatestDecisiveReviewsByReviewer(reviews);
-    const permissionByReviewer = new Map();
-
-    for (const review of latestByReviewer) {
-        const response = await client.request(
-            `/repos/${normalizedRepository}/collaborators/${encodeURIComponent(review.reviewer)}/permission`,
-        );
-        permissionByReviewer.set(review.reviewer, response?.permission);
-    }
-
-    return {
-        pullNumber: normalizedPullNumber,
-        ...buildDismissalPlan(reviews, permissionByReviewer),
-    };
-}
-
-export async function applyDismissalPlan(client, repository, plan) {
-    const normalizedRepository = normalizeRepository(repository);
-    if (plan?.status !== "dismiss") {
-        return [];
-    }
-
-    const pullNumber = requiredPositiveInteger(plan.pullNumber, "pull number");
-    const approval = normalizeDecisiveReview(plan.latestReview);
-    if (!approval || approval.state !== "APPROVED") {
-        throw new Error(`#${pullNumber} dismissal plan의 최종 승인이 올바르지 않습니다.`);
-    }
-
-    const dismissed = [];
-    for (const rawReview of plan.blockingReviews) {
-        const blockingReview = normalizeDecisiveReview(rawReview);
-        if (!blockingReview || blockingReview.state !== "CHANGES_REQUESTED") {
-            throw new Error(`#${pullNumber} dismissal plan에 변경요청이 아닌 리뷰가 있습니다.`);
-        }
-        if (compareDecisiveReviews(blockingReview, approval) >= 0) {
-            throw new Error(`#${pullNumber} 최종 승인보다 늦은 변경요청은 dismiss할 수 없습니다.`);
-        }
-
-        const message = [
-            `@${approval.reviewer}의 더 늦은 승인(review #${approval.id})을 최종 판정으로 사용합니다.`,
-            "저장소 정책은 PR 전체에서 가장 최근의 APPROVED/CHANGES_REQUESTED 판정을 우선합니다.",
-        ].join(" ");
-        const response = await client.request(
-            `/repos/${normalizedRepository}/pulls/${pullNumber}/reviews/${blockingReview.id}/dismissals`,
-            { method: "PUT", body: { event: "DISMISS", message } },
-        );
-        if (normalizeReviewState(response?.state) !== "DISMISSED") {
-            throw new Error(`#${pullNumber} review #${blockingReview.id} dismiss 응답이 DISMISSED가 아닙니다.`);
-        }
-        dismissed.push(blockingReview);
-    }
-    return dismissed;
-}
-
-export async function reconcileLatestReviewDecisions({ client, repository, pullNumbers, logger = console }) {
-    if (!Array.isArray(pullNumbers)) {
-        throw new Error("pullNumbers 는 배열이어야 합니다.");
-    }
-    const normalizedPullNumbers = [...new Set(
-        pullNumbers.map((pullNumber) => requiredPositiveInteger(pullNumber, "pull number")),
-    )];
-
-    // 모든 PR의 조회와 권한 판정을 먼저 끝낸다. 한 PR이라도 근거 조회가 실패하면
-    // 다른 PR의 blocking review까지 일부만 dismiss하지 않는다.
-    const plans = [];
-    for (const pullNumber of normalizedPullNumbers) {
-        plans.push(await planPullRequest(client, repository, pullNumber));
-    }
-
-    const results = [];
-    for (const plan of plans) {
-        const dismissed = await applyDismissalPlan(client, repository, plan);
-        if (dismissed.length === 0) {
-            logger.log(`#${plan.pullNumber}: ${plan.status}`);
-        } else {
-            logger.log(
-                `#${plan.pullNumber}: @${plan.latestReview.reviewer} 승인 뒤 변경요청 ${dismissed.length}건 dismiss`,
-            );
-        }
-        results.push({ plan, dismissed });
-    }
-    return results;
-}
-
-export function parseTargetPullNumber(value) {
-    if (value === undefined || value === null || String(value).trim() === "") {
-        return null;
-    }
-    return requiredPositiveInteger(String(value).trim(), "TARGET_PULL_NUMBER");
-}
-
-async function main() {
-    const repository = normalizeRepository(process.env.GITHUB_REPOSITORY);
-    const client = new GitHubClient({
-        token: process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN,
-        apiUrl: process.env.GITHUB_API_URL ?? "https://api.github.com",
-    });
-    const targetPullNumber = parseTargetPullNumber(process.env.TARGET_PULL_NUMBER);
-    let pullNumbers;
-
-    if (targetPullNumber === null) {
-        const openPullRequests = await client.paginate(`/repos/${repository}/pulls?state=open`);
-        pullNumbers = openPullRequests.map((pullRequest) =>
-            requiredPositiveInteger(pullRequest?.number, "pull_request.number"));
-    } else {
-        pullNumbers = [targetPullNumber];
-    }
-
-    console.log(`Latest review decision reconcile: ${pullNumbers.length} open pull request(s)`);
-    await reconcileLatestReviewDecisions({ client, repository, pullNumbers });
-}
-
-const isDirectExecution = process.argv[1]
-    && import.meta.url === pathToFileURL(process.argv[1]).href;
-
-if (isDirectExecution) {
-    try {
-        await main();
-    } catch (error) {
-        console.error(`::error::${error.message}`);
-        process.exitCode = 1;
-    }
-}
diff --git a/.github/scripts/reconcile-latest-review-decision.test.mjs b/.github/scripts/reconcile-latest-review-decision.test.mjs
deleted file mode 100644
index acc6303bc6..0000000000
--- a/.github/scripts/reconcile-latest-review-decision.test.mjs
+++ /dev/null
@@ -1,275 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import {
-    applyDismissalPlan,
-    buildDismissalPlan,
-    classifyRepositoryPermission,
-    parseTargetPullNumber,
-    reconcileLatestReviewDecisions,
-    selectLatestDecisiveReviewsByReviewer,
-} from "./reconcile-latest-review-decision.mjs";
-
-function review({
-    id,
-    reviewer,
-    state,
-    submittedAt,
-}) {
-    return {
-        id,
-        state,
-        submitted_at: submittedAt,
-        user: { login: reviewer },
-    };
-}
-
-const changesByAlice = review({
-    id: 10,
-    reviewer: "Alice",
-    state: "CHANGES_REQUESTED",
-    submittedAt: "2026-08-26T01:00:00Z",
-});
-const approvalByBob = review({
-    id: 20,
-    reviewer: "Bob",
-    state: "APPROVED",
-    submittedAt: "2026-08-26T02:00:00Z",
-});
-
-test("latest decisive review is selected separately for each reviewer", () => {
-    const reviews = [
-        changesByAlice,
-        review({
-            id: 11,
-            reviewer: "alice",
-            state: "COMMENTED",
-            submittedAt: "2026-08-26T02:30:00Z",
-        }),
-        review({
-            id: 12,
-            reviewer: "ALICE",
-            state: "APPROVED",
-            submittedAt: "2026-08-26T03:00:00Z",
-        }),
-        approvalByBob,
-    ];
-
-    assert.deepEqual(
-        selectLatestDecisiveReviewsByReviewer(reviews).map(({ id, reviewer, state }) => ({
-            id,
-            reviewer,
-            state,
-        })),
-        [
-            { id: 20, reviewer: "bob", state: "APPROVED" },
-            { id: 12, reviewer: "alice", state: "APPROVED" },
-        ],
-    );
-});
-
-test("a later write-access approval dismisses another reviewer's blocking request", () => {
-    const plan = buildDismissalPlan(
-        [changesByAlice, approvalByBob],
-        new Map([["alice", "write"], ["bob", "maintain"]]),
-    );
-
-    assert.equal(plan.status, "dismiss");
-    assert.equal(plan.latestReview.id, 20);
-    assert.deepEqual(plan.blockingReviews.map(({ id }) => id), [10]);
-});
-
-test("one later approval dismisses every older write-access blocking request", async () => {
-    const changesByCarol = review({
-        id: 15,
-        reviewer: "Carol",
-        state: "CHANGES_REQUESTED",
-        submittedAt: "2026-08-26T01:30:00Z",
-    });
-    const plan = {
-        pullNumber: 914,
-        ...buildDismissalPlan(
-            [changesByAlice, changesByCarol, approvalByBob],
-            new Map([["alice", "write"], ["bob", "maintain"], ["carol", "admin"]]),
-        ),
-    };
-    const calls = [];
-    const client = {
-        async request(path) {
-            calls.push(path);
-            return { state: "DISMISSED" };
-        },
-    };
-
-    const dismissed = await applyDismissalPlan(client, "Afternote/Afternote-FE", plan);
-
-    assert.deepEqual(dismissed.map(({ id }) => id), [10, 15]);
-    assert.deepEqual(calls, [
-        "/repos/Afternote/Afternote-FE/pulls/914/reviews/10/dismissals",
-        "/repos/Afternote/Afternote-FE/pulls/914/reviews/15/dismissals",
-    ]);
-});
-
-test("a later change request still blocks after an earlier approval", () => {
-    const plan = buildDismissalPlan(
-        [approvalByBob, review({
-            id: 30,
-            reviewer: "Alice",
-            state: "CHANGES_REQUESTED",
-            submittedAt: "2026-08-26T03:00:00Z",
-        })],
-        new Map([["alice", "admin"], ["bob", "write"]]),
-    );
-
-    assert.equal(plan.status, "latest-changes-requested");
-    assert.deepEqual(plan.blockingReviews, []);
-});
-
-test("a reviewer's own later approval supersedes their earlier change request", () => {
-    const plan = buildDismissalPlan(
-        [
-            changesByAlice,
-            review({
-                id: 15,
-                reviewer: "Alice",
-                state: "APPROVED",
-                submittedAt: "2026-08-26T01:30:00Z",
-            }),
-            review({
-                id: 12,
-                reviewer: "Carol",
-                state: "CHANGES_REQUESTED",
-                submittedAt: "2026-08-26T01:15:00Z",
-            }),
-        ],
-        new Map([["alice", "write"], ["carol", "write"]]),
-    );
-
-    assert.equal(plan.status, "dismiss");
-    assert.deepEqual(plan.blockingReviews.map(({ id }) => id), [12]);
-});
-
-test("read-only approval never overrides a write-access change request", () => {
-    const plan = buildDismissalPlan(
-        [changesByAlice, approvalByBob],
-        new Map([["alice", "write"], ["bob", "read"]]),
-    );
-
-    assert.equal(plan.status, "latest-changes-requested");
-    assert.equal(plan.latestReview.id, 10);
-});
-
-test("same-second reviews use the larger review id as the later decision", () => {
-    const submittedAt = "2026-08-26T01:00:00Z";
-    const plan = buildDismissalPlan(
-        [
-            review({ id: 100, reviewer: "Alice", state: "CHANGES_REQUESTED", submittedAt }),
-            review({ id: 101, reviewer: "Bob", state: "APPROVED", submittedAt }),
-        ],
-        new Map([["alice", "write"], ["bob", "write"]]),
-    );
-
-    assert.equal(plan.status, "dismiss");
-    assert.equal(plan.latestReview.id, 101);
-});
-
-test("unknown or missing permissions fail closed", () => {
-    assert.equal(classifyRepositoryPermission("admin"), "write");
-    assert.equal(classifyRepositoryPermission("triage"), "read");
-    assert.throws(() => classifyRepositoryPermission("mystery"), /알 수 없는/);
-    assert.throws(
-        () => buildDismissalPlan([approvalByBob], new Map()),
-        /repository permission 이 없습니다/,
-    );
-});
-
-test("only valid optional target pull numbers are accepted", () => {
-    assert.equal(parseTargetPullNumber(undefined), null);
-    assert.equal(parseTargetPullNumber(""), null);
-    assert.equal(parseTargetPullNumber(" 914 "), 914);
-    assert.throws(() => parseTargetPullNumber("0"), /양의 정수/);
-    assert.throws(() => parseTargetPullNumber("abc"), /양의 정수/);
-});
-
-test("dismissal calls the protected review endpoint and verifies the response", async () => {
-    const calls = [];
-    const client = {
-        async request(path, options) {
-            calls.push({ path, options });
-            return { state: "DISMISSED" };
-        },
-    };
-    const plan = {
-        pullNumber: 914,
-        status: "dismiss",
-        latestReview: {
-            id: 20,
-            reviewer: "bob",
-            state: "APPROVED",
-            submittedAt: "2026-08-26T02:00:00Z",
-            submittedTimestamp: Date.parse("2026-08-26T02:00:00Z"),
-        },
-        blockingReviews: [{
-            id: 10,
-            reviewer: "alice",
-            state: "CHANGES_REQUESTED",
-            submittedAt: "2026-08-26T01:00:00Z",
-            submittedTimestamp: Date.parse("2026-08-26T01:00:00Z"),
-        }],
-    };
-
-    const dismissed = await applyDismissalPlan(client, "Afternote/Afternote-FE", plan);
-
-    assert.deepEqual(dismissed.map(({ id }) => id), [10]);
-    assert.equal(
-        calls[0].path,
-        "/repos/Afternote/Afternote-FE/pulls/914/reviews/10/dismissals",
-    );
-    assert.equal(calls[0].options.method, "PUT");
-    assert.equal(calls[0].options.body.event, "DISMISS");
-    assert.match(calls[0].options.body.message, /@bob/);
-    assert.match(calls[0].options.body.message, /review #20/);
-});
-
-test("an unexpected dismiss response fails instead of reporting success", async () => {
-    const client = { async request() { return { state: "CHANGES_REQUESTED" }; } };
-    await assert.rejects(
-        applyDismissalPlan(client, "Afternote/Afternote-FE", {
-            pullNumber: 914,
-            status: "dismiss",
-            latestReview: approvalByBob,
-            blockingReviews: [changesByAlice],
-        }),
-        /DISMISSED가 아닙니다/,
-    );
-});
-
-test("all pull requests are read and authorized before the first dismissal", async () => {
-    const writes = [];
-    const client = {
-        async paginate(path) {
-            if (path.includes("/pulls/1/reviews")) {
-                return [changesByAlice, approvalByBob];
-            }
-            throw new Error("second PR review lookup failed");
-        },
-        async request(path, options = {}) {
-            if (options.method === "PUT") {
-                writes.push(path);
-                return { state: "DISMISSED" };
-            }
-            return { permission: "write" };
-        },
-    };
-
-    await assert.rejects(
-        reconcileLatestReviewDecisions({
-            client,
-            repository: "Afternote/Afternote-FE",
-            pullNumbers: [1, 2],
-            logger: { log() {} },
-        }),
-        /second PR review lookup failed/,
-    );
-    assert.deepEqual(writes, []);
-});
diff --git a/.github/scripts/resolve-pr-impact.mjs b/.github/scripts/resolve-pr-impact.mjs
index e60dc1a82a..9e0aebe15b 100644
--- a/.github/scripts/resolve-pr-impact.mjs
+++ b/.github/scripts/resolve-pr-impact.mjs
@@ -25,6 +25,7 @@ const IMPACT_POLICY_PATHS = new Set([
     ".github/workflows/unit-test.yml",
     ".github/workflows/screenshot.yml",
     ".github/workflows/codeql.yml",
+    ".github/workflows/dependency-review.yml",
     // 기대 실패 목록(xfail)은 검증 정책 그 자체다 — 목록·메커니즘 변경은 모든 lane 으로
     // fail-closed 해, 잘못 지운 항목이 그 자리에서 red 를 만들게 한다.
     ".github/ci-expected-failures.json",
@@ -35,6 +36,50 @@ const IMPACT_POLICY_PATHS = new Set([
 // 아키텍처 가드 전용 순수 JVM 모듈. src/main 이 없어 프로덕션 소스 분기를 탈 수 없고,
 // kover 도 안 붙어 coverageModules 로도 안 잡힌다 — 소스셋 판정에서 따로 건져야 한다.
 const KONSIST_PROJECT_PATH = ":konsist";
+// Dependency Review 를 깨우는 의존성 그래프 입력. 예전엔 dependency-review.yml 의 paths
+// 필터였는데, 그러면 소스만 고친 PR 에 check 가 생기지 않아 required 로 걸 수 없었다 (#2258).
+// 같은 glob 문법을 그대로 두고 job 안 분류로 옮긴다. 목록은 supply-chain-policy.test.mjs 가 고정한다.
+export const DEPENDENCY_GRAPH_INPUT_PATTERNS = Object.freeze([
+    "**/*.gradle",
+    "**/*.gradle.kts",
+    "**/*.lockfile",
+    "**/build-logic/**",
+    "**/buildSrc/**",
+    "**/gradle.properties",
+    "**/gradlew",
+    "**/gradlew.bat",
+    "gradle/**",
+    ".github/workflows/dependency-review.yml",
+    ".github/workflows/dependency-submission.yml",
+    ".github/workflows/dependency-submission-trusted.yml",
+    ".github/workflows/dependency-submission-upload.yml",
+]);
+
+function globToRegExp(pattern) {
+    let source = "";
+    for (let index = 0; index < pattern.length; ) {
+        if (pattern.startsWith("**/", index)) {
+            source += "(?:.*/)?";
+            index += 3;
+        } else if (pattern.startsWith("**", index)) {
+            source += ".*";
+            index += 2;
+        } else if (pattern[index] === "*") {
+            source += "[^/]*";
+            index += 1;
+        } else {
+            source += pattern[index].replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+            index += 1;
+        }
+    }
+    return new RegExp(`^${source}$`);
+}
+
+const DEPENDENCY_GRAPH_INPUT_MATCHERS = DEPENDENCY_GRAPH_INPUT_PATTERNS.map(globToRegExp);
+
+export function isDependencyGraphInput(filePath) {
+    return DEPENDENCY_GRAPH_INPUT_MATCHERS.some((matcher) => matcher.test(filePath));
+}
 
 function normalizePath(value) {
     return String(value ?? "")
@@ -172,6 +217,7 @@ export function resolvePrImpact(changedFiles, modules, dependencies) {
     let runNodeTests = false;
     let codeqlActions = false;
     let codeqlJavaKotlin = false;
+    let dependencyReview = false;
     let forceFull = false;
     let repositoryQualityFixtures = false;
 
@@ -214,6 +260,9 @@ export function resolvePrImpact(changedFiles, modules, dependencies) {
         if (filePath.startsWith(".github/workflows/") || filePath.startsWith(".github/actions/")) {
             codeqlActions = true;
         }
+        if (isDependencyGraphInput(filePath)) {
+            dependencyReview = true;
+        }
         if (filePath === ".editorconfig") {
             globalKtlintChange = true;
         }
@@ -286,6 +335,10 @@ export function resolvePrImpact(changedFiles, modules, dependencies) {
         runKonsist = true;
         compileAndroidTest = true;
     }
+    if (forceFull) {
+        // 분류기 자신이나 처음 보는 경로가 바뀌면 의존성 입력이 없다고 단정하지 않는다.
+        dependencyReview = true;
+    }
 
     const productionAffected = reverseDependencyClosure(productionSeeds, reverseDependencies);
     if (productionAffected.size > 0) {
@@ -353,6 +406,7 @@ export function resolvePrImpact(changedFiles, modules, dependencies) {
         screenshotTasks,
         codeqlActions,
         codeqlJavaKotlin,
+        dependencyReview,
         repositoryQualityFull: forceFull,
         repositoryQualityFixtures,
     };
@@ -430,6 +484,7 @@ export function githubOutputLines(impact) {
         screenshot_tasks: impact.screenshotTasks.join(" "),
         codeql_actions: impact.codeqlActions,
         codeql_java_kotlin: impact.codeqlJavaKotlin,
+        dependency_review_required: impact.dependencyReview,
         repository_quality_full: impact.repositoryQualityFull,
         repository_quality_fixtures: impact.repositoryQualityFixtures,
     };
diff --git a/.github/scripts/resolve-pr-impact.test.mjs b/.github/scripts/resolve-pr-impact.test.mjs
index eacafa372d..96c98d6c77 100644
--- a/.github/scripts/resolve-pr-impact.test.mjs
+++ b/.github/scripts/resolve-pr-impact.test.mjs
@@ -219,3 +219,28 @@ test("GitHub outputs preserve empty scopes and booleans", () => {
     assert.match(output, /^unit_test_tasks=$/m);
     assert.match(output, /^codeql_actions=false$/m);
 });
+
+test("dependency review runs only for dependency graph inputs and fails closed", () => {
+    // #2258: Dependency Review 는 required 라 매 PR 에 check 가 생긴다. 검사 자체는 의존성
+    // 입력이 바뀐 PR 에서만 하고, 분류가 확신할 수 없는 변경은 검사 쪽으로 닫는다.
+    const sourceOnly = resolvePrImpact(["feature/home/presentation/src/main/kotlin/Home.kt"], modules, dependencies);
+    assert.equal(sourceOnly.dependencyReview, false);
+    assert.match(githubOutputLines(sourceOnly).join("\n"), /^dependency_review_required=false$/m);
+
+    for (const changed of [
+        ["gradle/libs.versions.toml"],
+        ["feature/home/presentation/build.gradle.kts"],
+        ["build-logic/convention/src/main/kotlin/Convention.kt"],
+        [".github/workflows/dependency-submission.yml"],
+        [".github/workflows/dependency-review.yml"],
+        [".github/workflows/pr-validation.yml"],
+        [".github/scripts/resolve-pr-impact.mjs"],
+        ["unexpected/runtime-config.toml"],
+    ]) {
+        const impact = resolvePrImpact(changed, modules, dependencies);
+        assert.equal(impact.dependencyReview, true, changed[0]);
+        assert.match(githubOutputLines(impact).join("\n"), /^dependency_review_required=true$/m);
+    }
+
+    assert.equal(resolvePrImpact(["README.md", "docs/qa/plan.md"], modules, dependencies).dependencyReview, false);
+});
diff --git a/.github/scripts/review-debt-policy.test.mjs b/.github/scripts/review-debt-policy.test.mjs
deleted file mode 100644
index 1c507ddb5c..0000000000
--- a/.github/scripts/review-debt-policy.test.mjs
+++ /dev/null
@@ -1,249 +0,0 @@
-import assert from "node:assert/strict";
-import { readFile } from "node:fs/promises";
-import test from "node:test";
-
-const guard = await readFile(new URL("../workflows/review-debt-guard.yml", import.meta.url), "utf8");
-const requestAll = await readFile(new URL("../workflows/review-request-all.yml", import.meta.url), "utf8");
-
-test("team membership is judged by real permission, not author_association", () => {
-    // 웹훅 페이로드의 author_association 은 조직 멤버십이 비공개면 MEMBER 대신
-    // CONTRIBUTOR 를 내린다. 이 조직은 공개 멤버가 0명이라, 레포에 직접 초대된 한
-    // 계정만 COLLABORATOR 로 찍혀 검사를 받고 나머지 팀원은 전원 건너뛰어졌다.
-    // 가드가 한 사람만 막는 상태였다 (8/25 #1152·#1154 통과 / #1112 만 닫힘).
-    // 주석은 이력이라 남기고, 실제로 값을 끌어오는 자리만 금지한다.
-    assert.doesNotMatch(guard, /^\s*[A-Z_]+:\s*\$\{\{[^\n]*author_association/m);
-    assert.doesNotMatch(guard, /\$ASSOCIATION/);
-    assert.match(guard, /collaborators\/\$AUTHOR\/permission/);
-});
-
-test("only write-capable accounts are subject to the guard", () => {
-    // read 권한만 있는 계정은 리뷰로 판정을 낼 수 없으니 빚을 질 수도 없다.
-    assert.match(guard, /^\s*admin\|maintain\|write\)/m);
-    // 빈 값·예상 밖 값까지 «권한 없음» 으로 접으면 조회 실패가 통과로 둔갑한다.
-    assert.match(guard, /^\s*read\|none\)[^\n]*exit 0/m);
-    assert.match(guard, /^\s*\*\) echo "::error::권한 값을 알 수 없다[^\n]*exit 1/m);
-});
-
-test("a failed permission lookup fails the run instead of passing the pull request", () => {
-    // 조회 실패를 «권한 없음» 으로 접으면 가드 전체가 조용히 무력해진다.
-    assert.match(guard, /if ! perm=\$\(gh api[^\n]*\n\s*echo "::error::[^\n]*\n\s*exit 1/);
-});
-
-test("forks are excluded by head repository, not by contributor status", () => {
-    // fork PR 은 토큰이 read-only 라 닫지도 못한다. 그것이 원래 걸러내려던 것이고,
-    // author_association 은 그 판정에 쓸 수 없는 축이었다.
-    assert.match(guard, /\[ "\$HEAD_REPO" != "\$REPO" \]/);
-});
-
-test("the debt sweep still fails closed when open pull requests cannot be listed", () => {
-    // 조회 실패를 «빚 없음» 으로 오인하면 새 PR 이 전부 통과한다.
-    assert.match(guard, /if ! open_prs=\$\(gh api[^\n]*\n(?:[^\n]*\n)*?\s*exit 1/);
-});
-
-test("a pull request is never counted as debt against its own responsible person", () => {
-    // «자기 PR» 은 작성자가 아니라 담당자(어사인, 비어 있으면 작성자) 기준이다(#1974).
-    // 작성자 로그인만 보면 남이 올려 내게 어사인된 PR 을 내가 리뷰해야 하는 것으로 세고,
-    // 내가 올려 남에게 어사인된 PR 을 내 리뷰 목록에서 뺀다.
-    assert.doesNotMatch(guard, /select\(\.user\.login != \\"\$AUTHOR\\"\)/);
-    assert.match(guard, /if \(\.assignees \| length\) > 0 then \[\.assignees\[\]\.login\] else \[\.user\.login\] end/);
-    assert.match(guard, /select\(\(\\\$owners \| index\(\\"\$author_lc\\"\)\) == null\)/);
-});
-
-test("the request-all job excludes the responsible person, not only the author", () => {
-    // GitHub 은 작성자만 리뷰어에서 자동으로 뺀다. 어사인된 담당자는 직접 빼야 한다.
-    assert.match(requestAll, /ASSIGNEES: \$\{\{ join\(github\.event\.pull_request\.assignees\.\*\.login, ' '\) \}\}/);
-    assert.match(requestAll, /owners_lc=\$\(printf '%s' "\$\{ASSIGNEES:-\$AUTHOR\}"/);
-    assert.match(requestAll, /case " \$owners_lc " in\n\s*\*" \$u_lc "\*\) continue ;;/);
-    assert.doesNotMatch(requestAll, /\[ "\$u" != "\$AUTHOR" \] \|\| continue/);
-});
-
-test("the dead review_request_removed path is gone", () => {
-    // 빚 기준은 여전히 열린 PR 전체다. 변경요청 뒤 명시적 재요청 여부를 확인하더라도
-    // 요청 제거 자체를 별도 감사하는 job 은 가드 런 19건 동안 발동한 적이 없었다.
-    // 주석은 이력이라 남기고, 실제로 트리거를 걸고 job 을 세우는 자리만 금지한다.
-    assert.doesNotMatch(guard, /^\s*types:[^\n]*review_request_removed/m);
-    assert.doesNotMatch(guard, /^\s{2}bypass-audit:/m);
-});
-
-test("changes requested becomes debt only after explicit rerequest and a fix", () => {
-    // 수정 커밋만으로 리뷰 의무를 만들지 않는다. 변경요청을 낸 리뷰어가 현재 요청
-    // 목록에 다시 들어온 경우에만 반영 여부를 보고 빚으로 센다.
-    assert.match(guard, /CHANGES_REQUESTED/);
-    assert.match(guard, /requested_reviewers\[\]\.login/);
-    assert.match(guard, /blocked_by/);
-    assert.match(guard, /명시적 재리뷰 요청 없음/);
-    assert.match(guard, /sort_by\(\.t\) \| last/);
-    assert.doesNotMatch(guard, /group_by\(\.u/);
-    assert.match(guard, /\(\.parents \| length\) < 2/);
-    // 반영 판정의 기준 시각은 여전히 최신 변경요청 시각이다. 집계가 jq 에서 awk 로
-    // 옮겨 갔을 뿐, 그 이전 커밋을 반영으로 세지 않는다.
-    assert.match(guard, /-v cutoff="\$blocked_at"/);
-    assert.match(guard, /\$4 > cutoff/);
-});
-
-test("a reviewer's own commit is never counted as the author's fix", () => {
-    // 누가 올렸는지를 안 보면 리뷰어가 미는 CI 재트리거 커밋이 «작성자가 반영했다» 가
-    // 된다. 8/28 에 리뷰어가 건 +0/-0 커밋 하나로 koongmai PR 3건(#1379·#1365·#882)이
-    // 전부 가짜 빚이 됐고, 재트리거한 리뷰어가 그 대가로 자기 PR 을 못 열었다 (#1459).
-    assert.match(guard, /\(\.author\.login \/\/ ""\)/);
-    // 담당자는 여럿일 수 있어 집합으로 가린다.
-    assert.match(guard, /login in target/);
-    assert.match(guard, /-v owners="\$pr_owners"/);
-    // 계정이 연결되지 않은 커밋은 login 이 비어 가릴 수 없다. 같은 PR 에서 담당자
-    // 것으로 확인된 커밋의 이메일을 폴백 신원으로 쓴다.
-    assert.match(guard, /\(\.commit\.author\.email \/\/ ""\)/);
-    assert.match(guard, /email in own/);
-});
-
-test("an empty commit is not a fix", () => {
-    // pulls/{n}/commits 응답에는 파일 정보가 없다. 작성자 커밋으로 좁힌 후보에 한해
-    // commits/{sha} 를 조회해 바뀐 파일이 0건이면 버린다.
-    assert.match(guard, /repos\/\$REPO\/commits\/\$sha/);
-    assert.match(guard, /\(\.files \/\/ \[\]\) \| length/);
-    assert.match(guard, /\[ "\$changed" -gt 0 \] \|\| continue/);
-    // 조회 실패나 깨진 응답을 반영·미반영 어느 쪽으로도 접지 않는다. 근거가 완전하지
-    // 않으면 가드를 실패시켜 사람의 정상 PR 을 닫는 오탐을 막는다.
-    assert.doesNotMatch(guard, /changed=1/);
-    assert.match(guard, /변경 파일 조회에 실패했다/);
-    assert.match(guard, /변경 파일 수가 올바르지 않다/);
-});
-
-test("review evidence API failures stop the guard before it can close a pull request", () => {
-    // 리뷰·커밋·댓글을 못 읽은 상태는 «응답 없음» 이 아니다. 각 근거 조회가 실패하면
-    // 즉시 종료하고, `|| true` 나 stderr 폐기로 빈 결과를 만들어서는 안 된다.
-    for (const message of [
-        "리뷰 조회에 실패했다",
-        "커밋 조회에 실패했다",
-        "변경 파일 조회에 실패했다",
-        "작성자 일반 응답 조회에 실패했다",
-        "작성자 리뷰 응답 조회에 실패했다",
-        "본문 편집 이력 조회에 실패했다",
-        "본문 편집 이력이 불완전하다",
-    ]) {
-        assert.match(guard, new RegExp(message));
-    }
-    assert.doesNotMatch(guard, /gh api[^\n]*(?:\n[^\n]*){0,4}\|\| true/);
-    assert.doesNotMatch(guard, /gh api[^\n]*2>\/dev\/null/);
-});
-
-test("a fix delivered by a merge commit still counts as a response", () => {
-    // 비병합 커밋만 세면 base 를 끌어와 충돌을 풀며 반영한 PR 이 «미반영» 이 된다.
-    // #1316 은 리뷰가 지목한 파일이 실제로 바뀌고 작성자 응답 코멘트도 2건 달린
-    // 채로 빚에서 빠져 있었다. 커밋과 함께 작성자의 응답을 본다 (#1450).
-    assert.match(guard, /issues\/\$pn\/comments/);
-    assert.match(guard, /pulls\/\$pn\/comments/);
-    // 담당자·시각 판정은 review-debt-query.test.mjs에서 실제 jq로 검증한다.
-    assert.match(guard, /\[ "\$\{fixed:-0\}" -gt 0 \] \|\| \[ "\$responses" -gt 0 \]/);
-});
-
-test("counts are taken per item so paginated pull requests do not break the comparison", () => {
-    // --paginate 는 페이지마다 jq 를 돌린다. 페이지 단위로 length 를 뽑으면 커밋이
-    // 100건을 넘는 PR 에서 숫자가 여러 줄로 나와 -gt 비교가 죽는다.
-    assert.doesNotMatch(guard, /\| length" 2>\/dev\/null/);
-    assert.match(guard, /\| wc -l \| tr -d ' '/);
-});
-
-test("rerequests are automated so silence cannot pass the guard", () => {
-    // 가드는 변경요청을 낸 리뷰어에게 요청이 다시 걸린 경우에만 빚으로 센다. 그
-    // 되살리기를 작성자 손에 맡기면 아무도 걸지 않아 가드가 통째로 무력해진다 —
-    // 8/29 실측에서 반영까지 끝난 7건이 전원 «빚 아님» 이었다 (#1450).
-    assert.match(requestAll, /^\s*types: \[opened, ready_for_review, reopened, synchronize, edited\]/m);
-    assert.match(requestAll, /^\s{2}rerequest:/m);
-    assert.match(requestAll, /github\.event\.action == 'synchronize'/);
-    assert.match(requestAll, /github\.event\.action == 'edited'/);
-    assert.match(requestAll, /github\.event\.changes\.body != null/);
-    // 본문 편집은 담당자(어사인, 비어 있으면 작성자)의 것만 조치다(#1974).
-    assert.match(
-        requestAll,
-        /contains\(github\.event\.pull_request\.assignees\.\*\.login, github\.event\.sender\.login\)/,
-    );
-    assert.match(
-        requestAll,
-        /github\.event\.pull_request\.assignees\[0\] == null &&\n\s*github\.event\.sender\.login == github\.event\.pull_request\.user\.login/,
-    );
-    // 담당자가 낸 변경요청은 되살리지 않는다.
-    assert.match(requestAll, /\*" \$blocked_lc "\*\) echo "변경요청을 낸 사람이 담당자 본인/);
-    assert.match(requestAll, /github\.event\.pull_request\.state == 'open'/);
-    assert.match(requestAll, /--add-reviewer "\$blocked"/);
-    // 기존 전원 요청은 반영 커밋이나 본문 편집마다 다시 돌지 않는다.
-    assert.match(requestAll, /github\.event\.action != 'synchronize'/);
-    assert.match(requestAll, /github\.event\.action != 'edited'/);
-});
-
-test("rerequest review lookup fails closed because body edits are one-shot events", () => {
-    assert.match(requestAll, /리뷰 조회에 실패했다 — 재리뷰 요청을 누락시키지 않도록 재실행할 것/);
-    assert.match(requestAll, /최신 리뷰 판정에 실패했다 — 재리뷰 요청을 누락시키지 않도록 재실행할 것/);
-    assert.doesNotMatch(requestAll, /gh api[^\n]*(?:\n[^\n]*){0,4}2>\/dev\/null/);
-    assert.doesNotMatch(requestAll, /gh api[^\n]*(?:\n[^\n]*){0,4}\|\| true/);
-});
-
-test("an edited event cannot be attributed to a later change request", () => {
-    assert.match(requestAll, /EVENT_AT: \$\{\{ github\.event\.pull_request\.updated_at \}\}/);
-    assert.match(requestAll, /\$action != "edited" or \.t < \$event_at/);
-    assert.match(requestAll, /본문 편집 이벤트 시각이 없다/);
-});
-
-test("author body edits are durable review evidence and fail closed when truncated", () => {
-    // updated_at 은 댓글·라벨까지 섞이고 lastEditedAt 은 마지막 편집자만 남긴다. 영속
-    // userContentEdits 에서 최신 변경요청 뒤 PR 작성자의 편집만 세어야 한다.
-    assert.match(guard, /userContentEdits\(last:50\)/);
-    assert.match(guard, /editor\{login\}/);
-    assert.match(guard, /\.editor\.login/);
-    assert.match(guard, /\.editedAt > \$cutoff/);
-    assert.match(guard, /--arg owners ",\$pr_owners,"/);
-    assert.match(guard, /pageInfo\.hasPreviousPage != false/);
-    assert.match(guard, /\[ "\$body_edits" -gt 0 \]/);
-});
-
-test("the rerequest job and the guard judge by the same latest decision", () => {
-    // 한쪽만 «PR 전체의 최신 판정» 을 보면 자동 재요청이 빚으로 이어지지 않거나,
-    // 이미 승인된 PR 에 요청을 되살린다.
-    for (const wf of [guard, requestAll]) {
-        assert.match(wf, /sort_by\(\.t\) \| last/);
-        assert.match(wf, /CHANGES_REQUESTED/);
-    }
-    // 봇·fork 는 토큰이 read-only 라 요청을 걸 수 없다.
-    assert.match(requestAll, /\[ "\$HEAD_REPO" != "\$REPO" \]/);
-});
-
-function spaceSeparatedEnv(workflow, name) {
-    const match = new RegExp(`^\\s*${name}: ([^\\n#]+)$`, "m").exec(workflow);
-    assert.ok(match, `${name} 환경변수를 찾지 못했다`);
-    return match[1].trim().split(/\s+/).filter(Boolean).map((login) => login.toLowerCase());
-}
-
-test("the gate exemption is judged before any debt is counted", () => {
-    // 면제를 빚 계산 뒤에 두면, 면제받은 사람의 PR 때문에 조회가 실패했을 때 가드가 그를
-    // 대신해 죽는다. 봇·fork·권한 판정과 같은 자리, 열린 PR 을 훑기 전에 둔다 (#1910).
-    const exemptAt = guard.indexOf("리뷰 게이트 면제 작성자");
-    const sweepAt = guard.indexOf("if ! open_prs=$(gh api");
-    assert.ok(exemptAt > 0, "면제 경로가 없다");
-    assert.ok(sweepAt > exemptAt, "면제가 빚 계산 뒤에 있다");
-    assert.match(guard, /리뷰 게이트 면제 작성자\(\$AUTHOR\)[^\n]*exit 0/);
-});
-
-test("exempt logins are matched case-insensitively", () => {
-    // GitHub 로그인은 대소문자를 가리지 않는다. 그대로 비교하면 웹훅이 Koongmai 를 내리는
-    // 순간 면제가 조용히 풀리고, 그 사람의 PR 이 닫힌다.
-    assert.match(guard, /author_lc=\$\(printf '%s' "\$AUTHOR" \| tr '\[:upper:\]' '\[:lower:\]'\)/);
-    assert.match(guard, /exempt_lc=\$\(printf '%s' "\$REVIEW_GATE_EXEMPT_AUTHORS" \| tr '\[:upper:\]' '\[:lower:\]'\)/);
-});
-
-test("a change request from an exempt reviewer is not charged to the rest of the team", () => {
-    // 면제된 사람은 리뷰할 의무가 없다. 그가 자발적으로 낸 변경요청 뒤 침묵하면 그 침묵의
-    // 대가를 나머지 팀원이 "새 PR 을 못 연다" 로 치른다. 그래도 그 PR 이 그냥 머지되지는
-    // 않는다. 승인 1건은 required-approval 룰셋이 계속 요구한다.
-    assert.match(guard, /case " \$exempt_lc " in\n\s*\*" \$blocked_by "\*\)/);
-    assert.match(guard, /면제 리뷰어 @\$blocked_by/);
-});
-
-test("nobody is exempt from the gate while still on the automatic review roster", () => {
-    // 리뷰 의무가 없는 사람에게 요청만 계속 걸면, 그 요청은 아무도 응답하지 않는 알림으로
-    // 쌓이고 두 워크플로가 서로 다른 팀 명단을 갖게 된다.
-    const exempt = spaceSeparatedEnv(guard, "REVIEW_GATE_EXEMPT_AUTHORS");
-    const team = spaceSeparatedEnv(requestAll, "TEAM");
-    for (const login of exempt) {
-        assert.ok(!team.includes(login), `${login} 이 면제이면서 자동 요청 대상이다`);
-    }
-    assert.ok(team.length > 0, "자동 요청 대상이 비었다");
-});
diff --git a/.github/scripts/review-debt-query.test.mjs b/.github/scripts/review-debt-query.test.mjs
deleted file mode 100644
index 9751d19ab5..0000000000
--- a/.github/scripts/review-debt-query.test.mjs
+++ /dev/null
@@ -1,62 +0,0 @@
-import assert from "node:assert/strict";
-import { readFile } from "node:fs/promises";
-import { spawnSync } from "node:child_process";
-import test from "node:test";
-
-const guard = await readFile(new URL("../workflows/review-debt-guard.yml", import.meta.url), "utf8");
-const cutoff = "2026-09-10T00:00:00Z";
-const owners = "koongmai,1hyok";
-
-function runQuery(query, data, args = []) {
-    return spawnSync("jq", ["-r", ...args, query], { input: JSON.stringify(data), encoding: "utf8" });
-}
-
-for (const endpoint of ["issues", "pulls"]) {
-    test(`${endpoint} comments retain author context and count only later owner responses`, () => {
-        const start = guard.indexOf(`repos/$REPO/${endpoint}/$pn/comments?per_page=100`);
-        assert.ok(start >= 0);
-        const raw = guard.slice(start).match(/--jq "([\s\S]*?)" \\\n/)[1];
-        const query = raw.replaceAll("$pr_owners", owners).replaceAll("$blocked_at", cutoff)
-            .replaceAll('\\"', '"').replaceAll('\\$', '$');
-        const comments = [
-            { id: 1, user: { login: "KoongMai" }, created_at: "2026-09-11T00:00:00Z" },
-            { id: 2, user: { login: "1hyok" }, created_at: "2026-09-12T00:00:00Z" },
-            { id: 3, user: { login: "koongmai" }, created_at: cutoff },
-            { id: 4, user: { login: "koong" }, created_at: "2026-09-11T00:00:00Z" },
-            { id: 5, user: { login: "other" }, created_at: "2026-09-11T00:00:00Z" },
-        ];
-        // gh --paginate executes its query separately on each page.
-        const pages = [comments.slice(0, 1), comments.slice(1), []];
-        const output = pages.map(page => {
-            const result = runQuery(query, page);
-            assert.equal(result.status, 0, result.stderr);
-            return result.stdout;
-        }).join("");
-        assert.equal(output, "1\n2\n");
-    });
-}
-
-const bodyQuery = guard.match(/--arg cutoff "\$blocked_at" '([\s\S]*?)' <<< "\$edits_json"/)[1];
-function edits(nodes, hasPreviousPage = false) {
-    return { data: { repository: { pullRequest: { userContentEdits: { nodes, pageInfo: { hasPreviousPage } } } } } };
-}
-const args = ["--arg", "owners", `,${owners},`, "--arg", "cutoff", cutoff];
-
-test("body edit evidence keeps editor context, cutoff, and exact owner membership", () => {
-    const result = runQuery(bodyQuery, edits([
-        { editor: { login: "KOONGMAI" }, editedAt: "2026-09-11T00:00:00Z" },
-        { editor: { login: "1hyok" }, editedAt: "2026-09-12T00:00:00Z" },
-        { editor: { login: "koongmai" }, editedAt: cutoff },
-        { editor: { login: "koong" }, editedAt: "2026-09-11T00:00:00Z" },
-        { editor: null, editedAt: "2026-09-11T00:00:00Z" },
-    ]), args);
-    assert.equal(result.status, 0, result.stderr);
-    assert.equal(result.stdout, "2\n");
-    assert.equal(runQuery(bodyQuery, edits([]), args).stdout, "0\n");
-});
-
-test("truncated body edit history still fails closed", () => {
-    const result = runQuery(bodyQuery, edits([], true), args);
-    assert.notEqual(result.status, 0);
-    assert.match(result.stderr, /최근 50건보다 많은 본문 편집 이력/);
-});
diff --git a/.github/scripts/supply-chain-policy.test.mjs b/.github/scripts/supply-chain-policy.test.mjs
index 787af146b9..0ca50431f7 100644
--- a/.github/scripts/supply-chain-policy.test.mjs
+++ b/.github/scripts/supply-chain-policy.test.mjs
@@ -5,7 +5,11 @@ import path from 'node:path';
 import test from 'node:test';
 import { fileURLToPath } from 'node:url';
 
-import { inspectModules } from './resolve-pr-impact.mjs';
+import {
+  DEPENDENCY_GRAPH_INPUT_PATTERNS,
+  inspectModules,
+  isDependencyGraphInput,
+} from './resolve-pr-impact.mjs';
 
 const workflowDirectory = new URL('../workflows/', import.meta.url);
 const repoRoot = path.resolve(fileURLToPath(new URL('../..', import.meta.url)));
@@ -122,18 +126,6 @@ function checkoutStepBlocks(source) {
   return blocks;
 }
 
-function eventPathFilters(source, eventName) {
-  const match = new RegExp(`^  ${eventName}:\\n    paths:\\n((?:      - '[^']+'\\n)+)`, 'm').exec(
-    source,
-  );
-  assert.ok(match, `${eventName} must declare a paths filter`);
-  return match[1].trim().split('\n').map((line) => {
-    const path = /^- '([^']+)'$/.exec(line.trim());
-    assert.ok(path, `invalid dependency path filter: ${line}`);
-    return path[1];
-  });
-}
-
 function workflowName(source) {
   const match = /^name:\s*(.+)$/m.exec(source);
   assert.ok(match, 'workflow must declare a top-level name');
@@ -488,7 +480,7 @@ test('manual dependency baseline is hard-wired to the checked-out main SHA', asy
   assert.doesNotMatch(manualJob, /inputs\./);
 });
 
-test('all pull request heads produce a baseline while dependency review keeps its path filter', async () => {
+test('all pull request heads produce a baseline while dependency review classifies inputs in the job', async () => {
   const submission = await readFile(
     new URL('../workflows/dependency-submission.yml', import.meta.url),
     'utf8',
@@ -504,7 +496,12 @@ test('all pull request heads produce a baseline while dependency review keeps it
   assert.doesNotMatch(submission, /^\s+(?:paths(?:-ignore)?|branches(?:-ignore)?|types):/m);
   assert.doesNotMatch(submission, /^\s+if:/m);
   assert.doesNotMatch(submission, /pull_request_target:|workflow_dispatch:/);
-  assert.deepEqual(eventPathFilters(review, 'pull_request'), dependencyPathFilters);
+  // #2258: paths 필터는 소스만 고친 PR 에 check 를 만들지 않아 required 로 걸 수 없다.
+  // 같은 경로 목록을 repository-quality 의 분류로 옮기고, review 는 PR Validation 이 매번 부른다.
+  assert.match(review, /^on:\n  workflow_call:\n/m);
+  assert.doesNotMatch(review, /^\s+(?:paths(?:-ignore)?|branches(?:-ignore)?):/m);
+  assert.doesNotMatch(review, /^  (?:pull_request|merge_group|push):/m);
+  assert.deepEqual([...DEPENDENCY_GRAPH_INPUT_PATTERNS], dependencyPathFilters);
   assert.doesNotMatch(submission, /Detect dependency graph input changes/);
   assert.doesNotMatch(review, /Detect dependency graph input changes/);
 });
@@ -607,6 +604,44 @@ test('only the release pull request is exempt from the path-filter boundary', as
   assert.doesNotMatch(exemption[1], /exit\s+1/);
 });
 
+test('dependency graph input classification matches the former paths filter semantics', () => {
+  for (const filePath of [
+    'build.gradle.kts',
+    'settings.gradle.kts',
+    'app/build.gradle.kts',
+    'legacy/build.gradle',
+    'gradle.properties',
+    'feature/home/gradle.properties',
+    'gradlew',
+    'gradlew.bat',
+    'gradle/libs.versions.toml',
+    'gradle/wrapper/gradle-wrapper.properties',
+    'build-logic/convention/src/main/kotlin/AndroidLibrary.kt',
+    'tools/buildSrc/src/main/kotlin/Plugin.kt',
+    'app/dependencies.lockfile',
+    '.github/workflows/dependency-review.yml',
+    '.github/workflows/dependency-submission.yml',
+    '.github/workflows/dependency-submission-trusted.yml',
+    '.github/workflows/dependency-submission-upload.yml',
+  ]) {
+    assert.equal(isDependencyGraphInput(filePath), true, filePath);
+  }
+  for (const filePath of [
+    'README.md',
+    'docs/gradle.md',
+    'app/src/main/kotlin/MainActivity.kt',
+    'app/src/main/res/values/strings.xml',
+    'feature/gradle/Screen.kt',
+    'build-logic',
+    'gradle',
+    'gradlew.sh',
+    'app/build.gradle.kts.orig',
+    '.github/workflows/pr-validation.yml',
+  ]) {
+    assert.equal(isDependencyGraphInput(filePath), false, filePath);
+  }
+});
+
 test('dependency review blocks high severity changes without enforcing a license allowlist', async () => {
   const source = await readFile(new URL('../workflows/dependency-review.yml', import.meta.url), 'utf8');
 
diff --git a/.github/scripts/validate-pr-issue-link.mjs b/.github/scripts/validate-pr-issue-link.mjs
index 80c3c573ba..3319f1c681 100644
--- a/.github/scripts/validate-pr-issue-link.mjs
+++ b/.github/scripts/validate-pr-issue-link.mjs
@@ -75,7 +75,6 @@ function issueAssigneeLogins(issue) {
 }
 
 // 봇은 Issue 담당자로 지정할 수 없으므로 담당자 대조에서 면제한다.
-// review-debt-guard·review-request-all 의 봇 면제 규약과 같은 경계다.
 function isBotAuthor(user, login) {
     return user?.type === "Bot" || login.endsWith("[bot]");
 }
@@ -123,7 +122,9 @@ export async function validatePullRequestIssueLink({ pullRequest, repository, lo
     // 대표 Issue 는 이 PR 이 끝내는 Issue 다. Refs 로 걸 수 있게 두면 두 가지 도피로가 열린다 —
     // 열린 blocked_by 가 있는 Issue 를 merge-order-guard 밖에서 머지하고 Issue 는 손으로 닫는 것,
     // Issue 의 일부만 하고 남는 몫을 본문 산문에만 남기는 것 (#1748). 일부만 한다면 그 몫을 새 Issue 로
-    // 분리해 대표 Issue 로 삼는다. 봇 PR 은 사람이 나중에 링크를 붙이는 구조라 종전대로 Refs 를 허용한다.
+    // 분리해 대표 Issue 로 삼는다. 봇 PR 은 closing 키워드를 면제한다(금지가 아니다). 사람이 나중에 붙이는
+    // 링크는 여러 봇 PR 이 공유하는 Issue 일 수 있어 Refs 를 허용하고, dependabot-pr-gate 가 PR 마다 만든
+    // Issue 는 Closes 로 건다(#2274).
     const botAuthor = isBotAuthor(pullRequest.user, author);
     if (!botAuthor) {
         const closingReferences = extractClosingIssueNumbers(pullRequest.body, repository);
diff --git a/.github/workflows/android-managed-device.yml b/.github/workflows/android-managed-device.yml
index 7646189a31..5cfd3b6cfe 100644
--- a/.github/workflows/android-managed-device.yml
+++ b/.github/workflows/android-managed-device.yml
@@ -77,7 +77,7 @@ jobs:
           java-version: "21"
 
       - name: Set up Gradle and validate wrapper
-        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
+        uses: gradle/actions/setup-gradle@3f5f9adaf7d9fecd50b5935e54106014257a94e6 # v6.4.0
         with:
           cache-provider: basic
           cache-read-only: true
@@ -298,8 +298,21 @@ jobs:
               # tested revision의 권한 없는 classifier를 신뢰 경계 밖에서 실행하지 않는다.
               classifier=unavailable
             fi
-            printf 'renderer=%s\nclassifier=%s\nexpected_failures=%s\nsource=trusted\n' \
-              "$renderer" "$classifier" "$expected_failures" >> "$GITHUB_OUTPUT"
+            # dependabot PR 은 게이트가 CI Test Plan 을 채울 때까지 이 신뢰 사본으로 기다린다(#2212).
+            # 파일 존재가 아니라 await 명령의 존재로 가른다. 이 파일은 #2112 부터 default branch 에
+            # 있어서, 존재만 보면 도입 PR 이 명령 없는 옛 사본을 부른다.
+            if [[ -f .github/scripts/dependabot-pr-gate.mjs ]] &&
+               grep -q 'export async function awaitGate' .github/scripts/dependabot-pr-gate.mjs; then
+              install -m 0644 \
+                .github/scripts/dependabot-pr-gate.mjs \
+                "$policy_dir/dependabot-pr-gate.mjs"
+              dependabot_gate=trusted
+            else
+              # 도입 PR 은 사람이 연다. 기다릴 게이트가 없으니 종전처럼 이벤트 페이로드를 읽는다.
+              dependabot_gate=unavailable
+            fi
+            printf 'renderer=%s\nclassifier=%s\nexpected_failures=%s\ndependabot_gate=%s\nsource=trusted\n' \
+              "$renderer" "$classifier" "$expected_failures" "$dependabot_gate" >> "$GITHUB_OUTPUT"
           elif [[ ! -e .github/scripts/ci-test-plan.mjs &&
                   ! -e .github/scripts/resolve-android-test-plan.mjs &&
                   ! -e .github/scripts/resolve-pr-impact.mjs &&
@@ -312,6 +325,7 @@ jobs:
               renderer=bootstrap \
               classifier=unavailable \
               expected_failures=unavailable \
+              dependabot_gate=unavailable \
               source=bootstrap >> "$GITHUB_OUTPUT"
           else
             echo "::error::Android test policy가 부분 설치된 상태입니다"
@@ -322,10 +336,12 @@ jobs:
         id: target
         env:
           DEFAULT_BRANCH: ${{ github.event.repository.default_branch }}
+          DEPENDABOT_GATE: ${{ steps.policy.outputs.dependabot_gate }}
           DISPATCH_REF_NAME: ${{ github.ref_name }}
           DISPATCH_PR_NUMBER: ${{ inputs.pull_request_number || 0 }}
           DEVICE: ${{ matrix.device }}
           EVENT_NAME: ${{ github.event_name }}
+          EVENT_PR_AUTHOR: ${{ github.event.pull_request.user.login }}
           EVENT_PR_BRANCH: ${{ github.event.pull_request.head.ref }}
           EVENT_PR_NUMBER: ${{ github.event.pull_request.number }}
           EVENT_PR_SHA: ${{ github.event.pull_request.head.sha }}
@@ -344,7 +360,22 @@ jobs:
             target_pr="$EVENT_PR_NUMBER"
             target_branch="$EVENT_PR_BRANCH"
             target_sha="$EVENT_PR_SHA"
-            jq '.pull_request' "$GITHUB_EVENT_PATH" > "$pull_request_file"
+            if [[ "$EVENT_PR_AUTHOR" == "dependabot[bot]" && "$DEPENDABOT_GATE" == "trusted" ]]; then
+              # dependabot-pr-gate 가 같은 순간 GITHUB_TOKEN 으로 CI Test Plan 을 채운다. 그 edited 는
+              # 이 워크플로를 다시 깨우지 못하고 페이로드는 opened 시점 값이다(#2212). 페이로드 제목에
+              # 대표 이슈 번호가 이미 있으면 API 없이 그대로 쓰고, 없으면 게이트가 채울 때까지 live PR 을
+              # 기다린다. 재실행으로 풀면 실제 테스트가 attempt 2 에서 돌아 1회차 인프라 복구를 잃는다.
+              # lane timeout 이 15분 이상이라 3분까지 기다린다.
+              PR_NUMBER="$EVENT_PR_NUMBER" AWAIT_TIMEOUT_SECONDS=180 \
+                node "$RUNNER_TEMP/android-test-policy/dependabot-pr-gate.mjs" await "$pull_request_file"
+              live_head_sha="$(jq -r '.head.sha' "$pull_request_file")"
+              if [[ "$live_head_sha" != "$EVENT_PR_SHA" ]]; then
+                echo "::error::기다리는 사이 PR head 가 $EVENT_PR_SHA 에서 $live_head_sha 로 움직였습니다. 새 head 의 run 이 판정합니다"
+                exit 1
+              fi
+            else
+              jq '.pull_request' "$GITHUB_EVENT_PATH" > "$pull_request_file"
+            fi
           elif [[ "$EVENT_NAME" == "workflow_dispatch" && "$DISPATCH_PR_NUMBER" != "0" ]]; then
             if ! [[ "$DISPATCH_PR_NUMBER" =~ ^[1-9][0-9]*$ ]]; then
               echo "::error::유효한 pull_request_number 가 필요합니다"
@@ -556,7 +587,7 @@ jobs:
 
       - name: Set up Gradle and validate wrapper
         if: steps.target.outputs.run_lane == 'true'
-        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
+        uses: gradle/actions/setup-gradle@3f5f9adaf7d9fecd50b5935e54106014257a94e6 # v6.4.0
         with:
           cache-provider: basic
           cache-read-only: true
@@ -616,8 +647,11 @@ jobs:
             local test_arguments=() jvm_arguments=()
             # #1824 merge-group API34: cold APK packaging exhausted the 2Gi heap
             # in ApkFlinger. The 15Gi runner still had 7Gi available, so reserve
-            # 4Gi for this lane only and preserve the existing UTF-8 JVM flag.
-            if [[ "$DEVICE_TASK" == "pixel2Api34DebugAndroidTest" ]]; then
+            # 4Gi and preserve the existing UTF-8 JVM flag.
+            # #2250 merge-group API30 (#1837 큐): 같은 ApkFlinger OOM 이 :app:packageDebug 에서
+            # 시스템 이미지 설치와 겹쳐 났다. 전체 androidTest 레인도 같은 4Gi 를 쓴다.
+            if [[ "$DEVICE_TASK" == "pixel2Api34DebugAndroidTest" ||
+                  "$DEVICE_TASK" == "pixel2Api30DebugAndroidTest" ]]; then
               jvm_arguments+=("-Dorg.gradle.jvmargs=-Xmx4096m -Dfile.encoding=UTF-8")
             fi
             if [[ -n "$selectors" ]]; then
diff --git a/.github/workflows/api-contract-smoke.yml b/.github/workflows/api-contract-smoke.yml
index e72e94d48f..fa343bae0a 100644
--- a/.github/workflows/api-contract-smoke.yml
+++ b/.github/workflows/api-contract-smoke.yml
@@ -59,7 +59,7 @@ jobs:
           java-version: '21'
 
       - name: Set up Gradle and validate wrapper
-        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
+        uses: gradle/actions/setup-gradle@3f5f9adaf7d9fecd50b5935e54106014257a94e6 # v6.4.0
         with:
           cache-provider: basic
           cache-read-only: true
diff --git a/.github/workflows/baseline-profile.yml b/.github/workflows/baseline-profile.yml
index 4135680397..c14100494e 100644
--- a/.github/workflows/baseline-profile.yml
+++ b/.github/workflows/baseline-profile.yml
@@ -47,7 +47,7 @@ jobs:
           java-version: '21'
 
       - name: Set up Gradle and validate wrapper
-        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
+        uses: gradle/actions/setup-gradle@3f5f9adaf7d9fecd50b5935e54106014257a94e6 # v6.4.0
         with:
           cache-provider: basic
           cache-read-only: true
diff --git a/.github/workflows/build-cache-warm.yml b/.github/workflows/build-cache-warm.yml
index cc8655fa60..2094bbf7ad 100644
--- a/.github/workflows/build-cache-warm.yml
+++ b/.github/workflows/build-cache-warm.yml
@@ -63,7 +63,7 @@ jobs:
       # «default branch 에서만 write» 인데 이 저장소의 default branch 는 main 이라, develop 에서
       # 쓰려면 명시해야 한다. 캐시 대상에는 caches/build-cache-1 이 포함된다.
       - name: Set up Gradle and validate wrapper
-        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
+        uses: gradle/actions/setup-gradle@3f5f9adaf7d9fecd50b5935e54106014257a94e6 # v6.4.0
         with:
           cache-provider: basic
           cache-read-only: false
diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
index f527e90441..fabfb0defe 100644
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@@ -136,14 +136,14 @@ jobs:
           persist-credentials: false
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@1c5b675653bb5c22dbe9b12b556ec555138e09fd # v4.38.1
+        uses: github/codeql-action/init@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2
         with:
           languages: actions
           build-mode: none
 
       - name: Analyze and upload CodeQL results
         id: analyze
-        uses: github/codeql-action/analyze@1c5b675653bb5c22dbe9b12b556ec555138e09fd # v4.38.1
+        uses: github/codeql-action/analyze@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2
         with:
           category: /language:actions
 
@@ -173,14 +173,14 @@ jobs:
           persist-credentials: false
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@1c5b675653bb5c22dbe9b12b556ec555138e09fd # v4.38.1
+        uses: github/codeql-action/init@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2
         with:
           languages: javascript-typescript
           build-mode: none
 
       - name: Analyze and upload CodeQL results
         id: analyze
-        uses: github/codeql-action/analyze@1c5b675653bb5c22dbe9b12b556ec555138e09fd # v4.38.1
+        uses: github/codeql-action/analyze@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2
         with:
           category: /language:javascript-typescript
 
@@ -220,7 +220,7 @@ jobs:
       # 읽기 전용이다 — push 에서도 쓰지 않는다. 이 job 은 --build-cache 를 쓸 수 없어
       # build-cache-warm.yml 이 develop 에 채운 캐시 키를 빈 엔트리로 선점해서는 안 된다.
       - name: Set up Gradle and validate wrapper
-        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
+        uses: gradle/actions/setup-gradle@3f5f9adaf7d9fecd50b5935e54106014257a94e6 # v6.4.0
         with:
           cache-provider: basic
           cache-read-only: true
@@ -230,10 +230,12 @@ jobs:
         uses: ./.github/actions/setup-ci-config
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@1c5b675653bb5c22dbe9b12b556ec555138e09fd # v4.38.1
+        uses: github/codeql-action/init@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2
         with:
           languages: java-kotlin
           build-mode: manual
+          # Kotlin 2.4.20 support starts with the CodeQL 2.27.1 bundle.
+          tools: https://github.com/github/codeql-action/releases/download/codeql-bundle-v2.27.1/codeql-bundle.tar.gz
 
       # Java/Kotlin extraction observes compiler invocations, so a clean manual build is the
       # contract. Domain 모듈은 전부 순수 JVM 이라 classes 로 컴파일한다 (#1151). android 규약을
@@ -256,7 +258,7 @@ jobs:
 
       - name: Analyze and upload CodeQL results
         id: analyze
-        uses: github/codeql-action/analyze@1c5b675653bb5c22dbe9b12b556ec555138e09fd # v4.38.1
+        uses: github/codeql-action/analyze@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2
         with:
           category: /language:java-kotlin
 
diff --git a/.github/workflows/conflict-label.yml b/.github/workflows/conflict-label.yml
index 5b0cb8cea3..b99565c38b 100644
--- a/.github/workflows/conflict-label.yml
+++ b/.github/workflows/conflict-label.yml
@@ -8,10 +8,6 @@ name: PR Label Reconcile
 # 같은 자리에서 이슈 쪽 라벨도 맞춘다 (#1532) — base 가 기본 브랜치가 아닌 PR 은 이슈의
 # Development 칸에 뜨지 않아, 이슈만 보면 아무도 손대지 않은 것으로 읽힌다.
 #
-# 변경요청 뒤 작성자가 아무 조치도 하지 않은 PR 에도 라벨을 붙인다 (#1552). `review-debt-guard`
-# 는 리뷰어의 빚만 잡고 그 상태를 «공은 작성자에게» 로 흘려보내므로, 그쪽 축은 어디서도 신호가
-# 나지 않았다. 붙이기와 떼기를 한 번의 차이 계산으로 처리해 스테일 라벨이 남지 않게 한다.
-#
 # 열린 PR 끼리의 «형제 충돌» 도 같은 리컨사일러가 잡는다 (#1750). `conflict` 라벨은 base 와의 충돌만
 # 보므로, 두 PR 이 같은 파일을 서로 다르게 고친 사실은 한쪽이 머지된 뒤에야 드러났다. merge-tree 에
 # 전체 히스토리가 필요해 별도 job 으로 두고 checkout 을 fetch-depth 0 으로 받는다.
@@ -63,9 +59,7 @@ jobs:
           node --test \
             .github/scripts/label-conflicting-prs.test.mjs \
             .github/scripts/label-android-test-plan.test.mjs \
-            .github/scripts/label-issues-with-open-prs.test.mjs \
-            .github/scripts/label-awaiting-author-prs.test.mjs \
-            .github/scripts/awaiting-author-policy.test.mjs
+            .github/scripts/label-issues-with-open-prs.test.mjs
 
       - name: Reconcile pull request labels
         env:
@@ -79,7 +73,6 @@ jobs:
           node .github/scripts/label-conflicting-prs.mjs || failures=1
           node .github/scripts/label-android-test-prs.mjs || failures=1
           node .github/scripts/label-issues-with-open-prs.mjs || failures=1
-          node .github/scripts/label-awaiting-author-prs.mjs || failures=1
           exit "$failures"
 
   sibling-conflicts:
diff --git a/.github/workflows/dependabot-pr-gate.yml b/.github/workflows/dependabot-pr-gate.yml
index cd5e362f72..9e29ba67f8 100644
--- a/.github/workflows/dependabot-pr-gate.yml
+++ b/.github/workflows/dependabot-pr-gate.yml
@@ -6,6 +6,11 @@
 # pull_request_target 인 이유: dependabot 이 연 pull_request 이벤트의 토큰은 읽기 전용이라
 # 이슈 생성·PR 편집을 못 한다. default branch 의 워크플로 정의만 실행되고, PR 코드는
 # 체크아웃하지도 실행하지도 않는다. default branch 의 정책 스크립트와 GitHub API 응답만 쓴다.
+#
+# 이 편집이 낸 edited 는 GITHUB_TOKEN 이라 PR Validation·Managed Device 를 다시 깨우지 못한다.
+# 여기서 그 둘을 dispatch·재실행하지 않고 actions 권한도 두지 않는다. 같은 sha 의 dispatch 초록은
+# PR 롤업이 옛 실패를 덮지 못하고(#1825), 재실행은 옛 페이로드를 쓴다. 대신 두 검증이 dependabot
+# PR 에서만 이 게이트가 채울 때까지 live PR 을 기다린다(#2212, dependabot-pr-gate.mjs await).
 name: dependabot-pr-gate
 
 on:
diff --git a/.github/workflows/dependency-audit.yml b/.github/workflows/dependency-audit.yml
index 93c8a01dca..5ab84d9c07 100644
--- a/.github/workflows/dependency-audit.yml
+++ b/.github/workflows/dependency-audit.yml
@@ -41,7 +41,7 @@ jobs:
           java-version: '21'
 
       - name: Set up Gradle and validate wrapper
-        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
+        uses: gradle/actions/setup-gradle@3f5f9adaf7d9fecd50b5935e54106014257a94e6 # v6.4.0
         with:
           cache-provider: basic
           validate-wrappers: true
diff --git a/.github/workflows/dependency-review.yml b/.github/workflows/dependency-review.yml
index d230020ef0..5c314dd8b7 100644
--- a/.github/workflows/dependency-review.yml
+++ b/.github/workflows/dependency-review.yml
@@ -1,25 +1,26 @@
 name: Dependency Review
 
+# PR 에서는 pr-validation.yml 이 매번 부른다 (#2258). 예전에는 의존성 파일 paths 필터로
+# 직접 pull_request 를 들었는데, 그러면 소스만 고친 PR 에 check 가 생기지 않아 ruleset 의
+# required context 로 걸 수 없었다. 이제 repository-quality 가 같은 경로 목록으로 변경을
+# 분류하고, 의존성 입력이 없으면 아래 job 이 검사 스텝만 건너뛴 채 성공한다. 분류가
+# 실패하면 호출자가 run_review 를 true 로 넘겨 검사 쪽으로 닫힌다.
+#
+# 검사는 pull_request 이벤트에서만 할 수 있다. dependency-submission.yml 이 PR 스냅샷을
+# pull_request 에서만 만들기 때문이다.
+# - merge group 은 건너뛴다. 큐에 들어온 PR 은 각 head 에서 이 required check 를 이미
+#   통과했고, 큐 SHA 는 그 head 들과 develop 의 병합이다.
+# - bridge dispatch(GITHUB_TOKEN 커밋 뒤 PR Validation 재호출)는 의존성 입력이 바뀐 PR 이면
+#   실패로 닫는다. 건너뛰면 이전 head 의 실패를 검사 없는 초록이 덮는다. PR 브랜치에 새로
+#   push 하면 pull_request 실행이 스냅샷과 함께 다시 검사한다.
 on:
-  pull_request:
-    paths:
-      - '**/*.gradle'
-      - '**/*.gradle.kts'
-      - '**/*.lockfile'
-      - '**/build-logic/**'
-      - '**/buildSrc/**'
-      - '**/gradle.properties'
-      - '**/gradlew'
-      - '**/gradlew.bat'
-      - 'gradle/**'
-      - '.github/workflows/dependency-review.yml'
-      - '.github/workflows/dependency-submission.yml'
-      - '.github/workflows/dependency-submission-trusted.yml'
-      - '.github/workflows/dependency-submission-upload.yml'
-
-concurrency:
-  group: dependency-review-${{ github.event.pull_request.number }}
-  cancel-in-progress: true
+  workflow_call:
+    inputs:
+      run_review:
+        description: "의존성 그래프 입력이 바뀌어 검사가 필요한지 여부"
+        required: false
+        default: true
+        type: boolean
 
 permissions:
   contents: read
@@ -30,11 +31,28 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 30
     steps:
+      - name: Skip unchanged dependency graph inputs
+        if: ${{ !inputs.run_review }}
+        run: echo "::notice::의존성 그래프 입력이 바뀌지 않아 Dependency Review 를 건너뜁니다."
+
+      - name: Skip merge group revalidation
+        if: ${{ inputs.run_review && github.event_name == 'merge_group' }}
+        run: echo "::notice::큐에 들어온 PR head 가 이미 Dependency Review 를 통과했으므로 merge group 에서는 건너뜁니다."
+
+      - name: Reject dependency changes without a pull request snapshot
+        if: ${{ inputs.run_review && github.event_name != 'pull_request' && github.event_name != 'merge_group' }}
+        env:
+          EVENT_NAME: ${{ github.event_name }}
+        run: |
+          echo "::error::$EVENT_NAME 실행에는 비교할 PR 의존성 스냅샷이 없습니다. 의존성 입력이 바뀐 PR 은 브랜치에 새로 push 해 pull_request 실행으로 검사하세요."
+          exit 1
+
       # PR snapshot 은 두 workflow 를 거쳐 API 에 올라온다 (fork PR 을 checkout 하지 않기 위한 분리다).
       #   1. Generate PR Dependency Graph — PR context 에서 artifact 만 만든다.
       #   2. Submit PR Dependency Graph   — trusted workflow_run 에서 artifact 를 제출한다.
       # 이 job 은 1번과 동시에 출발하므로 제출이 끝날 때까지 snapshot warning 을 재시도한다.
       - name: Fail on newly introduced high-severity vulnerabilities
+        if: ${{ inputs.run_review && github.event_name == 'pull_request' }}
         uses: actions/dependency-review-action@a1d282b36b6f3519aa1f3fc636f609c47dddb294 # v5.0.0
         with:
           fail-on-scopes: runtime, development, unknown
diff --git a/.github/workflows/firebase-wif-canary.yml b/.github/workflows/firebase-wif-canary.yml
index 61238d6ab2..074357100e 100644
--- a/.github/workflows/firebase-wif-canary.yml
+++ b/.github/workflows/firebase-wif-canary.yml
@@ -91,7 +91,7 @@ jobs:
           java-version: '21'
 
       - name: Set up Gradle and validate wrapper
-        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
+        uses: gradle/actions/setup-gradle@3f5f9adaf7d9fecd50b5935e54106014257a94e6 # v6.4.0
         with:
           cache-provider: basic
           cache-read-only: false
diff --git a/.github/workflows/latest-review-decision-event.yml b/.github/workflows/latest-review-decision-event.yml
deleted file mode 100644
index ee0263767e..0000000000
--- a/.github/workflows/latest-review-decision-event.yml
+++ /dev/null
@@ -1,18 +0,0 @@
-name: Latest Review Decision Event
-
-# pull_request_review는 fork PR의 read-only 토큰으로도 발생한다. 여기서는 PR 코드나 API를
-# 건드리지 않고 완료 신호만 만든다. 실제 쓰기는 trusted default-branch workflow가 맡는다.
-on:
-  pull_request_review:
-    types: [submitted]
-
-permissions: {}
-
-jobs:
-  signal:
-    name: Signal latest review decision reconciliation
-    runs-on: ubuntu-latest
-    timeout-minutes: 1
-    steps:
-      - name: Record review decision event
-        run: echo 'A pull request review decision was submitted.'
diff --git a/.github/workflows/latest-review-decision-reconcile.yml b/.github/workflows/latest-review-decision-reconcile.yml
deleted file mode 100644
index 270dfc1ece..0000000000
--- a/.github/workflows/latest-review-decision-reconcile.yml
+++ /dev/null
@@ -1,46 +0,0 @@
-name: Latest Review Decision Reconcile
-
-on:
-  workflow_run:
-    workflows: [Latest Review Decision Event]
-    types: [completed]
-  workflow_dispatch:
-    inputs:
-      pull_number:
-        description: Optional pull request number; empty reconciles every open PR
-        required: false
-        type: string
-
-concurrency:
-  group: latest-review-decision-${{ github.repository }}
-  cancel-in-progress: false
-
-permissions: {}
-
-jobs:
-  reconcile:
-    name: Reconcile latest review decisions
-    if: >-
-      github.event_name == 'workflow_dispatch' ||
-      (github.event.workflow_run.event == 'pull_request_review' &&
-      github.event.workflow_run.conclusion == 'success')
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    permissions:
-      contents: read
-      pull-requests: write
-    steps:
-      - name: Clone trusted default branch
-        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          ref: ${{ github.event.repository.default_branch }}
-          persist-credentials: false
-
-      - name: Reconcile latest review decisions
-        env:
-          GITHUB_API_URL: ${{ github.api_url }}
-          GITHUB_REPOSITORY: ${{ github.repository }}
-          GITHUB_TOKEN: ${{ github.token }}
-          TARGET_PULL_NUMBER: >-
-            ${{ inputs.pull_number || github.event.workflow_run.pull_requests[0].number }}
-        run: node .github/scripts/reconcile-latest-review-decision.mjs
diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
index 4383e66ae4..839de9b2e3 100644
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -62,7 +62,7 @@ jobs:
       # 캐싱 소유자는 setup-gradle 하나 — setup-java 의 cache: gradle 은 정책 테스트
       # (supply-chain-policy.test.mjs)가 금지한다. wrapper 검증도 여기서 fail-closed.
       - name: Set up Gradle and validate wrapper
-        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
+        uses: gradle/actions/setup-gradle@3f5f9adaf7d9fecd50b5935e54106014257a94e6 # v6.4.0
         with:
           cache-provider: basic
           cache-read-only: true
@@ -108,7 +108,7 @@ jobs:
           java-version: '21'
 
       - name: Set up Gradle and validate wrapper
-        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
+        uses: gradle/actions/setup-gradle@3f5f9adaf7d9fecd50b5935e54106014257a94e6 # v6.4.0
         with:
           cache-provider: basic
           cache-read-only: true
diff --git a/.github/workflows/merge-queue-dequeue.yml b/.github/workflows/merge-queue-dequeue.yml
index 1ecb7f86bb..22de0e50c6 100644
--- a/.github/workflows/merge-queue-dequeue.yml
+++ b/.github/workflows/merge-queue-dequeue.yml
@@ -7,6 +7,9 @@
 # 판정은 handle-merge-queue-dequeue.mjs 가 한다 — 이 PR 의 큐 브랜치 merge_group run 에 실패 job 이
 # 있으면 링크를 코멘트로 남기고, 없으면(조용한 방출) 같은 head 당 한 번만 재투입하고,
 # MANUAL·ALREADY_MERGED·MERGE 는 아무것도 하지 않는다.
+#
+# 재투입은 여기서 하지 않고 merge-queue-requeue.yml 을 dispatch 한다. GITHUB_TOKEN 으로 넣은 큐 항목은
+# merge_group CI 를 띄우지 못하고, 이 브리지는 시크릿을 쓰지 않으므로 사람 토큰을 가진 쪽으로 넘긴다.
 name: merge-queue-dequeue
 
 on:
@@ -24,8 +27,9 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 5
     permissions:
-      actions: read
-      contents: write
+      # 재투입 워크플로 dispatch 에 쓴다.
+      actions: write
+      contents: read
       issues: write
       pull-requests: write
     steps:
@@ -44,4 +48,5 @@ jobs:
           GITHUB_REPOSITORY: ${{ github.repository }}
           PULL_REQUEST_NUMBER: ${{ github.event.pull_request.number }}
           DEQUEUE_REASON: ${{ github.event.reason }}
+          DEFAULT_BRANCH: ${{ github.event.repository.default_branch }}
         run: node .github/scripts/handle-merge-queue-dequeue.mjs
diff --git a/.github/workflows/merge-queue-requeue.yml b/.github/workflows/merge-queue-requeue.yml
new file mode 100644
index 0000000000..6b5f99988d
--- /dev/null
+++ b/.github/workflows/merge-queue-requeue.yml
@@ -0,0 +1,53 @@
+# merge queue 재투입 (merge-queue-dequeue.yml 이 dispatch)
+#
+# GITHUB_TOKEN 으로 큐에 넣으면 GitHub 이 그 이벤트로 워크플로를 띄우지 않아 merge_group CI 가 하나도 돌지 않는다.
+# 큐는 check timeout(60분)까지 기다렸다가 CI_TIMEOUT 으로 빼고, 그 뒤에 쌓인 PR 들도 다시 검증한다.
+# 그래서 투입은 사람 토큰(MERGE_QUEUE_TOKEN, 1hyok 의 fine-grained PAT)으로 한다. 시크릿이 없으면 넣지 않고
+# 직접 투입하라는 코멘트를 남긴다.
+#
+# 방출 판정과 마커 코멘트는 방출 처리 job 이 끝냈다. 여기서는 live 상태를 다시 보고 판정한 head 그대로 열려 있고
+# 큐 밖일 때만 넣는다. default branch 의 스크립트만 실행하고 PR 코드는 체크아웃하지 않는다.
+name: merge-queue-requeue
+
+on:
+  workflow_dispatch:
+    inputs:
+      pull_request_number:
+        description: 재투입할 PR 번호
+        required: true
+        type: string
+      head_sha:
+        description: 방출 판정 때의 head SHA. 그사이 새 커밋이 올라왔으면 넣지 않는다.
+        required: true
+        type: string
+
+permissions: {}
+
+jobs:
+  requeue:
+    concurrency:
+      group: merge-queue-requeue-${{ github.repository_id }}-${{ inputs.pull_request_number }}
+      cancel-in-progress: false
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    permissions:
+      contents: read
+      issues: write
+      pull-requests: write
+    steps:
+      - name: Clone requeue policy from the default branch
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          ref: ${{ github.event.repository.default_branch }}
+          persist-credentials: false
+          sparse-checkout: .github/scripts
+
+      - name: 사람 토큰으로 재투입
+        env:
+          MODE: requeue
+          GITHUB_TOKEN: ${{ github.token }}
+          MERGE_QUEUE_TOKEN: ${{ secrets.MERGE_QUEUE_TOKEN }}
+          GITHUB_REPOSITORY: ${{ github.repository }}
+          PULL_REQUEST_NUMBER: ${{ inputs.pull_request_number }}
+          HEAD_SHA: ${{ inputs.head_sha }}
+        run: node .github/scripts/handle-merge-queue-dequeue.mjs
diff --git a/.github/workflows/pr-assign-author.yml b/.github/workflows/pr-assign-author.yml
index 9e8f5c72e5..b72aa9ff57 100644
--- a/.github/workflows/pr-assign-author.yml
+++ b/.github/workflows/pr-assign-author.yml
@@ -5,7 +5,7 @@
 # 어사인이 비어 있는 PR 에만 작성자를 건다. 사람이 담당자를 바꾼 것(작성자를 떼고
 # 다른 사람을 건 것)은 그대로 둔다 — 강제하는 것은 «비어 있지 않음» 이지 «작성자» 가
 # 아니다. 전부 떼어 비게 되면 다시 작성자를 건다.
-# review-request-all 과 같은 조건(봇·외부 기여자 제외)으로 돈다.
+# 봇·외부 기여자 PR 은 건너뛴다.
 name: pr-assign-author
 
 on:
diff --git a/.github/workflows/pr-validation.yml b/.github/workflows/pr-validation.yml
index e33f356dc2..2f7b175516 100644
--- a/.github/workflows/pr-validation.yml
+++ b/.github/workflows/pr-validation.yml
@@ -1,7 +1,7 @@
 name: PR Validation
 
 # PR 검증의 유일한 진입점이다. repository quality 가 변경 파일을 완전하게 분류한 뒤
-# static analysis · unit test · screenshot 을 reusable workflow 로 한 번씩 부른다.
+# static analysis · unit test · screenshot · dependency review 를 reusable workflow 로 한 번씩 부른다.
 # 각 job check 를 ruleset 에서 직접 required 로 요구하므로 문서 전용 PR 도 같은 이름의
 # check 를 만들되, 무거운 job 내부는 즉시 건너뛴다. 모든 검증 뒤 집계용 runner 는 없다.
 # required context 이름은 pr-gate-policy.test.mjs 에 고정해 workflow 이름 변경과 ruleset
@@ -87,3 +87,11 @@ jobs:
       run_validation: ${{ needs.repository-quality.result != 'success' || needs.repository-quality.outputs.screenshot_required != 'false' }}
       gradle_tasks: ${{ needs.repository-quality.result == 'success' && needs.repository-quality.outputs.screenshot_tasks || ':core:ui:validateScreenshotTest :feature:home:presentation:validateScreenshotTest :feature:receiver:presentation:validateScreenshotTest :feature:onboarding:presentation:validateScreenshotTest :feature:afternote:presentation:validateScreenshotTest :feature:mindrecord:presentation:validateScreenshotTest :feature:setting:presentation:validateScreenshotTest :feature:timeletter:presentation:validateScreenshotTest' }}
       screenshot_modules: ${{ needs.repository-quality.result == 'success' && needs.repository-quality.outputs.screenshot_modules || ':core:ui :feature:home:presentation :feature:receiver:presentation :feature:onboarding:presentation :feature:afternote:presentation :feature:mindrecord:presentation :feature:setting:presentation :feature:timeletter:presentation' }}
+
+  dependency-review:
+    name: Dependency Review
+    needs: repository-quality
+    if: ${{ !cancelled() }}
+    uses: ./.github/workflows/dependency-review.yml
+    with:
+      run_review: ${{ needs.repository-quality.result != 'success' || needs.repository-quality.outputs.dependency_review_required != 'false' }}
diff --git a/.github/workflows/release-aab-preflight.yml b/.github/workflows/release-aab-preflight.yml
index cbaf5ff396..d6b83fb31f 100644
--- a/.github/workflows/release-aab-preflight.yml
+++ b/.github/workflows/release-aab-preflight.yml
@@ -43,7 +43,7 @@ jobs:
           java-version: "21"
 
       - name: Set up Gradle
-        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
+        uses: gradle/actions/setup-gradle@3f5f9adaf7d9fecd50b5935e54106014257a94e6 # v6.4.0
         with:
           cache-provider: basic
           cache-read-only: true
diff --git a/.github/workflows/release-distribution.yml b/.github/workflows/release-distribution.yml
index e051378929..959438b44d 100644
--- a/.github/workflows/release-distribution.yml
+++ b/.github/workflows/release-distribution.yml
@@ -75,7 +75,7 @@ jobs:
           java-version: '21'
 
       - name: Set up Gradle and validate wrapper
-        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
+        uses: gradle/actions/setup-gradle@3f5f9adaf7d9fecd50b5935e54106014257a94e6 # v6.4.0
         with:
           cache-provider: basic
           cache-read-only: false
diff --git a/.github/workflows/release-play-internal.yml b/.github/workflows/release-play-internal.yml
index b54248a1b1..a64d5a5a8e 100644
--- a/.github/workflows/release-play-internal.yml
+++ b/.github/workflows/release-play-internal.yml
@@ -90,7 +90,7 @@ jobs:
           java-version: '21'
 
       - name: Set up Gradle and validate wrapper
-        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
+        uses: gradle/actions/setup-gradle@3f5f9adaf7d9fecd50b5935e54106014257a94e6 # v6.4.0
         with:
           cache-provider: basic
           cache-read-only: true
diff --git a/.github/workflows/repository-quality.yml b/.github/workflows/repository-quality.yml
index 2c173a018d..7b92da1793 100644
--- a/.github/workflows/repository-quality.yml
+++ b/.github/workflows/repository-quality.yml
@@ -54,6 +54,9 @@ on:
       codeql_java_kotlin:
         description: "Java/Kotlin CodeQL 분석이 필요한지 여부"
         value: ${{ jobs.repository-quality.outputs.codeql_java_kotlin }}
+      dependency_review_required:
+        description: "의존성 그래프 입력이 바뀌어 Dependency Review 가 필요한지 여부"
+        value: ${{ jobs.repository-quality.outputs.dependency_review_required }}
   push:
     branches: [develop, main]
 
@@ -87,6 +90,7 @@ jobs:
       screenshot_tasks: ${{ steps.classify-documentation-changes.outputs.screenshot_tasks }}
       codeql_actions: ${{ steps.classify-documentation-changes.outputs.codeql_actions }}
       codeql_java_kotlin: ${{ steps.classify-documentation-changes.outputs.codeql_java_kotlin }}
+      dependency_review_required: ${{ steps.classify-documentation-changes.outputs.dependency_review_required }}
     steps:
       - name: Clone repo
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -109,7 +113,8 @@ jobs:
         run: node .github/scripts/ensure-api-quota.mjs ensure --max-wait 60
 
       # GitHub 의 server-side paths 평가는 유한한 diff 앞부분만 보므로, 그 경계를 넘는 PR 을
-      # 그대로 허용하면 뒤쪽 dependency 파일이 graph/review workflow 를 우회할 수 있다.
+      # 그대로 허용하면 뒤쪽 파일이 paths 필터를 쓰는 workflow 를 우회할 수 있다. Dependency
+      # Review 는 #2258 부터 아래 전체 파일 분류로 판정하지만 다른 paths 필터 workflow 가 남아 있다.
       # 공식 문서의 상충하는 300/3,000 한도 중 보수적인 300을 fail-closed 경계로 쓴다.
       - name: Guard server-side path filter boundary
         id: changed-files
@@ -118,6 +123,7 @@ jobs:
           CHANGED_FILES: ${{ github.event.pull_request.changed_files }}
           GH_TOKEN: ${{ github.token }}
           MAX_PATH_FILTER_FILES: 300
+          PR_AUTHOR: ${{ github.event.pull_request.user.login }}
           PR_NUMBER: ${{ inputs.pull_request_number }}
         run: |
           set -euo pipefail
@@ -138,6 +144,14 @@ jobs:
             fi
             CHANGED_FILES=$(jq -r '.changed_files' <<< "$pull_request")
             printf '%s' "$pull_request" > "$pull_request_file"
+          elif [ "$GITHUB_EVENT_NAME" = "pull_request" ] && [ "$PR_AUTHOR" = "dependabot[bot]" ]; then
+            # dependabot-pr-gate 가 같은 순간 GITHUB_TOKEN 으로 제목 (#N)·Closes·CI Test Plan 을 채운다.
+            # 그 edited 는 이 워크플로를 다시 깨우지 못하고 페이로드는 opened 시점 값이다(#2212).
+            # 페이로드 제목에 대표 이슈 번호가 이미 있으면 API 없이 그대로 쓰고, 없으면 게이트가 채울
+            # 때까지 live PR 을 기다렸다가 그 값으로 판정한다. quota 대기 60초와 합쳐도 job timeout
+            # 3분 안에 들도록 90초에서 끊는다.
+            AWAIT_TIMEOUT_SECONDS=90 node .github/scripts/dependabot-pr-gate.mjs await "$pull_request_file"
+            CHANGED_FILES=$(jq -r '.changed_files' "$pull_request_file")
           elif [ -z "$CHANGED_FILES" ]; then
             pull_request=$(gh api "repos/$GITHUB_REPOSITORY/pulls/$PR_NUMBER")
             CHANGED_FILES=$(jq -r '.changed_files' <<< "$pull_request")
diff --git a/.github/workflows/review-debt-guard.yml b/.github/workflows/review-debt-guard.yml
deleted file mode 100644
index f64c37a3c8..0000000000
--- a/.github/workflows/review-debt-guard.yml
+++ /dev/null
@@ -1,428 +0,0 @@
-# 리뷰 적체 가드 (#1136)
-#
-# 리뷰 요청을 처리하지 않거나 자기 PR 의 변경요청에 응답하지 않은 사람이 새 PR 을
-# 계속 여는 것을 막는다.
-# GitHub 네이티브에는 PR 생성을 막는 수단이 없어(ruleset·branch protection 은
-# push·merge 만 통제) 열린 직후 조회해 미처리 리뷰 요청이 1건이라도 있으면
-# 그 PR 을 닫는다. 브랜치는 남으므로 리뷰를 끝낸 뒤 되살릴 수 있다.
-#
-# 리뷰어 빚의 기준은 «나에게 걸린 리뷰 요청» 이 아니라 «아무도 응답하지 않은 열린
-# PR» 이다(#1148). 다만 한번 변경요청을 남긴 뒤에는 담당자가 그 리뷰어에게 명시적으로
-# 재요청해야만 공이 돌아온다. 수정 커밋만으로 리뷰 의무를 만들지는 않는다(#1136).
-# 작성자 빚은 같은 사람이 담당하는 다른 열린 PR 이 최신 변경요청 뒤 실질 커밋·응답·
-# 본문 편집 없이 남은 상태다. 라벨 갱신 시점에 기대지 않고 새 PR 을 열 때 현재 상태를
-# 다시 계산한다(#1679, #1700).
-#
-# PR 의 담당자는 «올린 사람» 이 아니라 «어사인된 사람» 이다(#1974 결정, #1980). 변경요청에
-# 응답하는 것도, «자기 PR» 을 리뷰어 빚에서 빼는 것도 어사인 기준이고, 어사인이 비어 있는
-# 동안만 작성자가 담당자다. 새 PR 을 여는 사람(AUTHOR)이 게이트를 받는 것은 그대로다.
-name: review-debt-guard
-
-on:
-  pull_request:
-    types: [opened, reopened, ready_for_review]
-
-permissions:
-  contents: read
-  pull-requests: write
-
-jobs:
-  debt-check:
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    steps:
-      # 게이트 스크립트는 **default branch 사본**으로 돌린다. PR 사본을 체크아웃하면 PR 이
-      # 자기를 검사하는 가드를 고쳐 통과시킬 수 있다. 필요한 건 .github/scripts 뿐이라
-      # sparse-checkout 으로 좁힌다.
-      - name: Clone gate scripts from the default branch
-        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          ref: ${{ github.event.repository.default_branch }}
-          persist-credentials: false
-          sparse-checkout: .github/scripts
-
-      # 한도가 바닥인 채로 들어가면 게이트가 코드와 무관하게 빨개진다. 남은 quota 를 요약에
-      # 남기고, 부족하면 리셋까지 기다린다 — 즉시 실패시키면 사람이 재실행을 걸고 그 재실행이
-      # 남은 quota 를 더 태운다 (#1465).
-      - name: Ensure GitHub API quota
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          # default branch 사본에 이 스크립트가 아직 없는 동안(= 스크립트를 심는 이 PR 자신)에는
-          # 건너뛴다. 머지 뒤에는 항상 존재하므로 이 경로는 부트스트랩 한 번에만 쓰인다.
-          if [ ! -f .github/scripts/ensure-api-quota.mjs ]; then
-            echo "::notice::quota 스크립트가 default branch 에 아직 없습니다 — 건너뜁니다"
-            exit 0
-          fi
-          # 두 자원을 순차 확인하므로 각각의 대기 상한을 절반 이하로 잡아 job 의 5분
-          # timeout 안에 판정 로그까지 남긴다(내부 +5초 경계 여유를 포함해 최대 240초).
-          node .github/scripts/ensure-api-quota.mjs ensure --resource core --max-wait 115
-          node .github/scripts/ensure-api-quota.mjs ensure --resource graphql --max-wait 115
-
-      - name: 리뷰·작성자 응답 빚 검사
-        env:
-          GH_TOKEN: ${{ github.token }}
-          REPO: ${{ github.repository }}
-          PR_NUMBER: ${{ github.event.pull_request.number }}
-          AUTHOR: ${{ github.event.pull_request.user.login }}
-          HEAD_REPO: ${{ github.event.pull_request.head.repo.full_name }}
-          # PR 제한·awaiting-author 라벨의 공통 면제 목록 (#1910, #1934).
-          # 라벨러도 이 선언을 읽는다. 인용·주석 없는 한 줄에서 공백으로 구분한다.
-          REVIEW_GATE_EXEMPT_AUTHORS: koongmai
-        run: |
-          # 조회 실패를 "빚 없음" 으로 오인해 통과시키지 않는다. 다만 판정 근거를
-          # 얻지 못한 상태로 남의 PR 을 닫지도 않는다 — 아래에서 명시적으로 나눈다.
-          set -euo pipefail
-
-          # 봇 PR 은 대상이 아니다.
-          case "$AUTHOR" in
-            *'[bot]'|dependabot|github-actions) echo "봇 PR — 건너뜀"; exit 0 ;;
-          esac
-
-          # fork PR 은 대상이 아니다 — 토큰이 read-only 라 닫지도 못하고, 팀 리뷰
-          # 적체와도 무관하다. 원래 걸러내려던 것이 이것이므로 head 저장소로 가른다.
-          if [ "$HEAD_REPO" != "$REPO" ]; then
-            echo "fork PR($HEAD_REPO) — 건너뜀"
-            exit 0
-          fi
-
-          # 팀원 여부는 author_association 으로 가리지 않는다. 웹훅 페이로드는 조직
-          # 멤버십이 비공개면 MEMBER 대신 CONTRIBUTOR 를 내리는데 이 조직은 공개
-          # 멤버가 0명이다. 그래서 레포에 직접 초대된 한 계정만 COLLABORATOR 로 찍혀
-          # 검사를 받고, 나머지 팀원은 전원 «외부 기여자» 로 건너뛰어졌다 — 8/25 에
-          # #1152·#1154 가 그렇게 통과했고 12분 뒤 같은 빚으로 #1112 만 닫혔다.
-          # REST 로 조회하면 MEMBER 로 보여 눈으로는 잡히지 않는다. 실권한을 묻는다.
-          if ! perm=$(gh api "repos/$REPO/collaborators/$AUTHOR/permission" --jq '.permission'); then
-            echo "::error::권한 조회에 실패했다 — 근거 없이 통과시키지 않는다. 재실행할 것"
-            exit 1
-          fi
-
-          # 빈 값·예상 밖 값을 «권한 없음» 으로 접으면 조회 실패가 통과로 둔갑한다.
-          case "$perm" in
-            admin|maintain|write) ;;
-            read|none) echo "쓰기 권한 없음($perm) — 건너뜀"; exit 0 ;;
-            *) echo "::error::권한 값을 알 수 없다($perm) — 재실행할 것"; exit 1 ;;
-          esac
-
-          # 이 가드 자체를 면제받은 작성자 (#1910). 팀이 koongmai 에게는 PR 을 여는 시점의
-          # 제약을 두지 않고 머지 시점 제약만 남기기로 했다. 리뷰 지적을 반영했는지와 무관하게
-          # 새 PR 을 열 수 있고, 남의 PR 을 리뷰할 의무도 없어 review-request-all 의 TEAM 에서도
-          # 빠져 있다. 머지 게이트는 그대로다. develop 은 여전히 승인 1건과 필수 체크를 요구하고,
-          # 그 요건은 이 가드가 아니라 required-approval·required-checks 룰셋이 건다.
-          #
-          # 면제는 "빚 계산" 앞에 둔다. 뒤에 두면 면제받은 사람의 PR 때문에 조회가 실패했을 때
-          # 가드가 그를 대신해 죽는다. GitHub 로그인은 대소문자를 가리지 않으므로 낮춰 비교한다.
-          author_lc=$(printf '%s' "$AUTHOR" | tr '[:upper:]' '[:lower:]')
-          exempt_lc=$(printf '%s' "$REVIEW_GATE_EXEMPT_AUTHORS" | tr '[:upper:]' '[:lower:]')
-          case " $exempt_lc " in
-            *" $author_lc "*) echo "리뷰 게이트 면제 작성자($AUTHOR) — 건너뜀"; exit 0 ;;
-          esac
-
-          # 빚의 기준은 «나에게 요청이 걸렸는가» 가 아니라 «아무도 응하지 않은 PR 이
-          # 남아 있는가» 다. 리뷰 요청은 알림 수단이지 담당 배정이 아니다 —
-          # 누구에게 걸렸든 팀에서 한 사람이 보면 그 PR 의 리뷰는 끝난 것이다.
-          # 그래서 요청 목록이 아니라 열린 PR 전체를 훑는다.
-          #
-          # 자기 PR 은 뺀다 — «자기» 는 담당자(어사인, 비어 있으면 작성자) 기준이다. 남이
-          # 올렸어도 내게 어사인된 PR 은 내 것이고, 내가 올렸어도 남에게 어사인된 PR 은 남의
-          # 것이라 내가 리뷰할 수 있다. draft 는 리뷰를 받을 상태가 아니므로 뺀다
-          # (review-request-all 도 draft 에는 요청을 걸지 않는다). 담당자 목록은 소문자
-          # 쉼표 구분으로 실어 아래 반영·응답 집계의 신원으로 쓴다.
-          if ! open_prs=$(gh api "repos/$REPO/pulls?state=open&per_page=100" --paginate \
-                --jq ".[] | select(.draft == false)
-                           | ((if (.assignees | length) > 0 then [.assignees[].login] else [.user.login] end) | map(ascii_downcase)) as \$owners
-                           | select((\$owners | index(\"$author_lc\")) == null)
-                           | \"\(.number)\t\(.created_at[0:10])\t\(\$owners | join(\",\"))\t\([.requested_reviewers[].login | ascii_downcase] | join(\",\"))\t\(.title)\""); then
-            echo "::error::열린 PR 조회에 실패했다 — 근거 없이 PR 을 닫지 않는다. 재실행할 것"
-            exit 1
-          fi
-          repo_owner=${REPO%%/*}
-          repo_name=${REPO#*/}
-
-          # 같은 작성자의 다른 PR 에 공이 남아 있는지도 실시간으로 다시 계산한다. 기존
-          # `awaiting-author` 라벨만 보면 리컨사일 주기와 이 실행이 엇갈릴 때 방금 붙거나
-          # 떨어진 상태를 놓친다. 라벨 리컨사일러와 같은 judgeAwaitingAuthor 술어를 쓰되,
-          # 현재 막 열려 판정 리뷰가 없는 PR 자신은 번호로 명시적으로 제외한다.
-          author_debt_file=$(mktemp)
-          if [ -f .github/scripts/check-author-debt.mjs ]; then
-            GITHUB_TOKEN="$GH_TOKEN" \
-            GITHUB_REPOSITORY="$REPO" \
-            AUTHOR="$AUTHOR" \
-            CURRENT_PULL_REQUEST_NUMBER="$PR_NUMBER" \
-            AUTHOR_DEBT_FILE="$author_debt_file" \
-              node .github/scripts/check-author-debt.mjs
-          else
-            # default branch 에 스크립트를 심는 이 PR 자신에게는 아직 사본이 없다. 머지
-            # 뒤에는 항상 존재하므로 부트스트랩 한 번만 작성자 빚 검사를 건너뛴다.
-            echo "::notice::작성자 빚 스크립트가 default branch 에 아직 없습니다 — 건너뜁니다"
-            : > "$author_debt_file"
-          fi
-
-          # 남은 것에서 «리뷰어의 공이 아닌» PR 을 걸러낸다. «누가» 봤는지는 따지지
-          # 않는다 — 팀에서 한 사람이 더 늦은 판정을 내리면 그 판정이 PR 의 현재
-          # 상태다. 더 오래된 다른 리뷰어의 변경요청을 다시 빚으로 살리지 않는다.
-          #
-          # 승인과 변경요청은 무게가 다르다.
-          #   APPROVED        머지 가능한 상태다. 그 뒤에 작성자가 손보는 것은
-          #                   작성자 몫이고, 다시 봐 줄 의무는 누구에게도 없다.
-          #   CHANGES_REQUESTED  아직 끝난 판정이 아니다. 다만 수정 커밋만으로 리뷰
-          #                   의무가 생기지는 않는다. 작성자가 같은 리뷰어에게 명시적으로
-          #                   재요청해야 공이 돌아온다.
-          #
-          # 그래서 빚은 두 종류다. (1) 아무도 판정을 내리지 않은 PR,
-          # (2) PR 전체의 최신 판정이 변경요청이고, 그 리뷰어에게 재요청이 걸렸으며,
-          # 그 판정 뒤 작성자가 반영 커밋·응답·PR 본문 편집을 남긴 PR. 재요청이 없거나
-          # 최신 변경요청 뒤 작성자 조치가 없으면 빚이 아니다. 반영 커밋은 병합 커밋
-          # (parents 2개 이상)을 뺀 실질 커밋으로만 센다.
-          debt_file=$(mktemp)
-          reviews_file=$(mktemp)
-          while IFS=$'\t' read -r pn created pr_owners requested_reviewers title; do
-            [ -n "$pn" ] || continue
-
-            if ! gh api "repos/$REPO/pulls/$pn/reviews" --paginate \
-              --jq '.[] | select(.state == "APPROVED" or .state == "CHANGES_REQUESTED")
-                        | {u: .user.login, s: .state, t: .submitted_at}' \
-              > "$reviews_file"; then
-              echo "::error::PR #$pn 리뷰 조회에 실패했다 — 근거 없이 PR 을 닫지 않는다"
-              exit 1
-            fi
-
-            if [ ! -s "$reviews_file" ]; then
-              echo "#$pn — 아무도 판정하지 않음"
-              printf '%s\t%s\t%s\n' "$pn" "$created" "$title" >> "$debt_file"
-              continue
-            fi
-
-            # PR 전체의 최신 판정만 본다. 그 판정이 CHANGES_REQUESTED 이면서 현재 같은
-            # 리뷰어에게 요청이 다시 걸렸다면, 리뷰 제출 시 제거된 요청을 작성자가
-            # 최신 판정 뒤 명시적으로 되살린 것이다. 이후 다른 리뷰어가 더 늦게 판정한
-            # 경우에는 과거 리뷰어의 남은 요청으로 공을 되돌리지 않는다.
-            if ! blocked=$(jq -rs --arg active ",$requested_reviewers," '
-                                  sort_by(.t) | last
-                                  | .u |= ascii_downcase
-                                  | select(.s == "CHANGES_REQUESTED")
-                                  | select(.u as $reviewer
-                                           | $active | contains("," + $reviewer + ","))
-                                  | [.u, .t] | @tsv' \
-                                "$reviews_file"); then
-              echo "::error::PR #$pn 최신 리뷰 판정에 실패했다 — 근거 없이 PR 을 닫지 않는다"
-              exit 1
-            fi
-
-            if [ -z "$blocked" ]; then
-              echo "#$pn — 결정 리뷰 뒤 명시적 재리뷰 요청 없음, 빚 아님"
-              continue
-            fi
-            IFS=$'\t' read -r blocked_by blocked_at <<< "$blocked"
-
-            # 면제 리뷰어가 낸 변경요청은 팀의 빚으로 돌아오지 않는다 (#1910). 면제된 사람은
-            # 리뷰할 의무가 없으므로, 그가 자발적으로 낸 변경요청 뒤 침묵하면 그 침묵의 대가를
-            # 나머지 팀원이 "새 PR 을 못 연다" 로 치르게 된다. 여기서 세지 않아도 그 PR 이
-            # 그냥 머지되지는 않는다. 승인 1건이 머지 게이트에 그대로 남아 있다.
-            # jq 의 최신 판정은 이미 소문자로 내려온다.
-            case " $exempt_lc " in
-              *" $blocked_by "*)
-                echo "#$pn — 면제 리뷰어 @$blocked_by 의 변경요청, 팀 빚 아님"
-                continue
-                ;;
-            esac
-
-            # 반영을 비병합 커밋으로만 세면 병합으로 반영한 PR 을 놓친다. base 를
-            # 끌어와 충돌을 풀며 지적을 반영하면 그 뒤 커밋이 전부 parents 2개라
-            # «미반영» 이 된다 — #1316 은 리뷰가 지목한 파일이 실제로 바뀌고 작성자
-            # 응답 코멘트까지 2건 달린 채로 8/29 까지 빚에서 빠져 있었다(#1450).
-            # 병합 커밋의 first-parent diff 는 base 에서 들어온 변경을 통째로 담아
-            # 반영분과 구별되지 않으므로, 커밋 대신 «작성자가 응답했는가» 를 함께 본다.
-            #
-            # 페이지마다 집계하면 100건이 넘는 PR 에서 숫자가 여러 줄로 나와 비교가
-            # 깨진다. 건별로 뽑아 한 번에 센다.
-            #
-            # 세는 것은 «작성자가 올린 실질 변경» 뿐이다. 누가 올렸는지·무엇이 바뀌었는지를
-            # 안 보면 리뷰어가 미는 CI 재트리거 빈 커밋까지 «작성자가 반영했다» 로 세어,
-            # 재트리거한 리뷰어가 그 대가로 자기 PR 을 못 열게 된다 — 8/28 에 리뷰어가 건
-            # +0/-0 커밋 하나로 koongmai PR 3건(#1379·#1365·#882)이 전부 가짜 빚이 됐다(#1459).
-            commits_file=$(mktemp)
-            if ! gh api "repos/$REPO/pulls/$pn/commits?per_page=100" --paginate \
-              --jq '.[] | select((.parents | length) < 2)
-                        | [.sha, (.author.login // ""), (.commit.author.email // ""), .commit.committer.date]
-                        | @tsv' > "$commits_file"; then
-              echo "::error::PR #$pn 커밋 조회에 실패했다 — 근거 없이 PR 을 닫지 않는다"
-              exit 1
-            fi
-
-            # 계정이 연결되지 않은 커밋은 .author 가 비어 login 으로 가릴 수 없다. 같은 PR 에서
-            # 담당자 것으로 확인된 커밋의 이메일을 모아 폴백 신원으로 쓴다. 담당자는 여럿일 수
-            # 있으므로 집합으로 들고 다닌다.
-            author_emails=$(awk -F'\t' -v owners="$pr_owners" '
-              BEGIN {
-                n = split(owners, list, ",")
-                for (i = 1; i <= n; i++) if (list[i] != "") target[list[i]] = 1
-              }
-              (tolower($2) in target) && $3 != "" { print tolower($3) }' "$commits_file" | sort -u)
-
-            author_commits=$(awk -F'\t' -v owners="$pr_owners" -v cutoff="$blocked_at" -v emails="$author_emails" '
-              BEGIN {
-                n = split(owners, list, ",")
-                for (i = 1; i <= n; i++) if (list[i] != "") target[list[i]] = 1
-                count = split(emails, list, "\n")
-                for (i = 1; i <= count; i++) if (list[i] != "") own[list[i]] = 1
-              }
-              $4 > cutoff {
-                login = tolower($2)
-                email = tolower($3)
-                if (login != "") { if (login in target) print $1 }
-                else if (email != "" && (email in own)) print $1
-              }' "$commits_file")
-
-            # 빈 커밋은 반영이 아니다. pulls/{n}/commits 응답에는 파일 정보가 없어 후보에
-            # 한해 commits/{sha} 를 더 조회한다 — 후보는 대개 한 자릿수라 비용이 작다.
-            # 조회 실패를 반영·미반영 어느 쪽으로도 접지 않는다. 불완전한 근거로 남의 PR 을
-            # 닫지 않고 가드를 실패시켜 재실행하게 한다.
-            fixed=0
-            while IFS= read -r sha; do
-              [ -n "$sha" ] || continue
-              if ! changed=$(gh api "repos/$REPO/commits/$sha" --jq '(.files // []) | length'); then
-                echo "::error::PR #$pn 커밋 $sha 변경 파일 조회에 실패했다 — 근거 없이 PR 을 닫지 않는다"
-                exit 1
-              fi
-              case "$changed" in
-                ''|*[!0-9]*)
-                  echo "::error::PR #$pn 커밋 $sha 변경 파일 수가 올바르지 않다($changed)"
-                  exit 1
-                  ;;
-              esac
-              [ "$changed" -gt 0 ] || continue
-              fixed=$((fixed + 1))
-            done <<< "$author_commits"
-
-            # 응답 주체도 담당자 집합이다. 쉼표로 감싼 목록에 쉼표로 감싼 로그인이 들어 있는지 본다.
-            if ! said=$(gh api "repos/$REPO/issues/$pn/comments?per_page=100" --paginate \
-              --jq ".[] | select((.user.login | ascii_downcase) as \$login | \",$pr_owners,\" | contains(\",\" + \$login + \",\"))
-                        | select(.created_at > \"$blocked_at\") | .id" \
-              | wc -l | tr -d ' '); then
-              echo "::error::PR #$pn 작성자 일반 응답 조회에 실패했다 — 근거 없이 PR 을 닫지 않는다"
-              exit 1
-            fi
-
-            if ! answered=$(gh api "repos/$REPO/pulls/$pn/comments?per_page=100" --paginate \
-              --jq ".[] | select((.user.login | ascii_downcase) as \$login | \",$pr_owners,\" | contains(\",\" + \$login + \",\"))
-                        | select(.created_at > \"$blocked_at\") | .id" \
-              | wc -l | tr -d ' '); then
-              echo "::error::PR #$pn 작성자 리뷰 응답 조회에 실패했다 — 근거 없이 PR 을 닫지 않는다"
-              exit 1
-            fi
-
-            # PR 본문은 커밋 없이도 CI 계약·설명을 고치는 변경 표면이다(#771). REST 의
-            # updated_at 은 댓글·라벨까지 섞이고 GraphQL lastEditedAt 은 마지막 편집자만
-            # 남기므로, 영속 편집 이력에서 «최신 변경요청 뒤 담당자가 직접 고친 본문»만 센다.
-            # 최근 50건보다 많은 편집 이력이 있으면 필요한 구간이 잘렸을 수 있으므로
-            # 근거 없이 작성자·리뷰어 어느 쪽으로도 공을 넘기지 않고 가드를 실패시킨다.
-            # shellcheck disable=SC2016 # GraphQL 변수는 gh가 -F 값으로 바인딩한다.
-            if ! edits_json=$(gh api graphql \
-              -F owner="$repo_owner" \
-              -F name="$repo_name" \
-              -F number="$pn" \
-              -f query='query($owner:String!,$name:String!,$number:Int!){repository(owner:$owner,name:$name){pullRequest(number:$number){userContentEdits(last:50){pageInfo{hasPreviousPage} nodes{editedAt editor{login}}}}}}'); then
-              echo "::error::PR #$pn 본문 편집 이력 조회에 실패했다 — 근거 없이 PR 을 닫지 않는다"
-              exit 1
-            fi
-            if ! body_edits=$(jq -er \
-              --arg owners ",$pr_owners," \
-              --arg cutoff "$blocked_at" '
-                .data.repository.pullRequest.userContentEdits as $edits
-                | if ($edits.pageInfo.hasPreviousPage != false) then
-                    error("최근 50건보다 많은 본문 편집 이력")
-                  else
-                    [
-                      $edits.nodes[]
-                      | select(((.editor.login // "") | ascii_downcase) as $login | $owners | contains("," + $login + ","))
-                      | select(.editedAt > $cutoff)
-                    ] | length
-                  end
-              ' <<< "$edits_json"); then
-              echo "::error::PR #$pn 본문 편집 이력이 불완전하다 — 근거 없이 PR 을 닫지 않는다"
-              exit 1
-            fi
-
-            responses=$(( ${said:-0} + ${answered:-0} ))
-
-            if [ "${fixed:-0}" -gt 0 ] || [ "$responses" -gt 0 ] || [ "$body_edits" -gt 0 ]; then
-              echo "#$pn — @$blocked_by 재리뷰 요청 뒤 변경요청 반영(${fixed}커밋 · 응답 ${responses}건 · 본문 편집 ${body_edits}건), 아직 미응답"
-              printf '%s\t%s\t%s\n' "$pn" "$created" "$title" >> "$debt_file"
-            else
-              echo "#$pn — 변경요청 미반영, 공은 담당자에게"
-            fi
-          done <<< "$open_prs"
-
-          if [ ! -s "$debt_file" ] && [ ! -s "$author_debt_file" ]; then
-            echo "리뷰·작성자 응답을 기다리는 PR 없음 — 통과"
-            exit 0
-          fi
-
-          debt=$(cat "$debt_file")
-          author_debt=$(cat "$author_debt_file")
-          review_count=$(wc -l < "$debt_file" | tr -d ' ')
-          author_count=$(wc -l < "$author_debt_file" | tr -d ' ')
-          count=$(( review_count + author_count ))
-          today=$(date -u +%s)
-
-          {
-            echo "## 🚧 리뷰 적체 가드 — 이 PR 을 닫습니다"
-            echo
-            if [ "$review_count" -gt 0 ]; then
-              echo "### 팀 리뷰 응답 대기 · ${review_count}건"
-              echo
-              echo "| PR | 열린 날 | 경과 | 제목 |"
-              echo "|---|---|---|---|"
-              while IFS=$'\t' read -r n created title; do
-                [ -n "$n" ] || continue
-                opened=$(date -u -d "$created" +%s 2>/dev/null || echo "$today")
-                days=$(( (today - opened) / 86400 ))
-                echo "| #$n | $created | ${days}일 | $title |"
-              done <<< "$debt"
-              echo
-            fi
-            if [ "$author_count" -gt 0 ]; then
-              echo "### 작성자 응답 대기 · ${author_count}건"
-              echo
-              echo "| PR | 열린 날 | 변경요청자 | 제목 |"
-              echo "|---|---|---|---|"
-              while IFS=$'\t' read -r n created reviewer title; do
-                [ -n "$n" ] || continue
-                echo "| #$n | $created | @$reviewer | $title |"
-              done <<< "$author_debt"
-              echo
-            fi
-            echo "이 저장소는 팀 리뷰 응답 또는 자기가 담당하는 PR 의 변경요청 대응을 기다리는 PR 이 1건이라도 남아 있으면 새 PR 을 열 수 없습니다 (#1136, #1679)."
-            echo
-            echo "PR 의 담당자는 올린 사람이 아니라 **어사인된 사람**입니다(어사인이 비어 있으면 작성자, #1974)."
-            echo "각 PR 에 필요한 리뷰는 **한 건**입니다 — 누구든 먼저 판정을 내면 그 PR 은 모두의 목록에서 빠집니다. 승인 뒤 변경을 다시 볼 의무는 없고, **변경요청도 담당자가 같은 리뷰어에게 재요청한 뒤 실질 커밋·응답·본문 편집을 남긴 경우에만** 다시 리뷰어의 몫이 됩니다."
-            echo "담당하는 PR 이 **최신 변경요청 뒤 실질 커밋·응답·본문 편집 없이** 남아 있으면 담당자의 몫입니다. 조치를 남기면 다음 검사에서 작성자 빚이 해소됩니다."
-            echo
-            echo "### 되살리는 법"
-            echo
-            echo "위 PR 에 필요한 리뷰나 작성자 조치를 끝낸 뒤 이 PR 을 다시 여세요. **브랜치는 지워지지 않았고 커밋도 그대로입니다.**"
-            echo
-            echo '```bash'
-            echo "gh pr reopen $PR_NUMBER"
-            echo '```'
-          } > /tmp/debt-comment.md
-
-          echo "리뷰·작성자 미응답 ${count}건 — PR #$PR_NUMBER 를 닫는다"
-          gh pr close "$PR_NUMBER" --repo "$REPO" --comment "$(cat /tmp/debt-comment.md)"
-
-      # 실패가 «가드가 사실을 확인하고 거절함» 인지 «한도 소진» 인지 가른다. 구분이 없으면
-      # 빨간 체크를 보고도 원인을 로그까지 들어가야 안다 (#1465).
-      - name: Classify a failed gate as rate limit exhaustion
-        if: failure()
-        run: |
-          # default branch 사본에 이 스크립트가 아직 없는 동안(= 스크립트를 심는 이 PR 자신)에는
-          # 건너뛴다. 머지 뒤에는 항상 존재하므로 이 경로는 부트스트랩 한 번에만 쓰인다.
-          if [ ! -f .github/scripts/ensure-api-quota.mjs ]; then
-            echo "::notice::quota 스크립트가 default branch 에 아직 없습니다 — 건너뜁니다"
-            exit 0
-          fi
-          node .github/scripts/ensure-api-quota.mjs classify --resource core
-          node .github/scripts/ensure-api-quota.mjs classify --resource graphql
-        env:
-          GH_TOKEN: ${{ github.token }}
diff --git a/.github/workflows/review-request-all.yml b/.github/workflows/review-request-all.yml
deleted file mode 100644
index cbcba2ebe2..0000000000
--- a/.github/workflows/review-request-all.yml
+++ /dev/null
@@ -1,206 +0,0 @@
-# 리뷰어 자동 요청 (#1136)
-#
-# 리뷰 요청을 손으로 걸다 보면 빠뜨린다. PR 이 열리면 담당자를 뺀 팀 전원에게
-# 자동으로 요청한다. GitHub 은 자기 PR 의 작성자를 리뷰어로 받지 않으므로
-# 목록에 전원을 적어도 작성자는 자동으로 빠진다. 담당자(어사인)는 GitHub 이 막지
-# 않으므로 여기서 직접 뺀다 — PR 의 공은 올린 사람이 아니라 어사인된 사람에게
-# 있다(#1974 결정, #1980). 어사인이 비어 있는 동안만 작성자가 담당자다.
-#
-# 이 워크플로는 review-debt-guard 와 한 세트다. 요청이 자동으로 걸려야
-# "리뷰를 안 하면 새 PR 을 못 연다" 가 성립한다 — 요청을 손으로 걸던 때는
-# 아예 걸지 않는 것으로 가드를 통과할 수 있었다.
-#
-# 같은 구멍이 «변경요청 뒤» 에 그대로 남아 있었다(#1450). GitHub 은 변경요청
-# 리뷰를 제출하는 순간 그 리뷰어의 요청을 떼어 내는데, 가드는 그 리뷰어에게
-# 요청이 다시 걸린 경우에만 빚으로 센다. 되살리는 일이 작성자 손에 맡겨져 있어
-# 8/29 실측에서 반영까지 끝난 PR 7건이 전원 «빚 아님» 이었고, 그중 하나는
-# dependabot 이 작성자라 되살릴 주체 자체가 없었다. 반영 커밋이 올라오거나
-# 작성자가 PR 본문을 고치면 재요청도 자동으로 건다.
-#
-# 옛 Review Assign(.github/workflows/PRassign.yml)을 대체한다. 그쪽은 develop
-# 에서 파일만 지워졌을 뿐 워크플로 등록이 살아 있어, 파일이 남은 옛 브랜치에서
-# 갈라진 PR 에는 지금도 구버전이 실행된다. 이 워크플로를 들이면서 함께 disable
-# 해야 중복 요청이 나지 않는다.
-name: review-request-all
-
-on:
-  pull_request:
-    types: [opened, ready_for_review, reopened, synchronize, edited]
-
-permissions:
-  pull-requests: write
-
-jobs:
-  request:
-    # draft 에는 걸지 않는다. 리뷰할 수 없는 PR 로 남의 미처리 건수를 늘리면
-    # review-debt-guard 가 그 사람의 새 PR 을 닫아 버린다.
-    if: >-
-      github.event.pull_request.state == 'open' &&
-      github.event.pull_request.draft == false &&
-      github.event.action != 'synchronize' &&
-      github.event.action != 'edited'
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    steps:
-      - name: 담당자를 뺀 전원에게 리뷰 요청
-        env:
-          GH_TOKEN: ${{ github.token }}
-          REPO: ${{ github.repository }}
-          PR_NUMBER: ${{ github.event.pull_request.number }}
-          AUTHOR: ${{ github.event.pull_request.user.login }}
-          ASSOCIATION: ${{ github.event.pull_request.author_association }}
-          # 이벤트 시점의 어사인. pr-assign-author 가 같은 이벤트에서 빈 어사인에 작성자를
-          # 거는 중일 수 있으므로, 비어 있으면 작성자로 폴백한다.
-          ASSIGNEES: ${{ join(github.event.pull_request.assignees.*.login, ' ') }}
-          # 리뷰 의무가 있는 팀원만 적는다. koongmai 는 남의 PR 을 리뷰할 의무가 없어
-          # 빠져 있다 (#1910). 자기 PR 에는 나머지 둘에게 그대로 요청이 걸리고,
-          # 스스로 리뷰하는 것도 막히지 않는다. 빠진 것은 자동 요청뿐이다.
-          TEAM: 1hyok Sadturtleman
-        run: |
-          set -euo pipefail
-
-          case "$AUTHOR" in
-            *'[bot]'|dependabot|github-actions) echo "봇 PR — 건너뜀"; exit 0 ;;
-          esac
-
-          # 외부 기여자 PR 은 토큰이 read-only 라 요청을 걸 수 없다.
-          case "$ASSOCIATION" in
-            OWNER|MEMBER|COLLABORATOR) ;;
-            *) echo "외부 기여자($ASSOCIATION) — 건너뜀"; exit 0 ;;
-          esac
-
-          # 이미 걸려 있는 요청은 다시 걸지 않는다. reopened·ready_for_review 가
-          # 여러 번 오갈 때 같은 사람에게 요청이 반복되는 것을 막는다.
-          current=$(gh api "repos/$REPO/pulls/$PR_NUMBER" \
-            --jq '[.requested_reviewers[].login] | join(" ")')
-
-          # 담당자는 리뷰어가 아니다. 어사인이 있으면 어사인, 없으면 작성자. 로그인은
-          # 대소문자를 가리지 않으므로 낮춰 비교한다.
-          owners_lc=$(printf '%s' "${ASSIGNEES:-$AUTHOR}" | tr '[:upper:]' '[:lower:]')
-          current_lc=$(printf '%s' "$current" | tr '[:upper:]' '[:lower:]')
-
-          targets=""
-          for u in $TEAM; do
-            u_lc=$(printf '%s' "$u" | tr '[:upper:]' '[:lower:]')
-            case " $owners_lc " in
-              *" $u_lc "*) continue ;;
-            esac
-            case " $current_lc " in
-              *" $u_lc "*) continue ;;
-            esac
-            targets="${targets:+$targets,}$u"
-          done
-
-          if [ -z "$targets" ]; then
-            echo "추가할 리뷰어 없음 (이미 요청됨 또는 담당자뿐)"
-            exit 0
-          fi
-
-          echo "리뷰 요청: $targets"
-          gh pr edit "$PR_NUMBER" --repo "$REPO" --add-reviewer "$targets"
-
-  # 변경요청 뒤 반영 커밋이 올라오거나 담당자가 PR 본문을 고치면 그 리뷰어에게
-  # 다시 요청을 건다(#1450, #1700). `edited` 전체를 받되 제목 수정·관리자 대리 수정은
-  # 담당자 조치가 아니므로 body 변경과 sender=담당자 를 함께 요구한다. 담당자는
-  # 어사인이고, 어사인이 비어 있으면 작성자다(#1974).
-  #
-  # 판정 기준은 review-debt-guard 와 같아야 한다 — 여기서 거는 요청이 곧 그쪽의
-  # 빚 성립 조건이므로, 한쪽만 «PR 전체의 최신 판정» 을 보면 자동 재요청이 빚으로
-  # 이어지지 않거나 이미 승인된 PR 을 되살린다.
-  rerequest:
-    if: >-
-      github.event.pull_request.state == 'open' &&
-      github.event.pull_request.draft == false &&
-      (
-        github.event.action == 'synchronize' ||
-        (
-          github.event.action == 'edited' &&
-          github.event.changes.body != null &&
-          (
-            contains(github.event.pull_request.assignees.*.login, github.event.sender.login) ||
-            (
-              github.event.pull_request.assignees[0] == null &&
-              github.event.sender.login == github.event.pull_request.user.login
-            )
-          )
-        )
-      )
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    steps:
-      - name: 변경요청 리뷰어에게 재요청
-        env:
-          GH_TOKEN: ${{ github.token }}
-          REPO: ${{ github.repository }}
-          PR_NUMBER: ${{ github.event.pull_request.number }}
-          AUTHOR: ${{ github.event.pull_request.user.login }}
-          ASSIGNEES: ${{ join(github.event.pull_request.assignees.*.login, ' ') }}
-          HEAD_REPO: ${{ github.event.pull_request.head.repo.full_name }}
-          ACTION: ${{ github.event.action }}
-          EVENT_AT: ${{ github.event.pull_request.updated_at }}
-        run: |
-          set -euo pipefail
-
-          # 봇 PR 은 건너뛴다. dependabot 이 연 PR 에서는 GITHUB_TOKEN 이 read-only 라
-          # 요청을 걸지 못한다 — 시도하면 403 으로 죽을 뿐이다. 봇 PR 의 변경요청이
-          # 빚이 되지 못하는 구멍은 이 워크플로로는 못 메운다(#1450 에 남겨 둔다).
-          case "$AUTHOR" in
-            *'[bot]'|dependabot|github-actions) echo "봇 PR — 건너뜀"; exit 0 ;;
-          esac
-
-          # fork PR 도 토큰이 read-only 다. 팀원 여부를 author_association 으로 가르지
-          # 않는 이유는 review-debt-guard 주석에 있다 — 비공개 멤버가 CONTRIBUTOR 로
-          # 내려와 팀원 대부분이 조용히 빠진다. 실제 제약인 head 저장소로 가른다.
-          if [ "$HEAD_REPO" != "$REPO" ]; then
-            echo "fork PR($HEAD_REPO) — 토큰이 read-only 라 건너뜀"
-            exit 0
-          fi
-          if [ "$ACTION" = "edited" ] && [ -z "$EVENT_AT" ]; then
-            echo "::error::본문 편집 이벤트 시각이 없다 — 과거 편집을 최신 변경요청에 귀속하지 않도록 재실행할 것"
-            exit 1
-          fi
-
-          # PR 전체의 최신 판정만 본다. 승인 뒤 올라온 커밋은 재요청 대상이 아니다.
-          # --paginate 는 페이지마다 jq 를 돌리므로 정렬은 모아서 한 번에 한다.
-          if ! decisions=$(gh api "repos/$REPO/pulls/$PR_NUMBER/reviews" --paginate \
-            --jq '.[] | select(.state == "APPROVED" or .state == "CHANGES_REQUESTED")
-                      | {u: .user.login, s: .state, t: .submitted_at}'); then
-            echo "::error::리뷰 조회에 실패했다 — 재리뷰 요청을 누락시키지 않도록 재실행할 것"
-            exit 1
-          fi
-          if ! blocked=$(printf '%s\n' "$decisions" \
-            | jq -rs --arg action "$ACTION" --arg event_at "$EVENT_AT" '
-                sort_by(.t) | last // empty
-                | select(.s == "CHANGES_REQUESTED")
-                | select($action != "edited" or .t < $event_at)
-                | [.u, .t] | @tsv
-              '); then
-            echo "::error::최신 리뷰 판정에 실패했다 — 재리뷰 요청을 누락시키지 않도록 재실행할 것"
-            exit 1
-          fi
-
-          if [ -z "$blocked" ]; then
-            echo "최신 판정이 변경요청이 아님 — 재요청할 대상 없음"
-            exit 0
-          fi
-          IFS=$'\t' read -r blocked blocked_at <<< "$blocked"
-
-          # 자기 자신은 리뷰어가 될 수 없다(422). 작성자가 자기 PR 에 변경요청을 낼
-          # 수는 없지만, 소유권이 옮겨진 PR 에서 그렇게 보일 수 있다. 담당자(어사인)가
-          # 낸 변경요청도 자기 PR 에 대한 것이라 되살리지 않는다.
-          owners_lc=$(printf '%s' "${ASSIGNEES:-$AUTHOR}" | tr '[:upper:]' '[:lower:]')
-          blocked_lc=$(printf '%s' "$blocked" | tr '[:upper:]' '[:lower:]')
-          case " $owners_lc " in
-            *" $blocked_lc "*) echo "변경요청을 낸 사람이 담당자 본인(@$blocked) — 건너뜀"; exit 0 ;;
-          esac
-
-          # 이미 걸려 있으면 다시 걸지 않는다. synchronize 는 force-push 마다 온다.
-          current=$(gh api "repos/$REPO/pulls/$PR_NUMBER" \
-            --jq '[.requested_reviewers[].login] | join(" ")')
-          current_lc=$(printf '%s' "$current" | tr '[:upper:]' '[:lower:]')
-          case " $current_lc " in
-            *" $blocked_lc "*) echo "@$blocked 요청이 이미 걸려 있음 — 건너뜀"; exit 0 ;;
-          esac
-
-          echo "변경요청($blocked_at) 뒤 담당자 조치($ACTION) — @$blocked 에게 재리뷰 요청"
-          gh pr edit "$PR_NUMBER" --repo "$REPO" --add-reviewer "$blocked"
diff --git a/.github/workflows/screenshot-baseline-generate.yml b/.github/workflows/screenshot-baseline-generate.yml
index 36cfd5f7cd..3ba4977c77 100644
--- a/.github/workflows/screenshot-baseline-generate.yml
+++ b/.github/workflows/screenshot-baseline-generate.yml
@@ -72,7 +72,7 @@ jobs:
         uses: ./.github/actions/setup-ci-config
 
       - name: Set up Gradle and validate wrapper
-        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
+        uses: gradle/actions/setup-gradle@3f5f9adaf7d9fecd50b5935e54106014257a94e6 # v6.4.0
         with:
           cache-provider: basic
           cache-read-only: true
diff --git a/.github/workflows/screenshot.yml b/.github/workflows/screenshot.yml
index 5465785242..5c283c4fa6 100644
--- a/.github/workflows/screenshot.yml
+++ b/.github/workflows/screenshot.yml
@@ -71,7 +71,7 @@ jobs:
       # setup-gradle 의 공개 MIT cache provider 로 host 의 Gradle home 을 복원한 뒤
       # 컨테이너 /root/.gradle 로 마운트한다. PR 은 cache poisoning 방지를 위해 읽기 전용이다.
       - name: Set up Gradle and validate wrapper
-        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
+        uses: gradle/actions/setup-gradle@3f5f9adaf7d9fecd50b5935e54106014257a94e6 # v6.4.0
         with:
           cache-provider: basic
           cache-read-only: true
diff --git a/.github/workflows/unit-test.yml b/.github/workflows/unit-test.yml
index cb1079109e..be742ad230 100644
--- a/.github/workflows/unit-test.yml
+++ b/.github/workflows/unit-test.yml
@@ -127,7 +127,7 @@ jobs:
 
       - name: Set up Gradle and validate wrapper
         if: inputs.gradle_tasks != ''
-        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
+        uses: gradle/actions/setup-gradle@3f5f9adaf7d9fecd50b5935e54106014257a94e6 # v6.4.0
         with:
           cache-provider: basic
           cache-read-only: true
diff --git a/.github/workflows/viewed-auto-merge.yml b/.github/workflows/viewed-auto-merge.yml
new file mode 100644
index 0000000000..df32ac8c89
--- /dev/null
+++ b/.github/workflows/viewed-auto-merge.yml
@@ -0,0 +1,82 @@
+# Viewed 기반 자동 머지 예약 (#2248)
+#
+# 적용 범위는 VIEWED_BY 본인이 작성한 PR 이다(#2270). 팀원·봇 PR 은 예약하지 않는다.
+#
+# VIEWED_BY 가 PR 의 모든 파일을 Viewed 로 체크하면 «Merge when ready» 를 대신 건다. 리뷰 상태는 보지 않는다.
+# 머지는 GitHub 가 룰셋·required check·merge queue 를 모두 통과시킨 뒤에만 하므로 CI 가 빨가면 머지되지 않는다.
+#
+# 반대 방향(예약 해제·큐에서 빼기)은 하지 않는다(#2252 폐지). Viewed 가 덜 찬 PR 도 사람이 직접 예약하거나 큐에 넣으면
+# 그대로 머지된다. Viewed 는 자동 예약의 조건일 뿐 머지를 막는 장치가 아니다.
+#
+# Viewed 체크는 webhook 이벤트가 없어 주기 실행으로 훑는다. viewerViewedState 는 토큰 주인 본인 것만 보이므로 VIEWED_BY 의 읽기 전용 토큰을 VIEWED_TOKEN
+# 시크릿으로 둔다. 시크릿이 없으면 아무것도 하지 않는다.
+#
+# 예약 쓰기는 MERGE_QUEUE_TOKEN(1hyok 의 fine-grained PAT)이 한다. GITHUB_TOKEN 으로 예약하거나 큐에 넣으면 GitHub 이
+# 그 이벤트로 워크플로를 띄우지 않아 merge_group CI 가 하나도 돌지 않는다. 큐는 check timeout(60분)까지 맨 앞을 붙잡았다가
+# CI_TIMEOUT 으로 빼고, 뒤에 쌓인 PR 들도 다시 검증한다(1005 #2208 실측). 시크릿이 없으면 예약하지 않는다.
+name: Viewed Auto Merge
+
+on:
+  schedule:
+    - cron: '*/10 * * * *'
+  workflow_dispatch:
+
+concurrency:
+  group: viewed-auto-merge-${{ github.repository }}
+  cancel-in-progress: false
+
+permissions: {}
+
+jobs:
+  enable:
+    name: Enable auto-merge for fully viewed PRs
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    permissions:
+      # 기본 브랜치의 스크립트만 체크아웃한다. 예약 쓰기는 MERGE_QUEUE_TOKEN 이 한다.
+      contents: read
+    steps:
+      - name: Clone script from the default branch
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          ref: ${{ github.event.repository.default_branch }}
+          persist-credentials: false
+          sparse-checkout: .github/scripts
+
+      - name: Find PRs to enable auto-merge
+        id: find
+        env:
+          VIEWED_TOKEN: ${{ secrets.VIEWED_TOKEN }}
+          VIEWED_BY: 1hyok
+          BASE_BRANCH: ${{ github.event.repository.default_branch }}
+          GITHUB_REPOSITORY: ${{ github.repository }}
+          GITHUB_API_URL: ${{ github.api_url }}
+        run: |
+          if [ -z "$VIEWED_TOKEN" ]; then
+            echo "::notice::VIEWED_TOKEN 시크릿이 없어 건너뜁니다"
+            echo 'targets=[]' >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+          node .github/scripts/find-viewed-auto-merge-targets.mjs
+
+      - name: Enable auto-merge
+        if: steps.find.outputs.targets != '[]'
+        env:
+          GH_TOKEN: ${{ secrets.MERGE_QUEUE_TOKEN }}
+          GH_REPO: ${{ github.repository }}
+          TARGETS: ${{ steps.find.outputs.targets }}
+        run: |
+          if [ -z "$GH_TOKEN" ]; then
+            echo "::warning::MERGE_QUEUE_TOKEN 시크릿이 없어 예약하지 않습니다. GITHUB_TOKEN 으로 넣으면 merge_group CI 가 돌지 않습니다."
+            exit 0
+          fi
+          # merge queue 대상이면 전략 없이 부른다. check 가 남았으면 auto-merge, 끝났으면 큐 투입이다.
+          # 판정 뒤 새 커밋이 올라왔으면 --match-head-commit 이 거부한다. 스택 PR 처럼 GitHub 가 거부하는
+          # 경우는 사람이 버튼을 누르면 되므로 경고로 남긴다.
+          jq -c '.[]' <<< "$TARGETS" | while read -r target; do
+            number=$(jq -r '.number' <<< "$target")
+            head_sha=$(jq -r '.headSha' <<< "$target")
+            if ! gh pr merge "$number" --match-head-commit "$head_sha"; then
+              echo "::warning::#$number 자동 머지 예약 실패 — PR 화면에서 Merge when ready 를 직접 누르세요"
+            fi
+          done
diff --git a/README.md b/README.md
index b7d2e69a98..9bb88e9762 100644
--- a/README.md
+++ b/README.md
@@ -183,13 +183,8 @@ Kover는 임의의 절대 커버리지 목표를 강제하지 않는다. 정확
 
 정기·기본 브랜치 수동 검증은 PR critical path 밖에서 minSdk API 26과 targetSdk API 36 경계 smoke도 실행한다. 문서 링크는 PR에서 로컬 경로·heading anchor를 검사하고 외부 URL은 주간 실행으로 분리하며, release AAB/R8 preflight는 `develop`에서 주 2회 조기 검증한다.
 
-## 코드 리뷰
-
-- PR의 담당자는 올린 사람이 아니라 **어사인된 사람**이다. 어사인이 비어 있으면 [자동 어사인 workflow](.github/workflows/pr-assign-author.yml)가 작성자를 걸고, 사람이 담당자를 바꾼 것은 되돌리지 않는다. 변경요청 대응·리뷰 요청 제외·아래 적체 가드의 «자기 PR» 판정은 모두 이 담당자 기준이다.
-- Draft가 아닌 내부 팀원 PR이 열리거나 리뷰 가능 상태가 되면 [자동 요청 workflow](.github/workflows/review-request-all.yml)가 담당자를 제외한 리뷰 담당 팀원(`TEAM`)에게 리뷰를 요청한다. 요청 인원 수와 필수 승인 수는 같은 뜻이 아니다.
-- 현재 `develop`·`main` 머지에는 **승인 1건**이 필요하다. `main`은 모든 리뷰 스레드 해결도 필요하다.
-- 리뷰 결과는 GitHub의 `APPROVED`·`CHANGES_REQUESTED`·일반 코멘트로 표현한다. 별도 RCA prefix나 12시간 SLA는 두지 않는다.
-- [리뷰 적체 가드](.github/workflows/review-debt-guard.yml)는 응답을 기다리는 다른 PR이 남았거나 자기가 담당하는 PR의 최신 변경요청 뒤 아무 조치도 하지 않은 팀원의 새 PR을 닫을 수 있다. 아래 면제 목록에 있는 작성자는 대상이 아니다. 각 PR은 팀원 한 명이 먼저 유효한 판정을 내리면 최초 미응답 목록에서 빠지고, 담당자가 실질 커밋이나 응답을 남기면 작성자 대기 목록에서 빠진다.
-- `awaiting-author` 라벨은 리뷰 게이트 적용 대상 중 변경요청 뒤 담당자 무조치 상태인 PR을 보여 준다. 면제 작성자에게는 붙이지 않으며, 이미 붙은 라벨도 리컨사일러가 제거한다. 새 PR 가드는 라벨 갱신 시점에 의존하지 않고 같은 판정을 현재 열린 PR에 다시 적용한다.
-- 쓰기 권한이 있는 리뷰어별 최신 `APPROVED`·`CHANGES_REQUESTED` 가운데 PR 전체에서 가장 늦은 판정을 최종 판정으로 사용한다. 가장 늦은 판정이 승인이면 더 오래된 변경 요청은 자동 해제되고, 승인 뒤에 새 변경 요청이 오면 다시 차단된다.
-- 적체 가드에는 라벨 우회가 없다. 가드와 `awaiting-author` 라벨이 함께 쓰는 면제 목록은 [review-debt-guard.yml](.github/workflows/review-debt-guard.yml)의 `REVIEW_GATE_EXEMPT_AUTHORS`이며, 지금은 `koongmai`가 거기에 있다. 면제받은 사람은 리뷰 지적 반영 여부와 무관하게 새 PR을 열 수 있고 남의 PR을 리뷰할 의무가 없다. 그래서 자동 요청 대상에서도 빠지고, 그가 낸 변경요청은 다른 팀원의 빚으로 세지 않는다. 머지 게이트는 면제와 무관하다. `develop` 승인 1건과 필수 체크는 그대로 요구된다.
+## 머지
+
+- PR의 담당자는 올린 사람이 아니라 **어사인된 사람**이다. 어사인이 비어 있으면 [자동 어사인 workflow](.github/workflows/pr-assign-author.yml)가 작성자를 건다. 사람이 담당자를 바꾼 것은 되돌리지 않는다.
+- `develop`·`main` 머지에 리뷰 승인은 필요 없다. PR 경유, 필수 검사, `develop`의 merge queue는 그대로 요구된다.
+- `develop` 대상 PR은 1hyok가 모든 파일을 Viewed로 체크하면 [Viewed 자동 머지 workflow](.github/workflows/viewed-auto-merge.yml)가 10분 안팎으로 자동 머지(Merge when ready)를 예약한다. Viewed 체크에는 이벤트가 없어 주기 실행으로 훑고, 본인 체크만 조회되므로 1hyok의 읽기 전용 토큰을 `VIEWED_TOKEN` 시크릿으로 둔다. 필수 검사가 통과해야 merge queue로 들어간다. 이 workflow는 예약을 걸기만 하고 풀거나 큐에서 빼지 않으므로, Viewed가 덜 찬 PR도 직접 예약하거나 큐에 넣으면 그대로 머지된다. 예약을 멈추려면 PR 화면에서 끈다.
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index 38b91e10e1..3592761784 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -50,6 +50,11 @@ android {
         execution = "ANDROIDX_TEST_ORCHESTRATOR"
         // Robolectric 이 병합된 매니페스트·리소스를 읽어야 NavHost 를 실제 컴포지션으로 띄울 수 있다 (#1601).
         unitTests.isIncludeAndroidResources = true
+        unitTests.all {
+            // 여러 SDK의 앱 리소스를 읽은 뒤에도 후속 테스트의 샌드박스를 생성할 수 있어야 한다.
+            // 기본 512 MB에서는 API 33 알림 권한 테스트의 리소스 로딩이 OOM으로 실패한다 (#2200).
+            it.maxHeapSize = "1g"
+        }
         managedDevices {
             localDevices {
                 create("pixel2Api26") {
@@ -228,7 +233,6 @@ baselineProfile {
 
 dependencies {
     implementation(libs.coil.compose)
-    implementation(libs.androidx.hilt.navigation.compose)
     implementation(libs.core.splashscreen)
 
     // App Startup — 기동 초기화는 app 매니페스트에 등록한 Initializer 로 실행한다.
@@ -309,10 +313,12 @@ dependencies {
     androidTestImplementation(testFixtures(projects.core.ui))
     androidTestImplementation(projects.feature.afternote.domain)
     androidTestImplementation(testFixtures(projects.feature.afternote.domain))
+    androidTestImplementation(testFixtures(projects.feature.afternote.presentation))
     androidTestImplementation(projects.feature.mindrecord.domain)
     androidTestImplementation(testFixtures(projects.feature.mindrecord.domain))
     androidTestImplementation(projects.feature.receiver.domain)
     androidTestImplementation(testFixtures(projects.feature.receiver.domain))
+    androidTestImplementation(testFixtures(projects.feature.setting.data))
     androidTestImplementation(projects.feature.setting.data)
     androidTestImplementation(projects.feature.setting.domain)
     androidTestImplementation(testFixtures(projects.feature.setting.domain))
diff --git a/app/src/androidTest/java/com/afternote/afternote_fe/AfternoteAuthorExtendedAndroidTest.kt b/app/src/androidTest/java/com/afternote/afternote_fe/AfternoteAuthorExtendedAndroidTest.kt
index 3d20af2511..eba20e2b69 100644
--- a/app/src/androidTest/java/com/afternote/afternote_fe/AfternoteAuthorExtendedAndroidTest.kt
+++ b/app/src/androidTest/java/com/afternote/afternote_fe/AfternoteAuthorExtendedAndroidTest.kt
@@ -25,8 +25,7 @@ import com.afternote.core.ui.theme.AfternoteTheme
 import com.afternote.feature.afternote.domain.AfternoteType
 import com.afternote.feature.afternote.domain.model.author.ListItem
 import com.afternote.feature.afternote.domain.testing.FakeAfternoteRepository
-import com.afternote.feature.afternote.presentation.home.AfternoteHomeEntry
-import com.afternote.feature.afternote.presentation.home.AfternoteHomeViewModel
+import com.afternote.feature.afternote.presentation.testing.AfternoteHomeScreenFixture
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.flowOf
@@ -66,17 +65,16 @@ class AfternoteAuthorExtendedAndroidTest {
         listFlows[null] =
             Pager(PagingConfig(pageSize = 20)) { pagingSource }.flow
         listFlows[AfternoteType.SOCIAL_NETWORK] = flowOf(PagingData.empty())
-        val viewModel = AfternoteHomeViewModel(repository, FakeErrorReporter())
+        val homeFixture = AfternoteHomeScreenFixture(repository, FakeErrorReporter())
         val detailRoutes = mutableListOf<Long>()
         val addRoutes = mutableListOf<AfternoteType?>()
 
         composeRule.setContent {
             AfternoteTheme {
-                AfternoteHomeEntry(
+                homeFixture.Content(
                     navigateToDetail = detailRoutes::add,
                     navigateToAdd = addRoutes::add,
                     onSettingClick = {},
-                    viewModel = viewModel,
                 )
             }
         }
diff --git a/app/src/androidTest/java/com/afternote/afternote_fe/AfternoteHomeRefreshBannerAndroidTest.kt b/app/src/androidTest/java/com/afternote/afternote_fe/AfternoteHomeRefreshBannerAndroidTest.kt
index 20b113c583..1902fc2cbe 100644
--- a/app/src/androidTest/java/com/afternote/afternote_fe/AfternoteHomeRefreshBannerAndroidTest.kt
+++ b/app/src/androidTest/java/com/afternote/afternote_fe/AfternoteHomeRefreshBannerAndroidTest.kt
@@ -20,8 +20,7 @@ import com.afternote.core.ui.theme.AfternoteTheme
 import com.afternote.feature.afternote.domain.AfternoteType
 import com.afternote.feature.afternote.domain.model.author.ListItem
 import com.afternote.feature.afternote.domain.testing.FakeAfternoteRepository
-import com.afternote.feature.afternote.presentation.home.AfternoteHomeEntry
-import com.afternote.feature.afternote.presentation.home.AfternoteHomeViewModel
+import com.afternote.feature.afternote.presentation.testing.AfternoteHomeScreenFixture
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -78,15 +77,14 @@ class AfternoteHomeRefreshBannerAndroidTest {
                     }.flow
                 }
             }
-        val viewModel = AfternoteHomeViewModel(repository, FakeErrorReporter())
+        val homeFixture = AfternoteHomeScreenFixture(repository, FakeErrorReporter())
 
         composeRule.setContent {
             AfternoteTheme {
-                AfternoteHomeEntry(
+                homeFixture.Content(
                     navigateToDetail = {},
                     navigateToAdd = {},
                     onSettingClick = {},
-                    viewModel = viewModel,
                 )
             }
         }
diff --git a/app/src/androidTest/java/com/afternote/afternote_fe/AppAndReceiverCompletionAndroidTest.kt b/app/src/androidTest/java/com/afternote/afternote_fe/AppAndReceiverCompletionAndroidTest.kt
index 5865b76162..6c0a2dc446 100644
--- a/app/src/androidTest/java/com/afternote/afternote_fe/AppAndReceiverCompletionAndroidTest.kt
+++ b/app/src/androidTest/java/com/afternote/afternote_fe/AppAndReceiverCompletionAndroidTest.kt
@@ -45,9 +45,7 @@ import com.afternote.core.ui.Route
 import com.afternote.core.ui.theme.AfternoteTheme
 import com.afternote.feature.afternote.domain.AfternoteType
 import com.afternote.feature.afternote.domain.model.LeaveMessageBlock
-import com.afternote.feature.afternote.presentation.receiver.detail.ReceivedAfternoteDetailRoute
-import com.afternote.feature.afternote.presentation.receiver.detail.ReceivedAfternoteDetailViewModel
-import com.afternote.feature.afternote.presentation.receiver.navigation.ReceivedAfternoteRoute
+import com.afternote.feature.afternote.presentation.testing.ReceivedAfternoteDetailScreenFixture
 import com.afternote.feature.home.presentation.HomeTabActions
 import com.afternote.feature.home.presentation.receiver.ReceiverHomeEvent
 import com.afternote.feature.mindrecord.domain.repository.WeeklyReportRepository
@@ -502,42 +500,30 @@ class ReceiverRuntimeCompletionAndroidTest {
                 actions = homeActions
             }
             AfternoteTheme {
-                NavHost(
-                    navController = currentAppState.navController,
-                    startDestination = Route.Home,
-                ) {
-                    composable<Route.Home> { Text("home route") }
-                    composable<Route.Afternote> { Text("afternote route") }
-                    composable<Route.MindRecord> { Text("mind record route") }
-                    composable<Route.TimeLetter> { Text("time letter route") }
-                    composable<Route.MemorySpace> { Text("memory space route") }
-                    composable<Route.Setting> { Text("setting route") }
-                }
+                Text("home route")
             }
         }
         composeRule.onNodeWithText("home route").assertIsDisplayed()
 
         val homeActions = checkNotNull(actions)
         composeRule.runOnIdle { homeActions.onNextStepClick() }
-        composeRule.onNodeWithText("afternote route").assertIsDisplayed()
+        assertEquals(Route.Afternote, composeRule.runOnIdle { checkNotNull(appState).backStack.last() })
         // 카테고리 카드는 시안에 없어 사라졌지만(#700) 주간 이미지·카운트는 여전히
         // Route.MindRecord 로 간다 — 살아 있는 진입점이라 가드를 그쪽으로 옮긴다 (리뷰 지적).
         composeRule.runOnIdle { homeActions.onWeeklyImageClick() }
-        composeRule.onNodeWithText("mind record route").assertIsDisplayed()
-        composeRule.runOnIdle { checkNotNull(appState).navController.popBackStack() }
+        assertEquals(Route.MindRecord, composeRule.runOnIdle { checkNotNull(appState).backStack.last() })
         composeRule.runOnIdle { homeActions.onWeeklyCountClick() }
-        composeRule.onNodeWithText("mind record route").assertIsDisplayed()
-        composeRule.runOnIdle { checkNotNull(appState).navController.popBackStack() }
+        assertEquals(Route.MindRecord, composeRule.runOnIdle { checkNotNull(appState).backStack.last() })
 
         // 2026-08-09 확정된 타임레터 NEXT STEP 카드의 목적지 (#700).
         composeRule.runOnIdle { homeActions.onTimeLetterNextStepClick() }
-        composeRule.onNodeWithText("time letter route").assertIsDisplayed()
+        assertEquals(Route.TimeLetter, composeRule.runOnIdle { checkNotNull(appState).backStack.last() })
 
-        composeRule.runOnIdle { checkNotNull(appState).navController.popBackStack() }
         composeRule.runOnIdle { homeActions.onMemoriesSectionClick() }
-        composeRule.onNodeWithText("memory space route").assertIsDisplayed()
+        assertEquals(Route.MindRecord, composeRule.runOnIdle { checkNotNull(appState).backStack.last() })
+        assertEquals(Route.MemorySpace, composeRule.runOnIdle { checkNotNull(appState).pendingMindRecordDestination })
         composeRule.runOnIdle { homeActions.onSettingClick() }
-        composeRule.onNodeWithText("setting route").assertIsDisplayed()
+        assertEquals(Route.Setting(), composeRule.runOnIdle { checkNotNull(appState).backStack.last() })
     }
 
     @Test
@@ -560,20 +546,19 @@ class ReceiverRuntimeCompletionAndroidTest {
                 ),
             ),
         )
-        val viewModel =
-            ReceivedAfternoteDetailViewModel(
-                route = ReceivedAfternoteRoute.DetailRoute(afternoteId = 202L),
+        val detailFixture =
+            ReceivedAfternoteDetailScreenFixture(
+                afternoteId = 202L,
                 receiverRepository = repository,
                 errorReporter = FakeErrorReporter(),
             )
 
         composeRule.setContent {
             AfternoteTheme {
-                ReceivedAfternoteDetailRoute(
+                detailFixture.Content(
                     onNavigateBack = {},
                     onNavigateToFullList = {},
                     onNavigateToPlaylist = {},
-                    viewModel = viewModel,
                 )
             }
         }
@@ -610,9 +595,9 @@ class ReceiverRuntimeCompletionAndroidTest {
                 ),
             ),
         )
-        val viewModel =
-            ReceivedAfternoteDetailViewModel(
-                route = ReceivedAfternoteRoute.DetailRoute(afternoteId = 303L),
+        val detailFixture =
+            ReceivedAfternoteDetailScreenFixture(
+                afternoteId = 303L,
                 receiverRepository = repository,
                 errorReporter = FakeErrorReporter(),
             )
@@ -620,11 +605,10 @@ class ReceiverRuntimeCompletionAndroidTest {
 
         composeRule.setContent {
             AfternoteTheme {
-                ReceivedAfternoteDetailRoute(
+                detailFixture.Content(
                     onNavigateBack = {},
                     onNavigateToFullList = {},
                     onNavigateToPlaylist = playlistRoutes::add,
-                    viewModel = viewModel,
                 )
             }
         }
diff --git a/app/src/androidTest/java/com/afternote/afternote_fe/MindRecordHomeRequestCountAndroidTest.kt b/app/src/androidTest/java/com/afternote/afternote_fe/MindRecordHomeRequestCountAndroidTest.kt
index c329232448..d59b9cd5e3 100644
--- a/app/src/androidTest/java/com/afternote/afternote_fe/MindRecordHomeRequestCountAndroidTest.kt
+++ b/app/src/androidTest/java/com/afternote/afternote_fe/MindRecordHomeRequestCountAndroidTest.kt
@@ -14,7 +14,7 @@ import androidx.navigation.compose.ComposeNavigator
 import androidx.navigation.testing.TestNavHostController
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import com.afternote.afternote_fe.navigation.AppNavigation
-import com.afternote.afternote_fe.navigation.AppState
+import com.afternote.afternote_fe.navigation.rememberAfternoteAppState
 import com.afternote.afternote_fe.test.FailureArtifactRule
 import com.afternote.core.ui.Route
 import com.afternote.core.ui.theme.AfternoteTheme
@@ -91,7 +91,8 @@ class MindRecordHomeRequestCountAndroidTest {
                 AfternoteTheme {
                     AppNavigation(
                         startDestination = Route.MindRecord,
-                        appState = AppState(navController),
+                        appState = rememberAfternoteAppState(Route.MindRecord),
+                        mindRecordNavController = navController,
                     )
                 }
             }
diff --git a/app/src/androidTest/java/com/afternote/afternote_fe/PasskeyRegistrationAndroidTest.kt b/app/src/androidTest/java/com/afternote/afternote_fe/PasskeyRegistrationAndroidTest.kt
new file mode 100644
index 0000000000..71abe41179
--- /dev/null
+++ b/app/src/androidTest/java/com/afternote/afternote_fe/PasskeyRegistrationAndroidTest.kt
@@ -0,0 +1,132 @@
+package com.afternote.afternote_fe
+
+import android.os.Build
+import androidx.activity.compose.setContent
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.hasText
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import androidx.compose.ui.test.performScrollTo
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.afternote.afternote_fe.navigation.AppNavigation
+import com.afternote.afternote_fe.navigation.rememberAfternoteAppState
+import com.afternote.core.ui.Route
+import com.afternote.core.ui.theme.AfternoteTheme
+import com.afternote.feature.setting.data.PasskeyTestScenario
+import com.afternote.feature.setting.domain.Passkey
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import jakarta.inject.Inject
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Assume.assumeFalse
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@HiltAndroidTest
+@RunWith(AndroidJUnit4::class)
+class PasskeyRegistrationAndroidTest {
+    @get:Rule(order = 0)
+    val hiltRule = HiltAndroidRule(this)
+
+    @get:Rule(order = 1)
+    val composeRule = createAndroidComposeRule<MainActivity>()
+
+    @Inject
+    lateinit var scenario: PasskeyTestScenario
+
+    @Before
+    fun setUp() {
+        hiltRule.inject()
+        composeRule.activityRule.scenario.onActivity { activity ->
+            activity.setContent {
+                AfternoteTheme {
+                    AppNavigation(startDestination = Route.Setting(), appState = rememberAfternoteAppState())
+                }
+            }
+        }
+    }
+
+    @Test
+    fun passkeyList_queriesServerWithoutLocalFlagAndRefreshesOnReturn() {
+        scenario.passkeys = listOf(Passkey(7L, "Server passkey", "2026-09-06T10:00:00"))
+        openPasskeys()
+        waitForText("Server passkey")
+        composeRule.onNodeWithText("Server passkey").assertIsDisplayed()
+
+        composeRule.runOnIdle { composeRule.activity.onBackPressedDispatcher.onBackPressed() }
+        scenario.passkeys = listOf(Passkey(8L, "New server passkey", "2026-09-06T11:00:00"))
+        openPasskeys()
+        waitForText("New server passkey")
+        composeRule.onNodeWithText("Server passkey").assertDoesNotExist()
+        assertTrue(scenario.listCalls.get() >= 2)
+    }
+
+    @Test
+    fun passkeyList_failureShowsRetryAndNeverPretendsThereAreNoPasskeys() {
+        scenario.listFails = true
+        openPasskeys()
+        waitForText("패스키 목록을 불러올 수 없습니다.")
+        composeRule.onNodeWithText("패스키 등록").assertDoesNotExist()
+
+        scenario.listFails = false
+        composeRule.onNodeWithText("다시 시도").performClick()
+        waitForText("패스키 등록")
+        composeRule.onNodeWithText("패스키 등록").assertIsDisplayed()
+        assertEquals(2, scenario.listCalls.get())
+    }
+
+    @Test
+    fun passkeyRegistration_withoutCredentialProviderShowsFailureAndDoesNotComplete() {
+        // CI의 AOSP lane에서 실제 Credential Manager 실패를 검증한다. 계정이 있는 Play 기기는 대상이 아니다.
+        val packageManager = composeRule.activity.packageManager
+        val hasPlayServices =
+            runCatching { packageManager.getPackageInfo("com.google.android.gms", 0) }.isSuccess
+        assumeFalse(hasPlayServices)
+        assumeFalse(Build.VERSION.SDK_INT < 28)
+
+        openPasskeyPassword()
+        listOf("1", "2", "3", "4").forEach { composeRule.onNodeWithText(it).performClick() }
+        waitForText("패스키 등록에 실패했습니다. 다시 시도해 주세요.")
+        composeRule.onNodeWithText("패스키 등록에 실패했습니다. 다시 시도해 주세요.").assertIsDisplayed()
+        assertEquals(1, scenario.optionsCalls.get())
+        assertTrue(scenario.registeredCredentials.isEmpty())
+        composeRule.onNodeWithText("패스키 생성이 완료되었습니다").assertDoesNotExist()
+    }
+
+    @Test
+    fun passkeyList_existingEntryRefreshesAfterRegistrationScreenReturns() {
+        scenario.passkeys = emptyList()
+        openPasskeys()
+        waitForText("패스키 등록")
+        composeRule.onNodeWithText("패스키 등록").performClick()
+        waitForText("비밀번호로 인증하기")
+        scenario.passkeys = listOf(Passkey(9L, "Registered on return", "2026-09-08T10:00:00"))
+        composeRule.runOnIdle { composeRule.activity.onBackPressedDispatcher.onBackPressed() }
+        waitForText("Registered on return")
+        assertEquals(2, scenario.listCalls.get())
+    }
+
+    private fun openPasskeys() {
+        waitForText("패스키 관리")
+        composeRule.onNodeWithText("패스키 관리").performScrollTo().performClick()
+    }
+
+    private fun openPasskeyPassword() {
+        openPasskeys()
+        waitForText("패스키 등록")
+        composeRule.onNodeWithText("패스키 등록").performClick()
+        waitForText("비밀번호로 인증하기")
+        composeRule.onNodeWithText("비밀번호로 인증하기").performClick()
+        waitForText("비밀번호를 입력해 주세요.")
+    }
+
+    private fun waitForText(text: String) {
+        composeRule.waitUntil(timeoutMillis = 15_000) {
+            composeRule.onAllNodes(hasText(text)).fetchSemanticsNodes().isNotEmpty()
+        }
+    }
+}
diff --git a/app/src/androidTest/java/com/afternote/afternote_fe/ProfileSaveBackAndroidTest.kt b/app/src/androidTest/java/com/afternote/afternote_fe/ProfileSaveBackAndroidTest.kt
new file mode 100644
index 0000000000..6f06072638
--- /dev/null
+++ b/app/src/androidTest/java/com/afternote/afternote_fe/ProfileSaveBackAndroidTest.kt
@@ -0,0 +1,120 @@
+package com.afternote.afternote_fe
+
+import androidx.activity.compose.setContent
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.assertIsEnabled
+import androidx.compose.ui.test.assertIsNotEnabled
+import androidx.compose.ui.test.hasSetTextAction
+import androidx.compose.ui.test.hasText
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import androidx.compose.ui.test.performScrollTo
+import androidx.compose.ui.test.performTextReplacement
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.afternote.core.domain.repository.MyProfileRepository
+import com.afternote.core.domain.testing.FakeUserRepository
+import com.afternote.core.model.user.User
+import com.afternote.core.ui.navigation.FeatureNavigationCallbacks
+import com.afternote.core.ui.theme.AfternoteTheme
+import com.afternote.feature.setting.presentation.navigation.SettingExternalActions
+import com.afternote.feature.setting.presentation.navigation.SettingNavHost
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CompletableDeferred
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import javax.inject.Inject
+
+/** #1438: 실제 SettingNavHost의 entry 이탈이 보류 중 저장을 취소하고 새 entry를 만드는지 검증한다. */
+@HiltAndroidTest
+@RunWith(AndroidJUnit4::class)
+class ProfileSaveBackAndroidTest {
+    @get:Rule(order = 0)
+    val hiltRule = HiltAndroidRule(this)
+
+    @get:Rule(order = 1)
+    val composeRule = createAndroidComposeRule<MainActivity>()
+
+    @Inject
+    lateinit var profileRepository: MyProfileRepository
+
+    @Before
+    fun setUp() {
+        hiltRule.inject()
+    }
+
+    @Test
+    fun systemBackDuringPendingSaveCancelsRequestAndReentryLoadsServerProfile() {
+        // 기존 app Hilt fixture가 제공하는 동일 저장소의 응답만 보류한다. 프로덕션 nav/VM은 그대로다.
+        val repository = profileRepository as FakeUserRepository
+        val saved = User("서버 이름", "qa@example.test", "01000000000", null)
+        repository.profile = saved
+        val pendingSave = CompletableDeferred<User>()
+        val cancelled = CompletableDeferred<Unit>()
+        var exits = 0
+        repository.onUpdateMyProfile = { _, _, _ ->
+            try {
+                pendingSave.await()
+            } catch (error: CancellationException) {
+                cancelled.complete(Unit)
+                throw error
+            }
+        }
+        composeRule.activityRule.scenario.onActivity { activity ->
+            activity.setContent {
+                AfternoteTheme {
+                    SettingNavHost(
+                        navigationCallbacks = FeatureNavigationCallbacks { exits += 1 },
+                        externalActions =
+                            object : SettingExternalActions {
+                                override fun onLogoutSuccess() = Unit
+
+                                override fun onWithdrawSuccess() = Unit
+                            },
+                    )
+                }
+            }
+        }
+        waitForText("프로필 수정")
+        composeRule.onNodeWithText("프로필 수정").performClick()
+        waitForText("프로필 설정")
+        composeRule.onAllNodes(hasSetTextAction())[0].performTextReplacement("저장 중 임시 이름")
+        composeRule.onNodeWithText("수정하기").performScrollTo().performClick()
+        composeRule.waitUntil(10_000) { repository.profileUpdateCalls.size == 1 }
+        composeRule.onNodeWithText("수정하기").assertIsNotEnabled()
+        assertFalse(pendingSave.isCompleted)
+
+        // Activity의 실제 back dispatcher가 SettingNavHost/NavDisplay의 back 처리를 실행한다.
+        composeRule.activityRule.scenario.onActivity { it.onBackPressedDispatcher.onBackPressed() }
+        waitForText("프로필 수정")
+        composeRule.waitUntil(10_000) { cancelled.isCompleted }
+        assertEquals(0, exits)
+        assertEquals(saved, repository.profile)
+
+        val loadsBeforeReentry = repository.profileCalls
+        composeRule.onNodeWithText("프로필 수정").performClick()
+        waitForText("서버 이름")
+        composeRule.waitUntil(10_000) { repository.profileCalls > loadsBeforeReentry }
+        composeRule.onNodeWithText("수정하기").performScrollTo().assertIsEnabled()
+
+        // 취소 뒤 늦은 성공도 현재 entry를 닫거나 서버 fake의 정본을 바꾸지 않는다.
+        pendingSave.complete(saved.copy(name = "저장 중 임시 이름"))
+        composeRule.waitForIdle()
+        composeRule.onNodeWithText("프로필 설정").assertIsDisplayed()
+        assertEquals(saved, repository.profile)
+        assertEquals(1, repository.profileUpdateCalls.size)
+        assertTrue(cancelled.isCompleted)
+        assertEquals(0, exits)
+    }
+
+    private fun waitForText(text: String) {
+        composeRule.waitUntil(10_000) { composeRule.onAllNodes(hasText(text)).fetchSemanticsNodes().isNotEmpty() }
+    }
+}
diff --git a/app/src/androidTest/java/com/afternote/afternote_fe/ReceiverAdvancedAndroidTest.kt b/app/src/androidTest/java/com/afternote/afternote_fe/ReceiverAdvancedAndroidTest.kt
index 8b52e0098f..aed9ab51fc 100644
--- a/app/src/androidTest/java/com/afternote/afternote_fe/ReceiverAdvancedAndroidTest.kt
+++ b/app/src/androidTest/java/com/afternote/afternote_fe/ReceiverAdvancedAndroidTest.kt
@@ -25,9 +25,7 @@ import com.afternote.afternote_fe.test.FakeErrorReporter
 import com.afternote.core.ui.theme.AfternoteTheme
 import com.afternote.feature.afternote.domain.AfternoteType
 import com.afternote.feature.afternote.domain.model.LeaveMessageBlock
-import com.afternote.feature.afternote.presentation.receiver.detail.ReceivedAfternoteDetailRoute
-import com.afternote.feature.afternote.presentation.receiver.detail.ReceivedAfternoteDetailViewModel
-import com.afternote.feature.afternote.presentation.receiver.navigation.ReceivedAfternoteRoute
+import com.afternote.feature.afternote.presentation.testing.ReceivedAfternoteDetailScreenFixture
 import com.afternote.feature.receiver.domain.model.ReceivedAccountCredentials
 import com.afternote.feature.receiver.domain.model.ReceivedAfternoteDetail
 import com.afternote.feature.receiver.domain.model.ReceivedExportBundle
@@ -177,20 +175,19 @@ class ReceiverAdvancedAndroidTest {
             }
         detailResults.addLast(Result.failure(IllegalStateException("offline")))
         detailResults.addLast(Result.success(receivedSocialDetail()))
-        val viewModel =
-            ReceivedAfternoteDetailViewModel(
-                route = ReceivedAfternoteRoute.DetailRoute(afternoteId = 91L),
+        val detailFixture =
+            ReceivedAfternoteDetailScreenFixture(
+                afternoteId = 91L,
                 receiverRepository = repository,
                 errorReporter = FakeErrorReporter(),
             )
 
         composeRule.setContent {
             AfternoteTheme {
-                ReceivedAfternoteDetailRoute(
+                detailFixture.Content(
                     onNavigateBack = {},
                     onNavigateToFullList = {},
                     onNavigateToPlaylist = {},
-                    viewModel = viewModel,
                 )
             }
         }
diff --git a/app/src/androidTest/java/com/afternote/afternote_fe/ReceiverSelectionResultAndroidTest.kt b/app/src/androidTest/java/com/afternote/afternote_fe/ReceiverSelectionResultAndroidTest.kt
index 07e2cd1e76..6be388cec2 100644
--- a/app/src/androidTest/java/com/afternote/afternote_fe/ReceiverSelectionResultAndroidTest.kt
+++ b/app/src/androidTest/java/com/afternote/afternote_fe/ReceiverSelectionResultAndroidTest.kt
@@ -24,7 +24,7 @@ import androidx.navigation.testing.TestNavHostController
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.platform.app.InstrumentationRegistry
 import com.afternote.afternote_fe.navigation.AppNavigation
-import com.afternote.afternote_fe.navigation.AppState
+import com.afternote.afternote_fe.navigation.rememberAfternoteAppState
 import com.afternote.afternote_fe.test.FailureArtifactRule
 import com.afternote.core.domain.repository.UserRepository
 import com.afternote.core.domain.testing.FakeUserRepository
@@ -118,7 +118,7 @@ class ReceiverSelectionResultAndroidTest {
                 AfternoteTheme {
                     AppNavigation(
                         startDestination = Route.Afternote,
-                        appState = AppState(navController),
+                        appState = rememberAfternoteAppState(Route.Afternote),
                     )
                 }
             }
diff --git a/app/src/androidTest/java/com/afternote/afternote_fe/SettingEditorSaveSignalAndroidTest.kt b/app/src/androidTest/java/com/afternote/afternote_fe/SettingEditorSaveSignalAndroidTest.kt
new file mode 100644
index 0000000000..670eaaf970
--- /dev/null
+++ b/app/src/androidTest/java/com/afternote/afternote_fe/SettingEditorSaveSignalAndroidTest.kt
@@ -0,0 +1,241 @@
+package com.afternote.afternote_fe
+
+import androidx.activity.compose.setContent
+import androidx.compose.ui.graphics.asAndroidBitmap
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.semantics.SemanticsProperties
+import androidx.compose.ui.test.SemanticsMatcher
+import androidx.compose.ui.test.assertCountEquals
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.assertIsEnabled
+import androidx.compose.ui.test.assertIsNotEnabled
+import androidx.compose.ui.test.captureToImage
+import androidx.compose.ui.test.hasScrollToIndexAction
+import androidx.compose.ui.test.hasSetTextAction
+import androidx.compose.ui.test.hasText
+import androidx.compose.ui.test.isEnabled
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.onRoot
+import androidx.compose.ui.test.performClick
+import androidx.compose.ui.test.performScrollTo
+import androidx.compose.ui.test.performScrollToNode
+import androidx.compose.ui.test.performTextReplacement
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.afternote.afternote_fe.test.FailureArtifactRule
+import com.afternote.core.domain.repository.UserRepository
+import com.afternote.core.domain.testing.FakeUserRepository
+import com.afternote.core.model.user.ReceiverDetail
+import com.afternote.core.ui.navigation.FeatureNavigationCallbacks
+import com.afternote.core.ui.theme.AfternoteTheme
+import com.afternote.feature.setting.presentation.navigation.SettingExternalActions
+import com.afternote.feature.setting.presentation.navigation.SettingNavHost
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.io.IOException
+import javax.inject.Inject
+
+/**
+ * 설정 편집 화면의 저장 신호를 실제 로컬 스택에서 본다 (#2179).
+ *
+ * reducer 가 세운 완료 신호(수신자 수정의 `pendingEvent`, 전달 조건의 `isSaveSuccessPending`)가 화면에서 한 번만
+ * 소비되어 스택을 정확히 한 칸 내리는지, 실패와 입력 검증은 화면을 닫지 않는지를 잰다. 신호 소비가
+ * 두 번 일어나면 한 칸이 아니라 설정 홈까지 내려가고, 소비가 안 되면 편집 화면에 남는다. 둘 다
+ * ViewModel 단위 테스트로는 보이지 않는 자리다.
+ */
+@HiltAndroidTest
+@RunWith(AndroidJUnit4::class)
+class SettingEditorSaveSignalAndroidTest {
+    @get:Rule(order = 0)
+    val hiltRule = HiltAndroidRule(this)
+
+    @get:Rule(order = 1)
+    val composeRule = createAndroidComposeRule<MainActivity>()
+
+    @get:Rule(order = 2)
+    val failureArtifactRule =
+        FailureArtifactRule {
+            composeRule.onRoot().captureToImage().asAndroidBitmap()
+        }
+
+    @Inject
+    lateinit var userRepository: UserRepository
+
+    private val fakeUserRepository: FakeUserRepository
+        get() = userRepository as FakeUserRepository
+
+    /** 로컬 스택 바닥에서 셸로 나간 횟수 — 설정 안에서 도는 동안은 0 이어야 한다. */
+    private var exits = 0
+
+    @Before
+    fun setUp() {
+        hiltRule.inject()
+        fakeUserRepository.receiverDetails[RECEIVER_ID] =
+            ReceiverDetail(
+                receiverId = RECEIVER_ID,
+                name = RECEIVER_NAME,
+                relation = "가족",
+                phone = "01012345678",
+                email = "kim@afternote.local",
+                dailyQuestionCount = 0,
+                timeLetterCount = 0,
+                afterNoteCount = 0,
+                message = "잘 지내",
+            )
+        fakeUserRepository.onGetReceiverDetail = null
+    }
+
+    @Test
+    fun receiverEdit_saveSuccessPopsExactlyOneScreenToReceiverList() {
+        fakeUserRepository.onUpdateReceiver = null
+        fakeUserRepository.onUpdateReceiverMessage = null
+        openReceiverEdit()
+        val updatesBefore = fakeUserRepository.receiverUpdateCalls.size
+        val messagesBefore = fakeUserRepository.receiverMessageCalls.size
+
+        composeRule.onNode(hasSetTextAction() and hasText(RECEIVER_NAME)).performTextReplacement("김수정")
+        composeRule.onNodeWithText(SAVE_ACTION).assertIsEnabled().performClick()
+
+        waitUntilGone(EDIT_TITLE)
+        // 한 칸만 내려와 목록이 보인다 — 신호가 두 번 소비되면 설정 홈까지 내려간다.
+        composeRule.onNodeWithText("김수정").assertIsDisplayed()
+        composeRule.onAllNodes(hasText("프로필 수정")).assertCountEquals(0)
+        assertEquals(1, fakeUserRepository.receiverUpdateCalls.size - updatesBefore)
+        assertEquals(1, fakeUserRepository.receiverMessageCalls.size - messagesBefore)
+        assertEquals(0, exits)
+    }
+
+    @Test
+    fun receiverEdit_saveFailureShowsMessageAndStaysOnEdit() {
+        fakeUserRepository.onUpdateReceiver = { _, _, _, _, _ -> throw IOException("offline") }
+        openReceiverEdit()
+        val updatesBefore = fakeUserRepository.receiverUpdateCalls.size
+        val messagesBefore = fakeUserRepository.receiverMessageCalls.size
+
+        composeRule.onNodeWithText(SAVE_ACTION).performClick()
+
+        composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
+            composeRule.runOnIdle { fakeUserRepository.receiverUpdateCalls.size > updatesBefore }
+        }
+        // 오류는 LazyColumn의 마지막 항목이므로 작은 화면에서도 스크롤해 실제 표시를 확인한다.
+        composeRule.onNode(hasScrollToIndexAction()).performScrollToNode(hasText(EDIT_FAILED_MESSAGE))
+        composeRule.onNodeWithText(EDIT_FAILED_MESSAGE).assertIsDisplayed()
+        // 실패는 화면을 닫지 않고, 저장 중 잠금도 풀려 다시 누를 수 있다.
+        composeRule.onNodeWithText(EDIT_TITLE).assertIsDisplayed()
+        composeRule.onNodeWithText(SAVE_ACTION).assertIsEnabled()
+        assertEquals(1, fakeUserRepository.receiverUpdateCalls.size - updatesBefore)
+        assertEquals(0, fakeUserRepository.receiverMessageCalls.size - messagesBefore)
+        assertEquals(0, exits)
+    }
+
+    @Test
+    fun receiverEdit_invalidEmailOrPhoneBlocksSaveWithoutRequest() {
+        openReceiverEdit()
+        val updatesBefore = fakeUserRepository.receiverUpdateCalls.size
+
+        composeRule.onNode(hasSetTextAction() and hasText("kim@afternote.local")).performTextReplacement("kim@afternote")
+        composeRule.onNodeWithText("올바른 이메일 주소를 입력해주세요.").assertIsDisplayed()
+        composeRule.onNodeWithText(SAVE_ACTION).assertIsNotEnabled().performClick()
+
+        composeRule.onNode(hasSetTextAction() and hasText("kim@afternote")).performTextReplacement("kim@afternote.local")
+        composeRule.onNode(hasSetTextAction() and hasText("010", substring = true)).performTextReplacement("0101234")
+        composeRule.onNodeWithText("올바른 연락처를 입력해주세요.").assertIsDisplayed()
+        composeRule.onNodeWithText(SAVE_ACTION).assertIsNotEnabled().performClick()
+
+        composeRule.onNodeWithText(EDIT_TITLE).assertIsDisplayed()
+        assertEquals(0, composeRule.runOnIdle { fakeUserRepository.receiverUpdateCalls.size - updatesBefore })
+        assertEquals(0, exits)
+    }
+
+    @Test
+    fun deliveryCondition_saveSuccessPopsExactlyOneScreenToReceiverSelection() {
+        fakeUserRepository.onGetReceiverDeliveryConditions = null
+        fakeUserRepository.onUpdateReceiverDeliveryConditions = null
+        launchHost()
+        waitForSettingHomeContent()
+        val updatesBefore = fakeUserRepository.deliveryUpdateCalls.size
+        composeRule.onNodeWithText("사후 전달 조건").performScrollTo().performClick()
+        composeRule.onAllNodes(checkboxMatcher).run {
+            assertCountEquals(1)
+            get(0).performClick()
+        }
+        composeRule.onNodeWithText(RECEIVER_SELECT_DONE).performClick()
+
+        // 조회가 끝나야 저장이 열린다.
+        composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
+            composeRule.onAllNodes(hasText(DELIVERY_SAVE) and isEnabled()).fetchSemanticsNodes().isNotEmpty()
+        }
+        composeRule.onNodeWithText(DELIVERY_SAVE).performClick()
+
+        waitUntilShown(RECEIVER_SELECT_DONE)
+        // 한 칸만 내려와 수신자 선택이 보인다 — 신호가 두 번 소비되면 설정 홈까지 내려간다.
+        composeRule.onAllNodes(hasText("프로필 수정")).assertCountEquals(0)
+        assertEquals(1, fakeUserRepository.deliveryUpdateCalls.size - updatesBefore)
+        assertEquals(RECEIVER_ID, fakeUserRepository.deliveryUpdateCalls[updatesBefore].receiverId)
+        assertEquals(0, exits)
+    }
+
+    /** 설정 홈 → 수신자 목록 → 김수신 행으로 수정 화면을 연다. 프리필이 끝나야 폼이 그려진다. */
+    private fun openReceiverEdit() {
+        launchHost()
+        waitForSettingHomeContent()
+        composeRule.onAllNodes(hasText("수신자 목록")).run {
+            assertCountEquals(2)
+            get(1).performScrollTo().performClick()
+        }
+        composeRule.onNodeWithText(RECEIVER_NAME).performClick()
+        composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
+            composeRule.onAllNodes(hasSetTextAction() and hasText(RECEIVER_NAME)).fetchSemanticsNodes().isNotEmpty()
+        }
+    }
+
+    private fun launchHost() {
+        composeRule.activityRule.scenario.onActivity { activity ->
+            activity.setContent {
+                AfternoteTheme {
+                    SettingNavHost(
+                        navigationCallbacks = FeatureNavigationCallbacks { exits += 1 },
+                        externalActions =
+                            object : SettingExternalActions {
+                                override fun onLogoutSuccess() = Unit
+
+                                override fun onWithdrawSuccess() = Unit
+                            },
+                        startWithRecipientRegistration = false,
+                    )
+                }
+            }
+        }
+    }
+
+    private fun waitForSettingHomeContent() = waitUntilShown("프로필 수정")
+
+    private fun waitUntilShown(text: String) {
+        composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
+            composeRule.onAllNodes(hasText(text)).fetchSemanticsNodes().isNotEmpty()
+        }
+    }
+
+    private fun waitUntilGone(text: String) {
+        composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
+            composeRule.onAllNodes(hasText(text)).fetchSemanticsNodes().isEmpty()
+        }
+    }
+
+    private companion object {
+        const val TIMEOUT_MILLIS = 10_000L
+        const val RECEIVER_ID = 7L
+        const val RECEIVER_NAME = "김수신"
+        const val EDIT_TITLE = "수신자 수정"
+        const val SAVE_ACTION = "수정"
+        const val EDIT_FAILED_MESSAGE = "수신자 수정에 실패했습니다. 잠시 후 다시 시도해주세요."
+        const val DELIVERY_SAVE = "저장"
+        const val RECEIVER_SELECT_DONE = "수신자 선택 완료하기"
+        val checkboxMatcher = SemanticsMatcher.expectValue(SemanticsProperties.Role, Role.Checkbox)
+    }
+}
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index c0acfe832c..93d79d6ed8 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -94,6 +94,21 @@
 
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
+            <!--
+              카카오톡 초대 메시지의 버튼이 앱을 여는 스킴 — `kakao{앱키}://kakaolink?inviteToken=…` (#944).
+              host 가 `kakaolink` 라 같은 스킴의 `oauth`(AuthCodeHandlerActivity)와 갈린다.
+              launchMode 는 그대로 둔다 — #1111 이 알림 진입에서 같은 판단을 했다(manifest 를 올리면
+              모든 진입의 태스크 동작이 바뀐다). 앱이 떠 있는 채로 들어오면 인스턴스가 하나 더 쌓일 수
+              있지만, 토큰은 기기 저장소에 남기고 어느 인스턴스든 그 저장소를 보므로 흐름은 같다.
+            -->
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+                <data
+                        android:host="kakaolink"
+                        android:scheme="kakao${KAKAO_NATIVE_APP_KEY}" />
+            </intent-filter>
         </activity>
 
         <!--
diff --git a/app/src/main/java/com/afternote/afternote_fe/MainActivity.kt b/app/src/main/java/com/afternote/afternote_fe/MainActivity.kt
index 030627f27e..ba6399037f 100644
--- a/app/src/main/java/com/afternote/afternote_fe/MainActivity.kt
+++ b/app/src/main/java/com/afternote/afternote_fe/MainActivity.kt
@@ -9,6 +9,7 @@ import androidx.core.net.toUri
 import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
 import androidx.fragment.app.FragmentActivity
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.afternote.afternote_fe.invitation.ReceiverInvitationIntentContract
 import com.afternote.afternote_fe.navigation.AppNavigation
 import com.afternote.afternote_fe.notification.NotificationIntentContract
 import com.afternote.afternote_fe.update.ForceUpdateGate
@@ -41,6 +42,7 @@ class MainActivity : FragmentActivity() {
         enableLightEdgeToEdge()
 
         enqueueNotificationIntent(intent)
+        enqueueInvitationIntent(intent)
 
         if (BuildConfig.DEBUG && intent.getBooleanExtra(EXTRA_DEBUG_START_TIMELETTER, false)) {
             setContent {
@@ -60,7 +62,10 @@ class MainActivity : FragmentActivity() {
             AfternoteTheme {
                 val startRoute by viewModel.startRoute.collectAsStateWithLifecycle()
                 startRoute?.let { route ->
-                    AppNavigation(startDestination = route)
+                    AppNavigation(
+                        startDestination = route,
+                        mainViewModel = viewModel,
+                    )
                 }
                 val forceUpdatePrompt by forceUpdateGate.prompt.collectAsStateWithLifecycle()
                 forceUpdatePrompt?.let { prompt ->
@@ -88,6 +93,18 @@ class MainActivity : FragmentActivity() {
         super.onNewIntent(intent)
         setIntent(intent)
         enqueueNotificationIntent(intent)
+        enqueueInvitationIntent(intent)
+    }
+
+    /**
+     * 카카오톡 초대 링크 진입 (#944). 토큰은 기기 저장소에 남기고, 띄울지는 앱 루트가 인증 상태와
+     * 함께 판정한다. 같은 Intent 가 재생성으로 다시 와도 같은 토큰을 다시 쓰는 것이라 재처리 방지가
+     * 따로 필요 없다 — 처분 기록은 [MainViewModel] 이 SavedState 로 갖는다.
+     */
+    private fun enqueueInvitationIntent(intent: Intent) {
+        ReceiverInvitationIntentContract
+            .fromIntent(intent)
+            ?.let(viewModel::enqueueInvitationToken)
     }
 
     private fun enqueueNotificationIntent(intent: Intent) {
diff --git a/app/src/main/java/com/afternote/afternote_fe/MainViewModel.kt b/app/src/main/java/com/afternote/afternote_fe/MainViewModel.kt
index 6e8783e31e..498cf863d7 100644
--- a/app/src/main/java/com/afternote/afternote_fe/MainViewModel.kt
+++ b/app/src/main/java/com/afternote/afternote_fe/MainViewModel.kt
@@ -4,6 +4,7 @@ import androidx.lifecycle.SavedStateHandle
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.afternote.afternote_fe.notification.NotificationEntryRequest
+import com.afternote.core.domain.repository.PendingReceiverInvitationStore
 import com.afternote.core.domain.repository.auth.AuthRepository
 import com.afternote.core.ui.Route
 import dagger.hilt.android.lifecycle.HiltViewModel
@@ -11,8 +12,10 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
 import javax.inject.Inject
 
 @HiltViewModel
@@ -20,6 +23,7 @@ class MainViewModel
     @Inject
     constructor(
         authRepository: AuthRepository,
+        private val pendingInvitationStore: PendingReceiverInvitationStore,
         private val savedStateHandle: SavedStateHandle,
     ) : ViewModel() {
         private val pendingNotificationEntryState = MutableStateFlow<NotificationEntryRequest?>(null)
@@ -28,20 +32,83 @@ class MainViewModel
         internal val pendingNotificationEntry: StateFlow<NotificationEntryRequest?> =
             pendingNotificationEntryState.asStateFlow()
 
+        private val isLoggedIn: StateFlow<Boolean?> =
+            authRepository.isLoggedIn.stateIn(
+                scope = viewModelScope,
+                started = SharingStarted.WhileSubscribed(5_000),
+                initialValue = null,
+            )
+
         /**
          * 초기 진입 시 null(로딩)이며, [AuthRepository.isLoggedIn]이 방출된 뒤 목적지가 확정된다.
          * null 여부가 기존 `isLoading`과 동일한 역할을 한다.
          */
         val startRoute: StateFlow<Route?> =
-            authRepository.isLoggedIn
-                .map { isLoggedIn ->
-                    if (isLoggedIn) Route.Home else Route.Onboarding
+            isLoggedIn
+                .map { loggedIn ->
+                    when (loggedIn) {
+                        null -> null
+                        true -> Route.Home
+                        false -> Route.Onboarding
+                    }
                 }.stateIn(
                     scope = viewModelScope,
                     started = SharingStarted.WhileSubscribed(5_000),
                     initialValue = null,
                 )
 
+        /**
+         * 이 Activity 안에서 처분(수락·보류·거절)이 끝난 초대 토큰 — 다시 띄우지 않는다 (#944).
+         * SavedState 에 두어 재생성 뒤에도 같은 토큰으로 랜딩이 또 뜨지 않는다.
+         */
+        private val settledInvitationToken: StateFlow<String?> =
+            savedStateHandle.getStateFlow(SETTLED_INVITATION_TOKEN_KEY, null)
+
+        /** 로그인 뒤 다시 띄우기로 한 토큰 — 랜딩에서 «수락» 을 눌렀는데 로그인 전이었던 경우. */
+        private val invitationAwaitingLogin: StateFlow<String?> =
+            savedStateHandle.getStateFlow(INVITATION_AWAITING_LOGIN_KEY, null)
+
+        /**
+         * 지금 랜딩을 띄워야 하는 초대 토큰. null 이면 띄울 것이 없다.
+         *
+         * 보관 토큰이 있고, 이 Activity 에서 아직 처분되지 않았으며, 로그인 대기로 미뤄 둔 토큰이면
+         * 로그인이 확정된 뒤에만 값을 낸다. 로그인 여부는 [startRoute] 와 같은 스트림을 본다 —
+         * 앱 루트의 인증 경계를 그대로 재사용한다.
+         */
+        val pendingInvitationToken: StateFlow<String?> =
+            combine(
+                pendingInvitationStore.pendingToken,
+                isLoggedIn,
+                settledInvitationToken,
+                invitationAwaitingLogin,
+            ) { token, loggedIn, settled, awaitingLogin ->
+                when {
+                    token == null || loggedIn == null -> null
+                    token == settled -> null
+                    token == awaitingLogin && !loggedIn -> null
+                    else -> token
+                }
+            }.stateIn(
+                scope = viewModelScope,
+                started = SharingStarted.WhileSubscribed(5_000),
+                initialValue = null,
+            )
+
+        /** 스킴 Intent 에서 뽑은 토큰을 보관한다. 같은 Intent 가 재생성으로 다시 와도 같은 값이라 무해하다. */
+        internal fun enqueueInvitationToken(token: String) {
+            viewModelScope.launch { pendingInvitationStore.save(token) }
+        }
+
+        /** 랜딩에서 로그인이 필요하다고 판정됐다 — 로그인이 끝날 때까지 이 토큰의 랜딩을 미룬다. */
+        internal fun deferInvitationUntilLogin(token: String) {
+            savedStateHandle[INVITATION_AWAITING_LOGIN_KEY] = token
+        }
+
+        /** 랜딩이 닫혔다(수락 완료·나중에·거절 안내 확인). 이 Activity 에서 이 토큰으로는 다시 띄우지 않는다. */
+        internal fun settleInvitation(token: String) {
+            savedStateHandle[SETTLED_INVITATION_TOKEN_KEY] = token
+        }
+
         /**
          * 새 알림 발생을 큐에 넣는다. Activity 재생성 때 같은 initial Intent가 다시 전달되더라도
          * [SavedStateHandle]에 기록한 마지막 소비 identity면 다시 수신 이벤트를 만들지 않는다.
@@ -65,5 +132,7 @@ class MainViewModel
 
         private companion object {
             const val CONSUMED_NOTIFICATION_IDENTITY_KEY = "consumed_notification_entry_identity"
+            const val SETTLED_INVITATION_TOKEN_KEY = "settled_receiver_invitation_token"
+            const val INVITATION_AWAITING_LOGIN_KEY = "receiver_invitation_awaiting_login"
         }
     }
diff --git a/app/src/main/java/com/afternote/afternote_fe/invitation/ReceiverInvitationIntentContract.kt b/app/src/main/java/com/afternote/afternote_fe/invitation/ReceiverInvitationIntentContract.kt
new file mode 100644
index 0000000000..de72e697ec
--- /dev/null
+++ b/app/src/main/java/com/afternote/afternote_fe/invitation/ReceiverInvitationIntentContract.kt
@@ -0,0 +1,42 @@
+package com.afternote.afternote_fe.invitation
+
+import android.content.Intent
+
+/**
+ * 카카오톡 초대 메시지 버튼이 여는 `kakao{앱키}://kakaolink?inviteToken=…` Intent 를 해석한다 (#944).
+ *
+ * `NotificationIntentContract` 처럼 순수 객체다 — 판정 규칙은 [resolve] 하나에 모여 있고,
+ * `MainActivity` 는 [fromIntent] 만 부른다.
+ *
+ * 토큰은 서버가 발급한 43자 base64url 이다. 형식 밖 값은 우리가 만든 링크가 아니므로 저장하지 않는다 —
+ * 스킴은 누구나 던질 수 있어 검증 없이 보관하면 임의 문자열이 서버 경로 세그먼트까지 흘러간다.
+ */
+internal object ReceiverInvitationIntentContract {
+    fun fromIntent(intent: Intent): String? {
+        val data = runCatching { intent.data }.getOrNull() ?: return null
+        return resolve(
+            scheme = data.scheme,
+            host = data.host,
+            rawToken = runCatching { data.getQueryParameter(QUERY_INVITE_TOKEN) }.getOrNull(),
+        )
+    }
+
+    private fun resolve(
+        scheme: String?,
+        host: String?,
+        rawToken: String?,
+    ): String? {
+        if (scheme == null || !scheme.startsWith(SCHEME_PREFIX)) return null
+        if (host != HOST_KAKAOLINK) return null
+        val token = rawToken?.takeIf { TOKEN_FORMAT.matches(it) } ?: return null
+        return token
+    }
+
+    /** 카카오 네이티브 앱 키를 붙인 스킴 — 키 값 자체는 매니페스트 플레이스홀더가 맞춘다. */
+    private const val SCHEME_PREFIX = "kakao"
+    private const val HOST_KAKAOLINK = "kakaolink"
+    private const val QUERY_INVITE_TOKEN = "inviteToken"
+
+    /** base64url 문자만, 길이 상한 128 — 서버 발급 길이(43)의 여유분이지 계약값은 아니다. */
+    private val TOKEN_FORMAT = Regex("^[A-Za-z0-9_-]{1,128}$")
+}
diff --git a/app/src/main/java/com/afternote/afternote_fe/messaging/FirebaseDevicePushTargetProvider.kt b/app/src/main/java/com/afternote/afternote_fe/messaging/FirebaseDevicePushTargetProvider.kt
index 7532b91e90..9828819856 100644
--- a/app/src/main/java/com/afternote/afternote_fe/messaging/FirebaseDevicePushTargetProvider.kt
+++ b/app/src/main/java/com/afternote/afternote_fe/messaging/FirebaseDevicePushTargetProvider.kt
@@ -1,8 +1,8 @@
 package com.afternote.afternote_fe.messaging
 
 import com.afternote.core.common.reporting.ErrorReporter
-import com.afternote.core.common.result.runCatchingCancellable
 import com.afternote.core.domain.push.DevicePushTargetProvider
+import com.afternote.core.domain.result.runCatchingCancellable
 import com.google.android.gms.tasks.Task
 import com.google.firebase.installations.FirebaseInstallations
 import com.google.firebase.messaging.FirebaseMessaging
diff --git a/app/src/main/java/com/afternote/afternote_fe/messaging/PushTargetSynchronizer.kt b/app/src/main/java/com/afternote/afternote_fe/messaging/PushTargetSynchronizer.kt
index 869a1f2a05..50883c9336 100644
--- a/app/src/main/java/com/afternote/afternote_fe/messaging/PushTargetSynchronizer.kt
+++ b/app/src/main/java/com/afternote/afternote_fe/messaging/PushTargetSynchronizer.kt
@@ -1,10 +1,10 @@
 package com.afternote.afternote_fe.messaging
 
 import com.afternote.core.common.reporting.ErrorReporter
-import com.afternote.core.common.result.runCatchingCancellable
 import com.afternote.core.domain.push.DevicePushTargetProvider
 import com.afternote.core.domain.repository.auth.AuthRepository
 import com.afternote.core.domain.repository.push.PushTargetRepository
+import com.afternote.core.domain.result.runCatchingCancellable
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
diff --git a/app/src/main/java/com/afternote/afternote_fe/navigation/AppNavigation.kt b/app/src/main/java/com/afternote/afternote_fe/navigation/AppNavigation.kt
index 26b3296d43..e53275e3a2 100644
--- a/app/src/main/java/com/afternote/afternote_fe/navigation/AppNavigation.kt
+++ b/app/src/main/java/com/afternote/afternote_fe/navigation/AppNavigation.kt
@@ -1,5 +1,9 @@
 package com.afternote.afternote_fe.navigation
 
+import android.app.Activity
+import android.content.Context
+import android.content.ContextWrapper
+import androidx.compose.animation.ContentTransform
 import androidx.compose.foundation.layout.WindowInsets
 import androidx.compose.foundation.layout.WindowInsetsSides
 import androidx.compose.foundation.layout.consumeWindowInsets
@@ -10,6 +14,8 @@ import androidx.compose.material3.Scaffold
 import androidx.compose.material3.SnackbarHost
 import androidx.compose.material3.SnackbarHostState
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.SideEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
@@ -17,17 +23,22 @@ import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
 import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.compose.LifecycleEventEffect
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.navigation.NavDestination.Companion.hasRoute
+import androidx.navigation.NavHostController
 import androidx.navigation.compose.NavHost
-import androidx.navigation.compose.composable
 import androidx.navigation.compose.currentBackStackEntryAsState
-import androidx.navigation.toRoute
+import androidx.navigation.compose.rememberNavController
+import androidx.navigation3.runtime.entryProvider
+import com.afternote.afternote_fe.MainViewModel
 import com.afternote.afternote_fe.notification.NotificationPermissionEffect
 import com.afternote.core.ui.Route
 import com.afternote.core.ui.bottombar.BottomBar
+import com.afternote.core.ui.navigation.FeatureNavDisplay
 import com.afternote.core.ui.navigation.FeatureNavigationCallbacks
 import com.afternote.core.ui.navigation.NavDestinationBackground
 import com.afternote.core.ui.navigation.PredictiveBackPopEnter
@@ -37,10 +48,13 @@ import com.afternote.feature.afternote.presentation.receiver.navigation.Received
 import com.afternote.feature.home.presentation.HomeTabScreen
 import com.afternote.feature.home.presentation.HomeTabViewModel
 import com.afternote.feature.home.presentation.receiver.ReceiverHomeEntry
+import com.afternote.feature.mindrecord.presentation.navigation.MindRecordNavActions
 import com.afternote.feature.mindrecord.presentation.navigation.mindRecordNavGraph
 import com.afternote.feature.onboarding.presentation.navigation.OnboardingNavHost
+import com.afternote.feature.receiver.presentation.navigation.ReceiverInvitationNavHost
 import com.afternote.feature.receiver.presentation.navigation.ReceiverNavHost
 import com.afternote.feature.setting.presentation.navigation.SettingNavHost
+import com.afternote.feature.timeletter.presentation.navigation.TimeLetterRoute
 import com.afternote.feature.timeletter.presentation.navigation.timeLetterNavGraph
 import kotlinx.coroutines.launch
 
@@ -48,40 +62,98 @@ import kotlinx.coroutines.launch
 fun AppNavigation(
     startDestination: Route,
     modifier: Modifier = Modifier,
-    appState: AppState = rememberAfternoteAppState(),
+    appState: AppState = rememberAfternoteAppState(startDestination),
+    mindRecordNavController: NavHostController? = null,
+    timeLetterNavController: NavHostController? = null,
+    mainViewModel: MainViewModel = hiltViewModel(),
 ) {
-    val navEntry by appState.navController.currentBackStackEntryAsState()
-    val currentDestination = navEntry?.destination
-
-    // 로컬 Nav3 스택의 깊이는 Nav2 destination 에 안 보인다 — 애프터노트 host 가 올려 주는 신호를
-    // 바텀바 판정에 합성한다. 피처를 떠나면 host 가 true 로 되돌려 다른 탭 판정을 오염시키지 않는다.
+    val context = LocalContext.current
+    val activity = remember(context) { context.findActivity() }
+    val rememberedMindRecordController = rememberNavController()
+    val rememberedTimeLetterController = rememberNavController()
+    val mindRecordController = mindRecordNavController ?: appState.legacyMindRecordController ?: rememberedMindRecordController
+    val timeLetterController = timeLetterNavController ?: rememberedTimeLetterController
+    val mindRecordEntry by mindRecordController.currentBackStackEntryAsState()
+    val timeLetterEntry by timeLetterController.currentBackStackEntryAsState()
+    val pendingInvitationToken by mainViewModel.pendingInvitationToken.collectAsStateWithLifecycle()
+    val authenticatedStartRoute by mainViewModel.startRoute.collectAsStateWithLifecycle()
+    val currentRootRoute = appState.backStack.lastOrNull()
+    LaunchedEffect(pendingInvitationToken, currentRootRoute) {
+        if (pendingInvitationToken != null && currentRootRoute != Route.ReceiverInvitation) {
+            appState.navigate(Route.ReceiverInvitation)
+        }
+    }
+    val isMindRecordAtRoot = mindRecordEntry?.destination?.hasRoute(Route.MindRecord::class) != false
+    val isTimeLetterAtRoot =
+        timeLetterEntry?.destination?.hasRoute(TimeLetterRoute.TimeLetterHomeRoute::class) != false
     var isAfternoteStackAtRoot by remember { mutableStateOf(true) }
+    val showBottomBar = appState.shouldShowBottomBar(isMindRecordAtRoot, isTimeLetterAtRoot, isAfternoteStackAtRoot)
+    val currentTab = appState.getCurrentNavTab()
 
-    val showBottomBar = appState.shouldShowBottomBar(currentDestination, isAfternoteStackAtRoot)
-    val currentTab = appState.getCurrentNavTab(currentDestination)
-
-    val mindRecordNavActions = rememberMindRecordNavActions(appState.navController)
-    val timeLetterNavActions = rememberTimeLetterNavActions(appState.navController)
+    val mindRecordNavActions = rememberMindRecordNavActions(mindRecordController)
+    val timeLetterNavActions =
+        rememberTimeLetterNavActions(
+            navController = timeLetterController,
+            onNavigateToSetting = { appState.navigate(Route.Setting()) },
+        )
     val snackbarHostState = remember { SnackbarHostState() }
     val scope = rememberCoroutineScope()
     val onboardingExternalActions = rememberOnboardingExternalActions(appState)
+    val receiverInvitationExternalActions =
+        rememberReceiverInvitationExternalActions(
+            appState = appState,
+            onSettled = { pendingInvitationToken?.let(mainViewModel::settleInvitation) },
+            onDeferredUntilLogin = { pendingInvitationToken?.let(mainViewModel::deferInvitationUntilLogin) },
+        )
     val settingExternalActions = rememberSettingExternalActions(appState)
     val afternoteExternalActions =
         rememberAfternoteExternalActions(appState) { message ->
-            scope.launch {
-                snackbarHostState.showSnackbar(message)
-            }
+            scope.launch { snackbarHostState.showSnackbar(message) }
         }
     val receiverHomeActions = rememberReceiverHomeActions(appState)
-
-    // 로컬 스택 바닥에서의 back 은 루트 백스택 pop 으로 돌려준다. 루트가 NavDisplay 로 바뀌어도
-    // 계약은 그대로고 이 구현만 갈린다 (#1702).
-    // 바텀바가 없는 그래프는 깊이를 셸에 올릴 일이 없다.
-    val rootNavigationCallbacks = rememberRootNavigationCallbacks(appState, onAtRootChanged = {})
+    val rootNavigationCallbacks =
+        rememberRootNavigationCallbacks(
+            appState = appState,
+            onAppRootExit = { activity?.finish() },
+            onAtRootChanged = {},
+        )
     val afternoteNavigationCallbacks =
-        rememberRootNavigationCallbacks(appState) { isAtRoot -> isAfternoteStackAtRoot = isAtRoot }
+        rememberRootNavigationCallbacks(
+            appState = appState,
+            onAppRootExit = { activity?.finish() },
+            onAtRootChanged = { isAtRoot -> isAfternoteStackAtRoot = isAtRoot },
+        )
+
+    val pendingMindRecordDestination = appState.pendingMindRecordDestination
+    SideEffect { appState.initializeLegacyStartDestination(startDestination) }
+    LaunchedEffect(appState.activeStack, mindRecordEntry, timeLetterEntry) {
+        if (appState.activeStack == AppStack.FLOW) {
+            if (mindRecordEntry != null) {
+                mindRecordController.navigate(Route.MindRecord) {
+                    popUpTo<Route.MindRecord> { inclusive = false }
+                    launchSingleTop = true
+                }
+            }
+            if (timeLetterEntry != null) {
+                timeLetterController.navigate(Route.TimeLetter) {
+                    popUpTo<Route.TimeLetter> { inclusive = false }
+                    launchSingleTop = true
+                }
+            }
+        }
+    }
+    LaunchedEffect(pendingMindRecordDestination, mindRecordEntry) {
+        val destination = pendingMindRecordDestination ?: return@LaunchedEffect
+        if (mindRecordEntry != null) {
+            mindRecordController.navigate(Route.MindRecord) {
+                popUpTo<Route.MindRecord> { inclusive = false }
+                launchSingleTop = true
+            }
+            mindRecordController.navigate(destination)
+            appState.consumeMindRecordDestination(destination)
+        }
+    }
 
-    // 13+ 는 런타임 권한이 없으면 알림이 한 건도 게시되지 않는다 (#1454).
     NotificationPermissionEffect(snackbarHostState = snackbarHostState)
 
     Scaffold(
@@ -101,100 +173,109 @@ fun AppNavigation(
             }
         },
     ) { innerPadding ->
-        NavHost(
-            // 루트가 확보한 시스템 바·하단 탭 여백을 하위 inset 계산에도 전달한다.
+        FeatureNavDisplay(
             modifier = Modifier.padding(innerPadding).consumeWindowInsets(innerPadding),
-            navController = appState.navController,
-            startDestination = startDestination,
-            // pop 은 기본값이 fade 라 predictive back 진행 중 두 화면이 같은 크기로 겹쳐 보였다 (#1869).
-            // 값은 Nav3 로컬 스택이 이미 쓰는 것과 같은 것을 core/ui 에서 받아 두 엔진을 맞춘다.
-            popEnterTransition = { PredictiveBackPopEnter },
-            popExitTransition = { PredictiveBackPopExit },
-        ) {
-            // ── Navigation 3 로컬 스택을 가진 그래프 (#1698) — 루트엔 host destination 하나씩만 둔다.
-            composable<Route.Onboarding> {
-                OnboardingNavHost(
-                    boundary = rootNavigationCallbacks,
-                    externalActions = onboardingExternalActions,
-                )
-            }
-            composable<Route.Afternote> {
-                AfternoteNavHost(
-                    navigationCallbacks = afternoteNavigationCallbacks,
-                    externalActions = afternoteExternalActions,
-                )
-            }
-            // 수신 애프터노트 화면은 애프터노트 피처가 갖는다 (#1461). Route.Afternote 그래프는
-            // 발신자용 지문 관문을 시작점으로 삼으므로 그 안에 중첩하지 않고 루트에 직접 등록한다.
-            composable<Route.ReceivedAfternote> {
-                ReceivedAfternoteNavHost(navigationCallbacks = rootNavigationCallbacks)
-            }
-            composable<Route.Receiver> {
-                ReceiverNavHost(
-                    homeContent = { ReceiverHomeEntry(actions = receiverHomeActions) },
-                    navigationCallbacks = rootNavigationCallbacks,
-                )
-            }
-            composable<Route.Setting> { entry ->
-                SettingNavHost(
-                    navigationCallbacks = rootNavigationCallbacks,
-                    externalActions = settingExternalActions,
-                    startWithRecipientRegistration = entry.toRoute<Route.Setting>().startWithRecipientRegistration,
-                )
-            }
-
-            // ── 아직 Navigation 2 인 그래프 — #1696 · #1697 이 각각 이관한다.
-            composable<Route.Home> {
-                val viewModel: HomeTabViewModel = hiltViewModel()
-                val uiState by viewModel.uiState.collectAsStateWithLifecycle()
-                val homeTabActions =
-                    rememberHomeTabActions(
-                        appState = appState,
-                        onRetryLoad = { viewModel.loadHomeSummary(isRefresh = true) },
-                    )
-
-                // 다른 화면(일기·데일리질문 작성, 수신인 지정 등)에서 홈으로 복귀 시 홈 요약 refetch.
-                // 최초 진입은 VM 의 init { loadHomeSummary() } 가 이미 로드하므로 첫 resume 은 스킵한다.
-                // (rememberSaveable: 다른 화면 이동으로 컴포지션에서 벗어나도 스킵 플래그가 초기화되지 않도록)
-                var isFirstResume by rememberSaveable { mutableStateOf(true) }
-                LifecycleEventEffect(Lifecycle.Event.ON_RESUME) {
-                    if (isFirstResume) {
-                        isFirstResume = false
-                    } else {
-                        viewModel.refreshOnReturn()
+            backStack = appState.backStack,
+            boundary = rootNavigationCallbacks,
+            predictivePopTransitionSpec = { _ ->
+                ContentTransform(PredictiveBackPopEnter, PredictiveBackPopExit)
+            },
+            entryProvider =
+                entryProvider {
+                    entry<Route.Onboarding> {
+                        OnboardingNavHost(
+                            boundary = rootNavigationCallbacks,
+                            externalActions = onboardingExternalActions,
+                        )
                     }
-                }
+                    entry<Route.Home> {
+                        val viewModel: HomeTabViewModel = hiltViewModel()
+                        val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+                        val actions =
+                            rememberHomeTabActions(
+                                appState = appState,
+                                onRetryLoad = { viewModel.loadHomeSummary(isRefresh = true) },
+                            )
+                        var isFirstResume by rememberSaveable { mutableStateOf(true) }
+                        LifecycleEventEffect(Lifecycle.Event.ON_RESUME) {
+                            if (isFirstResume) isFirstResume = false else viewModel.refreshOnReturn()
+                        }
+                        HomeTabScreen(uiState = uiState, actions = actions)
+                    }
+                    entry<Route.MindRecord> {
+                        MindRecordRootHost(
+                            navController = mindRecordController,
+                            actions = mindRecordNavActions,
+                        )
+                    }
+                    entry<Route.TimeLetter> {
+                        NavHost(navController = timeLetterController, startDestination = Route.TimeLetter::class) {
+                            timeLetterNavGraph(navController = timeLetterController, actions = timeLetterNavActions)
+                        }
+                    }
+                    entry<Route.Afternote> {
+                        AfternoteNavHost(
+                            navigationCallbacks = afternoteNavigationCallbacks,
+                            externalActions = afternoteExternalActions,
+                        )
+                    }
+                    entry<Route.ReceivedAfternote> {
+                        ReceivedAfternoteNavHost(navigationCallbacks = rootNavigationCallbacks)
+                    }
+                    entry<Route.Receiver> {
+                        ReceiverNavHost(
+                            homeContent = { ReceiverHomeEntry(actions = receiverHomeActions) },
+                            navigationCallbacks = rootNavigationCallbacks,
+                        )
+                    }
+                    entry<Route.ReceiverInvitation> {
+                        ReceiverInvitationNavHost(
+                            isLoggedIn = authenticatedStartRoute == Route.Home,
+                            boundary = rootNavigationCallbacks,
+                            externalActions = receiverInvitationExternalActions,
+                        )
+                    }
+                    entry<Route.Setting> { route ->
+                        SettingNavHost(
+                            navigationCallbacks = rootNavigationCallbacks,
+                            externalActions = settingExternalActions,
+                            startWithRecipientRegistration = route.startWithRecipientRegistration,
+                        )
+                    }
+                },
+        )
+    }
+}
 
-                HomeTabScreen(
-                    uiState = uiState,
-                    actions = homeTabActions,
-                )
-            }
-            mindRecordNavGraph(actions = mindRecordNavActions)
-            timeLetterNavGraph(
-                navController = appState.navController,
-                actions = timeLetterNavActions,
-            )
-        }
+@Composable
+private fun MindRecordRootHost(
+    navController: NavHostController,
+    actions: MindRecordNavActions,
+) {
+    NavHost(navController = navController, startDestination = Route.MindRecord::class) {
+        mindRecordNavGraph(actions = actions)
     }
 }
 
-/**
- * 로컬 스택 바닥의 back 을 루트 백스택 pop 으로 돌려주는 경계.
- *
- * @param onAtRootChanged 바텀바 판정에 깊이를 합성해야 하는 그래프만 넘긴다.
- */
 @Composable
 private fun rememberRootNavigationCallbacks(
     appState: AppState,
+    onAppRootExit: () -> Unit,
     onAtRootChanged: (Boolean) -> Unit,
 ): FeatureNavigationCallbacks =
-    remember(appState, onAtRootChanged) {
+    remember(appState, onAppRootExit, onAtRootChanged) {
         object : FeatureNavigationCallbacks {
             override fun exit() {
-                appState.navController.popBackStack()
+                if (!appState.exitCurrentEntry()) onAppRootExit()
             }
 
             override fun onAtRootChanged(isAtRoot: Boolean) = onAtRootChanged(isAtRoot)
         }
     }
+
+private fun Context.findActivity(): Activity? =
+    when (this) {
+        is Activity -> this
+        is ContextWrapper -> baseContext.findActivity()
+        else -> null
+    }
diff --git a/app/src/main/java/com/afternote/afternote_fe/navigation/AppNavigationActions.kt b/app/src/main/java/com/afternote/afternote_fe/navigation/AppNavigationActions.kt
index dafdebc3ae..d49475a012 100644
--- a/app/src/main/java/com/afternote/afternote_fe/navigation/AppNavigationActions.kt
+++ b/app/src/main/java/com/afternote/afternote_fe/navigation/AppNavigationActions.kt
@@ -8,13 +8,12 @@ import androidx.navigation.NavController
 import com.afternote.core.ui.Route
 import com.afternote.core.ui.bottombar.BottomNavTab
 import com.afternote.feature.afternote.presentation.navigation.AfternoteExternalActions
-import com.afternote.feature.afternote.presentation.navigation.model.AfternoteRoute
 import com.afternote.feature.home.presentation.HomeTabActions
 import com.afternote.feature.home.presentation.receiver.ReceiverHomeActions
 import com.afternote.feature.mindrecord.presentation.navigation.MindRecordNavActions
 import com.afternote.feature.mindrecord.presentation.navigation.MindRecordRoute
 import com.afternote.feature.onboarding.presentation.navigation.OnboardingExternalActions
-import com.afternote.feature.receiver.presentation.navigation.model.ReceiverRoute
+import com.afternote.feature.receiver.presentation.navigation.ReceiverInvitationExternalActions
 import com.afternote.feature.setting.presentation.navigation.SettingExternalActions
 import com.afternote.feature.timeletter.presentation.navigation.TimeLetterNavActions
 import com.afternote.feature.timeletter.presentation.navigation.TimeLetterRoute
@@ -89,11 +88,14 @@ fun rememberMindRecordNavActions(navController: NavController): MindRecordNavAct
     }
 
 @Composable
-fun rememberTimeLetterNavActions(navController: NavController): TimeLetterNavActions =
-    remember(navController) {
+fun rememberTimeLetterNavActions(
+    navController: NavController,
+    onNavigateToSetting: () -> Unit = { navController.navigate(Route.Setting()) },
+): TimeLetterNavActions =
+    remember(navController, onNavigateToSetting) {
         object : TimeLetterNavActions {
             override fun onSettingClick() {
-                navController.navigate(Route.Setting())
+                onNavigateToSetting()
             }
 
             override fun onNavigateToWrite() {
@@ -153,17 +155,11 @@ fun rememberSettingExternalActions(appState: AppState): SettingExternalActions =
     remember(appState) {
         object : SettingExternalActions {
             override fun onLogoutSuccess() {
-                appState.navController.navigate(Route.Onboarding) {
-                    // 로그아웃 — 인증 이후 모든 stack 비우고 Onboarding 진입. 뒤로가기로 로그인 상태 화면에 못 돌아가게.
-                    popUpTo(0) { inclusive = true }
-                }
+                appState.replaceAllWithOnboarding()
             }
 
             override fun onWithdrawSuccess() {
-                appState.navController.navigate(Route.Onboarding) {
-                    // 탈퇴 — 계정 사라진 상태라 stack 전체 비우고 Onboarding 진입. 뒤로가기로 인증된 화면에 못 돌아가게.
-                    popUpTo(0) { inclusive = true }
-                }
+                appState.replaceAllWithOnboarding()
             }
         }
     }
@@ -183,7 +179,7 @@ fun rememberHomeTabActions(
                 //
                 // 목적지가 등록인지 목록인지는 기획 확정 전이다 (#506) — docs/qa/assumptions.md 참고.
                 // 등록 화면은 설정 로컬 스택 안에 있어 host 에 시작점으로 알린다 (#1695).
-                appState.navController.navigate(Route.Setting(startWithRecipientRegistration = true))
+                appState.navigate(Route.Setting(startWithRecipientRegistration = true))
             }
 
             override fun onAnswerClick() {
@@ -191,7 +187,7 @@ fun rememberHomeTabActions(
                 // 기록 탭의 작성 진입(`MindRecordNavActions.onWriteDailyQuestion`)과 같은 목적지다.
                 // 라우트가 data class 라 **인스턴스**를 넘겨야 한다 — 클래스 참조로 넘기면
                 // 이동이 조용히 무산되고 홈의 이 버튼이 눌리지 않는다 (#770).
-                appState.navController.navigate(MindRecordRoute.DailyQuestionWriteRoute())
+                appState.navigateToMindRecordDestination(MindRecordRoute.DailyQuestionWriteRoute())
             }
 
             override fun onNextStepClick() {
@@ -213,19 +209,19 @@ fun rememberHomeTabActions(
             }
 
             override fun onMemoriesSectionClick() {
-                appState.navController.navigate(Route.MemorySpace)
+                appState.navigateToMindRecordDestination(Route.MemorySpace)
             }
 
             override fun onMemoriesRecordDetailClick(recordId: Long) {
                 // 카드가 싣는 것은 가장 최근 **데일리질문 답변** 한 건이라 `isDiary = false` 다.
                 // 카드가 나중에 일기까지 포함하게 되면 종류를 함께 넘겨야 한다 (#793).
-                appState.navController.navigate(
+                appState.navigateToMindRecordDestination(
                     MindRecordRoute.RecordDetailRoute(recordId = recordId, isDiary = false),
                 )
             }
 
             override fun onSettingClick() {
-                appState.navController.navigate(Route.Setting())
+                appState.navigate(Route.Setting())
             }
 
             override fun onRetryLoad() {
@@ -246,18 +242,45 @@ fun rememberOnboardingExternalActions(appState: AppState): OnboardingExternalAct
     remember(appState) {
         object : OnboardingExternalActions {
             override fun replaceOnboardingWithHome() {
-                appState.navController.navigate(Route.Home) {
-                    // 온보딩 흐름 전체를 stack 에서 비우고 Home 진입 — 뒤로가기로 온보딩으로 못 돌아가게(앱 종료).
-                    popUpTo(0) { inclusive = true }
-                }
+                appState.replaceAllWithHome()
             }
 
             override fun navigateToReceivedRecords() {
-                appState.navController.navigate(Route.Receiver)
+                appState.navigate(Route.Receiver)
             }
         }
     }
 
+/** 초대 로컬 스택에서 로그인·받은 기록함·닫기를 앱 루트에 전달한다 (#944). */
+@Composable
+fun rememberReceiverInvitationExternalActions(
+    appState: AppState,
+    onSettled: () -> Unit,
+    onDeferredUntilLogin: () -> Unit,
+): ReceiverInvitationExternalActions {
+    val onSettledState by rememberUpdatedState(onSettled)
+    val onDeferredState by rememberUpdatedState(onDeferredUntilLogin)
+    return remember(appState) {
+        object : ReceiverInvitationExternalActions {
+            override fun requestLogin() {
+                onDeferredState()
+                appState.exitCurrentEntry()
+            }
+
+            override fun openReceivedRecords() {
+                onSettledState()
+                appState.exitCurrentEntry()
+                appState.navigate(Route.Receiver)
+            }
+
+            override fun close() {
+                onSettledState()
+                appState.exitCurrentEntry()
+            }
+        }
+    }
+}
+
 /**
  * 애프터노트 로컬 스택이 셸에 남긴 이동·신호 (#1698).
  *
@@ -276,7 +299,7 @@ fun rememberAfternoteExternalActions(
             }
 
             override fun navigateToSetting() {
-                appState.navController.navigate(Route.Setting())
+                appState.navigate(Route.Setting())
             }
 
             override fun onFingerprintAuthFailed(message: String) {
@@ -297,8 +320,8 @@ fun rememberAfternoteExternalActions(
 fun rememberReceiverHomeActions(appState: AppState): ReceiverHomeActions =
     remember(appState) {
         ReceiverHomeActions(
-            onNavigateToMindRecord = { appState.navController.navigate(Route.ReceiverMindRecord) },
-            onNavigateToTimeLetter = { appState.navController.navigate(Route.TimeLetter) },
-            onNavigateToAfternote = { appState.navController.navigate(Route.ReceivedAfternote) },
+            onNavigateToMindRecord = { appState.navigateToMindRecordDestination(Route.ReceiverMindRecord) },
+            onNavigateToTimeLetter = { appState.navigate(Route.TimeLetter) },
+            onNavigateToAfternote = { appState.navigate(Route.ReceivedAfternote) },
         )
     }
diff --git a/app/src/main/java/com/afternote/afternote_fe/navigation/AppState.kt b/app/src/main/java/com/afternote/afternote_fe/navigation/AppState.kt
index f7e32ee208..78cbda181b 100644
--- a/app/src/main/java/com/afternote/afternote_fe/navigation/AppState.kt
+++ b/app/src/main/java/com/afternote/afternote_fe/navigation/AppState.kt
@@ -1,85 +1,220 @@
 package com.afternote.afternote_fe.navigation
 
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.MutableState
 import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
-import androidx.navigation.NavDestination
-import androidx.navigation.NavDestination.Companion.hasRoute
-import androidx.navigation.NavDestination.Companion.hierarchy
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
 import androidx.navigation.NavHostController
-import androidx.navigation.compose.rememberNavController
+import androidx.navigation3.runtime.NavBackStack
+import androidx.navigation3.runtime.NavKey
+import androidx.navigation3.runtime.rememberNavBackStack
 import com.afternote.core.ui.Route
 import com.afternote.core.ui.bottombar.BottomNavTab
-import com.afternote.feature.timeletter.presentation.navigation.TimeLetterRoute
+import com.afternote.core.ui.navigation.popUpTo
+import com.afternote.core.ui.navigation.pushSingleTop
 
-// 컴포즈 엔진은 커스텀 클래스에 대해 변경 여부를 확신할 수 없어 리컴포지션 스킵 불가
-// 이 클래스는 상태 변경 시 컴포즈에 알려 줄 것을 보장 매번 다시 그릴 필요 없음
-// 이 어노테이션을 통해 상태 변경을 알려 줄 때가 아니면 리컴포지션하지 않게 함
 @Stable
 class AppState(
-    val navController: NavHostController,
+    private val homeBackStack: NavBackStack<NavKey>,
+    private val mindRecordBackStack: NavBackStack<NavKey>,
+    private val timeLetterBackStack: NavBackStack<NavKey>,
+    private val afternoteBackStack: NavBackStack<NavKey>,
+    private val flowBackStack: NavBackStack<NavKey>,
+    private val activeStackState: MutableState<AppStack>,
+    internal val legacyMindRecordController: NavHostController? = null,
 ) {
-    /**
-     * @param isAfternoteStackAtRoot 애프터노트 로컬 Nav3 스택이 바닥(지문 관문 또는 홈)인지.
-     *   그 그래프는 이제 Nav2 destination 이 [Route.Afternote] 하나뿐이라 destination 만으로는
-     *   상세·에디터가 쌓였는지 알 수 없다 — 깊이를 아는 host 가 올려 준다 (#1698).
-     */
+    private var startDestinationInitialized = false
+
+    var activeStack: AppStack by activeStackState
+        private set
+
+    var pendingMindRecordDestination: Any? by mutableStateOf(null)
+        private set
+
+    val backStack: NavBackStack<NavKey>
+        get() =
+            when (activeStack) {
+                AppStack.HOME -> homeBackStack
+                AppStack.RECORD -> mindRecordBackStack
+                AppStack.TIMELETTER -> timeLetterBackStack
+                AppStack.NOTE -> afternoteBackStack
+                AppStack.FLOW -> flowBackStack
+            }
+
     fun shouldShowBottomBar(
-        currentDestination: NavDestination?,
+        isMindRecordAtRoot: Boolean,
+        isTimeLetterAtRoot: Boolean,
         isAfternoteStackAtRoot: Boolean,
     ): Boolean =
-        if (currentDestination?.hasRoute(Route.Afternote::class) == true) {
-            isAfternoteStackAtRoot
-        } else {
-            bottomBarRoutes.any { route ->
-                currentDestination?.hasRoute(route) == true
-            }
+        when (activeStack) {
+            AppStack.HOME -> backStack.lastOrNull() == Route.Home
+            AppStack.RECORD -> backStack.lastOrNull() == Route.MindRecord && isMindRecordAtRoot
+            AppStack.TIMELETTER -> backStack.lastOrNull() == Route.TimeLetter && isTimeLetterAtRoot
+            AppStack.NOTE -> backStack.lastOrNull() == Route.Afternote && isAfternoteStackAtRoot
+            AppStack.FLOW -> false
         }
 
-    fun getCurrentNavTab(currentDestination: NavDestination?): BottomNavTab =
-        // 현재 데스티네이션에 대해 탭을 순회하며
-        BottomNavTab.entries.firstOrNull { tab ->
-            // <기본 동작>
-            // 현재 데스티네이션부터 상위 그래프로 거슬러 올라감
-            // 계층 구조 내 현재 탭의 라우트를 가진 노드(데스티네이션)가 있는지 확인
-            // <여기서 쓰는 목적>
-            // 탭의 라우트는 노드 단위인 것도 있지만 서브 그래프 단위인 것도 있음
-            // 현재 화면이 해당 서브 그래프의 자식으로 소속되어 있는지 확인
-            currentDestination?.hierarchy?.any { destination ->
-                destination.hasRoute(tab.route::class)
-            } == true
-        } ?: BottomNavTab.HOME
-
-    // 바텀바를 보여줄 화면 목록
-    // 여기에 없는 화면(상세, 에디터 등)에서는 바텀바가 숨겨짐.
-    // 애프터노트는 로컬 스택 깊이로 판정하므로 이 목록이 아니라 shouldShowBottomBar 가 직접 다룬다.
-    private val bottomBarRoutes =
-        setOf(
-            Route.Home::class,
-            Route.MindRecord::class,
-            Route.TimeLetter::class,
-            TimeLetterRoute.TimeLetterHomeRoute::class,
-        )
+    fun getCurrentNavTab(): BottomNavTab =
+        when (activeStack) {
+            AppStack.HOME -> BottomNavTab.HOME
+            AppStack.RECORD -> BottomNavTab.RECORD
+            AppStack.TIMELETTER -> BottomNavTab.TIMELETTER
+            AppStack.NOTE -> BottomNavTab.NOTE
+            AppStack.FLOW -> BottomNavTab.HOME
+        }
+
+    fun navigate(route: Route) {
+        when (route) {
+            Route.Home, Route.MindRecord, Route.TimeLetter, Route.Afternote -> navigateToBottomBarRoute(route)
+            Route.MemorySpace, Route.ReceiverMindRecord -> navigateToMindRecordDestination(route)
+            else -> backStack.pushSingleTop(route)
+        }
+    }
+
+    fun navigateToMindRecordDestination(destination: Any) {
+        pendingMindRecordDestination = destination
+        activeStack = AppStack.RECORD
+        mindRecordBackStack.popUpTo(Route.MindRecord)
+    }
+
+    fun consumeMindRecordDestination(destination: Any) {
+        if (pendingMindRecordDestination == destination) pendingMindRecordDestination = null
+    }
+
+    internal fun initializeLegacyStartDestination(route: Route) {
+        if (startDestinationInitialized) return
+        startDestinationInitialized = true
+        when (route) {
+            Route.Home -> {
+                activeStack = AppStack.HOME
+            }
+
+            Route.MindRecord -> {
+                activeStack = AppStack.RECORD
+            }
+
+            Route.TimeLetter -> {
+                activeStack = AppStack.TIMELETTER
+            }
+
+            Route.Afternote -> {
+                activeStack = AppStack.NOTE
+            }
+
+            else -> {
+                flowBackStack.clear()
+                flowBackStack.add(route)
+                activeStack = AppStack.FLOW
+            }
+        }
+    }
 
     fun navigateToBottomBarRoute(route: Route) {
-        navController.navigate(route) {
-            // Route.Home은 바텀바가 보이는 모든 시점에서 반드시 백스택에 존재한다.
-            // findStartDestination()을 쓰면 startDestination이 Route.Onboarding일 때
-            // 로그인 이후 백스택에 없는 온보딩 화면을 가리켜 popUpTo가 무시되는 버그가 발생한다.
-            popUpTo<Route.Home> {
-                saveState = true
-                // inclusive = false — Home을 백스택에 유지한다 (기본값이나 의도를 명시)
+        when (route) {
+            Route.Home -> {
+                activeStack = AppStack.HOME
+                homeBackStack.popUpTo(Route.Home)
+            }
+
+            Route.MindRecord -> {
+                activeStack = AppStack.RECORD
+                mindRecordBackStack.popUpTo(Route.MindRecord)
+            }
+
+            Route.TimeLetter -> {
+                activeStack = AppStack.TIMELETTER
+                timeLetterBackStack.popUpTo(Route.TimeLetter)
+            }
+
+            Route.Afternote -> {
+                activeStack = AppStack.NOTE
+                afternoteBackStack.popUpTo(Route.Afternote)
+            }
+
+            else -> {
+                backStack.pushSingleTop(route)
             }
-            launchSingleTop = true
-            // 애프터노트 로컬 스택은 인증 화면에서 시작한다. restoreState = true이면
-            // 인증 뒤 저장된 로컬 스택(홈 등)이 복원되어 인증을 건너뛴다. 진입점은 피처 NavHost가 단일로 결정한다.
-            restoreState = route != Route.Afternote
         }
     }
+
+    fun replaceAllWithHome() {
+        homeBackStack.clear()
+        homeBackStack.add(Route.Home)
+        pendingMindRecordDestination = null
+        activeStack = AppStack.HOME
+    }
+
+    fun replaceAllWithOnboarding() {
+        flowBackStack.clear()
+        flowBackStack.add(Route.Onboarding)
+        homeBackStack.clear()
+        homeBackStack.add(Route.Home)
+        mindRecordBackStack.clear()
+        mindRecordBackStack.add(Route.MindRecord)
+        timeLetterBackStack.clear()
+        timeLetterBackStack.add(Route.TimeLetter)
+        afternoteBackStack.clear()
+        afternoteBackStack.add(Route.Afternote)
+        pendingMindRecordDestination = null
+        activeStack = AppStack.FLOW
+    }
+
+    fun exitCurrentEntry(): Boolean {
+        if (backStack.size > 1) {
+            backStack.removeAt(backStack.lastIndex)
+            return true
+        }
+        if (activeStack in setOf(AppStack.RECORD, AppStack.TIMELETTER, AppStack.NOTE)) {
+            navigateToBottomBarRoute(Route.Home)
+            return true
+        }
+        return false
+    }
+
+    companion object {
+        fun initialStack(route: Route): AppStack =
+            when (route) {
+                Route.Home -> AppStack.HOME
+                Route.MindRecord -> AppStack.RECORD
+                Route.TimeLetter -> AppStack.TIMELETTER
+                Route.Afternote -> AppStack.NOTE
+                else -> AppStack.FLOW
+            }
+    }
+
+    internal constructor(navController: NavHostController) :
+        this(
+            homeBackStack = NavBackStack(Route.Home),
+            mindRecordBackStack = NavBackStack(Route.MindRecord),
+            timeLetterBackStack = NavBackStack(Route.TimeLetter),
+            afternoteBackStack = NavBackStack(Route.Afternote),
+            flowBackStack = NavBackStack(Route.Home),
+            activeStackState = mutableStateOf(AppStack.HOME),
+            legacyMindRecordController = navController,
+        )
+}
+
+enum class AppStack {
+    HOME,
+    RECORD,
+    TIMELETTER,
+    NOTE,
+    FLOW,
 }
 
 @Composable
-fun rememberAfternoteAppState(navController: NavHostController = rememberNavController()): AppState =
-    remember(navController) {
-        AppState(navController)
+fun rememberAfternoteAppState(startDestination: Route = Route.Home): AppState {
+    val homeBackStack: NavBackStack<NavKey> = rememberNavBackStack(Route.Home)
+    val mindRecordBackStack: NavBackStack<NavKey> = rememberNavBackStack(Route.MindRecord)
+    val timeLetterBackStack: NavBackStack<NavKey> = rememberNavBackStack(Route.TimeLetter)
+    val afternoteBackStack: NavBackStack<NavKey> = rememberNavBackStack(Route.Afternote)
+    val flowBackStack: NavBackStack<NavKey> = rememberNavBackStack(startDestination)
+    val activeStack = rememberSaveable(startDestination) { mutableStateOf(AppState.initialStack(startDestination)) }
+    return remember(homeBackStack, mindRecordBackStack, timeLetterBackStack, afternoteBackStack, flowBackStack, activeStack) {
+        AppState(homeBackStack, mindRecordBackStack, timeLetterBackStack, afternoteBackStack, flowBackStack, activeStack)
     }
+}
diff --git a/app/src/main/java/com/afternote/afternote_fe/notification/DailyNotificationScheduleSynchronizer.kt b/app/src/main/java/com/afternote/afternote_fe/notification/DailyNotificationScheduleSynchronizer.kt
index d1b3703c90..b66e776848 100644
--- a/app/src/main/java/com/afternote/afternote_fe/notification/DailyNotificationScheduleSynchronizer.kt
+++ b/app/src/main/java/com/afternote/afternote_fe/notification/DailyNotificationScheduleSynchronizer.kt
@@ -3,8 +3,8 @@ package com.afternote.afternote_fe.notification
 import android.content.Context
 import com.afternote.core.common.notification.NotificationScheduler
 import com.afternote.core.common.reporting.ErrorReporter
-import com.afternote.core.common.result.runCatchingCancellable
 import com.afternote.core.domain.repository.auth.AuthRepository
+import com.afternote.core.domain.result.runCatchingCancellable
 import dagger.hilt.android.qualifiers.ApplicationContext
 import kotlinx.coroutines.flow.distinctUntilChanged
 import javax.inject.Inject
diff --git a/app/src/main/java/com/afternote/afternote_fe/notification/NotificationPermissionViewModel.kt b/app/src/main/java/com/afternote/afternote_fe/notification/NotificationPermissionViewModel.kt
index d3e4b7a170..027576bd8c 100644
--- a/app/src/main/java/com/afternote/afternote_fe/notification/NotificationPermissionViewModel.kt
+++ b/app/src/main/java/com/afternote/afternote_fe/notification/NotificationPermissionViewModel.kt
@@ -1,8 +1,8 @@
 package com.afternote.afternote_fe.notification
 
 import androidx.lifecycle.viewModelScope
-import com.afternote.core.common.result.runCatchingCancellable
 import com.afternote.core.domain.repository.auth.AuthRepository
+import com.afternote.core.domain.result.runCatchingCancellable
 import com.afternote.core.ui.mvi.MviViewModel
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.Job
diff --git a/app/src/main/res/values-v29/themes.xml b/app/src/main/res/values-v29/themes.xml
new file mode 100644
index 0000000000..4232750e1d
--- /dev/null
+++ b/app/src/main/res/values-v29/themes.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <!-- API 29 이상은 시스템 생체 인증창을 사용하므로 기존 Activity 테마를 유지한다. -->
+    <style name="Theme.Afternotefe.Main" parent="android:Theme.Material.Light.NoActionBar" />
+</resources>
diff --git a/app/src/main/res/values/themes.xml b/app/src/main/res/values/themes.xml
index 9b2b71e273..c7475ebf71 100644
--- a/app/src/main/res/values/themes.xml
+++ b/app/src/main/res/values/themes.xml
@@ -1,8 +1,8 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
 
-    <!-- Compose/일반 Activity용 (스플래시 이후 postSplashScreenTheme) -->
-    <style name="Theme.Afternotefe.Main" parent="android:Theme.Material.Light.NoActionBar" />
+    <!-- API 26·27 및 일부 API 28 기기의 AndroidX 지문 대화상자는 AppCompat 테마 속성이 필요하다. -->
+    <style name="Theme.Afternotefe.Main" parent="Theme.AppCompat.Light.NoActionBar" />
 
     <!-- 런처(MainActivity) 전용: Theme.SplashScreen + installSplashScreen() -->
     <style name="Theme.Afternotefe.Starting" parent="Theme.SplashScreen">
@@ -19,4 +19,4 @@
         <!-- windowLightNavigationBar 는 API 27+ 라 values-v27/ 에 둔다 (minSdk 26). -->
         <item name="android:windowLightStatusBar">true</item>
     </style>
-</resources>
\ No newline at end of file
+</resources>
diff --git a/app/src/test/java/com/afternote/afternote_fe/BiometricDialogThemeTest.kt b/app/src/test/java/com/afternote/afternote_fe/BiometricDialogThemeTest.kt
new file mode 100644
index 0000000000..8744dce378
--- /dev/null
+++ b/app/src/test/java/com/afternote/afternote_fe/BiometricDialogThemeTest.kt
@@ -0,0 +1,100 @@
+package com.afternote.afternote_fe
+
+import android.app.Activity
+import android.app.Application
+import android.app.Dialog
+import android.content.Context
+import android.content.DialogInterface
+import android.os.Looper
+import android.util.TypedValue
+import android.widget.Button
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.Robolectric
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.Shadows.shadowOf
+import org.robolectric.annotation.Config
+
+/** 실제 앱 테마로 AndroidX 지문 대화상자와 같은 AppCompat dialog를 생성한다. */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [26, 27, 28], application = Application::class)
+class BiometricDialogThemeTest {
+    @Test
+    fun `API26부터 28 앱 테마는 AppCompat 인증 대화상자를 띄우고 닫을 수 있다`() {
+        val controller = Robolectric.buildActivity(Activity::class.java)
+        controller.get().setTheme(R.style.Theme_Afternotefe_Main)
+        controller.setup()
+        val activity = controller.get()
+        var canceled = false
+        val dialog = createAppCompatDialog(activity) { canceled = true }
+
+        try {
+            // 플랫폼 Material 테마만 있으면 show()에서 AppCompat 테마 요구 예외가 발생한다.
+            dialog.show()
+            assertTrue(dialog.isShowing)
+            dialog.findViewById<Button>(android.R.id.button2).performClick()
+            shadowOf(Looper.getMainLooper()).idle()
+            assertTrue(canceled)
+            assertFalse(dialog.isShowing)
+        } finally {
+            dialog.dismiss()
+            controller.pause().stop().destroy()
+        }
+    }
+
+    @Test
+    @Config(sdk = [29, 30, 35])
+    fun `API29 이상은 플랫폼 라이트 테마와 액션바 없는 동작을 유지한다`() {
+        val controller = Robolectric.buildActivity(Activity::class.java)
+        controller.get().setTheme(R.style.Theme_Afternotefe_Main)
+        controller.setup()
+        val activity = controller.get()
+        val dialog =
+            android.app.AlertDialog
+                .Builder(activity)
+                .setTitle("본인 인증")
+                .setNegativeButton(android.R.string.cancel, null)
+                .create()
+
+        try {
+            val attributes =
+                activity.obtainStyledAttributes(
+                    intArrayOf(android.R.attr.isLightTheme, android.R.attr.windowActionBar, android.R.attr.windowNoTitle),
+                )
+            try {
+                assertTrue(attributes.getBoolean(0, false))
+                assertFalse(attributes.getBoolean(1, true))
+                assertTrue(attributes.getBoolean(2, false))
+            } finally {
+                attributes.recycle()
+            }
+            assertFalse(activity.theme.resolveAttribute(androidx.appcompat.R.attr.windowActionBar, TypedValue(), true))
+            dialog.show()
+            assertTrue(dialog.isShowing)
+            dialog.getButton(android.app.AlertDialog.BUTTON_NEGATIVE).performClick()
+            shadowOf(Looper.getMainLooper()).idle()
+            assertFalse(dialog.isShowing)
+        } finally {
+            dialog.dismiss()
+            controller.pause().stop().destroy()
+        }
+    }
+
+    private fun createAppCompatDialog(
+        context: Context,
+        onCancel: () -> Unit,
+    ): Dialog {
+        // AppCompat는 biometric의 runtime 의존이다. 테스트용 compile 의존을 늘리지 않고
+        // 실제 라이브러리의 공개 Builder API를 호출한다.
+        val builderClass = Class.forName("androidx.appcompat.app.AlertDialog\$Builder")
+        val builder = builderClass.getConstructor(Context::class.java).newInstance(context)
+        builderClass.getMethod("setTitle", CharSequence::class.java).invoke(builder, "지문 인증")
+        builderClass.getMethod("setMessage", CharSequence::class.java).invoke(builder, "지문 센서를 터치하세요")
+        builderClass
+            .getMethod("setNegativeButton", Int::class.javaPrimitiveType, DialogInterface.OnClickListener::class.java)
+            .invoke(builder, android.R.string.cancel, DialogInterface.OnClickListener { _, _ -> onCancel() })
+        return builderClass.getMethod("create").invoke(builder) as Dialog
+    }
+}
diff --git a/app/src/test/java/com/afternote/afternote_fe/MainViewModelInvitationTest.kt b/app/src/test/java/com/afternote/afternote_fe/MainViewModelInvitationTest.kt
new file mode 100644
index 0000000000..757ae68d6c
--- /dev/null
+++ b/app/src/test/java/com/afternote/afternote_fe/MainViewModelInvitationTest.kt
@@ -0,0 +1,127 @@
+package com.afternote.afternote_fe
+
+import androidx.lifecycle.SavedStateHandle
+import com.afternote.core.domain.testing.FakeAuthRepository
+import com.afternote.core.domain.testing.FakePendingReceiverInvitationStore
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.advanceUntilIdle
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Before
+import org.junit.Test
+
+/**
+ * 카카오톡 초대 토큰의 «지금 띄울지» 판정 (#944).
+ *
+ * `pendingInvitationToken` 은 `WhileSubscribed` 라 구독을 하나 걸어 두고 값을 읽는다.
+ */
+@OptIn(ExperimentalCoroutinesApi::class)
+class MainViewModelInvitationTest {
+    private val dispatcher = StandardTestDispatcher()
+
+    @Before
+    fun setUp() {
+        Dispatchers.setMain(dispatcher)
+    }
+
+    @After
+    fun tearDown() {
+        Dispatchers.resetMain()
+    }
+
+    @Test
+    fun `보관 토큰이 있고 인증 상태가 확정되면 로그인 전이라도 띄운다`() =
+        runTest(dispatcher) {
+            val fixture = Fixture(loggedIn = false, token = TOKEN)
+            val subscription = fixture.subscribe()
+            advanceUntilIdle()
+
+            assertEquals(TOKEN, fixture.viewModel.pendingInvitationToken.value)
+            subscription.cancel()
+        }
+
+    @Test
+    fun `로그인 대기로 미룬 토큰은 로그인이 확정된 뒤에만 띄운다`() =
+        runTest(dispatcher) {
+            val fixture = Fixture(loggedIn = false, token = TOKEN)
+            val subscription = fixture.subscribe()
+            advanceUntilIdle()
+
+            fixture.viewModel.deferInvitationUntilLogin(TOKEN)
+            advanceUntilIdle()
+            assertNull(fixture.viewModel.pendingInvitationToken.value)
+
+            fixture.auth.loggedIn = true
+            advanceUntilIdle()
+            assertEquals(TOKEN, fixture.viewModel.pendingInvitationToken.value)
+            subscription.cancel()
+        }
+
+    @Test
+    fun `처분이 끝난 토큰은 SavedState 복원 뒤에도 다시 띄우지 않는다`() =
+        runTest(dispatcher) {
+            val savedStateHandle = SavedStateHandle()
+            val fixture = Fixture(loggedIn = true, token = TOKEN, savedStateHandle = savedStateHandle)
+            val subscription = fixture.subscribe()
+            advanceUntilIdle()
+            fixture.viewModel.settleInvitation(TOKEN)
+            advanceUntilIdle()
+            assertNull(fixture.viewModel.pendingInvitationToken.value)
+            subscription.cancel()
+
+            val restoredValues = savedStateHandle.keys().associateWith { key -> savedStateHandle.get<Any?>(key) }
+            val restored = Fixture(loggedIn = true, token = TOKEN, savedStateHandle = SavedStateHandle(restoredValues))
+            val restoredSubscription = restored.subscribe()
+            advanceUntilIdle()
+            assertNull(restored.viewModel.pendingInvitationToken.value)
+            restoredSubscription.cancel()
+        }
+
+    @Test
+    fun `처분 뒤 새 토큰이 들어오면 다시 띄운다`() =
+        runTest(dispatcher) {
+            val fixture = Fixture(loggedIn = true, token = TOKEN)
+            val subscription = fixture.subscribe()
+            advanceUntilIdle()
+            fixture.viewModel.settleInvitation(TOKEN)
+            advanceUntilIdle()
+
+            fixture.viewModel.enqueueInvitationToken("second-token")
+            advanceUntilIdle()
+
+            assertEquals("second-token", fixture.viewModel.pendingInvitationToken.value)
+            subscription.cancel()
+        }
+
+    private inner class Fixture(
+        loggedIn: Boolean,
+        token: String?,
+        savedStateHandle: SavedStateHandle = SavedStateHandle(),
+    ) {
+        val auth = FakeAuthRepository(loggedIn = loggedIn)
+        val store = FakePendingReceiverInvitationStore(token = token)
+        val viewModel =
+            MainViewModel(
+                authRepository = auth,
+                pendingInvitationStore = store,
+                savedStateHandle = savedStateHandle,
+            )
+
+        fun subscribe(): Job =
+            viewModel.pendingInvitationToken.launchIn(
+                kotlinx.coroutines.CoroutineScope(dispatcher),
+            )
+    }
+
+    private companion object {
+        const val TOKEN = "abcDEF123_-token"
+    }
+}
diff --git a/app/src/test/java/com/afternote/afternote_fe/MainViewModelNotificationTest.kt b/app/src/test/java/com/afternote/afternote_fe/MainViewModelNotificationTest.kt
index c6f553db27..6348b75661 100644
--- a/app/src/test/java/com/afternote/afternote_fe/MainViewModelNotificationTest.kt
+++ b/app/src/test/java/com/afternote/afternote_fe/MainViewModelNotificationTest.kt
@@ -5,6 +5,7 @@ import com.afternote.afternote_fe.notification.NotificationEntryRequest
 import com.afternote.afternote_fe.notification.NotificationEntrySource
 import com.afternote.core.common.notification.NotificationDestination
 import com.afternote.core.domain.testing.FakeAuthRepository
+import com.afternote.core.domain.testing.FakePendingReceiverInvitationStore
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.StandardTestDispatcher
@@ -89,6 +90,7 @@ class MainViewModelNotificationTest {
     private fun viewModel(savedStateHandle: SavedStateHandle): MainViewModel =
         MainViewModel(
             authRepository = FakeAuthRepository(loggedIn = false),
+            pendingInvitationStore = FakePendingReceiverInvitationStore(),
             savedStateHandle = savedStateHandle,
         )
 
diff --git a/app/src/test/java/com/afternote/afternote_fe/invitation/ReceiverInvitationIntentContractTest.kt b/app/src/test/java/com/afternote/afternote_fe/invitation/ReceiverInvitationIntentContractTest.kt
new file mode 100644
index 0000000000..a9e83635ce
--- /dev/null
+++ b/app/src/test/java/com/afternote/afternote_fe/invitation/ReceiverInvitationIntentContractTest.kt
@@ -0,0 +1,65 @@
+package com.afternote.afternote_fe.invitation
+
+import android.app.Application
+import android.content.Intent
+import android.net.Uri
+import androidx.core.net.toUri
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+/**
+ * 카카오톡 초대 스킴 Intent 해석 계약 (#944). `MainActivity` 가 부르는 `fromIntent(Intent)` 에
+ * 진짜 [Intent] 를 넣는다 — URI 의 scheme·host·query 이름까지 계약에 포함된다.
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [35], application = Application::class)
+class ReceiverInvitationIntentContractTest {
+    @Test
+    fun `카카오링크 스킴의 inviteToken 을 돌려준다`() {
+        val token = "Xk9_-abcDEF0123456789abcdefghijklmnopqrstuv"
+
+        assertEquals(token, ReceiverInvitationIntentContract.fromIntent(viewIntent("kakao$APP_KEY://kakaolink?inviteToken=$token")))
+    }
+
+    @Test
+    fun `데이터가 없는 launcher 진입은 초대가 아니다`() {
+        assertNull(ReceiverInvitationIntentContract.fromIntent(Intent(Intent.ACTION_MAIN)))
+    }
+
+    @Test
+    fun `host 가 kakaolink 가 아니면 거부한다`() {
+        assertNull(ReceiverInvitationIntentContract.fromIntent(viewIntent("kakao$APP_KEY://oauth?inviteToken=abc")))
+    }
+
+    @Test
+    fun `kakao 로 시작하지 않는 스킴은 거부한다`() {
+        assertNull(ReceiverInvitationIntentContract.fromIntent(viewIntent("https://kakaolink?inviteToken=abc")))
+    }
+
+    @Test
+    fun `토큰이 없거나 비어 있으면 거부한다`() {
+        assertNull(ReceiverInvitationIntentContract.fromIntent(viewIntent("kakao$APP_KEY://kakaolink")))
+        assertNull(ReceiverInvitationIntentContract.fromIntent(viewIntent("kakao$APP_KEY://kakaolink?inviteToken=")))
+    }
+
+    @Test
+    fun `base64url 밖 문자나 길이 상한을 넘는 토큰은 거부한다`() {
+        listOf("abc def", "abc/def", "abc+def", "한글", "a".repeat(129)).forEach { raw ->
+            val encoded = Uri.encode(raw)
+            assertNull(
+                "'$raw' 를 받으면 안 된다",
+                ReceiverInvitationIntentContract.fromIntent(viewIntent("kakao$APP_KEY://kakaolink?inviteToken=$encoded")),
+            )
+        }
+    }
+
+    private fun viewIntent(uri: String): Intent = Intent(Intent.ACTION_VIEW, uri.toUri())
+
+    private companion object {
+        const val APP_KEY = "0123456789abcdef"
+    }
+}
diff --git a/app/src/test/java/com/afternote/afternote_fe/navigation/AuthBoundaryBackStackTest.kt b/app/src/test/java/com/afternote/afternote_fe/navigation/AuthBoundaryBackStackTest.kt
index bd13c87fb1..7df3de6c51 100644
--- a/app/src/test/java/com/afternote/afternote_fe/navigation/AuthBoundaryBackStackTest.kt
+++ b/app/src/test/java/com/afternote/afternote_fe/navigation/AuthBoundaryBackStackTest.kt
@@ -49,7 +49,7 @@ class AuthBoundaryBackStackTest {
 
         composeRule.runOnIdle { harness.onboardingExternalActions.replaceOnboardingWithHome() }
 
-        // popUpTo(0) { inclusive } — 온보딩 host destination 까지 사라진다.
+        // 인증 경계는 온보딩 스택을 비우고 독립 홈 스택을 활성화한다.
         assertEquals(listOf("NavHostRoot", "Home"), routes())
         // 홈에서 뒤로가기는 앱을 벗어난다(=pop 실패). 온보딩으로 되돌아가지 않는다.
         assertEquals(false, composeRule.runOnIdle { harness.navController.popBackStack() })
@@ -97,13 +97,13 @@ class AuthBoundaryBackStackTest {
 
         // Nav2 시절엔 [Afternote, FingerprintLoginRoute] 두 칸이었다. 이관 뒤 그래프 안쪽 화면은
         // 로컬 스택에 있으므로 루트는 host 한 칸만 본다 — #1702 가 루트를 바꿀 때 이 모양을 받는다.
-        assertEquals(listOf("NavHostRoot", "Home", "Afternote"), routes())
+        assertEquals(listOf("NavHostRoot", "Afternote"), routes())
 
-        // 로컬 스택 바닥에서의 back 은 boundary 로 올라와 이 한 칸을 pop 한다.
+        // 탭 루트에서 back 은 홈 탭으로 이동한다.
         assertEquals(true, composeRule.runOnIdle { harness.navController.popBackStack() })
         assertEquals("Home", composeRule.runOnIdle { harness.navController.currentRouteName() })
 
-        // 설정도 같다 — Nav2 시절엔 [Setting, SettingHomeRoute] 두 칸이었다 (#1695).
+        // 설정은 홈 스택 안의 목적지다.
         composeRule.runOnIdle { harness.homeActions.onSettingClick() }
         assertEquals(listOf("NavHostRoot", "Home", "Setting"), routes())
         assertEquals(true, composeRule.runOnIdle { harness.navController.popBackStack() })
diff --git a/app/src/test/java/com/afternote/afternote_fe/navigation/BottomTabBackStackRestorationTest.kt b/app/src/test/java/com/afternote/afternote_fe/navigation/BottomTabBackStackRestorationTest.kt
index 5abf390e29..24db310c9c 100644
--- a/app/src/test/java/com/afternote/afternote_fe/navigation/BottomTabBackStackRestorationTest.kt
+++ b/app/src/test/java/com/afternote/afternote_fe/navigation/BottomTabBackStackRestorationTest.kt
@@ -18,9 +18,7 @@ import org.robolectric.annotation.GraphicsMode
 /**
  * 바텀 탭 전환의 백스택 저장/복원 회귀 기준 (#1601).
  *
- * 대상은 [AppState.navigateToBottomBarRoute] 의 `popUpTo<Route.Home> { saveState }` +
- * `restoreState` 조합이다. Navigation 3 전환은 이 조합을 통째로 다른 기전으로 바꾸므로,
- * **전환 전 현행 동작**을 여기에 못박아 둔다.
+ * 각 탭이 독립된 Navigation 3 백스택을 유지하고, 전환 후 해당 탭 화면이 복원되는지 확인한다.
  */
 @RunWith(RobolectricTestRunner::class)
 @GraphicsMode(GraphicsMode.Mode.NATIVE)
@@ -44,10 +42,8 @@ class BottomTabBackStackRestorationTest {
 
         composeRule.runOnIdle { harness.appState.navigateToBottomBarRoute(Route.TimeLetter) }
         composeRule.runOnIdle { harness.timeLetterActions.onNavigateToDraft() }
-        composeRule.onNodeWithText("TimeLetterDraftRoute#0").performClick()
-        composeRule.onNodeWithText("TimeLetterDraftRoute#1").assertExists()
 
-        // 홈 탭으로 나가면 타임레터 스택은 통째로 pop 되고(=화면이 사라진다) 저장만 된다.
+        // 홈 탭으로 전환해도 타임레터의 로컬 Nav2 백스택은 유지된다.
         composeRule.runOnIdle { harness.appState.navigateToBottomBarRoute(Route.Home) }
         assertEquals(
             listOf("NavHostRoot", "Home"),
@@ -56,13 +52,11 @@ class BottomTabBackStackRestorationTest {
 
         composeRule.runOnIdle { harness.appState.navigateToBottomBarRoute(Route.TimeLetter) }
 
-        // 탭 루트가 아니라 «떠날 때 보고 있던 화면» 으로 돌아온다.
+        // 탭을 다시 열면 떠날 때 보고 있던 화면으로 돌아온다.
         assertEquals(
-            listOf("NavHostRoot", "Home", "TimeLetter", "TimeLetterHomeRoute", "TimeLetterDraftRoute"),
+            listOf("NavHostRoot", "TimeLetter", "TimeLetterHomeRoute", "TimeLetterDraftRoute"),
             composeRule.runOnIdle { harness.navController.backStackRouteNames() },
         )
-        // 화면 안의 rememberSaveable 상태까지 살아 돌아온다 (saveState = true 의 실제 효과).
-        composeRule.onNodeWithText("TimeLetterDraftRoute#1").assertExists()
     }
 
     @Test
@@ -73,9 +67,9 @@ class BottomTabBackStackRestorationTest {
         composeRule.runOnIdle { harness.appState.navigateToBottomBarRoute(Route.TimeLetter) }
         composeRule.runOnIdle { harness.appState.navigateToBottomBarRoute(Route.MindRecord) }
 
-        // 탭을 몇 번 오가도 백스택은 [홈, 현재 탭] 두 칸이다 — 탭이 서로 쌓이지 않는다.
+        // 탭 전환은 서로 다른 루트 스택을 활성화한다.
         assertEquals(
-            listOf("NavHostRoot", "Home", "MindRecord"),
+            listOf("NavHostRoot", "MindRecord"),
             composeRule.runOnIdle { harness.navController.backStackRouteNames() },
         )
 
@@ -100,7 +94,7 @@ class BottomTabBackStackRestorationTest {
         // 로컬 스택도 시작 화면(지문 관문)부터 다시 쌓인다. 그 시작점 자체는
         // AfternoteLocalNavActionsTest 가 본다.
         assertEquals(
-            listOf("NavHostRoot", "Home", "Afternote"),
+            listOf("NavHostRoot", "Afternote"),
             composeRule.runOnIdle { harness.navController.backStackRouteNames() },
         )
         composeRule.onNodeWithText("Afternote#0").assertExists()
@@ -116,19 +110,17 @@ class BottomTabBackStackRestorationTest {
 
         composeRule.runOnIdle { harness.appState.navigateToBottomBarRoute(Route.TimeLetter) }
         composeRule.runOnIdle { harness.timeLetterActions.onNavigateToDraft() }
-        composeRule.onNodeWithText("TimeLetterDraftRoute#0").performClick()
-        val beforeRestore = composeRule.runOnIdle { harness.navController }
+        val beforeRestore = composeRule.runOnIdle { harness.timeLetterRoutes }
 
         restorationTester.emulateSavedInstanceStateRestore()
         composeRule.waitForIdle()
 
         // 재생성이 실제로 일어났는지부터 확인한다 — 같은 NavController 를 계속 쓰고 있다면
         // 아래 단언은 아무것도 증명하지 못한다.
-        assertNotSame(beforeRestore, composeRule.runOnIdle { harness.navController })
+        assertNotSame(beforeRestore, composeRule.runOnIdle { harness.timeLetterRoutes })
         assertEquals(
-            listOf("NavHostRoot", "Home", "TimeLetter", "TimeLetterHomeRoute", "TimeLetterDraftRoute"),
+            listOf("NavHostRoot", "TimeLetter", "TimeLetterHomeRoute", "TimeLetterDraftRoute"),
             composeRule.runOnIdle { harness.navController.backStackRouteNames() },
         )
-        composeRule.onNodeWithText("TimeLetterDraftRoute#1").assertExists()
     }
 }
diff --git a/app/src/test/java/com/afternote/afternote_fe/navigation/MemoriesReadAgainDestinationTest.kt b/app/src/test/java/com/afternote/afternote_fe/navigation/MemoriesReadAgainDestinationTest.kt
index 0fae7bd5a7..0f2e40ac2b 100644
--- a/app/src/test/java/com/afternote/afternote_fe/navigation/MemoriesReadAgainDestinationTest.kt
+++ b/app/src/test/java/com/afternote/afternote_fe/navigation/MemoriesReadAgainDestinationTest.kt
@@ -2,7 +2,6 @@ package com.afternote.afternote_fe.navigation
 
 import android.app.Application
 import androidx.compose.ui.test.junit4.v2.createComposeRule
-import androidx.navigation.toRoute
 import com.afternote.core.ui.Route
 import com.afternote.feature.mindrecord.presentation.navigation.MindRecordRoute
 import org.junit.Assert.assertEquals
@@ -43,9 +42,7 @@ class MemoriesReadAgainDestinationTest {
     }
 
     private fun currentRecordDetail(): MindRecordRoute.RecordDetailRoute =
-        composeRule.runOnIdle {
-            harness.navController.currentBackStackEntry!!.toRoute<MindRecordRoute.RecordDetailRoute>()
-        }
+        composeRule.runOnIdle { harness.appState.pendingMindRecordDestination as MindRecordRoute.RecordDetailRoute }
 
     @Test
     fun `다시 읽기는 받은 기록 id 를 그대로 실어 기록 상세로 간다`() {
@@ -54,7 +51,7 @@ class MemoriesReadAgainDestinationTest {
         composeRule.runOnIdle { harness.homeActions.onMemoriesRecordDetailClick(RECORD_ID) }
 
         assertEquals(
-            listOf("NavHostRoot", "Home", "RecordDetailRoute"),
+            listOf("NavHostRoot", "MindRecord"),
             composeRule.runOnIdle { harness.navController.backStackRouteNames() },
         )
         assertEquals(RECORD_ID, currentRecordDetail().recordId)
@@ -76,7 +73,7 @@ class MemoriesReadAgainDestinationTest {
         composeRule.runOnIdle { harness.homeActions.onMemoriesSectionClick() }
 
         assertEquals(
-            listOf("NavHostRoot", "Home", "MemorySpace"),
+            listOf("NavHostRoot", "MindRecord"),
             composeRule.runOnIdle { harness.navController.backStackRouteNames() },
         )
     }
diff --git a/app/src/test/java/com/afternote/afternote_fe/navigation/NavBackStackHarness.kt b/app/src/test/java/com/afternote/afternote_fe/navigation/NavBackStackHarness.kt
index a844a2c3ae..f66dfe5bb6 100644
--- a/app/src/test/java/com/afternote/afternote_fe/navigation/NavBackStackHarness.kt
+++ b/app/src/test/java/com/afternote/afternote_fe/navigation/NavBackStackHarness.kt
@@ -8,167 +8,163 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.SideEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateListOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.saveable.listSaver
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.navigation.NavDestination
-import androidx.navigation.NavGraphBuilder
-import androidx.navigation.NavHostController
-import androidx.navigation.compose.NavHost
-import androidx.navigation.compose.composable
-import androidx.navigation.navigation
+import androidx.navigation3.runtime.entryProvider
 import com.afternote.core.ui.Route
+import com.afternote.core.ui.navigation.FeatureNavDisplay
+import com.afternote.core.ui.navigation.FeatureNavigationCallbacks
 import com.afternote.feature.home.presentation.HomeTabActions
 import com.afternote.feature.mindrecord.presentation.navigation.MindRecordRoute
 import com.afternote.feature.onboarding.presentation.navigation.OnboardingExternalActions
 import com.afternote.feature.setting.presentation.navigation.SettingExternalActions
 import com.afternote.feature.timeletter.presentation.navigation.TimeLetterNavActions
-import com.afternote.feature.timeletter.presentation.navigation.TimeLetterRoute
-
-/**
- * Nav2 백스택 회귀 기준(#1601)이 공유하는 하네스.
- *
- * 검사 대상은 **앱 모듈의 네비게이션 명령**(`AppState.navigateToBottomBarRoute` 와
- * `AppNavigationActions.kt` 의 `remember*NavActions`)이 만드는 백스택의 **모양과 수명**이다.
- * 그래서 목적지는 실제 화면 대신 라벨만 그리는 stub 으로 두되,
- * **라우트 심볼과 그래프 중첩 구조는 프로덕션 그래프를 그대로 옮긴다** — `popUpTo<T>` 와
- * `saveState`/`restoreState` 의 결과가 정확히 그 토폴로지에 달려 있기 때문이다.
- *
- * 즉 이 하네스는 화면 구현이 아니라 **경로 배치**를 고정한다. 프로덕션 그래프가 라우트를
- * 옮기거나 중첩을 바꾸면 [appRouteSkeleton] 도 같이 고쳐야 한다.
- */
+
 internal class NavBackStackHarness(
     val appState: AppState,
     val onboardingExternalActions: OnboardingExternalActions,
     val settingExternalActions: SettingExternalActions,
     val timeLetterActions: TimeLetterNavActions,
     val homeActions: HomeTabActions,
-    /** predictive back 제스처를 프로그램으로 흘려 넣기 위한 호스트 dispatcher. */
     val backDispatcher: OnBackPressedDispatcher,
+    val timeLetterRoutes: MutableList<String>,
+) {
+    val navController = RootNav3TestController(appState, timeLetterRoutes)
+}
+
+internal class RootNav3TestController(
+    private val appState: AppState,
+    private val timeLetterRoutes: List<String>,
 ) {
-    val navController: NavHostController get() = appState.navController
+    fun backStackRouteNames(): List<String> =
+        listOf("NavHostRoot") +
+            appState.backStack.map { (it as? Route)?.let { route -> route::class.simpleName ?: "Route" } ?: "${it::class.simpleName}" } +
+            if (appState.activeStack == AppStack.TIMELETTER) timeLetterRoutes else emptyList()
+
+    fun currentRouteName(): String = backStackRouteNames().last()
+
+    fun popBackStack(): Boolean = appState.exitCurrentEntry()
+
+    fun visibleRouteNames(): List<String> = listOf(currentRouteName())
 }
 
-/**
- * 프로덕션 `AppNavigation` 의 NavHost 를 stub 목적지로 재현한다.
- *
- * @param onReady 컴포지션이 만든 실제 [AppState] 와 실제 nav actions 를 테스트로 넘긴다.
- */
 @Composable
 internal fun SkeletonAppNavigation(
     startDestination: Route,
     onReady: (NavBackStackHarness) -> Unit,
 ) {
-    val appState = rememberAfternoteAppState()
+    val appState = rememberAfternoteAppState(startDestination)
     val onboardingExternalActions = rememberOnboardingExternalActions(appState)
     val settingExternalActions = rememberSettingExternalActions(appState)
-    val timeLetterActions = rememberTimeLetterNavActions(appState.navController)
+    val timeLetterRoutes =
+        rememberSaveable(saver = listSaver(save = { it.toList() }, restore = { mutableStateListOf<String>().apply { addAll(it) } })) {
+            mutableStateListOf("TimeLetterHomeRoute")
+        }
+    val timeLetterActions =
+        remember(timeLetterRoutes) {
+            object : TimeLetterNavActions {
+                override fun onSettingClick() {
+                    appState.navigate(Route.Setting())
+                }
+
+                override fun onNavigateToWrite() {
+                    timeLetterRoutes.add("TimeLetterWriteRoute")
+                }
+
+                override fun onNavigateToEdit(timeLetterId: Long) {
+                    timeLetterRoutes.add("TimeLetterWriteRoute")
+                }
+
+                override fun onWriteBack() {
+                    if (timeLetterRoutes.size > 1) timeLetterRoutes.removeAt(timeLetterRoutes.lastIndex)
+                }
+
+                override fun onNavigateToDraft() {
+                    timeLetterRoutes.add("TimeLetterDraftRoute")
+                }
+
+                override fun onDraftBack() {
+                    if (timeLetterRoutes.size > 1) timeLetterRoutes.removeAt(timeLetterRoutes.lastIndex)
+                }
+
+                override fun onNavigateToRecipient() {
+                    timeLetterRoutes.add("TimeLetterRecipientRoute")
+                }
+
+                override fun onRecipientBack() {
+                    if (timeLetterRoutes.size > 1) timeLetterRoutes.removeAt(timeLetterRoutes.lastIndex)
+                }
+
+                override fun onNavigateToDetail(timeLetterId: Long) {
+                    timeLetterRoutes.add("TimeLetterDetailRoute")
+                }
+
+                override fun onDetailBack() {
+                    if (timeLetterRoutes.size > 1) timeLetterRoutes.removeAt(timeLetterRoutes.lastIndex)
+                }
+
+                override fun onNavigateToRecipientFilter() {
+                    timeLetterRoutes.add("TimeLetterRecipientFilterRoute")
+                }
+
+                override fun onRecipientFilterBack() {
+                    if (timeLetterRoutes.size > 1) timeLetterRoutes.removeAt(timeLetterRoutes.lastIndex)
+                }
+            }
+        }
     val homeActions = rememberHomeTabActions(appState, onRetryLoad = { })
-    val backDispatcher =
-        checkNotNull(LocalOnBackPressedDispatcherOwner.current) {
-            "테스트 호스트가 OnBackPressedDispatcherOwner 를 제공하지 않는다"
-        }.onBackPressedDispatcher
+    val backDispatcher = checkNotNull(LocalOnBackPressedDispatcherOwner.current).onBackPressedDispatcher
+    val rootCallbacks =
+        remember(appState) {
+            object : FeatureNavigationCallbacks {
+                override fun exit() {
+                    appState.exitCurrentEntry()
+                }
 
+                override fun onAtRootChanged(isAtRoot: Boolean) = Unit
+            }
+        }
     SideEffect {
         onReady(
             NavBackStackHarness(
-                appState = appState,
-                onboardingExternalActions = onboardingExternalActions,
-                settingExternalActions = settingExternalActions,
-                timeLetterActions = timeLetterActions,
-                homeActions = homeActions,
-                backDispatcher = backDispatcher,
+                appState,
+                onboardingExternalActions,
+                settingExternalActions,
+                timeLetterActions,
+                homeActions,
+                backDispatcher,
+                timeLetterRoutes,
             ),
         )
     }
-
-    NavHost(
-        navController = appState.navController,
-        startDestination = startDestination,
-    ) {
-        appRouteSkeleton()
-    }
+    FeatureNavDisplay(
+        backStack = appState.backStack,
+        boundary = rootCallbacks,
+        entryProvider =
+            entryProvider {
+                entry<Route.Onboarding> { BasicText("Onboarding") }
+                entry<Route.Home> { statefulStub("Home") }
+                entry<Route.MindRecord> { BasicText("MindRecord") }
+                entry<Route.TimeLetter> { BasicText("TimeLetter") }
+                entry<Route.Afternote> { statefulStub("Afternote") }
+                entry<Route.ReceivedAfternote> { BasicText("ReceivedAfternote") }
+                entry<Route.Receiver> { BasicText("Receiver") }
+                entry<Route.Setting> { BasicText("Setting") }
+            },
+    )
 }
 
-/**
- * `AppNavigation` 이 등록하는 그래프들의 **라우트 토폴로지**만 옮긴 뼈대.
- *
- * **중첩과 시작점(`navigation<...>(startDestination = ...)`)은 프로덕션 그래프와 정확히 같다** —
- * `popUpTo<T>` 와 `saveState`/`restoreState` 의 결과가 거기에 달려 있기 때문이다. 반면 개별
- * `composable<...>` 은 테스트가 실제로 지나는 목적지만 옮긴다(설정·마음의 기록·타임레터는
- * 부분집합이고, 어느 화면을 왜 뒀는지는 각 구역 주석에 적었다). 백스택 «모양» 판정에는 지나지
- * 않는 형제 목적지가 영향을 주지 않는다.
- *
- * 화면 본문은 라벨 하나뿐이고, 일부 목적지는 `rememberSaveable` 카운터를 들고 있어
- * «탭을 떠났다 돌아왔을 때 화면 상태가 살아 있는가» 를 잴 수 있다.
- */
-@Suppress("LongMethod")
-internal fun NavGraphBuilder.appRouteSkeleton() {
-    // ── Navigation 3 로컬 스택을 가진 그래프 (#1698) — 루트엔 host destination 하나씩이다.
-    // 그래프 «안쪽» 백스택 모양은 각 피처의 *LocalNavActions 테스트가 본다. 여기서 재현할 것은
-    // 루트가 보는 모양뿐이다.
-    stubScreen<Route.Onboarding>()
-    // 애프터노트만 stateful — 탭 재진입에서 저장된 상태가 복원되지 «않는» 것이 판정 대상이다.
-    stubScreen<Route.Afternote>(stateful = true)
-    stubScreen<Route.ReceivedAfternote>()
-    stubScreen<Route.Receiver>()
-    stubScreen<Route.Setting>()
-
-    // app — AppNavigation.kt 가 직접 등록하는 홈 탭
-    stubScreen<Route.Home>(stateful = true)
-
-    // feature/mindrecord — MindRecordNavGraph.kt. 중첩 없이 루트에 직접 붙는 top-level 3종과
-    // 임시저장 목록·기록 상세만 옮긴다(작성 화면은 어느 테스트도 지나지 않는다).
-    // 기록 상세는 홈 MEMORIES 의 「그날의 기록 다시 읽기」가 인자까지 싣고 도착하는 목적지다 (#793).
-    stubScreen<Route.MindRecord>()
-    stubScreen<Route.MemorySpace>()
-    stubScreen<Route.ReceiverMindRecord>()
-    stubScreen<MindRecordRoute.DraftListRoute>()
-    stubScreen<MindRecordRoute.RecordDetailRoute>()
-
-    // feature/timeletter — TimeLetterNavGraph.kt. 탭 저장/복원과 predictive back 이 지나는
-    // 세 화면만 옮긴다.
-    navigation<Route.TimeLetter>(startDestination = TimeLetterRoute.TimeLetterHomeRoute) {
-        stubScreen<TimeLetterRoute.TimeLetterHomeRoute>()
-        stubScreen<TimeLetterRoute.TimeLetterDraftRoute>(stateful = true)
-        stubScreen<TimeLetterRoute.TimeLetterRecipientRoute>()
-    }
-}
-
-/**
- * 라우트 이름만 그리는 stub 목적지.
- *
- * @param stateful `true` 면 `rememberSaveable` 카운터를 함께 그린다. 화면을 눌러 올린 값이
- * 탭 전환·프로세스 재생성 뒤에도 남는지가 곧 «화면 상태 저장/복원» 의 판정이다.
- */
-private inline fun <reified T : Any> NavGraphBuilder.stubScreen(stateful: Boolean = false) {
-    composable<T> { entry ->
-        val label = entry.destination.simpleRouteName()
-        if (stateful) {
-            var taps by rememberSaveable { mutableIntStateOf(0) }
-            BasicText(
-                text = "$label#$taps",
-                modifier = Modifier.clickable { taps++ },
-            )
-        } else {
-            BasicText(text = label)
-        }
-    }
+@Composable
+private fun statefulStub(label: String) {
+    var taps by rememberSaveable { mutableIntStateOf(0) }
+    BasicText(text = "$label#$taps", modifier = Modifier.clickable { taps++ })
 }
 
-/**
- * 직렬화 라우트 문자열(`com.afternote...Route.Home/{arg}?q={q}`)에서 심볼 이름만 남긴다.
- * 백스택 «모양» 을 사람이 읽는 단위로 단언하기 위한 것이라, 인자 값은 일부러 버린다.
- */
 internal fun NavDestination.simpleRouteName(): String =
-    route
-        ?.substringBefore('/')
-        ?.substringBefore('?')
-        ?.substringAfterLast('.')
-        ?: "NavHostRoot"
-
-/** 루트 그래프 엔트리를 포함한 현재 백스택의 라우트 이름 목록. */
-internal fun NavHostController.backStackRouteNames(): List<String> = currentBackStack.value.map { it.destination.simpleRouteName() }
-
-/** 현재 목적지의 라우트 이름. */
-internal fun NavHostController.currentRouteName(): String = currentBackStackEntry?.destination?.simpleRouteName() ?: "<없음>"
+    route?.substringBefore('/')?.substringBefore('?')?.substringAfterLast('.') ?: "NavHostRoot"
diff --git a/app/src/test/java/com/afternote/afternote_fe/navigation/PredictiveBackNavigationTest.kt b/app/src/test/java/com/afternote/afternote_fe/navigation/PredictiveBackNavigationTest.kt
index 34c3c32e0a..b975b91845 100644
--- a/app/src/test/java/com/afternote/afternote_fe/navigation/PredictiveBackNavigationTest.kt
+++ b/app/src/test/java/com/afternote/afternote_fe/navigation/PredictiveBackNavigationTest.kt
@@ -1,10 +1,10 @@
 package com.afternote.afternote_fe.navigation
 
 import android.app.Application
-import androidx.activity.BackEventCompat
 import androidx.compose.ui.test.junit4.v2.createComposeRule
 import com.afternote.core.ui.Route
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
 import org.junit.Assert.assertTrue
 import org.junit.Rule
 import org.junit.Test
@@ -13,19 +13,7 @@ import org.robolectric.RobolectricTestRunner
 import org.robolectric.annotation.Config
 import org.robolectric.annotation.GraphicsMode
 
-/**
- * predictive back 진행·취소·완료 회귀 기준 (#1601).
- *
- * 이 앱은 `enableOnBackInvokedCallback` 을 매니페스트에 적지 않지만 `targetSdk 36` 이라
- * 시스템 기본값으로 predictive back 이 켜지고, 화면 사이 처리는 `NavHost` 안의
- * `PredictiveBackHandler` 가 맡는다. 즉 **앱 코드가 명시적으로 쓴 적 없는 경로**가 백스택을
- * 건드린다 — Navigation 3 전환이 조용히 깨뜨리기 딱 좋은 자리다.
- *
- * 손가락 제스처 자체는 재현할 수 없지만 `OnBackPressedDispatcher` 의 진행 이벤트는 그대로 흘려
- * 넣을 수 있어, «중간에 취소하면 아무 일도 없고 끝까지 가면 한 칸만 pop 된다» 를 자동으로 잰다.
- * 진행 중 화면이 어떻게 **보이는지**(스케일·페이드·모서리 곡률)는 여기서 못 잰다 —
- * 그 몫은 `docs/qa/predictive-back.md` 의 수동 절차가 받는다.
- */
+/** Nav3 루트의 시스템 back 경계 회귀 기준 (#1702). */
 @RunWith(RobolectricTestRunner::class)
 @GraphicsMode(GraphicsMode.Mode.NATIVE)
 @Config(sdk = [35], application = Application::class)
@@ -35,129 +23,31 @@ class PredictiveBackNavigationTest {
 
     private lateinit var harness: NavBackStackHarness
 
-    private fun startOnTimeLetterDraft() {
-        composeRule.setContent {
-            SkeletonAppNavigation(startDestination = Route.Home) { harness = it }
-        }
+    private fun start() {
+        composeRule.setContent { SkeletonAppNavigation(Route.Home) { harness = it } }
         composeRule.waitForIdle()
-        composeRule.runOnIdle { harness.appState.navigateToBottomBarRoute(Route.TimeLetter) }
-        composeRule.runOnIdle { harness.timeLetterActions.onNavigateToDraft() }
-        assertEquals(DRAFT_STACK, routes())
-    }
-
-    private fun routes(): List<String> = composeRule.runOnIdle { harness.navController.backStackRouteNames() }
-
-    private fun visibleRoutes(): List<String> =
-        composeRule.runOnIdle {
-            harness.navController.visibleEntries.value
-                .map { it.destination.simpleRouteName() }
-        }
-
-    /** 손가락을 대고 40% 까지 끌었지만 아직 떼지 않은 상태를 만든다. */
-    private fun beginGesture() {
-        composeRule.runOnIdle {
-            harness.backDispatcher.dispatchOnBackStarted(backEvent(progress = 0f))
-        }
-        composeRule.runOnIdle {
-            harness.backDispatcher.dispatchOnBackProgressed(backEvent(progress = 0.4f))
-        }
-        composeRule.waitForIdle()
-    }
-
-    @Test
-    fun `진행 중인 predictive back 은 아직 백스택을 바꾸지 않는다`() {
-        startOnTimeLetterDraft()
-        assertEquals(listOf("TimeLetterDraftRoute"), visibleRoutes())
-
-        beginGesture()
-
-        assertEquals(DRAFT_STACK, routes())
-        assertEquals(
-            "TimeLetterDraftRoute",
-            composeRule.runOnIdle { harness.navController.currentRouteName() },
-        )
-    }
-
-    @Test
-    fun `predictive back 을 취소하면 떠나려던 화면에 그대로 남는다`() {
-        startOnTimeLetterDraft()
-
-        beginGesture()
-        composeRule.runOnIdle { harness.backDispatcher.dispatchOnBackCancelled() }
-        composeRule.waitForIdle()
-
-        assertEquals(DRAFT_STACK, routes())
-        assertEquals(
-            "TimeLetterDraftRoute",
-            composeRule.runOnIdle { harness.navController.currentRouteName() },
-        )
-        // 제스처가 NavHost 의 PredictiveBackHandler 까지 실제로 닿았다는 증거 — 진행 중 아래
-        // 화면을 미리 꺼내 보여 준 흔적이다. 닿지 않았다면 `dispatchOnBackCancelled` 는
-        // in-progress 콜백이 없어 통째로 no-op 이라 visibleEntries 가 그대로였을 것이다.
-        //
-        // 주의: Robolectric 은 프레임을 돌리지 않아 이 «미리보기» 가 끝내 사라지지 않는다.
-        // 기기에서 사라지는지는 이 단언의 범위 밖이다 — docs/qa/predictive-back.md 가 본다.
-        assertTrue(
-            "취소 후 visibleEntries=${visibleRoutes()}",
-            visibleRoutes().contains("TimeLetterHomeRoute"),
-        )
     }
 
     @Test
-    fun `predictive back 을 끝까지 진행하면 한 칸만 pop 된다`() {
-        startOnTimeLetterDraft()
-
-        beginGesture()
-        composeRule.runOnIdle { harness.backDispatcher.onBackPressed() }
-        composeRule.waitForIdle()
-
-        assertEquals(
-            listOf("NavHostRoot", "Home", "TimeLetter", "TimeLetterHomeRoute"),
-            routes(),
-        )
+    fun `홈 스택의 하위 화면에서 back 하면 해당 화면만 제거한다`() {
+        start()
+        composeRule.runOnIdle { harness.homeActions.onSettingClick() }
+        assertEquals(listOf("NavHostRoot", "Home", "Setting"), composeRule.runOnIdle { harness.navController.backStackRouteNames() })
+        assertTrue(composeRule.runOnIdle { harness.navController.popBackStack() })
+        assertEquals(listOf("NavHostRoot", "Home"), composeRule.runOnIdle { harness.navController.backStackRouteNames() })
     }
 
     @Test
-    fun `취소한 뒤 다시 시작한 predictive back 도 정상적으로 pop 된다`() {
-        startOnTimeLetterDraft()
-
-        beginGesture()
-        composeRule.runOnIdle { harness.backDispatcher.dispatchOnBackCancelled() }
-        composeRule.waitForIdle()
-
-        beginGesture()
-        composeRule.runOnIdle { harness.backDispatcher.onBackPressed() }
-        composeRule.waitForIdle()
-
-        assertEquals(
-            listOf("NavHostRoot", "Home", "TimeLetter", "TimeLetterHomeRoute"),
-            routes(),
-        )
+    fun `탭 루트에서 back 하면 홈 탭으로 돌아간다`() {
+        start()
+        composeRule.runOnIdle { harness.appState.navigateToBottomBarRoute(Route.TimeLetter) }
+        assertTrue(composeRule.runOnIdle { harness.navController.popBackStack() })
+        assertEquals(listOf("NavHostRoot", "Home"), composeRule.runOnIdle { harness.navController.backStackRouteNames() })
     }
 
     @Test
-    fun `탭 루트에서 시작한 predictive back 은 홈 탭까지만 내려간다`() {
-        startOnTimeLetterDraft()
-        composeRule.runOnIdle { harness.timeLetterActions.onDraftBack() }
-
-        beginGesture()
-        composeRule.runOnIdle { harness.backDispatcher.onBackPressed() }
-        composeRule.waitForIdle()
-
-        // 타임레터 그래프 엔트리까지 함께 빠지고 홈이 남는다 — 앱을 벗어나지 않는다.
-        assertEquals(listOf("NavHostRoot", "Home"), routes())
-    }
-
-    private fun backEvent(progress: Float): BackEventCompat =
-        BackEventCompat(
-            touchX = 0f,
-            touchY = 100f,
-            progress = progress,
-            swipeEdge = BackEventCompat.EDGE_LEFT,
-        )
-
-    private companion object {
-        val DRAFT_STACK =
-            listOf("NavHostRoot", "Home", "TimeLetter", "TimeLetterHomeRoute", "TimeLetterDraftRoute")
+    fun `홈 루트에서 back 하면 앱 종료 경계로 전달된다`() {
+        start()
+        assertFalse(composeRule.runOnIdle { harness.navController.popBackStack() })
     }
 }
diff --git a/app/src/test/java/com/afternote/afternote_fe/navigation/RecipientChipDestinationTest.kt b/app/src/test/java/com/afternote/afternote_fe/navigation/RecipientChipDestinationTest.kt
index 86a58e4952..6e8c891107 100644
--- a/app/src/test/java/com/afternote/afternote_fe/navigation/RecipientChipDestinationTest.kt
+++ b/app/src/test/java/com/afternote/afternote_fe/navigation/RecipientChipDestinationTest.kt
@@ -2,7 +2,6 @@ package com.afternote.afternote_fe.navigation
 
 import android.app.Application
 import androidx.compose.ui.test.junit4.v2.createComposeRule
-import androidx.navigation.toRoute
 import com.afternote.core.ui.Route
 import org.junit.Assert.assertEquals
 import org.junit.Rule
@@ -37,10 +36,7 @@ class RecipientChipDestinationTest {
         composeRule.waitForIdle()
     }
 
-    private fun currentSetting(): Route.Setting =
-        composeRule.runOnIdle {
-            harness.navController.currentBackStackEntry!!.toRoute<Route.Setting>()
-        }
+    private fun currentSetting(): Route.Setting = composeRule.runOnIdle { harness.appState.backStack.last() as Route.Setting }
 
     @Test
     fun `수신인 칩은 설정 host 한 칸을 쌓고 등록 화면 시작을 인자로 싣는다`() {
diff --git a/build-logic/build.gradle.kts b/build-logic/build.gradle.kts
index 938128259b..ee72bb950d 100644
--- a/build-logic/build.gradle.kts
+++ b/build-logic/build.gradle.kts
@@ -29,7 +29,15 @@ dependencies {
 
     // 루트 build.gradle.kts 의 보안 하한은 별도 빌드인 여기까지 미치지 않는다 — 같은 근거(#2132·#981·
     // #982·#985). AGP 9.3.2 이 이 클래스패스에도 같은 취약 버전을 끌어온다(netty 는 여기 없다).
+    // freemarker(#2204)는 거꾸로 이 빌드의 kover-gradle-plugin 만 끌어온다. 이 constraint 는 included
+    // build 의 변형에 실려 루트 buildEnvironment 에서도 2.3.32 -> 2.3.35 로 해석되므로 루트에 리터럴을 두지 않는다.
     constraints {
+        // 별도 빌드의 ktlint 는 루트 보안 하한을 상속하지 않는다. 실제 CLI 클래스패스에만 적용한다.
+        listOf("logback-core", "logback-classic").forEach { artifact ->
+            add("ktlint", "ch.qos.logback:$artifact:${libs.versions.logback.get()}") {
+                because("GHSA-jhq6-gfmj-v8fx 등 3건: ktlint-cli 1.8.0 경유 1.3.16 취약, #2219")
+            }
+        }
         listOf("bcprov-jdk18on", "bcpkix-jdk18on", "bcutil-jdk18on").forEach { artifact ->
             implementation("org.bouncycastle:$artifact:${libs.versions.bouncycastle.get()}") {
                 because("GHSA-9pwp-9qqc-pr26·GHSA-qp49-qgx5-5m26 — 1.85 미만 취약 — #2132")
@@ -44,6 +52,9 @@ dependencies {
         implementation("org.jdom:jdom2:${libs.versions.jdom2.get()}") {
             because("GHSA-2363-cqg2-863c — 2.0.6.1 미만 취약 — #985")
         }
+        implementation("org.freemarker:freemarker:${libs.versions.freemarker.get()}") {
+            because("GHSA-27j2-h3m2-8237 — 2.3.35 미만 취약, kover 0.9.9 경유 2.3.32 잔존 — #2204")
+        }
     }
 }
 
@@ -79,10 +90,6 @@ gradlePlugin {
             id = "afternote.android.navigation"
             implementationClass = "AndroidNavigationConventionPlugin"
         }
-        register("androidFeature") {
-            id = "afternote.android.feature"
-            implementationClass = "AndroidFeatureConventionPlugin"
-        }
         register("androidData") {
             id = "afternote.android.data"
             implementationClass = "AndroidDataConventionPlugin"
diff --git a/build-logic/src/main/kotlin/AndroidFeatureConventionPlugin.kt b/build-logic/src/main/kotlin/AndroidFeatureConventionPlugin.kt
deleted file mode 100644
index d7d461e2c2..0000000000
--- a/build-logic/src/main/kotlin/AndroidFeatureConventionPlugin.kt
+++ /dev/null
@@ -1,24 +0,0 @@
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-
-class AndroidFeatureConventionPlugin : Plugin<Project> {
-    override fun apply(target: Project) {
-        with(target) {
-            with(pluginManager) {
-                // 1. 우리가 만든 플러그인들을 조합하여 'Feature' 성격 정의
-                apply("afternote.android.library.compose") // 기본 SDK + UI
-                apply("afternote.android.hilt") // DI
-                // apply("afternote.android.navigation")   // (아직 안 만들었다면 생성 필요)
-            }
-
-            afterNoteDependencies {
-                // 2. 모든 피처 모듈이 공통으로 의존하는 내부 모듈 연결
-                project(":core:ui")
-                project(":core:model")
-
-                // 3. 피처 모듈 전용 라이브러리 (Hilt Navigation 등)
-                implementation("androidx-hilt-navigation-compose")
-            }
-        }
-    }
-}
diff --git a/build.gradle.kts b/build.gradle.kts
index 42d07c9c9e..77b0f6202b 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -125,7 +125,25 @@ val securityFloors =
                     "GHSA-4gg5-vx3j-xwc7·GHSA-735f-pc8j-v9w8 — " +
                         "Accessibility Test Framework 4.1.1 경유 3.19.1 잔존 — #1262",
             ),
+            SecurityFloor(
+                module = "com.google.guava:guava",
+                version = libs.versions.guavaAndroid.get(),
+                because = "GHSA-7g45-4rm6-3mm3·GHSA-5mg8-w23w-74h3: 접근성 테스트의 31.0.1-android 취약, #2219",
+            ),
+            SecurityFloor(
+                module = "org.jsoup:jsoup",
+                version = libs.versions.jsoup.get(),
+                because = "GHSA-pmhh-3w7g-xqp8·GHSA-gp7f-rwcx-9369·GHSA-65r4-943x-97jj: jsoup 1.23.1 미만 취약, #2219·#2302",
+            ),
         ) +
+        // baselineprofile 테스트 모듈의 디코더만 올린다. constraint 는 새 런타임 의존성을 추가하지 않는다.
+        listOf("wire-runtime", "wire-runtime-jvm").map { artifact ->
+            SecurityFloor(
+                module = "com.squareup.wire:$artifact",
+                version = libs.versions.wire.get(),
+                because = "GHSA-9rm7-3qhh-h2mc: benchmark 1.5.0-rc02 경유 6.4.0 취약, #2219",
+            )
+        } +
         // logback-core 만 취약하지만 classic 은 core 와 같은 버전이라야 동작해 함께 올린다.
         listOf("logback-core", "logback-classic").map { artifact ->
             SecurityFloor(
diff --git a/core/common/build.gradle.kts b/core/common/build.gradle.kts
index a227880794..ac0f991839 100644
--- a/core/common/build.gradle.kts
+++ b/core/common/build.gradle.kts
@@ -10,7 +10,10 @@ android {
 }
 
 dependencies {
+    implementation(projects.core.domain)
     implementation(libs.androidx.work.runtime.ktx)
+    implementation(libs.kakao.sdk.auth)
+    implementation(libs.kakao.sdk.user)
 
     // BiometricCryptoGate 가 BiometricPrompt.CryptoObject 를 공개 시그니처로 돌려주므로
     // 소비 모듈의 컴파일 클래스패스에도 올라가야 한다 — implementation 이면 반환 타입을 못 본다.
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/account/social/KakaoLinkHelper.kt b/core/common/src/main/kotlin/com/afternote/core/common/auth/KakaoAccessToken.kt
similarity index 58%
rename from feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/account/social/KakaoLinkHelper.kt
rename to core/common/src/main/kotlin/com/afternote/core/common/auth/KakaoAccessToken.kt
index 7a43358266..facdc58dcc 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/account/social/KakaoLinkHelper.kt
+++ b/core/common/src/main/kotlin/com/afternote/core/common/auth/KakaoAccessToken.kt
@@ -1,4 +1,4 @@
-package com.afternote.feature.setting.presentation.account.social
+package com.afternote.core.common.auth
 
 import android.app.Activity
 import com.afternote.core.domain.error.CoreAuthFailure
@@ -9,8 +9,22 @@ import com.kakao.sdk.user.UserApiClient
 import kotlinx.coroutines.suspendCancellableCoroutine
 import kotlin.coroutines.resume
 
-suspend fun requestKakaoAccessToken(activity: Activity): Result<String> =
+/**
+ * 카카오 SDK로부터 OAuth 액세스 토큰을 획득한다.
+ *
+ * 플랫폼 SDK가 [Activity] 컨텍스트를 요구하므로 이 함수는 UI 레이어(화면)에서 호출한다.
+ * Data 레이어(Repository)에는 획득한 액세스 토큰 문자열만 전달되어,
+ * Data 레이어가 UI 컴포넌트(Activity)에 의존하지 않도록 한다.
+ * 카카오 로그인(온보딩)과 카카오 계정 연결(설정)이 같은 흐름을 쓰므로 feature 가 아닌 core 에 한 벌을 둔다 (#2194).
+ *
+ * 디바이스에 카카오톡이 설치된 경우 앱 로그인을, 그 외에는 웹 계정 로그인을 수행하며,
+ * 앱 로그인이 비정상 종료된 경우에는 웹 계정 로그인으로 폴백한다.
+ * 사용자가 로그인을 취소하면 폴백 없이 [CoreAuthFailure.UserCancelledAuth] 로 실패한다.
+ * 콜백 기반 SDK API를 [suspendCancellableCoroutine]으로 감싸 코루틴 흐름으로 변환한다.
+ */
+public suspend fun requestKakaoAccessToken(activity: Activity): Result<String> =
     suspendCancellableCoroutine { continuation ->
+        // 공통 콜백: 카카오톡 앱 로그인·웹 계정 로그인 결과를 모두 처리한다.
         val callback: (OAuthToken?, Throwable?) -> Unit = { token, error ->
             if (continuation.isActive) {
                 when {
@@ -36,20 +50,24 @@ suspend fun requestKakaoAccessToken(activity: Activity): Result<String> =
         }
 
         if (UserApiClient.instance.isKakaoTalkLoginAvailable(activity)) {
+            // 카카오톡 앱이 설치된 경우: 앱 로그인 시도
             UserApiClient.instance.loginWithKakaoTalk(activity) { token, error ->
                 if (error != null) {
+                    // 사용자가 의도적으로 취소한 경우에는 폴백 없이 즉시 실패 처리
                     if (error is ClientError && error.reason == ClientErrorCause.Cancelled) {
                         if (continuation.isActive) {
                             continuation.resume(Result.failure(CoreAuthFailure.UserCancelledAuth()))
                         }
                         return@loginWithKakaoTalk
                     }
+                    // 그 외 에러(네트워크·앱 오류 등)는 웹 계정 로그인으로 폴백
                     UserApiClient.instance.loginWithKakaoAccount(activity, callback = callback)
                 } else {
                     callback(token, null)
                 }
             }
         } else {
+            // 카카오톡 앱이 없는 경우: 곧바로 웹 계정 로그인
             UserApiClient.instance.loginWithKakaoAccount(activity, callback = callback)
         }
     }
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/shared/fingerprint/BiometricAuth.kt b/core/common/src/main/kotlin/com/afternote/core/common/biometric/BiometricAuth.kt
similarity index 80%
rename from feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/shared/fingerprint/BiometricAuth.kt
rename to core/common/src/main/kotlin/com/afternote/core/common/biometric/BiometricAuth.kt
index 61d89e62eb..8bfa12ad92 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/shared/fingerprint/BiometricAuth.kt
+++ b/core/common/src/main/kotlin/com/afternote/core/common/biometric/BiometricAuth.kt
@@ -1,5 +1,6 @@
-package com.afternote.feature.afternote.presentation.shared.fingerprint
+package com.afternote.core.common.biometric
 
+import android.os.Build
 import android.util.Log
 import androidx.biometric.BiometricManager
 import androidx.biometric.BiometricManager.Authenticators.BIOMETRIC_STRONG
@@ -7,21 +8,19 @@ import androidx.biometric.BiometricManager.Authenticators.DEVICE_CREDENTIAL
 import androidx.biometric.BiometricPrompt
 import androidx.core.content.ContextCompat
 import androidx.fragment.app.FragmentActivity
-import com.afternote.core.common.biometric.confirmWithCryptoOperation
-import com.afternote.core.common.biometric.createBiometricCryptoObject
-import com.afternote.core.common.biometric.isBiometricCryptoSupported
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.suspendCancellableCoroutine
 import kotlinx.coroutines.withContext
 import kotlin.coroutines.resume
 
-internal const val LOG_TAG = "FingerprintLogin"
+private const val LOG_TAG = "BiometricAuth"
 
 /**
  * 생체 인식 프롬프트에 노출할 상황별 문구.
  * `stringResource`로 해석된 값이 필요하므로 Composable에서 빌드해 주입한다.
+ * 문구는 소비 feature 마다 다르므로 core 는 값을 정하지 않고 호출 측이 넘긴다.
  */
-data class BiometricMessages(
+public data class BiometricMessages(
     val initFailed: String,
     val noHardware: String,
     val noneEnrolled: String,
@@ -36,12 +35,12 @@ data class BiometricMessages(
  * UI 레이어에서 단방향으로 흘려 성공·취소·오류를 명시적으로 분기한다.
  * 취소는 오류로 노출하지 않도록 별도 타입으로 정의한다.
  */
-sealed interface BiometricAuthResult {
-    data object Success : BiometricAuthResult
+public sealed interface BiometricAuthResult {
+    public data object Success : BiometricAuthResult
 
-    data object Canceled : BiometricAuthResult
+    public data object Canceled : BiometricAuthResult
 
-    data class Error(
+    public data class Error(
         val message: String,
     ) : BiometricAuthResult
 }
@@ -57,10 +56,12 @@ sealed interface BiometricAuthResult {
  *   `MainActivity`는 반드시 `FragmentActivity`(또는 `AppCompatActivity`)를 상속해야 한다.
  * - [BiometricPrompt]는 UI 컴포넌트이므로 본문을 [Dispatchers.Main.immediate]에서 실행해,
  *   호출 코루틴이 백그라운드 디스패처에 있어도 초기화·실행이 메인 스레드로 수렴하도록 한다.
- * - 성공은 콜백의 boolean 이 아니라 [confirmWithCryptoOperation] 의 암호 연산 성사로 확정한다.
- *   프롬프트를 거치지 않고 성공 콜백만 가로챈 경우 사용자 인증에 묶인 키를 쓸 수 없어 연산이 실패한다.
+ * - 성공 콜백의 cipher는 [confirmWithCryptoOperation]으로 연산을 검증한다.
+ *   API 30 이상에서 앱 소유 CryptoObject를 준비한 경우에는 사용자 인증에 묶인 키이므로
+ *   인증 없이 성공 콜백만 가로채 호출하면 연산이 실패한다. AndroidX의 내부 cipher에는
+ *   이 인증 결합을 가정하지 않으며, 플랫폼 프롬프트의 강한 생체 인증 결과를 따른다.
  */
-suspend fun FragmentActivity.authenticateBiometric(
+public suspend fun FragmentActivity.authenticateBiometric(
     title: String,
     subtitle: String,
     messages: BiometricMessages,
@@ -68,12 +69,15 @@ suspend fun FragmentActivity.authenticateBiometric(
     withContext(Dispatchers.Main.immediate) {
         suspendCancellableCoroutine { continuation ->
             val biometricManager = BiometricManager.from(this@authenticateBiometric)
-            val authenticators = BIOMETRIC_STRONG or DEVICE_CREDENTIAL
+            // Android 9·10은 STRONG과 기기 자격의 조합을 지원하지 않는다.
+            // 강도를 낮추지 않고 이 두 버전에서만 생체 인증을 단독 사용한다.
+            val biometricOnly = Build.VERSION.SDK_INT in Build.VERSION_CODES.P..Build.VERSION_CODES.Q
+            val authenticators = if (biometricOnly) BIOMETRIC_STRONG else BIOMETRIC_STRONG or DEVICE_CREDENTIAL
 
             when (biometricManager.canAuthenticate(authenticators)) {
                 BiometricManager.BIOMETRIC_SUCCESS -> {
-                    // API 26~29 에서는 DEVICE_CREDENTIAL 허용자와 CryptoObject 를 함께 쓸 수 없다.
-                    // 이때는 관문 없이 인증하고, 성공 확정은 cipher 부재로 통과시킨다.
+                    // 앱 소유 CryptoObject는 기존 API 30 이상 정책을 유지한다.
+                    // API 28~29의 STRONG 강제는 AndroidX 프롬프트가 담당한다.
                     val cryptoObject = if (isBiometricCryptoSupported) createBiometricCryptoObject() else null
 
                     val promptInfo =
@@ -82,7 +86,11 @@ suspend fun FragmentActivity.authenticateBiometric(
                             .setTitle(title)
                             .setSubtitle(subtitle)
                             .setAllowedAuthenticators(authenticators)
-                            .build()
+                            .apply {
+                                if (biometricOnly) {
+                                    setNegativeButtonText(getString(android.R.string.cancel))
+                                }
+                            }.build()
 
                     val biometricPrompt =
                         BiometricPrompt(
diff --git a/core/common/src/main/kotlin/com/afternote/core/common/biometric/BiometricCryptoGate.kt b/core/common/src/main/kotlin/com/afternote/core/common/biometric/BiometricCryptoGate.kt
index 9688a5db95..8a54b27f8b 100644
--- a/core/common/src/main/kotlin/com/afternote/core/common/biometric/BiometricCryptoGate.kt
+++ b/core/common/src/main/kotlin/com/afternote/core/common/biometric/BiometricCryptoGate.kt
@@ -25,15 +25,16 @@ private val TRANSFORMATION =
 private val CRYPTO_CHALLENGE = "afternote-biometric-gate".toByteArray()
 
 /**
- * `CryptoObject` 를 동반한 인증이 가능한 API 레벨인지.
+ * 앱 소유 `CryptoObject` 를 동반하는 인증 경로인지.
  *
- * `androidx.biometric` 1.1.0 의 `authenticate(promptInfo, cryptoObject)` 는 허용자에
+ * `androidx.biometric` 의 `authenticate(promptInfo, cryptoObject)` 는 허용자에
  * `DEVICE_CREDENTIAL` 이 포함된 채 API 30 미만이면 다음 메시지로 `IllegalArgumentException` 을 던진다.
  *
  * > Crypto-based authentication is not supported for device credential prior to API 30.
  *
- * minSdk 는 26 이고 기기 잠금(PIN·패턴)만 등록한 사용자를 막지 않는 것이 현 정책이므로,
- * API 26~29 에서는 허용자 조합을 유지한 채 `CryptoObject` 없이 인증한다.
+ * API 26~27은 기존 기기 자격 폴백을 유지한다. API 28~29는 강한 생체 인증만 허용하며
+ * 강도 제한에 필요한 내부 CryptoObject는 AndroidX가 준비한다.
+ * 앱 소유 CryptoObject의 사용 범위는 기존과 같이 API 30 이상으로 유지한다.
  */
 val isBiometricCryptoSupported: Boolean
     get() = Build.VERSION.SDK_INT >= Build.VERSION_CODES.R
@@ -51,13 +52,15 @@ fun createBiometricCryptoObject(): BiometricPrompt.CryptoObject? =
         .getOrNull()
 
 /**
- * 인증 성공 콜백이 받은 [cipher] 로 실제 암호 연산을 수행해 인증을 확정한다.
+ * 인증 성공 콜백이 받은 [cipher] 로 실제 암호 연산이 가능한지 검증한다.
  *
- * 키가 `setUserAuthenticationRequired(true)` 로 만들어져 있어, 프롬프트를 거치지 않은 채
- * 성공 콜백만 가로채 호출한 경우에는 이 연산이 `UserNotAuthenticatedException` 으로 실패한다.
- * 즉 성패 boolean 이 아니라 암호 연산의 성사 여부가 인증의 근거가 된다.
+ * [createBiometricCryptoObject]의 앱 소유 키는 `setUserAuthenticationRequired(true)`로
+ * 만들어져 있어, 프롬프트를 거치지 않고 성공 콜백만 가로채 호출하면 이 연산이 실패한다.
+ * AndroidX가 강도 제한을 위해 준비하는 내부 cipher는 사용자 인증에 묶인 키가 아니므로
+ * 같은 연산을 수행하더라도 그 연산 자체를 사용자 인증의 추가 증거로 간주하지 않는다.
  *
- * [cipher] 가 null 인 경로(API 26~29 폴백)는 검증할 대상이 없으므로 통과시킨다.
+ * [cipher] 가 null 인 폴백은 검증할 대상이 없으므로 통과시킨다.
+ * API 30 미만에도 AndroidX가 내부 cipher를 반환하면 동일한 암호 연산으로 검증한다.
  * 실패 원인을 호출 측이 기록할 수 있도록 예외를 삼키지 않고 [Result] 로 실어 보낸다.
  *
  * **거부는 `UserNotAuthenticatedException` 으로 오지 않는다.** API 35 실측(2026-08-26)에서
diff --git a/core/common/src/main/kotlin/com/afternote/core/common/result/RunCatchingCancellable.kt b/core/common/src/main/kotlin/com/afternote/core/common/result/RunCatchingCancellable.kt
index 78cb4ec12c..94347f6983 100644
--- a/core/common/src/main/kotlin/com/afternote/core/common/result/RunCatchingCancellable.kt
+++ b/core/common/src/main/kotlin/com/afternote/core/common/result/RunCatchingCancellable.kt
@@ -1,32 +1,17 @@
 package com.afternote.core.common.result
 
-import kotlin.coroutines.cancellation.CancellationException
+import com.afternote.core.domain.result.runCatchingCancellable as domainRunCatchingCancellable
 
 /**
- * suspend 호출을 감싸 [Result] 로 돌려주되, [CancellationException] 만은 삼키지 않고 다시 던진다.
- *
- * suspend 경계에서 stdlib `runCatching` 을 쓰면 안 되는 이유 — 그 함수는 "catching any Throwable"
- * 이라(https://kotlinlang.org/api/core/kotlin-stdlib/kotlin/run-catching.html) 코루틴 취소까지
- * `Result.failure` 로 바꾼다. 그러면 취소가 상위로 전파되지 못하고, 이미 취소된 코루틴에서 호출부의
- * `onFailure` 갈래(UI 상태 갱신·스낵바 안내 등)가 실행된다.
- *
- * Android 코루틴 모범 사례가 이 소비를 직접 금지한다 — "To enable coroutine cancellation, don't
- * consume exceptions of type CancellationException (don't catch them, or always rethrow them if
- * caught)" (https://developer.android.com/kotlin/coroutines/coroutines-best-practices).
- *
- * 같은 역할을 stdlib 이 제공하지 않아 여기 둔다: cancellation-aware `runCatching` 요청은
- * kotlinx.coroutines #1814 로 2020-02-18 에 올라와 아직 열려 있다
- * (https://github.com/Kotlin/kotlinx.coroutines/issues/1814).
- *
- * 쓰는 자리는 suspend 를 감싸는 경계다. 취소가 없는 동기 코드에는 stdlib `runCatching` 을 그대로
- * 쓴다 — `inline` 이라 동기 코드에서도 호출은 되지만(그 경우 stdlib 과 동작이 같다) 이름값을 하지
- * 못한다.
+ * 정본은 [com.afternote.core.domain.result.runCatchingCancellable] 이다. feature domain UseCase 도 쓸 수
+ * 있도록 JVM 모듈로 옮겼고, 기존 호출처가 바뀌지 않도록 이 자리는 위임만 남긴다.
  */
-inline fun <T> runCatchingCancellable(block: () -> T): Result<T> =
-    try {
-        Result.success(block())
-    } catch (e: CancellationException) {
-        throw e
-    } catch (e: Throwable) {
-        Result.failure(e)
-    }
+@Deprecated(
+    message = "core:domain 으로 옮겼다. com.afternote.core.domain.result.runCatchingCancellable 을 쓴다.",
+    replaceWith =
+        ReplaceWith(
+            expression = "runCatchingCancellable(block)",
+            imports = ["com.afternote.core.domain.result.runCatchingCancellable"],
+        ),
+)
+inline fun <T> runCatchingCancellable(block: () -> T): Result<T> = domainRunCatchingCancellable(block)
diff --git a/core/data/src/main/java/com/afternote/core/data/di/CoreReceiverInvitationModule.kt b/core/data/src/main/java/com/afternote/core/data/di/CoreReceiverInvitationModule.kt
new file mode 100644
index 0000000000..c211b3010b
--- /dev/null
+++ b/core/data/src/main/java/com/afternote/core/data/di/CoreReceiverInvitationModule.kt
@@ -0,0 +1,23 @@
+package com.afternote.core.data.di
+
+import com.afternote.core.data.repoimpl.invitation.PendingReceiverInvitationStoreImpl
+import com.afternote.core.data.repoimpl.invitation.ReceiverInvitationRepositoryImpl
+import com.afternote.core.domain.repository.PendingReceiverInvitationStore
+import com.afternote.core.domain.repository.ReceiverInvitationRepository
+import dagger.Binds
+import dagger.Module
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
+
+/** 카카오톡 수신자 초대 계약 바인딩 (#944). */
+@Module
+@InstallIn(SingletonComponent::class)
+internal interface CoreReceiverInvitationModule {
+    @Binds
+    fun bindReceiverInvitationRepository(impl: ReceiverInvitationRepositoryImpl): ReceiverInvitationRepository
+
+    @Binds
+    @Singleton
+    fun bindPendingReceiverInvitationStore(impl: PendingReceiverInvitationStoreImpl): PendingReceiverInvitationStore
+}
diff --git a/core/data/src/main/java/com/afternote/core/data/mapper/auth/AuthMapper.kt b/core/data/src/main/java/com/afternote/core/data/mapper/auth/AuthMapper.kt
index 7e98186f76..85e7d15171 100644
--- a/core/data/src/main/java/com/afternote/core/data/mapper/auth/AuthMapper.kt
+++ b/core/data/src/main/java/com/afternote/core/data/mapper/auth/AuthMapper.kt
@@ -9,27 +9,25 @@ import com.afternote.core.network.dto.LoginDto
 import com.afternote.core.network.dto.ReissueDto
 import com.afternote.core.network.dto.SignUpDto
 
-/**
+/*
  * Auth DTO를 Domain 모델로 변환. (스웨거 기준)
  */
-object AuthMapper {
-    fun toSignUpResult(dto: SignUpDto): AccountRegistration = AccountRegistration(userId = dto.userId, email = dto.email)
 
-    fun toFoundAccount(dto: EmailFindDto): FoundAccount = FoundAccount(name = dto.name, email = dto.email)
+internal fun SignUpDto.toDomain(): AccountRegistration = AccountRegistration(userId = userId, email = email)
 
-    fun toDefaultLoginResult(dto: LoginDto.DefaultLoginDto): Session.DefaultSession =
-        Session.DefaultSession(
-            accessToken = dto.accessToken,
-            refreshToken = dto.refreshToken,
-        )
+internal fun EmailFindDto.toDomain(): FoundAccount = FoundAccount(name = name, email = email)
 
-    fun toSocialLoginResult(dto: LoginDto.SocialLoginDto): Session.SocialSession =
-        Session.SocialSession(
-            accessToken = dto.accessToken,
-            refreshToken = dto.refreshToken,
-            isNewUser = dto.isNewUser,
-        )
+internal fun LoginDto.DefaultLoginDto.toDomain(): Session.DefaultSession =
+    Session.DefaultSession(
+        accessToken = accessToken,
+        refreshToken = refreshToken,
+    )
 
-    fun toRotateTokenResult(dto: ReissueDto): TokenBundle =
-        TokenBundle(accessToken = dto.accessToken, refreshToken = dto.refreshToken, expiresIn = dto.expiresIn)
-}
+internal fun LoginDto.SocialLoginDto.toDomain(): Session.SocialSession =
+    Session.SocialSession(
+        accessToken = accessToken,
+        refreshToken = refreshToken,
+        isNewUser = isNewUser,
+    )
+
+internal fun ReissueDto.toDomain(): TokenBundle = TokenBundle(accessToken = accessToken, refreshToken = refreshToken, expiresIn = expiresIn)
diff --git a/core/data/src/main/java/com/afternote/core/data/repoimpl/PhotoUploadRepositoryImpl.kt b/core/data/src/main/java/com/afternote/core/data/repoimpl/PhotoUploadRepositoryImpl.kt
index 55222618f6..5509bad081 100644
--- a/core/data/src/main/java/com/afternote/core/data/repoimpl/PhotoUploadRepositoryImpl.kt
+++ b/core/data/src/main/java/com/afternote/core/data/repoimpl/PhotoUploadRepositoryImpl.kt
@@ -4,9 +4,9 @@ import android.content.Context
 import android.webkit.MimeTypeMap
 import androidx.core.net.toUri
 import com.afternote.core.common.di.IoDispatcher
-import com.afternote.core.common.result.runCatchingCancellable
 import com.afternote.core.domain.model.UploadedFile
 import com.afternote.core.domain.repository.PhotoUploadRepository
+import com.afternote.core.domain.result.runCatchingCancellable
 import com.afternote.core.network.dto.PresignedUrlRequestDto
 import com.afternote.core.network.model.requireData
 import com.afternote.core.network.service.ImageApiService
diff --git a/core/data/src/main/java/com/afternote/core/data/repoimpl/UserReceiverRepositoryImpl.kt b/core/data/src/main/java/com/afternote/core/data/repoimpl/UserReceiverRepositoryImpl.kt
index 944efe020c..ed785a0346 100644
--- a/core/data/src/main/java/com/afternote/core/data/repoimpl/UserReceiverRepositoryImpl.kt
+++ b/core/data/src/main/java/com/afternote/core/data/repoimpl/UserReceiverRepositoryImpl.kt
@@ -1,13 +1,13 @@
 package com.afternote.core.data.repoimpl
 
 import com.afternote.core.common.reporting.ErrorReporter
-import com.afternote.core.common.result.runCatchingCancellable
 import com.afternote.core.data.mapper.delivery.toRequestDto
 import com.afternote.core.data.mapper.user.toDomain
 import com.afternote.core.datastore.TokenDataSource
 import com.afternote.core.domain.error.ReceiverRequestRejectedException
 import com.afternote.core.domain.model.ReceiverListState
 import com.afternote.core.domain.repository.UserReceiverRepository
+import com.afternote.core.domain.result.runCatchingCancellable
 import com.afternote.core.model.delivery.DeliveryConditionItem
 import com.afternote.core.model.delivery.ReceiverDeliveryConditions
 import com.afternote.core.model.user.Receiver
diff --git a/core/data/src/main/java/com/afternote/core/data/repoimpl/VideoUploadRepositoryImpl.kt b/core/data/src/main/java/com/afternote/core/data/repoimpl/VideoUploadRepositoryImpl.kt
index 1a3c5f724c..9483dc9588 100644
--- a/core/data/src/main/java/com/afternote/core/data/repoimpl/VideoUploadRepositoryImpl.kt
+++ b/core/data/src/main/java/com/afternote/core/data/repoimpl/VideoUploadRepositoryImpl.kt
@@ -4,9 +4,9 @@ import android.content.Context
 import android.net.Uri
 import androidx.core.net.toUri
 import com.afternote.core.common.di.IoDispatcher
-import com.afternote.core.common.result.runCatchingCancellable
 import com.afternote.core.domain.model.UploadedFile
 import com.afternote.core.domain.repository.VideoUploadRepository
+import com.afternote.core.domain.result.runCatchingCancellable
 import com.afternote.core.network.dto.PresignedUrlRequestDto
 import com.afternote.core.network.model.requireData
 import com.afternote.core.network.service.ImageApiService
diff --git a/core/data/src/main/java/com/afternote/core/data/repoimpl/account/AccountRepositoryImpl.kt b/core/data/src/main/java/com/afternote/core/data/repoimpl/account/AccountRepositoryImpl.kt
index 7108fce92e..8e98177639 100644
--- a/core/data/src/main/java/com/afternote/core/data/repoimpl/account/AccountRepositoryImpl.kt
+++ b/core/data/src/main/java/com/afternote/core/data/repoimpl/account/AccountRepositoryImpl.kt
@@ -1,8 +1,8 @@
 package com.afternote.core.data.repoimpl.account
 
-import com.afternote.core.common.result.runCatchingCancellable
-import com.afternote.core.data.mapper.auth.AuthMapper
+import com.afternote.core.data.mapper.auth.toDomain
 import com.afternote.core.domain.repository.account.AccountRepository
+import com.afternote.core.domain.result.runCatchingCancellable
 import com.afternote.core.model.AccountRegistration
 import com.afternote.core.model.FoundAccount
 import com.afternote.core.network.dto.EmailFindRequestDto
@@ -62,7 +62,7 @@ internal class AccountRepositoryImpl
                             certificateCode,
                         ),
                     )
-                AuthMapper.toFoundAccount(response.requireData())
+                response.requireData().toDomain()
             }.mapAccountFailure()
 
         override suspend fun resetPassword(
@@ -99,7 +99,7 @@ internal class AccountRepositoryImpl
                             profileUrl,
                         ),
                     )
-                AuthMapper.toSignUpResult(response.requireData())
+                response.requireData().toDomain()
             }.mapAccountFailure()
 
         override suspend fun passwordChange(
diff --git a/core/data/src/main/java/com/afternote/core/data/repoimpl/appversion/AppVersionRepositoryImpl.kt b/core/data/src/main/java/com/afternote/core/data/repoimpl/appversion/AppVersionRepositoryImpl.kt
index 08e9f297cd..3f1243525b 100644
--- a/core/data/src/main/java/com/afternote/core/data/repoimpl/appversion/AppVersionRepositoryImpl.kt
+++ b/core/data/src/main/java/com/afternote/core/data/repoimpl/appversion/AppVersionRepositoryImpl.kt
@@ -1,7 +1,7 @@
 package com.afternote.core.data.repoimpl.appversion
 
-import com.afternote.core.common.result.runCatchingCancellable
 import com.afternote.core.domain.repository.appversion.AppVersionRepository
+import com.afternote.core.domain.result.runCatchingCancellable
 import com.afternote.core.model.appversion.AppVersionCheck
 import com.afternote.core.network.dto.AppPlatformDto
 import com.afternote.core.network.model.requireData
diff --git a/core/data/src/main/java/com/afternote/core/data/repoimpl/auth/AuthRepositoryImpl.kt b/core/data/src/main/java/com/afternote/core/data/repoimpl/auth/AuthRepositoryImpl.kt
index dbdf296cf9..5883365199 100644
--- a/core/data/src/main/java/com/afternote/core/data/repoimpl/auth/AuthRepositoryImpl.kt
+++ b/core/data/src/main/java/com/afternote/core/data/repoimpl/auth/AuthRepositoryImpl.kt
@@ -1,13 +1,14 @@
 package com.afternote.core.data.repoimpl.auth
 
-import com.afternote.core.common.result.runCatchingCancellable
-import com.afternote.core.data.mapper.auth.AuthMapper
+import com.afternote.core.data.mapper.auth.toDomain
 import com.afternote.core.datastore.LocalStoreRegistry
 import com.afternote.core.datastore.StoreScope
 import com.afternote.core.datastore.TokenDataSource
+import com.afternote.core.domain.error.SessionChangedException
 import com.afternote.core.domain.push.DevicePushTargetProvider
 import com.afternote.core.domain.repository.auth.AuthRepository
 import com.afternote.core.domain.repository.push.PushTargetRepository
+import com.afternote.core.domain.result.runCatchingCancellable
 import com.afternote.core.model.Session
 import com.afternote.core.model.TokenBundle
 import com.afternote.core.network.dto.LoginRequestDto
@@ -18,7 +19,9 @@ import com.afternote.core.network.model.requireData
 import com.afternote.core.network.service.AuthApiService
 import com.afternote.core.network.service.TokenApiService
 import com.afternote.core.network.token.AccessTokenExpiryTracker
+import kotlinx.coroutines.NonCancellable
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.withContext
 import javax.inject.Inject
 
 internal class AuthRepositoryImpl
@@ -43,6 +46,22 @@ internal class AuthRepositoryImpl
                 expiryTracker.clear()
             }
 
+        /**
+         * 토큰 저장소의 대조·정리를 먼저 한 번의 쓰기로 끝내고, 정리됐을 때만 나머지 SESSION 저장소와 deadline 을
+         * 비운다. 대조가 어긋났다면 그 저장소와 deadline 은 새 세션의 것이다 (#2238).
+         */
+        override suspend fun clearSessionIfCurrent(sessionId: String) =
+            runCatchingCancellable {
+                val cleared = tokenDataSource.clearIfSession(sessionId)
+                if (cleared) {
+                    localStoreRegistry.clearScope(StoreScope.SESSION)
+                    expiryTracker.clear()
+                }
+                cleared
+            }
+
+        override suspend fun getSessionId() = runCatchingCancellable { tokenDataSource.currentSessionId() }
+
         override suspend fun getAccessToken() = runCatchingCancellable { tokenDataSource.getAccessToken() }
 
         override suspend fun getRefreshToken() = runCatchingCancellable { tokenDataSource.getRefreshToken() }
@@ -77,7 +96,7 @@ internal class AuthRepositoryImpl
             runCatchingCancellable {
                 val data = authApiService.login(LoginRequestDto(email, password)).requireData()
                 recordIssuedExpiresIn(data.expiresIn)
-                AuthMapper.toDefaultLoginResult(data)
+                data.toDomain()
             }.mapLoginFailure()
 
         override suspend fun kakaoLogin(oauthToken: String): Result<Session.SocialSession> =
@@ -91,7 +110,7 @@ internal class AuthRepositoryImpl
                             ),
                         ).requireData()
                 recordIssuedExpiresIn(data.expiresIn)
-                AuthMapper.toSocialLoginResult(data)
+                data.toDomain()
             }.mapLoginFailure()
 
         override suspend fun googleLogin(idToken: String): Result<Session.SocialSession> =
@@ -105,45 +124,70 @@ internal class AuthRepositoryImpl
                             ),
                         ).requireData()
                 recordIssuedExpiresIn(data.expiresIn)
-                AuthMapper.toSocialLoginResult(data)
+                data.toDomain()
             }.mapLoginFailure()
 
-        override suspend fun rotateToken(): Result<TokenBundle> =
+        /**
+         * 재발급 HTTP 가 떠 있는 동안 로그아웃이나 새 로그인이 끝날 수 있다(둘 다 재발급 락 밖이다). 그래서
+         * 리프레시 토큰은 [sessionId] 세션의 것만 읽고, 응답은 그 세션이 아직 저장돼 있을 때만 쓴다 (#2237).
+         * 쓰지 못한 회전은 성공으로 돌려주지 않는다. 호출자가 그 토큰으로 deadline 을 기록하거나 재시도하면 안 된다.
+         */
+        override suspend fun rotateToken(sessionId: String): Result<TokenBundle> =
             runCatchingCancellable {
                 val refreshToken =
-                    getRefreshToken().getOrNull()
-                        ?: error("리프레시 토큰이 존재하지 않습니다.")
+                    tokenDataSource.refreshTokenOf(sessionId)
+                        ?: throw missingRefreshFailure(sessionId)
                 val response = tokenApiService.reissue(ReissueRequestDto(refreshToken))
-                val tokenBundleResult = AuthMapper.toRotateTokenResult(response.requireData())
+                val tokenBundleResult = response.requireData().toDomain()
                 check(tokenBundleResult.accessToken.isNotEmpty()) {
                     "Token rotation returned an empty access token"
                 }
-                updateTokens(
-                    accessToken = tokenBundleResult.accessToken,
-                    refreshToken = tokenBundleResult.refreshToken,
-                ).getOrThrow()
+                val applied =
+                    tokenDataSource.updateTokensIfSession(
+                        expectedSessionId = sessionId,
+                        accessToken = tokenBundleResult.accessToken,
+                        refreshToken = tokenBundleResult.refreshToken,
+                    )
+                if (!applied) throw SessionChangedException()
                 tokenBundleResult
             }
 
+        private suspend fun missingRefreshFailure(sessionId: String): Exception =
+            if (tokenDataSource.currentSessionId() == sessionId) {
+                IllegalStateException("리프레시 토큰이 존재하지 않습니다.")
+            } else {
+                SessionChangedException()
+            }
+
         /**
          * 서버 로그아웃은 best-effort (네트워크 실패해도 사용자는 로그아웃 상태로 가야 함).
          * SESSION 스코프 로컬 저장소와 선제 reissue deadline 은 서버 호출 결과와 무관하게 항상 정리한다.
+         *
+         * 호출자가 취소돼도 로컬 정리는 끝낸다 (#2243). 서버는 요청을 받은 순간 refresh 를 지우는데
+         * 클라이언트의 취소는 서버에 전달되지 않으므로, 호출 화면이 응답 전에 사라졌다고 로컬 세션을
+         * 남기면 앱만 로그인 상태로 남는다. 정리를 마친 뒤 취소는 그대로 다시 던진다.
          */
         override suspend fun logout(): Result<Unit> =
             runCatchingCancellable {
-                // 푸시 대상 해제가 먼저다 — 이 요청도 액세스 토큰을 달고 나가므로 세션이 살아 있어야 한다.
-                // 실패해도 로그아웃은 진행한다(best-effort). 남은 등록은 서버가 다음 발송 실패로 정리한다.
-                unregisterDevicePushTarget()
+                try {
+                    // 푸시 대상 해제가 먼저다. 이 요청도 액세스 토큰을 달고 나가므로 세션이 살아 있어야 한다.
+                    // 실패해도 로그아웃은 진행한다(best-effort). 남은 등록은 서버가 다음 발송 실패로 정리한다.
+                    unregisterDevicePushTarget()
 
-                val refreshToken = getRefreshToken().getOrNull()
-                if (refreshToken != null) {
-                    runCatchingCancellable { authApiService.logout(LogoutRequestDto(refreshToken)) }
+                    val refreshToken = getRefreshToken().getOrNull()
+                    if (refreshToken != null) {
+                        runCatchingCancellable { authApiService.logout(LogoutRequestDto(refreshToken)) }
+                    }
+                } finally {
+                    // 두 정리 모두 반드시 위 API 호출 뒤여야 한다. 로그아웃 HTTP 요청도 AuthInterceptor 를
+                    // 지나므로 그 시점엔 토큰이 살아 있어야 하고, 토큰이 만료 임박이면 요청 직전 선제 reissue 가
+                    // tracker 에 새 deadline 을 기록할 수 있어 tracker 를 먼저 비우면 그 기록이 되살아난다.
+                    // 취소된 코루틴에서도 suspend 정리가 돌도록 NonCancellable 로 감싼다.
+                    withContext(NonCancellable) {
+                        localStoreRegistry.clearScope(StoreScope.SESSION)
+                        expiryTracker.clear()
+                    }
                 }
-                // 두 정리 모두 반드시 위 API 호출 뒤여야 한다. 로그아웃 HTTP 요청도 AuthInterceptor 를
-                // 지나므로 그 시점엔 토큰이 살아 있어야 하고, 토큰이 만료 임박이면 요청 직전 선제 reissue 가
-                // tracker 에 새 deadline 을 기록할 수 있다 — tracker 를 먼저 비우면 그 기록이 되살아난다.
-                localStoreRegistry.clearScope(StoreScope.SESSION)
-                expiryTracker.clear()
             }
 
         /**
diff --git a/core/data/src/main/java/com/afternote/core/data/repoimpl/auth/LoginFailureTranslation.kt b/core/data/src/main/java/com/afternote/core/data/repoimpl/auth/LoginFailureTranslation.kt
index 5c82dbda1b..3bb0de07cf 100644
--- a/core/data/src/main/java/com/afternote/core/data/repoimpl/auth/LoginFailureTranslation.kt
+++ b/core/data/src/main/java/com/afternote/core/data/repoimpl/auth/LoginFailureTranslation.kt
@@ -1,7 +1,7 @@
 package com.afternote.core.data.repoimpl.auth
 
-import com.afternote.core.common.result.runCatchingCancellable
 import com.afternote.core.domain.error.CoreAuthFailure
+import com.afternote.core.domain.result.runCatchingCancellable
 import com.afternote.core.network.model.ApiException
 import java.io.IOException
 
diff --git a/core/data/src/main/java/com/afternote/core/data/repoimpl/invitation/PendingReceiverInvitationStoreImpl.kt b/core/data/src/main/java/com/afternote/core/data/repoimpl/invitation/PendingReceiverInvitationStoreImpl.kt
new file mode 100644
index 0000000000..657b4d22ad
--- /dev/null
+++ b/core/data/src/main/java/com/afternote/core/data/repoimpl/invitation/PendingReceiverInvitationStoreImpl.kt
@@ -0,0 +1,19 @@
+package com.afternote.core.data.repoimpl.invitation
+
+import com.afternote.core.datastore.ReceiverInvitationDataSource
+import com.afternote.core.domain.repository.PendingReceiverInvitationStore
+import kotlinx.coroutines.flow.Flow
+import javax.inject.Inject
+
+/** [PendingReceiverInvitationStore] 구현 — 기기 수명 DataStore 에 위임한다 (#944). */
+internal class PendingReceiverInvitationStoreImpl
+    @Inject
+    constructor(
+        private val dataSource: ReceiverInvitationDataSource,
+    ) : PendingReceiverInvitationStore {
+        override val pendingToken: Flow<String?> get() = dataSource.pendingTokenFlow
+
+        override suspend fun save(token: String) = dataSource.savePendingToken(token)
+
+        override suspend fun clear() = dataSource.clearPendingToken()
+    }
diff --git a/core/data/src/main/java/com/afternote/core/data/repoimpl/invitation/ReceiverInvitationFailureTranslation.kt b/core/data/src/main/java/com/afternote/core/data/repoimpl/invitation/ReceiverInvitationFailureTranslation.kt
new file mode 100644
index 0000000000..cd9396ecb8
--- /dev/null
+++ b/core/data/src/main/java/com/afternote/core/data/repoimpl/invitation/ReceiverInvitationFailureTranslation.kt
@@ -0,0 +1,50 @@
+package com.afternote.core.data.repoimpl.invitation
+
+import com.afternote.core.domain.error.ReceiverInvitationFailure
+import com.afternote.core.network.model.ApiException
+import java.io.IOException
+
+/**
+ * 초대 API 실패를 [ReceiverInvitationFailure] 로 옮긴다 (#944).
+ *
+ * BE `ErrorCode` 번호를 아는 것은 이 파일까지다. 판정 순서 —
+ * 1. [IOException] — 서버에 닿지 못했다. 재시도 가능.
+ * 2. 5xx — 등재 code 여도 장애다. 재시도 가능.
+ * 3. 등재 code — code 만으로 사유가 확정된다. 서버 문구는 쓰지 않는다.
+ * 4. 그 밖의 4xx — 사유 미확정, 재시도해도 같은 거절이라 재시도 불가로 둔다.
+ *
+ * 취소는 여기 오지 않는다 — 호출부의 `runCatchingCancellable` 이 먼저 되던진다.
+ */
+internal fun <T> Result<T>.mapReceiverInvitationFailure(): Result<T> {
+    val original = exceptionOrNull() ?: return this
+    return Result.failure(original.toReceiverInvitationFailure())
+}
+
+private fun Throwable.toReceiverInvitationFailure(): ReceiverInvitationFailure =
+    when (this) {
+        is ReceiverInvitationFailure -> this
+        is IOException -> ReceiverInvitationFailure.Other(this, isRetryable = true)
+        is ApiException -> toServerFailure()
+        else -> ReceiverInvitationFailure.Other(this, isRetryable = false)
+    }
+
+private fun ApiException.toServerFailure(): ReceiverInvitationFailure =
+    when {
+        status >= SERVER_ERROR_STATUS_MIN -> ReceiverInvitationFailure.Other(this, isRetryable = true)
+        code == CODE_UNAUTHENTICATED -> ReceiverInvitationFailure.Unauthenticated(this)
+        code == CODE_INVITATION_NOT_FOUND -> ReceiverInvitationFailure.NotFound(this)
+        code == CODE_INVITATION_EXPIRED -> ReceiverInvitationFailure.Expired(this)
+        code == CODE_INVITATION_ACCEPTED_BY_OTHER -> ReceiverInvitationFailure.AcceptedByOther(this)
+        code == CODE_INVITATION_SELF_ACCEPT -> ReceiverInvitationFailure.SelfAccept(this)
+        code == CODE_RECEIVER_ALREADY_REGISTERED -> ReceiverInvitationFailure.AlreadyRegistered(this)
+        else -> ReceiverInvitationFailure.Other(this, isRetryable = false)
+    }
+
+private const val SERVER_ERROR_STATUS_MIN = 500
+
+private const val CODE_UNAUTHENTICATED = 1000
+private const val CODE_INVITATION_NOT_FOUND = 1905
+private const val CODE_INVITATION_EXPIRED = 1906
+private const val CODE_INVITATION_ACCEPTED_BY_OTHER = 1907
+private const val CODE_INVITATION_SELF_ACCEPT = 1908
+private const val CODE_RECEIVER_ALREADY_REGISTERED = 1909
diff --git a/core/data/src/main/java/com/afternote/core/data/repoimpl/invitation/ReceiverInvitationRepositoryImpl.kt b/core/data/src/main/java/com/afternote/core/data/repoimpl/invitation/ReceiverInvitationRepositoryImpl.kt
new file mode 100644
index 0000000000..bf5664ed69
--- /dev/null
+++ b/core/data/src/main/java/com/afternote/core/data/repoimpl/invitation/ReceiverInvitationRepositoryImpl.kt
@@ -0,0 +1,38 @@
+package com.afternote.core.data.repoimpl.invitation
+
+import com.afternote.core.common.result.runCatchingCancellable
+import com.afternote.core.domain.repository.ReceiverInvitationRepository
+import com.afternote.core.model.user.ReceiverInvitationAccepted
+import com.afternote.core.model.user.ReceiverInvitationCreated
+import com.afternote.core.model.user.ReceiverInvitationLookup
+import com.afternote.core.network.model.requireData
+import com.afternote.core.network.service.ReceiverInvitationApiService
+import javax.inject.Inject
+
+/**
+ * [ReceiverInvitationRepository] 구현 (#944).
+ *
+ * 모든 메서드가 `runCatchingCancellable { ... }.mapReceiverInvitationFailure()` 한 형태다 — 번역을
+ * 빠뜨린 endpoint 가 인프라 예외를 그대로 흘리지 않게 한다(`ReceiverAuthRepositoryImpl` 과 같은 규약).
+ */
+internal class ReceiverInvitationRepositoryImpl
+    @Inject
+    constructor(
+        private val api: ReceiverInvitationApiService,
+    ) : ReceiverInvitationRepository {
+        override suspend fun create(): Result<ReceiverInvitationCreated> =
+            runCatchingCancellable {
+                ReceiverInvitationCreated(token = api.createInvitation().requireData().invitationToken)
+            }.mapReceiverInvitationFailure()
+
+        override suspend fun lookup(token: String): Result<ReceiverInvitationLookup> =
+            runCatchingCancellable {
+                val dto = api.getInvitation(token).requireData()
+                ReceiverInvitationLookup(inviterName = dto.inviterName, isExpired = dto.expired)
+            }.mapReceiverInvitationFailure()
+
+        override suspend fun accept(token: String): Result<ReceiverInvitationAccepted> =
+            runCatchingCancellable {
+                ReceiverInvitationAccepted(inviterName = api.acceptInvitation(token).requireData().inviterName)
+            }.mapReceiverInvitationFailure()
+    }
diff --git a/core/data/src/main/java/com/afternote/core/data/repoimpl/push/PushTargetRepositoryImpl.kt b/core/data/src/main/java/com/afternote/core/data/repoimpl/push/PushTargetRepositoryImpl.kt
index 7ef2cea350..22a963b140 100644
--- a/core/data/src/main/java/com/afternote/core/data/repoimpl/push/PushTargetRepositoryImpl.kt
+++ b/core/data/src/main/java/com/afternote/core/data/repoimpl/push/PushTargetRepositoryImpl.kt
@@ -1,7 +1,7 @@
 package com.afternote.core.data.repoimpl.push
 
-import com.afternote.core.common.result.runCatchingCancellable
 import com.afternote.core.domain.repository.push.PushTargetRepository
+import com.afternote.core.domain.result.runCatchingCancellable
 import com.afternote.core.network.dto.DeletePushTokenRequestDto
 import com.afternote.core.network.dto.RegisterPushTokenRequestDto
 import com.afternote.core.network.model.requireStatus
diff --git a/core/data/src/test/java/com/afternote/core/data/mapper/auth/AuthMapperTest.kt b/core/data/src/test/java/com/afternote/core/data/mapper/auth/AuthMapperTest.kt
index d352afa5ee..b7bc808a68 100644
--- a/core/data/src/test/java/com/afternote/core/data/mapper/auth/AuthMapperTest.kt
+++ b/core/data/src/test/java/com/afternote/core/data/mapper/auth/AuthMapperTest.kt
@@ -12,7 +12,7 @@ import org.junit.Assert.assertEquals
 import org.junit.Test
 
 /**
- * [AuthMapper] DTO → Domain 변환 회귀 가드.
+ * Auth DTO → Domain 변환 회귀 가드.
  *
  * 매퍼가 단순 필드 복사라 분기 로직은 없지만, `accessToken` ↔ `refreshToken` 자리 바뀜·필드 누락
  * 같은 사고를 잡는다. 두 토큰엔 서로 다른 sentinel 값을 줘서 자리가 바뀌면 도메인 객체 equals
@@ -20,26 +20,24 @@ import org.junit.Test
  */
 class AuthMapperTest {
     @Test
-    fun `toSignUpResult - userId·email 매핑`() {
-        val result = AuthMapper.toSignUpResult(SignUpDto(userId = 42L, email = "user@example.com"))
+    fun `SignUpDto toDomain - userId·email 매핑`() {
+        val result = SignUpDto(userId = 42L, email = "user@example.com").toDomain()
 
         assertEquals(AccountRegistration(userId = 42L, email = "user@example.com"), result)
     }
 
     @Test
-    fun `toFoundAccount - name·email 매핑 (자리 바뀜 가드)`() {
+    fun `EmailFindDto toDomain - name·email 매핑 (자리 바뀜 가드)`() {
         // 둘 다 String 이라 자리가 바뀌어도 컴파일은 통과한다 — 서로 구분되는 값으로 가드.
-        val result = AuthMapper.toFoundAccount(EmailFindDto(name = "박채연", email = "parkchae01@gmail.com"))
+        val result = EmailFindDto(name = "박채연", email = "parkchae01@gmail.com").toDomain()
 
         assertEquals(FoundAccount(name = "박채연", email = "parkchae01@gmail.com"), result)
     }
 
     @Test
-    fun `toDefaultLoginResult - 토큰 매핑 (자리 바뀜 가드)`() {
+    fun `DefaultLoginDto toDomain - 토큰 매핑 (자리 바뀜 가드)`() {
         val result =
-            AuthMapper.toDefaultLoginResult(
-                LoginDto.DefaultLoginDto(accessToken = "access-1", refreshToken = "refresh-1"),
-            )
+            LoginDto.DefaultLoginDto(accessToken = "access-1", refreshToken = "refresh-1").toDomain()
 
         assertEquals(
             Session.DefaultSession(accessToken = "access-1", refreshToken = "refresh-1"),
@@ -48,18 +46,17 @@ class AuthMapperTest {
     }
 
     @Test
-    fun `toSocialLoginResult - 토큰·isNewUser 매핑`() {
+    fun `SocialLoginDto toDomain - 토큰·isNewUser 매핑`() {
         // isNewUser 는 온보딩 진입을 가르는 값이라 뒤집히면 안 된다 — true/false 왕복 확인(#993).
         // 토큰 자리 바뀜도 같은 케이스에서 객체 비교로 함께 가드.
         listOf(true, false).forEach { newUser ->
             val result =
-                AuthMapper.toSocialLoginResult(
-                    LoginDto.SocialLoginDto(
+                LoginDto
+                    .SocialLoginDto(
                         accessToken = "access-1",
                         refreshToken = "refresh-1",
                         isNewUser = newUser,
-                    ),
-                )
+                    ).toDomain()
 
             assertEquals(
                 "isNewUser=$newUser",
@@ -70,11 +67,9 @@ class AuthMapperTest {
     }
 
     @Test
-    fun `toRotateTokenResult - 토큰·expiresIn 매핑 (자리 바뀜 가드)`() {
+    fun `ReissueDto toDomain - 토큰·expiresIn 매핑 (자리 바뀜 가드)`() {
         val result =
-            AuthMapper.toRotateTokenResult(
-                ReissueDto(accessToken = "access-1", refreshToken = "refresh-1", expiresIn = 3599),
-            )
+            ReissueDto(accessToken = "access-1", refreshToken = "refresh-1", expiresIn = 3599).toDomain()
 
         assertEquals(
             TokenBundle(accessToken = "access-1", refreshToken = "refresh-1", expiresIn = 3599),
diff --git a/core/data/src/test/java/com/afternote/core/data/repoimpl/ReceiverSessionBoundaryRaceTest.kt b/core/data/src/test/java/com/afternote/core/data/repoimpl/ReceiverSessionBoundaryRaceTest.kt
index 5b5f46b51a..daee7b0188 100644
--- a/core/data/src/test/java/com/afternote/core/data/repoimpl/ReceiverSessionBoundaryRaceTest.kt
+++ b/core/data/src/test/java/com/afternote/core/data/repoimpl/ReceiverSessionBoundaryRaceTest.kt
@@ -218,7 +218,7 @@ class ReceiverSessionBoundaryRaceTest {
             try {
                 assertEquals(listOf(ACCOUNT_A_RECEIVER), emissions.receiveNames())
 
-                authRepository.rotateToken().getOrThrow()
+                authRepository.rotateToken(checkNotNull(authRepository.getSessionId().getOrThrow())).getOrThrow()
                 createReceiver(repository, "회전 뒤 등록한 수신자")
 
                 assertEquals(
@@ -264,7 +264,7 @@ class ReceiverSessionBoundaryRaceTest {
                     emissions.receiveNames(),
                 )
 
-                authRepository.rotateToken().getOrThrow()
+                authRepository.rotateToken(checkNotNull(authRepository.getSessionId().getOrThrow())).getOrThrow()
                 createReceiver(repository, "회전 뒤 등록한 수신자")
 
                 assertEquals(
diff --git a/core/data/src/test/java/com/afternote/core/data/repoimpl/UploadFailureTranslationTest.kt b/core/data/src/test/java/com/afternote/core/data/repoimpl/UploadFailureTranslationTest.kt
index 2ee1da15ac..c940ebe405 100644
--- a/core/data/src/test/java/com/afternote/core/data/repoimpl/UploadFailureTranslationTest.kt
+++ b/core/data/src/test/java/com/afternote/core/data/repoimpl/UploadFailureTranslationTest.kt
@@ -1,7 +1,7 @@
 package com.afternote.core.data.repoimpl
 
-import com.afternote.core.common.result.runCatchingCancellable
 import com.afternote.core.domain.error.FileUploadFailure
+import com.afternote.core.domain.result.runCatchingCancellable
 import com.afternote.core.network.model.ApiException
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertSame
diff --git a/core/data/src/test/java/com/afternote/core/data/repoimpl/auth/AuthRepositoryImplTest.kt b/core/data/src/test/java/com/afternote/core/data/repoimpl/auth/AuthRepositoryImplTest.kt
index 13b0360aed..c0f1814473 100644
--- a/core/data/src/test/java/com/afternote/core/data/repoimpl/auth/AuthRepositoryImplTest.kt
+++ b/core/data/src/test/java/com/afternote/core/data/repoimpl/auth/AuthRepositoryImplTest.kt
@@ -20,8 +20,11 @@ import com.afternote.core.network.model.BaseResponse
 import com.afternote.core.network.service.AuthApiService
 import com.afternote.core.network.service.TokenApiService
 import com.afternote.core.network.token.AccessTokenExpiryTracker
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.cancelAndJoin
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
@@ -159,6 +162,63 @@ class AuthRepositoryImplTest {
         assertFalse(tracker.isExpiringSoon())
     }
 
+    @Test
+    fun `logout - 서버 응답을 기다리는 중 호출자가 취소돼도 SESSION 스코프·deadline 정리는 끝낸다`() {
+        runBlocking { tokenDataSource.saveTokens(accessToken = "access", refreshToken = "stored-refresh") }
+        tracker.record(expiresInSeconds = 30)
+        val logoutArrived = CompletableDeferred<Unit>()
+        val serverResponse = CompletableDeferred<BaseResponse<Unit>>()
+        val authApiService =
+            FakeAuthApiService(
+                onLogout = {
+                    logoutArrived.complete(Unit)
+                    serverResponse.await()
+                },
+            )
+        val repository = repository(authApiService)
+
+        runBlocking {
+            // 설정 화면 ViewModel 이 정리되며 viewModelScope 가 취소되는 상황 (#2243).
+            val caller = launch { repository.logout() }
+            logoutArrived.await()
+            caller.cancelAndJoin()
+
+            assertTrue(caller.isCancelled)
+        }
+
+        assertEquals(listOf(StoreScope.SESSION), localStoreRegistry.clearedScopes)
+        assertNull(runBlocking { tokenDataSource.getRefreshToken() })
+        assertFalse(tracker.isExpiringSoon())
+    }
+
+    @Test
+    fun `logout - 푸시 대상 해제를 기다리는 중 호출자가 취소돼도 SESSION 스코프·deadline 정리는 끝낸다`() {
+        runBlocking { tokenDataSource.saveTokens(accessToken = "access", refreshToken = "stored-refresh") }
+        tracker.record(expiresInSeconds = 30)
+        val unregisterArrived = CompletableDeferred<Unit>()
+        val unregisterResponse = CompletableDeferred<Unit>()
+        val pushTargetRepository =
+            FakePushTargetRepository(
+                onUnregister = {
+                    unregisterArrived.complete(Unit)
+                    unregisterResponse.await()
+                },
+            )
+        val repository = repository(pushTargetRepository = pushTargetRepository)
+
+        runBlocking {
+            val caller = launch { repository.logout() }
+            unregisterArrived.await()
+            caller.cancelAndJoin()
+
+            assertTrue(caller.isCancelled)
+        }
+
+        assertEquals(listOf(StoreScope.SESSION), localStoreRegistry.clearedScopes)
+        assertNull(runBlocking { tokenDataSource.getAccessToken() })
+        assertFalse(tracker.isExpiringSoon())
+    }
+
     @Test
     fun `clearSession - SESSION 스코프·deadline 함께 정리 (탈퇴 경로도 이 메서드를 쓴다)`() {
         runBlocking { tokenDataSource.saveTokens(accessToken = "access", refreshToken = "refresh") }
@@ -183,7 +243,9 @@ class AuthRepositoryImplTest {
                     },
             )
 
-        val result = runBlocking { repository.rotateToken() }
+        val sessionId = checkNotNull(runBlocking { tokenDataSource.currentSessionId() })
+
+        val result = runBlocking { repository.rotateToken(sessionId) }
 
         assertTrue(result.exceptionOrNull() is IllegalStateException)
         assertEquals("old-access", runBlocking { tokenDataSource.getAccessToken() })
@@ -436,7 +498,7 @@ private class FakeAuthApiService(
     private val onSocialLogin: () -> BaseResponse<LoginDto.SocialLoginDto> = {
         error("socialLogin 은 이 시나리오에서 호출되면 안 됨")
     },
-    private val onLogout: () -> BaseResponse<Unit> = { success(Unit) },
+    private val onLogout: suspend () -> BaseResponse<Unit> = { success(Unit) },
 ) : AuthApiService {
     val logoutRequests = mutableListOf<LogoutRequestDto>()
 
@@ -513,6 +575,7 @@ private class ThrowingDevicePushTargetProvider : DevicePushTargetProvider {
 
 private class FakePushTargetRepository(
     private val failing: Boolean = false,
+    private val onUnregister: suspend () -> Unit = {},
 ) : PushTargetRepository {
     val unregistered = mutableListOf<String>()
 
@@ -521,6 +584,7 @@ private class FakePushTargetRepository(
 
     override suspend fun unregister(targetId: String): Result<Unit> {
         unregistered += targetId
+        onUnregister()
         return if (failing) Result.failure(IllegalStateException("해제 실패")) else Result.success(Unit)
     }
 }
diff --git a/core/data/src/test/java/com/afternote/core/data/repoimpl/auth/SessionBoundReissueTest.kt b/core/data/src/test/java/com/afternote/core/data/repoimpl/auth/SessionBoundReissueTest.kt
new file mode 100644
index 0000000000..f610c3e07f
--- /dev/null
+++ b/core/data/src/test/java/com/afternote/core/data/repoimpl/auth/SessionBoundReissueTest.kt
@@ -0,0 +1,325 @@
+package com.afternote.core.data.repoimpl.auth
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.stringPreferencesKey
+import com.afternote.core.datastore.LocalStoreRegistry
+import com.afternote.core.datastore.StoreScope
+import com.afternote.core.datastore.TokenDataSource
+import com.afternote.core.domain.error.SessionChangedException
+import com.afternote.core.domain.push.DevicePushTargetProvider
+import com.afternote.core.domain.repository.push.PushTargetRepository
+import com.afternote.core.network.dto.LoginDto
+import com.afternote.core.network.dto.LoginRequestDto
+import com.afternote.core.network.dto.LogoutRequestDto
+import com.afternote.core.network.dto.ReissueDto
+import com.afternote.core.network.dto.ReissueRequestDto
+import com.afternote.core.network.dto.SocialLoginRequestDto
+import com.afternote.core.network.model.BaseResponse
+import com.afternote.core.network.service.AuthApiService
+import com.afternote.core.network.service.TokenApiService
+import com.afternote.core.network.token.AccessTokenExpiryTracker
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.async
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import java.io.File
+
+/**
+ * 재발급 응답은 그 재발급을 시작한 세션에만 적용된다 (#2237).
+ *
+ * 재발급 HTTP 가 떠 있는 동안 로그아웃이나 새 로그인이 끝날 수 있다. 둘 다 재발급 락을 거치지 않기 때문이다.
+ * 그 뒤 도착한 성공 응답을 그대로 쓰면 로그아웃한 계정이 되살아나거나(세션 식별자가 없어 legacy 세션으로 읽힌다)
+ * 새 계정의 토큰이 이전 계정 토큰으로 덮인다. 저장소는 실제 파일 DataStore 이고, 쓰기 직전에 다른 쓰기를
+ * 끼워 넣는 장치로 확인과 저장 사이의 창까지 결정적으로 연다.
+ */
+class SessionBoundReissueTest {
+    @get:Rule
+    val temporaryFolder = TemporaryFolder()
+
+    private val storeScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+    private val tracker = AccessTokenExpiryTracker()
+    private val reissue = ScriptedReissue()
+    private lateinit var store: InterleavingDataStore
+    private lateinit var tokenDataSource: TokenDataSource
+    private lateinit var repository: AuthRepositoryImpl
+
+    @Before
+    fun setUp() {
+        val file = File(temporaryFolder.root, "Token.preferences_pb")
+        store = InterleavingDataStore(PreferenceDataStoreFactory.create(scope = storeScope) { file })
+        tokenDataSource = TokenDataSource(store)
+        repository =
+            AuthRepositoryImpl(
+                tokenDataSource = tokenDataSource,
+                authApiService = LogoutOnlyAuthApiService,
+                tokenApiService = reissue,
+                expiryTracker = tracker,
+                // 실제 레지스트리처럼 SESSION 정리가 토큰 저장소의 키를 비운다.
+                localStoreRegistry =
+                    object : LocalStoreRegistry {
+                        override fun store(
+                            name: String,
+                            scope: StoreScope,
+                        ): DataStore<Preferences> = error("store 는 이 테스트에서 호출되면 안 됨")
+
+                        override suspend fun clearScope(scope: StoreScope) {
+                            if (scope == StoreScope.SESSION) store.edit { it.clear() }
+                        }
+                    },
+                pushTargetRepository = NoopPushTargetRepository,
+                devicePushTargetProvider = NoDevicePushTargetProvider,
+            )
+    }
+
+    @After
+    fun tearDown() = storeScope.cancel()
+
+    @Test
+    fun `로그아웃 뒤 도착한 재발급 성공은 이전 세션을 되살리지 않는다`() =
+        runBlocking {
+            repository.saveSession(accessToken = "A-access", refreshToken = "A-refresh").getOrThrow()
+            val rotation = async(Dispatchers.IO) { repository.rotateToken(currentSessionId()) }
+            reissue.awaitStarted()
+
+            repository.logout().getOrThrow()
+            assertNull(tokenDataSource.getAccessToken())
+
+            reissue.respond(ReissueDto(accessToken = "A-rotated", refreshToken = "A-refresh-rotated", expiresIn = 3599))
+            val result = withTimeout(TIMEOUT_MILLIS) { rotation.await() }
+
+            assertTrue("쓰이지 않은 회전이 성공으로 보고됐다: $result", result.exceptionOrNull() is SessionChangedException)
+            assertNull(tokenDataSource.getAccessToken())
+            assertNull(tokenDataSource.getRefreshToken())
+            assertNull(tokenDataSource.sessionId.first())
+            assertFalse(tokenDataSource.isLoggedIn.first())
+        }
+
+    @Test
+    fun `재발급 대기 중 새로 로그인한 세션은 늦은 성공에 덮이지 않는다`() =
+        runBlocking {
+            repository.saveSession(accessToken = "A-access", refreshToken = "A-refresh").getOrThrow()
+            val rotation = async(Dispatchers.IO) { repository.rotateToken(currentSessionId()) }
+            reissue.awaitStarted()
+
+            repository.logout().getOrThrow()
+            repository.saveSession(accessToken = "B-access", refreshToken = "B-refresh").getOrThrow()
+            val sessionB = tokenDataSource.sessionId.first()
+
+            reissue.respond(ReissueDto(accessToken = "A-rotated", refreshToken = "A-refresh-rotated"))
+            val result = withTimeout(TIMEOUT_MILLIS) { rotation.await() }
+
+            assertTrue(result.exceptionOrNull() is SessionChangedException)
+            assertEquals("B-access", tokenDataSource.getAccessToken())
+            assertEquals("B-refresh", tokenDataSource.getRefreshToken())
+            assertEquals(sessionB, tokenDataSource.sessionId.first())
+        }
+
+    @Test
+    fun `세션 확인과 저장 사이에 끼어든 새 로그인을 덮지 않는다`() =
+        runBlocking {
+            repository.saveSession(accessToken = "A-access", refreshToken = "A-refresh").getOrThrow()
+            val rotation = async(Dispatchers.IO) { repository.rotateToken(currentSessionId()) }
+            reissue.awaitStarted()
+
+            // 응답 뒤 저장소에 처음 닿는 순간(읽기든 쓰기든)에 로그아웃과 B 로그인을 끼워 넣는다.
+            // 읽기라면 읽은 값(A)을 돌려준 뒤가 아니라 돌려주기 직전에 끼워, 확인한 값과 저장 시점의 값이 갈리게 한다.
+            store.interleaveOnce {
+                store.edit { it.clear() }
+                tokenDataSource.saveTokens(accessToken = "B-access", refreshToken = "B-refresh")
+            }
+            reissue.respond(ReissueDto(accessToken = "A-rotated", refreshToken = "A-refresh-rotated"))
+            val result = withTimeout(TIMEOUT_MILLIS) { rotation.await() }
+
+            assertTrue("끼워 넣기가 실행되지 않았다", store.interleaved)
+            assertTrue(result.exceptionOrNull() is SessionChangedException)
+            assertEquals("B-access", tokenDataSource.getAccessToken())
+            assertEquals("B-refresh", tokenDataSource.getRefreshToken())
+        }
+
+    @Test
+    fun `같은 세션의 회전은 토큰만 바꾸고 세션 식별자를 유지한다`() =
+        runBlocking {
+            repository.saveSession(accessToken = "A-access", refreshToken = "A-refresh").getOrThrow()
+            val sessionA = tokenDataSource.sessionId.first()
+            assertNotNull(sessionA)
+            val rotation = async(Dispatchers.IO) { repository.rotateToken(currentSessionId()) }
+
+            assertEquals(ReissueRequestDto("A-refresh"), reissue.awaitStarted())
+            reissue.respond(ReissueDto(accessToken = "A-rotated", refreshToken = "A-refresh-rotated", expiresIn = 3599))
+            val bundle = withTimeout(TIMEOUT_MILLIS) { rotation.await() }.getOrThrow()
+
+            assertEquals("A-rotated", bundle.accessToken)
+            assertEquals("A-rotated", tokenDataSource.getAccessToken())
+            assertEquals("A-refresh-rotated", tokenDataSource.getRefreshToken())
+            assertEquals(sessionA, tokenDataSource.sessionId.first())
+        }
+
+    @Test
+    fun `식별자 없이 저장된 기존 세션도 회전하고 식별자 없는 채로 남는다`() =
+        runBlocking {
+            store.edit { prefs ->
+                prefs[stringPreferencesKey("access_token")] = "legacy-access"
+                prefs[stringPreferencesKey("refresh_token")] = "legacy-refresh"
+            }
+            val legacySession = currentSessionId()
+            val rotation = async(Dispatchers.IO) { repository.rotateToken(legacySession) }
+
+            assertEquals(ReissueRequestDto("legacy-refresh"), reissue.awaitStarted())
+            reissue.respond(ReissueDto(accessToken = "legacy-rotated", refreshToken = "legacy-refresh-rotated"))
+            withTimeout(TIMEOUT_MILLIS) { rotation.await() }.getOrThrow()
+
+            assertEquals("legacy-rotated", tokenDataSource.getAccessToken())
+            assertEquals(legacySession, tokenDataSource.sessionId.first())
+        }
+
+    @Test
+    fun `이전 세션의 정리 요청은 새로 로그인한 세션과 그 deadline 을 지우지 않는다`() =
+        runBlocking {
+            repository.saveSession(accessToken = "A-access", refreshToken = "A-refresh").getOrThrow()
+            val sessionA = currentSessionId()
+            repository.logout().getOrThrow()
+            repository.saveSession(accessToken = "B-access", refreshToken = "B-refresh").getOrThrow()
+            val sessionB = currentSessionId()
+            tracker.record(expiresInSeconds = 30)
+
+            val cleared = repository.clearSessionIfCurrent(sessionA).getOrThrow()
+
+            assertFalse(cleared)
+            assertEquals("B-access", tokenDataSource.getAccessToken())
+            assertEquals("B-refresh", tokenDataSource.getRefreshToken())
+            assertEquals(sessionB, tokenDataSource.sessionId.first())
+            assertTrue("B 의 선제 갱신 deadline 이 지워졌다", tracker.isExpiringSoon())
+        }
+
+    @Test
+    fun `세션 확인과 정리 사이에 끼어든 새 로그인을 지우지 않는다`() =
+        runBlocking {
+            repository.saveSession(accessToken = "A-access", refreshToken = "A-refresh").getOrThrow()
+            val sessionA = currentSessionId()
+            store.interleaveOnce {
+                store.edit { it.clear() }
+                tokenDataSource.saveTokens(accessToken = "B-access", refreshToken = "B-refresh")
+            }
+
+            val cleared = repository.clearSessionIfCurrent(sessionA).getOrThrow()
+
+            assertTrue("끼워 넣기가 실행되지 않았다", store.interleaved)
+            assertFalse(cleared)
+            assertEquals("B-access", tokenDataSource.getAccessToken())
+        }
+
+    @Test
+    fun `현재 세션의 정리 요청은 토큰과 deadline 을 함께 정리한다`() =
+        runBlocking {
+            repository.saveSession(accessToken = "A-access", refreshToken = "A-refresh").getOrThrow()
+            tracker.record(expiresInSeconds = 30)
+
+            val cleared = repository.clearSessionIfCurrent(currentSessionId()).getOrThrow()
+
+            assertTrue(cleared)
+            assertNull(tokenDataSource.getAccessToken())
+            assertNull(tokenDataSource.getRefreshToken())
+            assertFalse(tokenDataSource.isLoggedIn.first())
+            assertFalse(tracker.isExpiringSoon())
+        }
+
+    private suspend fun currentSessionId(): String = checkNotNull(repository.getSessionId().getOrThrow())
+
+    private companion object {
+        const val TIMEOUT_MILLIS = 5_000L
+    }
+}
+
+/** 재발급 요청이 들어온 사실과 응답 시점을 테스트가 따로 쥔다. */
+private class ScriptedReissue : TokenApiService {
+    private val started = CompletableDeferred<ReissueRequestDto>()
+    private val response = CompletableDeferred<ReissueDto>()
+
+    override suspend fun reissue(body: ReissueRequestDto): BaseResponse<ReissueDto> {
+        started.complete(body)
+        return BaseResponse(status = 200, code = 200, message = "성공", data = response.await())
+    }
+
+    suspend fun awaitStarted(): ReissueRequestDto = withTimeout(5_000L) { started.await() }
+
+    fun respond(data: ReissueDto) {
+        response.complete(data)
+    }
+}
+
+/**
+ * 다음 한 번의 접근에 다른 쓰기를 끼워 넣는 DataStore.
+ *
+ * 쓰기라면 그 쓰기보다 먼저 끼워 넣고, 읽기라면 읽은 값이 호출자에게 전달되기 직전에 끼워 넣는다. 읽기 쪽은
+ * 호출자가 끼워 넣기 이전 값을 받으므로, 확인과 저장을 따로 하는 구현은 낡은 값으로 판정하게 된다.
+ */
+private class InterleavingDataStore(
+    private val delegate: DataStore<Preferences>,
+) : DataStore<Preferences> {
+    @Volatile
+    private var pending: (suspend () -> Unit)? = null
+
+    @Volatile
+    var interleaved: Boolean = false
+        private set
+
+    fun interleaveOnce(action: suspend () -> Unit) {
+        pending = action
+    }
+
+    private suspend fun runPending() {
+        val action = synchronized(this) { pending.also { pending = null } } ?: return
+        action()
+        interleaved = true
+    }
+
+    override val data: Flow<Preferences>
+        get() = delegate.data.onEach { runPending() }
+
+    override suspend fun updateData(transform: suspend (t: Preferences) -> Preferences): Preferences {
+        runPending()
+        return delegate.updateData(transform)
+    }
+}
+
+private object LogoutOnlyAuthApiService : AuthApiService {
+    override suspend fun login(body: LoginRequestDto): BaseResponse<LoginDto.DefaultLoginDto> = error("login 은 이 테스트에서 호출되면 안 됨")
+
+    override suspend fun socialLogin(body: SocialLoginRequestDto): BaseResponse<LoginDto.SocialLoginDto> =
+        error("socialLogin 은 이 테스트에서 호출되면 안 됨")
+
+    override suspend fun logout(body: LogoutRequestDto): BaseResponse<Unit> =
+        BaseResponse(status = 200, code = 200, message = "성공", data = Unit)
+}
+
+private object NoopPushTargetRepository : PushTargetRepository {
+    override suspend fun register(targetId: String): Result<Unit> = error("register 는 이 테스트에서 호출되면 안 됨")
+
+    override suspend fun unregister(targetId: String): Result<Unit> = Result.success(Unit)
+}
+
+private object NoDevicePushTargetProvider : DevicePushTargetProvider {
+    override suspend fun currentTargetId(): String? = error("currentTargetId 는 이 테스트에서 호출되면 안 됨")
+
+    override suspend fun existingTargetId(): String? = null
+}
diff --git a/core/data/src/test/java/com/afternote/core/data/repoimpl/invitation/ReceiverInvitationFailureTranslationTest.kt b/core/data/src/test/java/com/afternote/core/data/repoimpl/invitation/ReceiverInvitationFailureTranslationTest.kt
new file mode 100644
index 0000000000..7fa00c8583
--- /dev/null
+++ b/core/data/src/test/java/com/afternote/core/data/repoimpl/invitation/ReceiverInvitationFailureTranslationTest.kt
@@ -0,0 +1,63 @@
+package com.afternote.core.data.repoimpl.invitation
+
+import com.afternote.core.domain.error.ReceiverInvitationFailure
+import com.afternote.core.network.model.ApiException
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertSame
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import java.io.IOException
+import java.net.UnknownHostException
+
+/** BE 초대 실패 code → 도메인 어휘 번역 (#944). */
+class ReceiverInvitationFailureTranslationTest {
+    @Test
+    fun `등재 code 는 code 만으로 사유가 확정된다`() {
+        assertTrue(api(401, 1000).translate() is ReceiverInvitationFailure.Unauthenticated)
+        assertTrue(api(404, 1905).translate() is ReceiverInvitationFailure.NotFound)
+        assertTrue(api(410, 1906).translate() is ReceiverInvitationFailure.Expired)
+        assertTrue(api(409, 1907).translate() is ReceiverInvitationFailure.AcceptedByOther)
+        assertTrue(api(400, 1908).translate() is ReceiverInvitationFailure.SelfAccept)
+        assertTrue(api(409, 1909).translate() is ReceiverInvitationFailure.AlreadyRegistered)
+    }
+
+    @Test
+    fun `5xx 는 등재 code 여도 재시도 가능한 장애다`() {
+        val failure = api(500, 1905).translate()
+
+        assertTrue(failure is ReceiverInvitationFailure.Other)
+        assertTrue((failure as ReceiverInvitationFailure.Other).isRetryable)
+    }
+
+    @Test
+    fun `전송 실패는 재시도 가능하다`() {
+        val failure = UnknownHostException("no host").translate()
+
+        assertTrue(failure is ReceiverInvitationFailure.Other)
+        assertTrue((failure as ReceiverInvitationFailure.Other).isRetryable)
+        assertTrue(failure.cause is IOException)
+    }
+
+    @Test
+    fun `미등재 4xx 는 재시도 불가로 남긴다`() {
+        val failure = api(400, 1400).translate()
+
+        assertTrue(failure is ReceiverInvitationFailure.Other)
+        assertFalse((failure as ReceiverInvitationFailure.Other).isRetryable)
+    }
+
+    @Test
+    fun `원인 예외는 cause 로 보존된다`() {
+        val apiError = api(404, 1905)
+
+        assertSame(apiError, apiError.translate().cause)
+    }
+
+    private fun Throwable.translate(): ReceiverInvitationFailure =
+        Result.failure<Unit>(this).mapReceiverInvitationFailure().exceptionOrNull() as ReceiverInvitationFailure
+
+    private fun api(
+        status: Int,
+        code: Int,
+    ) = ApiException(status = status, code = code, serverMessage = "server", fallbackMessage = "fallback")
+}
diff --git a/core/datastore/src/main/java/com/afternote/core/datastore/ReceiverInvitationDataSource.kt b/core/datastore/src/main/java/com/afternote/core/datastore/ReceiverInvitationDataSource.kt
new file mode 100644
index 0000000000..de8dba7ceb
--- /dev/null
+++ b/core/datastore/src/main/java/com/afternote/core/datastore/ReceiverInvitationDataSource.kt
@@ -0,0 +1,48 @@
+package com.afternote.core.datastore
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.emptyPreferences
+import androidx.datastore.preferences.core.stringPreferencesKey
+import com.afternote.core.datastore.di.ReceiverInvitationDataStore
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.map
+import java.io.IOException
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * 대기 중인 카카오톡 수신자 초대 토큰 로컬 저장 (#944).
+ *
+ * 값은 비밀이라 로그에 남기지 않는다. 읽기 스트림은 [IOException] 시 [emptyPreferences] 로 복구한다.
+ */
+@Singleton
+class ReceiverInvitationDataSource
+    @Inject
+    constructor(
+        @param:ReceiverInvitationDataStore private val dataStore: DataStore<Preferences>,
+    ) {
+        private object Keys {
+            val PENDING_TOKEN = stringPreferencesKey("pending_invitation_token")
+        }
+
+        val pendingTokenFlow: Flow<String?> =
+            dataStore.data
+                .catch { exception ->
+                    if (exception is IOException) {
+                        emit(emptyPreferences())
+                    } else {
+                        throw exception
+                    }
+                }.map { prefs -> prefs[Keys.PENDING_TOKEN]?.takeIf { it.isNotBlank() } }
+
+        suspend fun savePendingToken(token: String) {
+            dataStore.edit { prefs -> prefs[Keys.PENDING_TOKEN] = token }
+        }
+
+        suspend fun clearPendingToken() {
+            dataStore.edit { prefs -> prefs.remove(Keys.PENDING_TOKEN) }
+        }
+    }
diff --git a/core/datastore/src/main/java/com/afternote/core/datastore/TokenDataSource.kt b/core/datastore/src/main/java/com/afternote/core/datastore/TokenDataSource.kt
index 2193103bea..3b76d9c3dc 100644
--- a/core/datastore/src/main/java/com/afternote/core/datastore/TokenDataSource.kt
+++ b/core/datastore/src/main/java/com/afternote/core/datastore/TokenDataSource.kt
@@ -58,14 +58,7 @@ class TokenDataSource
          * 식별자 키가 없던 시절에 저장된 세션은 [LEGACY_SESSION_ID] 로 읽는다. 로그인 상태는 그대로 유지되고,
          * 다음 로그인부터 발급된 식별자를 쓴다.
          */
-        val sessionId: Flow<String?> =
-            preferencesFlow.map { prefs ->
-                if (prefs[Keys.ACCESS_TOKEN] == null) {
-                    null
-                } else {
-                    prefs[Keys.SESSION_ID] ?: LEGACY_SESSION_ID
-                }
-            }
+        val sessionId: Flow<String?> = preferencesFlow.map { prefs -> prefs.sessionIdOrNull() }
 
         val isLoggedIn: Flow<Boolean> = sessionId.map { it != null }
 
@@ -84,6 +77,8 @@ class TokenDataSource
         /**
          * 같은 세션 안에서 토큰만 회전한다 ([saveTokens] 와 달리 [sessionId] 를 새로 발급하지 않는다).
          * 회전은 계정이 바뀌는 사건이 아니므로, 세션에 귀속된 캐시를 버리게 만들면 안 된다.
+         *
+         * 지금 세션을 묻지 않고 쓰므로 재발급 응답 적용에는 [updateTokensIfSession] 을 쓴다.
          */
         suspend fun updateTokens(
             accessToken: String,
@@ -95,10 +90,67 @@ class TokenDataSource
             }
         }
 
+        /**
+         * 저장된 세션이 [expectedSessionId] 일 때만 토큰을 회전하고, 실제로 썼는지 돌려준다 (#2237).
+         *
+         * 재발급 HTTP 가 떠 있는 동안 로그아웃이나 새 로그인이 끝날 수 있다. 둘 다 재발급 락을 거치지 않는다.
+         * 그 뒤 도착한 응답을 묻지 않고 쓰면 로그아웃한 계정이 식별자 없는 세션([LEGACY_SESSION_ID])으로
+         * 되살아나거나 새 계정의 토큰이 덮인다. 대조와 쓰기를 같은 `edit` 안에서 하는 이유는 그 사이에
+         * 로그인 쓰기가 끼어들 틈을 없애기 위해서다.
+         */
+        suspend fun updateTokensIfSession(
+            expectedSessionId: String,
+            accessToken: String,
+            refreshToken: String,
+        ): Boolean {
+            var applied = false
+            dataStore.edit { prefs ->
+                applied = prefs.sessionIdOrNull() == expectedSessionId
+                if (applied) {
+                    prefs[Keys.ACCESS_TOKEN] = accessToken
+                    prefs[Keys.REFRESH_TOKEN] = refreshToken
+                }
+            }
+            return applied
+        }
+
+        /**
+         * 저장된 세션이 [expectedSessionId] 일 때만 이 저장소의 키를 비우고, 실제로 비웠는지 돌려준다 (#2238).
+         *
+         * 이전 세션의 재발급 거절이 늦게 도착했을 때 그사이 로그인한 새 세션을 지우지 않기 위한 정리다.
+         * 대조와 정리를 같은 `edit` 안에서 하는 이유는 [updateTokensIfSession] 과 같다.
+         */
+        suspend fun clearIfSession(expectedSessionId: String): Boolean {
+            var cleared = false
+            dataStore.edit { prefs ->
+                cleared = prefs.sessionIdOrNull() == expectedSessionId
+                if (cleared) prefs.clear()
+            }
+            return cleared
+        }
+
+        /** 지금 저장된 세션의 식별자. [sessionId] 의 현재 값이다. */
+        suspend fun currentSessionId(): String? = sessionId.first()
+
+        /**
+         * 저장된 세션이 [expectedSessionId] 일 때 그 세션의 리프레시 토큰. 세션이 다르거나 토큰이 없으면 `null` 이다.
+         *
+         * 세션과 토큰을 한 번의 읽기에서 꺼낸다. 따로 읽으면 그 사이 로그인한 새 세션의 리프레시 토큰으로
+         * 재발급을 칠 수 있고, 서버가 그 토큰을 회전(RTR)하면 새 세션에 남은 리프레시 토큰이 무효가 된다.
+         */
+        suspend fun refreshTokenOf(expectedSessionId: String): String? {
+            val prefs = preferencesFlow.first()
+            return if (prefs.sessionIdOrNull() == expectedSessionId) prefs[Keys.REFRESH_TOKEN] else null
+        }
+
         suspend fun getAccessToken(): String? = preferencesFlow.first()[Keys.ACCESS_TOKEN]
 
         suspend fun getRefreshToken(): String? = preferencesFlow.first()[Keys.REFRESH_TOKEN]
 
+        /** 액세스 토큰이 없으면 세션도 없다. 식별자 키가 없던 시절의 세션은 [LEGACY_SESSION_ID] 로 읽는다. */
+        private fun Preferences.sessionIdOrNull(): String? =
+            if (this[Keys.ACCESS_TOKEN] == null) null else this[Keys.SESSION_ID] ?: LEGACY_SESSION_ID
+
         private companion object {
             /** 세션 식별자 키가 생기기 전에 저장된 세션의 식별자. 그 세션이 끝날 때까지 이 값 하나로 고정된다. */
             const val LEGACY_SESSION_ID = "legacy-session"
diff --git a/core/datastore/src/main/java/com/afternote/core/datastore/di/ReceiverInvitationDataStore.kt b/core/datastore/src/main/java/com/afternote/core/datastore/di/ReceiverInvitationDataStore.kt
new file mode 100644
index 0000000000..69d7a49f1f
--- /dev/null
+++ b/core/datastore/src/main/java/com/afternote/core/datastore/di/ReceiverInvitationDataStore.kt
@@ -0,0 +1,8 @@
+package com.afternote.core.datastore.di
+
+import javax.inject.Qualifier
+
+/** Hilt 한정자: 대기 중인 카카오톡 수신자 초대 토큰 전용 [androidx.datastore.core.DataStore] 바인딩 (#944). */
+@Qualifier
+@Retention(AnnotationRetention.BINARY)
+annotation class ReceiverInvitationDataStore
diff --git a/core/datastore/src/main/java/com/afternote/core/datastore/di/ReceiverInvitationDataStoreModule.kt b/core/datastore/src/main/java/com/afternote/core/datastore/di/ReceiverInvitationDataStoreModule.kt
new file mode 100644
index 0000000000..e069532b78
--- /dev/null
+++ b/core/datastore/src/main/java/com/afternote/core/datastore/di/ReceiverInvitationDataStoreModule.kt
@@ -0,0 +1,23 @@
+package com.afternote.core.datastore.di
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import com.afternote.core.datastore.LocalStoreRegistry
+import com.afternote.core.datastore.StoreScope
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+internal object ReceiverInvitationDataStoreModule {
+    @Provides
+    @Singleton
+    @ReceiverInvitationDataStore
+    fun provideReceiverInvitationDataStore(registry: LocalStoreRegistry): DataStore<Preferences> =
+        // name 은 저장 파일명 계약 — 바꾸면 보관 중인 초대가 끊긴다 (#912 필수 주의).
+        // DEVICE 스코프 — 초대는 계정이 아니라 기기로 들어온 것이라 로그아웃에 지우지 않는다 (#944).
+        registry.store(name = "ReceiverInvitation", scope = StoreScope.DEVICE)
+}
diff --git a/core/datastore/src/test/java/com/afternote/core/datastore/ReceiverInvitationDataSourceTest.kt b/core/datastore/src/test/java/com/afternote/core/datastore/ReceiverInvitationDataSourceTest.kt
new file mode 100644
index 0000000000..09fe1a92e7
--- /dev/null
+++ b/core/datastore/src/test/java/com/afternote/core/datastore/ReceiverInvitationDataSourceTest.kt
@@ -0,0 +1,67 @@
+package com.afternote.core.datastore
+
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.job
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import java.io.File
+
+/** 초대 토큰 보관소의 save/read/clear 와 프로세스 재시작 생존 (#944). */
+class ReceiverInvitationDataSourceTest {
+    @get:Rule
+    val tmp = TemporaryFolder()
+
+    private fun newScope() = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+
+    private fun dataSource(scope: CoroutineScope) =
+        ReceiverInvitationDataSource(
+            PreferenceDataStoreFactory.create(scope = scope) { File(tmp.root, "ReceiverInvitation.preferences_pb") },
+        )
+
+    private fun shutdown(scope: CoroutineScope) =
+        runBlocking {
+            scope.coroutineContext.job.cancel()
+            scope.coroutineContext.job.join()
+        }
+
+    @Test
+    fun `저장한 토큰은 재시작 뒤에도 읽히고 clear 로 사라진다`() {
+        val first = newScope()
+        runBlocking {
+            val source = dataSource(first)
+            assertNull(source.pendingTokenFlow.first())
+            source.savePendingToken("token-1")
+            assertEquals("token-1", source.pendingTokenFlow.first())
+        }
+        shutdown(first)
+
+        val second = newScope()
+        runBlocking {
+            val source = dataSource(second)
+            assertEquals("token-1", source.pendingTokenFlow.first())
+            source.clearPendingToken()
+            assertNull(source.pendingTokenFlow.first())
+        }
+        shutdown(second)
+    }
+
+    @Test
+    fun `새 토큰은 이전 토큰을 덮는다`() {
+        val scope = newScope()
+        runBlocking {
+            val source = dataSource(scope)
+            source.savePendingToken("token-1")
+            source.savePendingToken("token-2")
+            assertEquals("token-2", source.pendingTokenFlow.first())
+        }
+        shutdown(scope)
+    }
+}
diff --git a/core/datastore/src/test/java/com/afternote/core/datastore/TokenDataSourceTest.kt b/core/datastore/src/test/java/com/afternote/core/datastore/TokenDataSourceTest.kt
index 60b28806ee..634f623741 100644
--- a/core/datastore/src/test/java/com/afternote/core/datastore/TokenDataSourceTest.kt
+++ b/core/datastore/src/test/java/com/afternote/core/datastore/TokenDataSourceTest.kt
@@ -122,6 +122,49 @@ class TokenDataSourceTest {
             assertEquals(legacySessionId, tokenDataSource.sessionId.first())
         }
 
+    /** 재발급 응답은 그것을 시작한 세션에만 쓴다 (#2237). 로그아웃 뒤에는 식별자 없는 세션으로도 되살아나지 않는다. */
+    @Test
+    fun `세션 대조 회전은 다른 세션이나 로그아웃 상태에 쓰지 않는다`() =
+        runBlocking {
+            tokenDataSource.saveTokens(accessToken = "A-access", refreshToken = "A-refresh")
+            val sessionA = checkNotNull(tokenDataSource.currentSessionId())
+
+            assertTrue(tokenDataSource.updateTokensIfSession(sessionA, accessToken = "A-rotated", refreshToken = "A-refresh-rotated"))
+            assertEquals("A-rotated", tokenDataSource.getAccessToken())
+            assertEquals(sessionA, tokenDataSource.currentSessionId())
+
+            registry.clearScope(StoreScope.SESSION)
+            assertFalse(tokenDataSource.updateTokensIfSession(sessionA, accessToken = "A-late", refreshToken = "A-refresh-late"))
+            assertNull(tokenDataSource.getAccessToken())
+            assertNull(tokenDataSource.getRefreshToken())
+            assertFalse(tokenDataSource.isLoggedIn.first())
+
+            tokenDataSource.saveTokens(accessToken = "B-access", refreshToken = "B-refresh")
+            assertFalse(tokenDataSource.updateTokensIfSession(sessionA, accessToken = "A-late", refreshToken = "A-refresh-late"))
+            assertEquals("B-access", tokenDataSource.getAccessToken())
+            assertNull(tokenDataSource.refreshTokenOf(sessionA))
+            assertEquals("B-refresh", tokenDataSource.refreshTokenOf(checkNotNull(tokenDataSource.currentSessionId())))
+        }
+
+    /** 거절 정리는 그 거절을 받은 세션일 때만 한다 (#2238). */
+    @Test
+    fun `세션 대조 정리는 지금 세션일 때만 비운다`() =
+        runBlocking {
+            tokenDataSource.saveTokens(accessToken = "A-access", refreshToken = "A-refresh")
+            val sessionA = checkNotNull(tokenDataSource.currentSessionId())
+            registry.clearScope(StoreScope.SESSION)
+            tokenDataSource.saveTokens(accessToken = "B-access", refreshToken = "B-refresh")
+            val sessionB = checkNotNull(tokenDataSource.currentSessionId())
+
+            assertFalse(tokenDataSource.clearIfSession(sessionA))
+            assertEquals("B-access", tokenDataSource.getAccessToken())
+            assertEquals(sessionB, tokenDataSource.currentSessionId())
+
+            assertTrue(tokenDataSource.clearIfSession(sessionB))
+            assertNull(tokenDataSource.getAccessToken())
+            assertNull(tokenDataSource.currentSessionId())
+        }
+
     private fun assertNotNullSessionId(sessionId: String?) {
         assertTrue("로그인된 세션에는 식별자가 있어야 한다 (실제=$sessionId)", !sessionId.isNullOrBlank())
     }
diff --git a/core/domain/src/main/java/com/afternote/core/domain/auth/NewPasswordRule.kt b/core/domain/src/main/java/com/afternote/core/domain/auth/NewPasswordRule.kt
new file mode 100644
index 0000000000..bfaac24eed
--- /dev/null
+++ b/core/domain/src/main/java/com/afternote/core/domain/auth/NewPasswordRule.kt
@@ -0,0 +1,25 @@
+package com.afternote.core.domain.auth
+
+/**
+ * 새 비밀번호에 요구하는 조합 규칙의 클라 정본 (#2191).
+ *
+ * **서버 규칙과 같다.** BE `domain/auth/dto/PasswordValidation.REGEX` 를 그대로 옮겼다 — 영문·숫자·허용
+ * 특수문자(`@ $ ! % * # ? &`)를 각각 하나 이상 포함하고, 전체 문자는 그 ASCII 허용 목록 안에서만
+ * 8~15자여야 한다. 서버는 이 상수 하나를 `SignupRequest`·`PasswordChangeRequest`·`PasswordFindRequest`
+ * 세 곳에 `@Pattern` 으로 걸고 컨트롤러 진입 전에 거절하므로, 클라가 더 넓으면 사용자는 조건 충족
+ * 표시를 다 받고 제출에서 400 을 맞는다. 서버가 상수 하나를 쓰듯 클라도 여기 하나만 둔다 — 화면마다
+ * 사본을 들면 규칙이 바뀔 때 한쪽만 고쳐져 가입과 변경의 판정이 조용히 갈린다.
+ *
+ * Android 정규식의 `\d` 는 Unicode 숫자까지 포함해 전각 `１`·아라비아-인도 `١` 을 통과시킨다.
+ * 서버 JVM 의 기본 판정과 갈리지 않도록 숫자를 `[0-9]` 로 명시한다(#1628).
+ *
+ * **현재 비밀번호와 로그인 입력에는 걸지 않는다.** 옛 규칙으로 만든 비밀번호가 그대로 살아 있을 수
+ * 있어, 클라가 막으면 그 계정은 로그인도 변경도 못 한다.
+ */
+object NewPasswordRule {
+    /** 8~15자, 영문·숫자·허용 특수문자 8종 각 1개 이상, 그 밖의 문자는 금지. */
+    private val REGEX =
+        Regex("^(?=.*[A-Za-z])(?=.*[0-9])(?=.*[@$!%*#?&])[A-Za-z0-9@$!%*#?&]{8,15}$")
+
+    fun isSatisfied(password: String): Boolean = REGEX.matches(password)
+}
diff --git a/core/domain/src/main/java/com/afternote/core/domain/error/ReceiverInvitationFailure.kt b/core/domain/src/main/java/com/afternote/core/domain/error/ReceiverInvitationFailure.kt
new file mode 100644
index 0000000000..cb6a31c64a
--- /dev/null
+++ b/core/domain/src/main/java/com/afternote/core/domain/error/ReceiverInvitationFailure.kt
@@ -0,0 +1,56 @@
+package com.afternote.core.domain.error
+
+/**
+ * 카카오톡 수신자 초대(발급·조회·수락) 흐름의 실패 어휘 (#944).
+ *
+ * Data 계층이 서버 code 를 이 계열로 번역하고, presentation 은 타입만 보고 안내와 토큰 처분을 정한다.
+ * BE `ErrorCode` 번호는 Data 계층 밖으로 나오지 않는다(`ReceiverFailure` 와 같은 규약).
+ *
+ * @param message 리포팅 콘솔용 정적 진단 문구 — 화면에 싣지 않는다.
+ * @param cause 이 실패를 만든 인프라 예외. stack trace 보존용이다.
+ */
+sealed class ReceiverInvitationFailure(
+    message: String,
+    cause: Throwable,
+) : Exception(message, cause) {
+    /** 초대가 없다(404·1905). 토큰을 지우고 안내로 끝낸다. */
+    class NotFound(
+        cause: Throwable,
+    ) : ReceiverInvitationFailure("receiver invitation not found", cause)
+
+    /** 초대가 만료됐다(410·1906). 토큰을 지우고 안내로 끝낸다. */
+    class Expired(
+        cause: Throwable,
+    ) : ReceiverInvitationFailure("receiver invitation expired", cause)
+
+    /** 다른 사용자가 이미 수락한 초대다(409·1907). 토큰을 지우고 안내로 끝낸다. */
+    class AcceptedByOther(
+        cause: Throwable,
+    ) : ReceiverInvitationFailure("receiver invitation accepted by another user", cause)
+
+    /** 초대를 만든 본인이 수락하려 했다(400·1908). 토큰을 지우고 안내로 끝낸다. */
+    class SelfAccept(
+        cause: Throwable,
+    ) : ReceiverInvitationFailure("receiver invitation self accept", cause)
+
+    /** 이미 그 초대자의 수신자로 등록돼 있다(409·1909). 토큰을 지우고 받은 기록함으로 보낸다. */
+    class AlreadyRegistered(
+        cause: Throwable,
+    ) : ReceiverInvitationFailure("receiver already registered for inviter", cause)
+
+    /** 로그인 세션이 없거나 만료됐다(401·1000). 토큰은 남기고 로그인으로 보낸다. */
+    class Unauthenticated(
+        cause: Throwable,
+    ) : ReceiverInvitationFailure("receiver invitation requires authentication", cause)
+
+    /**
+     * 위 어느 사유로도 확정되지 않은 실패.
+     *
+     * @property isRetryable 서버에 닿지 못했거나(IOException) 5xx 라 같은 토큰으로 다시 시도할 수 있다.
+     *   이 갈래에서는 토큰을 지우지 않는다. 미등재 4xx 는 false — 다시 보내도 같은 거절이 온다.
+     */
+    class Other(
+        cause: Throwable,
+        val isRetryable: Boolean,
+    ) : ReceiverInvitationFailure("receiver invitation failed: retryable=$isRetryable", cause)
+}
diff --git a/core/domain/src/main/java/com/afternote/core/domain/error/SessionChangedException.kt b/core/domain/src/main/java/com/afternote/core/domain/error/SessionChangedException.kt
new file mode 100644
index 0000000000..1d27af4714
--- /dev/null
+++ b/core/domain/src/main/java/com/afternote/core/domain/error/SessionChangedException.kt
@@ -0,0 +1,9 @@
+package com.afternote.core.domain.error
+
+/**
+ * 세션에 묶인 작업이 끝나기 전에 그 세션이 끝났거나 다른 세션으로 바뀌었다는 사실 (#2237, #2238).
+ *
+ * 재발급은 로그인·로그아웃과 락을 공유하지 않는다. 그래서 재발급을 시작한 세션이 응답 도착 전에 사라질 수 있고,
+ * 그 응답은 지금 세션에 적용하지 않는다. 이 예외는 "적용하지 않았다" 를 성공과 구분해 알린다.
+ */
+class SessionChangedException : Exception("session changed before the token rotation was applied")
diff --git a/core/domain/src/main/java/com/afternote/core/domain/repository/PendingReceiverInvitationStore.kt b/core/domain/src/main/java/com/afternote/core/domain/repository/PendingReceiverInvitationStore.kt
new file mode 100644
index 0000000000..f5a5cbadab
--- /dev/null
+++ b/core/domain/src/main/java/com/afternote/core/domain/repository/PendingReceiverInvitationStore.kt
@@ -0,0 +1,21 @@
+package com.afternote.core.domain.repository
+
+import kotlinx.coroutines.flow.Flow
+
+/**
+ * 카카오톡 스킴으로 들어온 초대 토큰을 수락·처분할 때까지 보관한다 (#944).
+ *
+ * 스킴 진입 뒤 로그인·가입을 거치는 동안 Activity 가 재생성되고 프로세스도 죽을 수 있어 메모리에
+ * 둘 수 없다. 기기 수명 저장소에 두며 **로그아웃에 지우지 않는다** — 초대는 계정이 아니라 기기로
+ * 들어온 것이고, 로그인 전에 받은 초대를 로그인 뒤에 수락하는 것이 정상 경로다.
+ */
+interface PendingReceiverInvitationStore {
+    /** 보관 중인 토큰. 없으면 null. */
+    val pendingToken: Flow<String?>
+
+    /** 새 토큰을 보관한다. 이미 있던 토큰은 새 것으로 바뀐다 — 가장 최근에 열린 초대가 사용자의 의도다. */
+    suspend fun save(token: String)
+
+    /** 수락 완료·만료·거절처럼 더는 쓸 수 없는 토큰을 지운다. */
+    suspend fun clear()
+}
diff --git a/core/domain/src/main/java/com/afternote/core/domain/repository/ReceiverInvitationRepository.kt b/core/domain/src/main/java/com/afternote/core/domain/repository/ReceiverInvitationRepository.kt
new file mode 100644
index 0000000000..db2b6815c8
--- /dev/null
+++ b/core/domain/src/main/java/com/afternote/core/domain/repository/ReceiverInvitationRepository.kt
@@ -0,0 +1,27 @@
+package com.afternote.core.domain.repository
+
+import com.afternote.core.model.user.ReceiverInvitationAccepted
+import com.afternote.core.model.user.ReceiverInvitationCreated
+import com.afternote.core.model.user.ReceiverInvitationLookup
+
+/**
+ * 카카오톡 수신자 초대 계약 (#944, BE main 3593aa30).
+ *
+ * 발신자(설정 > 수신자 등록)가 [create] 로 초대를 만들어 카카오톡으로 보내고, 수신자(스킴으로 앱에
+ * 들어온 사람)가 [lookup] 으로 초대자를 확인한 뒤 [accept] 로 수신자가 된다. 두 역할이 같은 초대를
+ * 다루므로 발신자 쪽 [UserReceiverRepository] 와 수신자 쪽 `feature:receiver:domain` 어느 한쪽에
+ * 두지 않고 core 에 둔다.
+ *
+ * **실패 계약** — 서버 거절·전송 실패는 전부
+ * [com.afternote.core.domain.error.ReceiverInvitationFailure] 로 온다.
+ */
+interface ReceiverInvitationRepository {
+    /** 로그인한 사용자의 새 초대를 만든다. 유효 기간은 서버가 정한다(7일). */
+    suspend fun create(): Result<ReceiverInvitationCreated>
+
+    /** 비로그인도 가능한 조회 — 랜딩 화면이 초대자 이름과 만료 여부를 그린다. */
+    suspend fun lookup(token: String): Result<ReceiverInvitationLookup>
+
+    /** 로그인한 사용자를 초대자의 수신자로 등록한다. 같은 사용자의 재수락은 멱등 성공이다. */
+    suspend fun accept(token: String): Result<ReceiverInvitationAccepted>
+}
diff --git a/core/domain/src/main/java/com/afternote/core/domain/repository/auth/AuthRepository.kt b/core/domain/src/main/java/com/afternote/core/domain/repository/auth/AuthRepository.kt
index ff3f5153c2..65536c74cb 100644
--- a/core/domain/src/main/java/com/afternote/core/domain/repository/auth/AuthRepository.kt
+++ b/core/domain/src/main/java/com/afternote/core/domain/repository/auth/AuthRepository.kt
@@ -19,6 +19,15 @@ interface AuthRepository {
 
     suspend fun clearSession(): Result<Unit>
 
+    /**
+     * 지금 세션이 [sessionId] 일 때만 [clearSession] 과 같은 정리를 하고, 실제로 정리했는지 돌려준다.
+     * 재발급 거절처럼 특정 세션에 대한 판정을 적용할 때 쓴다. 그사이 로그인한 새 세션은 지우지 않는다 (#2238).
+     */
+    suspend fun clearSessionIfCurrent(sessionId: String): Result<Boolean>
+
+    /** 지금 저장된 로그인 세션의 식별자. 세션이 없으면 `null`. 로그인할 때마다 새로 발급된다. */
+    suspend fun getSessionId(): Result<String?>
+
     suspend fun getAccessToken(): Result<String?>
 
     suspend fun getRefreshToken(): Result<String?>
@@ -32,7 +41,13 @@ interface AuthRepository {
 
     suspend fun googleLogin(idToken: String): Result<Session.SocialSession>
 
-    suspend fun rotateToken(): Result<TokenBundle>
+    /**
+     * [sessionId] 세션의 리프레시 토큰으로 재발급하고 그 세션에만 새 토큰을 저장한다 (#2237).
+     *
+     * 시작할 때나 저장할 때 세션이 [sessionId] 가 아니면 저장하지 않고
+     * [com.afternote.core.domain.error.SessionChangedException] 으로 실패한다.
+     */
+    suspend fun rotateToken(sessionId: String): Result<TokenBundle>
 
     suspend fun logout(): Result<Unit>
 }
diff --git a/core/domain/src/main/java/com/afternote/core/domain/result/RunCatchingCancellable.kt b/core/domain/src/main/java/com/afternote/core/domain/result/RunCatchingCancellable.kt
new file mode 100644
index 0000000000..1fa0f2044c
--- /dev/null
+++ b/core/domain/src/main/java/com/afternote/core/domain/result/RunCatchingCancellable.kt
@@ -0,0 +1,35 @@
+package com.afternote.core.domain.result
+
+import kotlin.coroutines.cancellation.CancellationException
+
+/**
+ * suspend 호출을 감싸 [Result] 로 돌려주되, [CancellationException] 만은 삼키지 않고 다시 던진다.
+ *
+ * suspend 경계에서 stdlib `runCatching` 을 쓰면 안 되는 이유 — 그 함수는 "catching any Throwable"
+ * 이라(https://kotlinlang.org/api/core/kotlin-stdlib/kotlin/run-catching.html) 코루틴 취소까지
+ * `Result.failure` 로 바꾼다. 그러면 취소가 상위로 전파되지 못하고, 이미 취소된 코루틴에서 호출부의
+ * `onFailure` 갈래(UI 상태 갱신·스낵바 안내 등)가 실행된다.
+ *
+ * Android 코루틴 모범 사례가 이 소비를 직접 금지한다 — "To enable coroutine cancellation, don't
+ * consume exceptions of type CancellationException (don't catch them, or always rethrow them if
+ * caught)" (https://developer.android.com/kotlin/coroutines/coroutines-best-practices).
+ *
+ * 같은 역할을 stdlib 이 제공하지 않아 여기 둔다: cancellation-aware `runCatching` 요청은
+ * kotlinx.coroutines #1814 로 2020-02-18 에 올라와 아직 열려 있다
+ * (https://github.com/Kotlin/kotlinx.coroutines/issues/1814).
+ *
+ * Android 라이브러리인 core:common 이 아니라 JVM 모듈인 core:domain 에 두는 것은 feature domain
+ * UseCase 도 이 함수를 쓰게 하기 위해서다. domain 모듈은 core:common 에 의존할 수 없다.
+ *
+ * 쓰는 자리는 suspend 를 감싸는 경계다. 취소가 없는 동기 코드에는 stdlib `runCatching` 을 그대로
+ * 쓴다 — `inline` 이라 동기 코드에서도 호출은 되지만(그 경우 stdlib 과 동작이 같다) 이름값을 하지
+ * 못한다.
+ */
+inline fun <T> runCatchingCancellable(block: () -> T): Result<T> =
+    try {
+        Result.success(block())
+    } catch (e: CancellationException) {
+        throw e
+    } catch (e: Throwable) {
+        Result.failure(e)
+    }
diff --git a/core/domain/src/test/java/com/afternote/core/domain/auth/NewPasswordRuleTest.kt b/core/domain/src/test/java/com/afternote/core/domain/auth/NewPasswordRuleTest.kt
new file mode 100644
index 0000000000..2522d74d47
--- /dev/null
+++ b/core/domain/src/test/java/com/afternote/core/domain/auth/NewPasswordRuleTest.kt
@@ -0,0 +1,77 @@
+package com.afternote.core.domain.auth
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * 새 비밀번호 규칙이 서버 `PasswordValidation.REGEX` 와 같은 판정을 내는지 지킨다.
+ *
+ * 사례는 dev 서버에 실제로 보내 본 결과(1차·2차)를 그대로 옮겼다. 유니코드 숫자는 **허용 목록 밖
+ * 문자라서** 거절된다 — `[0-9]` 를 `\d` 로 되돌리는 변이는 이 단언으로 잡히지 않는다. 허용 목록
+ * `[A-Za-z0-9@$!%*#?&]` 이 이미 그 문자들을 닫고 있어 두 정규식의 판정이 갈리는 입력이 없고, JVM
+ * 유닛 테스트는 호스트 정규식 엔진이라 Android 의 유니코드 문자 클래스도 재현하지 못한다. `\d` 를
+ * 쓰지 않는 근거는 [NewPasswordRule] KDoc 이 갖는다.
+ */
+class NewPasswordRuleTest {
+    @Test
+    fun `dev 서버를 통과한 비밀번호를 모두 허용한다`() {
+        val acceptedPasswords =
+            listOf(
+                PasswordCase("1차 #1", "Password1!"),
+                PasswordCase("1차 #2 - 15자", "Password12345!a"),
+                PasswordCase("1차 #7 - 소문자 영문", "password12345!a"),
+                PasswordCase("2차 기준", "Aa1!aaaa"),
+                PasswordCase("2차 15자", "Aa1!aaaaaaaaaaa"),
+                PasswordCase("2차 대문자만", "AA1!AAAA"),
+                PasswordCase("2차 소문자만", "aa1!aaaa"),
+                PasswordCase("허용 특수문자 @", "Aa1@aaaa"),
+                PasswordCase("허용 특수문자 $", "Aa1\$aaaa"),
+                PasswordCase("허용 특수문자 !", "Aa1!aaaa"),
+                PasswordCase("허용 특수문자 %", "Aa1%aaaa"),
+                PasswordCase("허용 특수문자 *", "Aa1*aaaa"),
+                PasswordCase("허용 특수문자 #", "Aa1#aaaa"),
+                PasswordCase("허용 특수문자 ?", "Aa1?aaaa"),
+                PasswordCase("허용 특수문자 &", "Aa1&aaaa"),
+            )
+
+        acceptedPasswords.forEach { case ->
+            assertTrue("${case.description}: ${case.password}", NewPasswordRule.isSatisfied(case.password))
+        }
+    }
+
+    @Test
+    fun `dev 서버가 거절한 비밀번호와 Unicode 숫자를 모두 차단한다`() {
+        val rejectedPasswords =
+            listOf(
+                PasswordCase("1차 #3 - 16자", "Password12345!ab"),
+                PasswordCase("1차 #4 - 하이픈", "Password123-abc"),
+                PasswordCase("1차 #5 - 언더바", "Password123_abc"),
+                PasswordCase("1차 #6 - 물결", "Password123~abc"),
+                PasswordCase("1차 #8 - 한글", "Password1가나다"),
+                PasswordCase("1차 #9 - 공백", "Password1 abc"),
+                PasswordCase("2차 하이픈", "Aa1!aaa-"),
+                PasswordCase("2차 언더바", "Aa1!aaa_"),
+                PasswordCase("2차 물결", "Aa1!aaa~"),
+                PasswordCase("2차 마침표", "Aa1!aaa."),
+                PasswordCase("2차 한글", "Aa1!aaa가"),
+                PasswordCase("2차 중간 공백", "Aa1!a a a"),
+                PasswordCase("2차 7자", "Aa1!aaa"),
+                PasswordCase("2차 16자", "Aa1!aaaaaaaaaaaa"),
+                PasswordCase("영문 없음", "12345678!"),
+                PasswordCase("숫자 없음", "Abcdefgh!"),
+                PasswordCase("특수문자 없음", "Abcdefg12"),
+                PasswordCase("전각 숫자", "Aa１!aaaa"),
+                PasswordCase("아라비아-인도 숫자", "Aa١!aaaa"),
+            )
+
+        rejectedPasswords.forEach { case ->
+            assertFalse("${case.description}: ${case.password}", NewPasswordRule.isSatisfied(case.password))
+        }
+    }
+}
+
+private data class PasswordCase(
+    val description: String,
+    val password: String,
+)
diff --git a/core/common/src/test/java/com/afternote/core/common/result/RunCatchingCancellableTest.kt b/core/domain/src/test/java/com/afternote/core/domain/result/RunCatchingCancellableTest.kt
similarity index 98%
rename from core/common/src/test/java/com/afternote/core/common/result/RunCatchingCancellableTest.kt
rename to core/domain/src/test/java/com/afternote/core/domain/result/RunCatchingCancellableTest.kt
index cbfd64d9ba..eb8ee8c393 100644
--- a/core/common/src/test/java/com/afternote/core/common/result/RunCatchingCancellableTest.kt
+++ b/core/domain/src/test/java/com/afternote/core/domain/result/RunCatchingCancellableTest.kt
@@ -1,4 +1,4 @@
-package com.afternote.core.common.result
+package com.afternote.core.domain.result
 
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
diff --git a/core/domain/src/test/java/com/afternote/core/domain/testing/FakeCoreRepositoriesTest.kt b/core/domain/src/test/java/com/afternote/core/domain/testing/FakeCoreRepositoriesTest.kt
index e2da536f56..157e586a3a 100644
--- a/core/domain/src/test/java/com/afternote/core/domain/testing/FakeCoreRepositoriesTest.kt
+++ b/core/domain/src/test/java/com/afternote/core/domain/testing/FakeCoreRepositoriesTest.kt
@@ -1,5 +1,6 @@
 package com.afternote.core.domain.testing
 
+import com.afternote.core.domain.error.SessionChangedException
 import com.afternote.core.model.TokenBundle
 import com.afternote.core.model.delivery.ConditionState
 import com.afternote.core.model.delivery.DeliveryConditionItem
@@ -32,7 +33,7 @@ class FakeCoreRepositoriesTest {
         assertTrue(repository.loggedIn)
 
         repository.loggedIn = false
-        val rotateResult = runBlocking { repository.rotateToken() }
+        val rotateResult = runBlocking { repository.rotateToken(repository.sessionId) }
 
         assertTrue(rotateResult.isSuccess)
         assertEquals("rotated-access", repository.accessToken)
@@ -44,7 +45,7 @@ class FakeCoreRepositoriesTest {
     fun `rotateToken 기본 경로는 refresh가 없거나 새 access가 비어 있으면 실패한다`() {
         val missingRefresh = FakeAuthRepository(loggedIn = false)
 
-        val missingRefreshResult = runBlocking { missingRefresh.rotateToken() }
+        val missingRefreshResult = runBlocking { missingRefresh.rotateToken(missingRefresh.sessionId) }
 
         assertTrue(missingRefreshResult.isFailure)
         assertNull(missingRefresh.accessToken)
@@ -54,18 +55,48 @@ class FakeCoreRepositoriesTest {
         val emptyAccess =
             FakeAuthRepository(
                 loggedIn = false,
+                accessToken = "current-access",
                 refreshToken = "current-refresh",
                 rotatedTokens = TokenBundle("", "rotated-refresh"),
             )
 
-        val emptyAccessResult = runBlocking { emptyAccess.rotateToken() }
+        val emptyAccessResult = runBlocking { emptyAccess.rotateToken(emptyAccess.sessionId) }
 
         assertTrue(emptyAccessResult.isFailure)
-        assertNull(emptyAccess.accessToken)
+        assertEquals("current-access", emptyAccess.accessToken)
         assertEquals("current-refresh", emptyAccess.refreshToken)
         assertFalse(emptyAccess.loggedIn)
     }
 
+    @Test
+    fun `세션에 묶인 기본 경로는 다른 세션이면 쓰지도 지우지도 않는다`() {
+        val repository =
+            FakeAuthRepository(
+                loggedIn = true,
+                accessToken = "A-access",
+                refreshToken = "A-refresh",
+                rotatedTokens = TokenBundle("A-rotated", "A-refresh-rotated"),
+            )
+        val sessionA = repository.sessionId
+        runBlocking { repository.saveSession("B-access", "B-refresh") }
+
+        val rotateResult = runBlocking { repository.rotateToken(sessionA) }
+        val clearResult = runBlocking { repository.clearSessionIfCurrent(sessionA) }
+
+        assertTrue(rotateResult.exceptionOrNull() is SessionChangedException)
+        assertEquals(false, clearResult.getOrThrow())
+        assertEquals(0, repository.clearSessionCalls)
+        assertEquals("B-access", repository.accessToken)
+        assertEquals("B-refresh", repository.refreshToken)
+
+        val currentClear = runBlocking { repository.clearSessionIfCurrent(repository.sessionId) }
+
+        assertEquals(true, currentClear.getOrThrow())
+        assertEquals(1, repository.clearSessionCalls)
+        assertNull(repository.accessToken)
+        assertNull(runBlocking { repository.getSessionId() }.getOrThrow())
+    }
+
     @Test
     fun `Auth onX는 기록 외 기본 메모리 동작을 완전히 대체한다`() {
         val updateRepository =
@@ -92,7 +123,7 @@ class FakeCoreRepositoriesTest {
                 onRotateToken = { Result.success(TokenBundle("new-access", "new-refresh")) },
             )
 
-        val rotateResult = runBlocking { rotateRepository.rotateToken() }
+        val rotateResult = runBlocking { rotateRepository.rotateToken(rotateRepository.sessionId) }
 
         assertTrue(rotateResult.isSuccess)
         assertEquals(1, rotateRepository.rotateTokenCalls)
diff --git a/core/domain/src/testFixtures/kotlin/com/afternote/core/domain/testing/FakeAuthRepository.kt b/core/domain/src/testFixtures/kotlin/com/afternote/core/domain/testing/FakeAuthRepository.kt
index ab4aee8b92..47d1a6a923 100644
--- a/core/domain/src/testFixtures/kotlin/com/afternote/core/domain/testing/FakeAuthRepository.kt
+++ b/core/domain/src/testFixtures/kotlin/com/afternote/core/domain/testing/FakeAuthRepository.kt
@@ -1,5 +1,6 @@
 package com.afternote.core.domain.testing
 
+import com.afternote.core.domain.error.SessionChangedException
 import com.afternote.core.domain.repository.auth.AuthRepository
 import com.afternote.core.model.Session
 import com.afternote.core.model.TokenBundle
@@ -14,6 +15,9 @@ import java.util.concurrent.atomic.AtomicInteger
  * 기본은 토큰과 로그인 상태를 메모리에 저장하며 모든 호출을 기록한다. 특정 실패, 경합,
  * 서버 응답은 `onX` 로 갈아끼운다. 호출 금지 경계가 필요한 테스트는 [strict] 로 시작해
  * 실제로 쓰는 경로만 연다.
+ *
+ * 세션 식별자는 [sessionId] 로 들고 있다. 액세스 토큰이 있을 때만 세션이 있는 것으로 읽고, [saveSession] 이
+ * 새 값을 발급한다. 세션에 묶인 호출([rotateToken], [clearSessionIfCurrent])의 기본 동작은 이 값으로 대조한다.
  */
 class FakeAuthRepository(
     loggedIn: Boolean = false,
@@ -27,6 +31,8 @@ class FakeAuthRepository(
     var onSaveSession: (suspend (String, String) -> Result<Unit>)? = null,
     var onUpdateTokens: (suspend (String, String) -> Result<Unit>)? = null,
     var onClearSession: (suspend () -> Result<Unit>)? = null,
+    var onClearSessionIfCurrent: (suspend (String) -> Result<Boolean>)? = null,
+    var onGetSessionId: (suspend () -> Result<String?>)? = null,
     var onGetAccessToken: (suspend () -> Result<String?>)? = null,
     var onGetRefreshToken: (suspend () -> Result<String?>)? = null,
     var onDefaultLogin: (suspend (String, String) -> Result<Session.DefaultSession>)? = null,
@@ -37,6 +43,12 @@ class FakeAuthRepository(
 ) : AuthRepository {
     val loggedInState = MutableStateFlow(loggedIn)
 
+    /** 지금 세션의 식별자. 액세스 토큰이 없으면 [getSessionId] 는 이 값과 무관하게 `null` 이다. */
+    @Volatile
+    var sessionId: String = DEFAULT_SESSION_ID
+
+    private val sessionCounter = AtomicInteger()
+
     private val isLoggedInCounter = AtomicInteger()
 
     var loggedIn: Boolean
@@ -53,6 +65,7 @@ class FakeAuthRepository(
 
     val savedSessions = CopyOnWriteArrayList<Pair<String, String>>()
     val updatedTokens = CopyOnWriteArrayList<Pair<String, String>>()
+    val rotatedSessionIds = CopyOnWriteArrayList<String>()
     val attemptedEmailLogins = CopyOnWriteArrayList<Pair<String, String>>()
     val attemptedKakaoLogins = CopyOnWriteArrayList<String>()
     val attemptedGoogleLogins = CopyOnWriteArrayList<String>()
@@ -84,6 +97,7 @@ class FakeAuthRepository(
     ): Result<Unit> {
         savedSessions += accessToken to refreshToken
         onSaveSession?.let { return it(accessToken, refreshToken) }
+        sessionId = "session-${sessionCounter.incrementAndGet()}"
         this.accessToken = accessToken
         this.refreshToken = refreshToken
         loggedIn = true
@@ -111,6 +125,20 @@ class FakeAuthRepository(
         return Result.success(Unit)
     }
 
+    /** 세션이 [sessionId] 일 때만 [clearSession] 을 부른다. 대조가 어긋나면 [clearSession] 호출 수도 늘지 않는다. */
+    override suspend fun clearSessionIfCurrent(sessionId: String): Result<Boolean> {
+        onClearSessionIfCurrent?.let { return it(sessionId) }
+        if (currentSessionId() != sessionId) return Result.success(false)
+        return clearSession().map { true }
+    }
+
+    override suspend fun getSessionId(): Result<String?> {
+        onGetSessionId?.let { return it() }
+        return Result.success(currentSessionId())
+    }
+
+    private fun currentSessionId(): String? = if (accessToken == null) null else sessionId
+
     override suspend fun getAccessToken(): Result<String?> {
         accessTokenCounter.incrementAndGet()
         onGetAccessToken?.let { return it() }
@@ -144,12 +172,16 @@ class FakeAuthRepository(
         return Result.success(googleSession)
     }
 
-    override suspend fun rotateToken(): Result<TokenBundle> {
+    override suspend fun rotateToken(sessionId: String): Result<TokenBundle> {
         rotateTokenCounter.incrementAndGet()
+        rotatedSessionIds += sessionId
         onRotateToken?.let { return it(this) }
         if (refreshToken == null) {
             return Result.failure(IllegalStateException("리프레시 토큰이 존재하지 않습니다."))
         }
+        if (currentSessionId() != sessionId) {
+            return Result.failure(SessionChangedException())
+        }
         if (rotatedTokens.accessToken.isEmpty()) {
             return Result.failure(IllegalStateException("Token rotation returned an empty access token"))
         }
@@ -171,6 +203,7 @@ class FakeAuthRepository(
     companion object {
         private const val DEFAULT_ACCESS_TOKEN = "access"
         private const val DEFAULT_REFRESH_TOKEN = "refresh"
+        private const val DEFAULT_SESSION_ID = "session-0"
 
         /** 모든 경로를 닫고, 테스트가 쓰는 `onX` 만 명시적으로 연다. */
         fun strict(
@@ -186,6 +219,7 @@ class FakeAuthRepository(
                 onSaveSession = { _, _ -> unexpectedCall("AuthRepository.saveSession") },
                 onUpdateTokens = { _, _ -> unexpectedCall("AuthRepository.updateTokens") },
                 onClearSession = { unexpectedCall("AuthRepository.clearSession") },
+                onGetSessionId = { unexpectedCall("AuthRepository.getSessionId") },
                 onGetAccessToken = { unexpectedCall("AuthRepository.getAccessToken") },
                 onGetRefreshToken = { unexpectedCall("AuthRepository.getRefreshToken") },
                 onDefaultLogin = { _, _ -> unexpectedCall("AuthRepository.defaultLogin") },
diff --git a/core/domain/src/testFixtures/kotlin/com/afternote/core/domain/testing/FakePendingReceiverInvitationStore.kt b/core/domain/src/testFixtures/kotlin/com/afternote/core/domain/testing/FakePendingReceiverInvitationStore.kt
new file mode 100644
index 0000000000..69f12632c2
--- /dev/null
+++ b/core/domain/src/testFixtures/kotlin/com/afternote/core/domain/testing/FakePendingReceiverInvitationStore.kt
@@ -0,0 +1,27 @@
+package com.afternote.core.domain.testing
+
+import com.afternote.core.domain.repository.PendingReceiverInvitationStore
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+
+/** [PendingReceiverInvitationStore] fake 정본 (#944). 토큰을 메모리 상태로 보관한다. */
+class FakePendingReceiverInvitationStore(
+    token: String? = null,
+) : PendingReceiverInvitationStore {
+    val tokenState = MutableStateFlow(token)
+
+    @Volatile
+    var clearCalls: Int = 0
+        private set
+
+    override val pendingToken: Flow<String?> get() = tokenState
+
+    override suspend fun save(token: String) {
+        tokenState.value = token
+    }
+
+    override suspend fun clear() {
+        clearCalls += 1
+        tokenState.value = null
+    }
+}
diff --git a/core/domain/src/testFixtures/kotlin/com/afternote/core/domain/testing/FakeReceiverInvitationRepository.kt b/core/domain/src/testFixtures/kotlin/com/afternote/core/domain/testing/FakeReceiverInvitationRepository.kt
new file mode 100644
index 0000000000..fabd384f7e
--- /dev/null
+++ b/core/domain/src/testFixtures/kotlin/com/afternote/core/domain/testing/FakeReceiverInvitationRepository.kt
@@ -0,0 +1,51 @@
+package com.afternote.core.domain.testing
+
+import com.afternote.core.domain.repository.ReceiverInvitationRepository
+import com.afternote.core.model.user.ReceiverInvitationAccepted
+import com.afternote.core.model.user.ReceiverInvitationCreated
+import com.afternote.core.model.user.ReceiverInvitationLookup
+import java.util.concurrent.CopyOnWriteArrayList
+
+/**
+ * [ReceiverInvitationRepository] fake 정본 (#944).
+ *
+ * 기본은 성공을 돌려주고 호출 인자를 기록한다. 실패 경로는 `onX` 로 갈아끼운다.
+ */
+class FakeReceiverInvitationRepository(
+    @Volatile var created: ReceiverInvitationCreated = ReceiverInvitationCreated(DEFAULT_TOKEN),
+    @Volatile var lookup: ReceiverInvitationLookup = ReceiverInvitationLookup(inviterName = DEFAULT_INVITER, isExpired = false),
+    @Volatile var accepted: ReceiverInvitationAccepted = ReceiverInvitationAccepted(inviterName = DEFAULT_INVITER),
+    var onCreate: (suspend () -> Result<ReceiverInvitationCreated>)? = null,
+    var onLookup: (suspend (String) -> Result<ReceiverInvitationLookup>)? = null,
+    var onAccept: (suspend (String) -> Result<ReceiverInvitationAccepted>)? = null,
+) : ReceiverInvitationRepository {
+    val lookupTokens = CopyOnWriteArrayList<String>()
+    val acceptTokens = CopyOnWriteArrayList<String>()
+
+    @Volatile
+    var createCalls: Int = 0
+        private set
+
+    override suspend fun create(): Result<ReceiverInvitationCreated> {
+        createCalls += 1
+        onCreate?.let { return it() }
+        return Result.success(created)
+    }
+
+    override suspend fun lookup(token: String): Result<ReceiverInvitationLookup> {
+        lookupTokens += token
+        onLookup?.let { return it(token) }
+        return Result.success(lookup)
+    }
+
+    override suspend fun accept(token: String): Result<ReceiverInvitationAccepted> {
+        acceptTokens += token
+        onAccept?.let { return it(token) }
+        return Result.success(accepted)
+    }
+
+    companion object {
+        const val DEFAULT_TOKEN = "fake-invitation-token"
+        const val DEFAULT_INVITER = "김혜성"
+    }
+}
diff --git a/core/model/src/main/kotlin/com/afternote/core/model/user/ReceiverInvitationModel.kt b/core/model/src/main/kotlin/com/afternote/core/model/user/ReceiverInvitationModel.kt
new file mode 100644
index 0000000000..6e8dd5ec27
--- /dev/null
+++ b/core/model/src/main/kotlin/com/afternote/core/model/user/ReceiverInvitationModel.kt
@@ -0,0 +1,36 @@
+package com.afternote.core.model.user
+
+/**
+ * 카카오톡 수신자 초대 (`POST receiver-invitations`) 발급 결과 (#944).
+ *
+ * 서버는 `invitationId`·`invitationUrl`·`expiresAt` 도 함께 내려주지만 여기엔 올리지 않는다 —
+ * 공유는 카카오 메시지 템플릿에 [token] 만 싣고, 만료 안내 문구는 «7일» 고정 캡션이라 읽는 곳이 없다.
+ * 소비처가 생기면 그때 올린다.
+ *
+ * @property token 초대를 식별하는 비밀값(43자 base64url). 로그·리포팅에 원문을 남기지 않는다.
+ */
+data class ReceiverInvitationCreated(
+    val token: String,
+)
+
+/**
+ * 초대 조회 (`GET receiver-invitations/{token}`) 결과 — 랜딩 화면이 그리는 값만 담는다.
+ *
+ * 서버 `status`(PENDING·ACCEPTED)는 올리지 않는다. ACCEPTED 여도 본인이 수락한 것인지 남이 수락한
+ * 것인지 조회만으로는 갈리지 않고, 그 판정은 수락 요청의 실패 코드가 한다.
+ *
+ * @property isExpired 만료된 초대. 수락 버튼을 보이지 않고 안내로 끝낸다.
+ */
+data class ReceiverInvitationLookup(
+    val inviterName: String,
+    val isExpired: Boolean,
+)
+
+/**
+ * 초대 수락 (`POST receiver-invitations/{token}/accept`) 결과.
+ *
+ * 서버가 주는 `receiverId` 는 올리지 않는다 — 완료 화면은 이름만 쓰고, 받은 기록함은 자기 조회로 목록을 만든다.
+ */
+data class ReceiverInvitationAccepted(
+    val inviterName: String,
+)
diff --git a/core/network/src/main/kotlin/com/afternote/core/network/di/ServiceModule.kt b/core/network/src/main/kotlin/com/afternote/core/network/di/ServiceModule.kt
index d070e1c47b..018f4c70e0 100644
--- a/core/network/src/main/kotlin/com/afternote/core/network/di/ServiceModule.kt
+++ b/core/network/src/main/kotlin/com/afternote/core/network/di/ServiceModule.kt
@@ -6,6 +6,7 @@ import com.afternote.core.network.service.AccountApiService
 import com.afternote.core.network.service.AppVersionApiService
 import com.afternote.core.network.service.AuthApiService
 import com.afternote.core.network.service.ImageApiService
+import com.afternote.core.network.service.ReceiverInvitationApiService
 import com.afternote.core.network.service.TokenApiService
 import com.afternote.core.network.service.UserApiService
 import dagger.Module
@@ -66,4 +67,9 @@ object ServiceModule {
     @Provides
     @Singleton
     fun provideImageApiService(retrofit: Retrofit): ImageApiService = retrofit.create<ImageApiService>()
+
+    @Provides
+    @Singleton
+    fun provideReceiverInvitationApiService(retrofit: Retrofit): ReceiverInvitationApiService =
+        retrofit.create<ReceiverInvitationApiService>()
 }
diff --git a/core/network/src/main/kotlin/com/afternote/core/network/dto/ReceiverInvitationDto.kt b/core/network/src/main/kotlin/com/afternote/core/network/dto/ReceiverInvitationDto.kt
new file mode 100644
index 0000000000..af411e9950
--- /dev/null
+++ b/core/network/src/main/kotlin/com/afternote/core/network/dto/ReceiverInvitationDto.kt
@@ -0,0 +1,35 @@
+package com.afternote.core.network.dto
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+/**
+ * `POST receiver-invitations` 응답 (#944, BE main 3593aa30 · 2026-09-18 실측).
+ *
+ * 서버가 주는 필드를 전부 적어 계약을 코드에 고정한다. 도메인으로 올리는 것은 소비처가 있는
+ * `invitationToken` 뿐이고, 나머지는 파싱만 한다. `expiresAt` 은 `LocalDateTime` 직렬화라
+ * 나노초 자릿수가 가변인 문자열이다 — 이 앱에는 파싱하는 곳이 없어 문자열로 둔다.
+ */
+@Serializable
+data class ReceiverInvitationCreateDto(
+    @SerialName("invitationId") val invitationId: Long,
+    @SerialName("invitationToken") val invitationToken: String,
+    @SerialName("invitationUrl") val invitationUrl: String,
+    @SerialName("expiresAt") val expiresAt: String,
+)
+
+/** `GET receiver-invitations/{token}` 응답. `status` 는 `PENDING`·`ACCEPTED`. */
+@Serializable
+data class ReceiverInvitationLookupDto(
+    @SerialName("inviterName") val inviterName: String,
+    @SerialName("status") val status: String,
+    @SerialName("expired") val expired: Boolean,
+    @SerialName("expiresAt") val expiresAt: String,
+)
+
+/** `POST receiver-invitations/{token}/accept` 응답. */
+@Serializable
+data class ReceiverInvitationAcceptDto(
+    @SerialName("receiverId") val receiverId: Long,
+    @SerialName("inviterName") val inviterName: String,
+)
diff --git a/core/network/src/main/kotlin/com/afternote/core/network/interceptor/TokenAuthenticator.kt b/core/network/src/main/kotlin/com/afternote/core/network/interceptor/TokenAuthenticator.kt
index 974bac1bc4..52b1d42584 100644
--- a/core/network/src/main/kotlin/com/afternote/core/network/interceptor/TokenAuthenticator.kt
+++ b/core/network/src/main/kotlin/com/afternote/core/network/interceptor/TokenAuthenticator.kt
@@ -4,11 +4,17 @@ import com.afternote.core.common.reporting.ErrorReporter
 import com.afternote.core.domain.repository.auth.AuthRepository
 import com.afternote.core.network.token.TokenReissuer
 import kotlinx.coroutines.runBlocking
+import kotlinx.serialization.SerializationException
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.intOrNull
 import okhttp3.Authenticator
 import okhttp3.Request
 import okhttp3.Response
 import okhttp3.Route
 import java.io.IOException
+import java.nio.charset.CharacterCodingException
 import javax.inject.Inject
 
 class TokenAuthenticator
@@ -23,6 +29,10 @@ class TokenAuthenticator
             route: Route?,
             response: Response,
         ): Request? {
+            // 현재 비밀번호 불일치도 HTTP 401이다. 토큰 갱신이나 한도 초과로 세션을 지우지 않고
+            // 원래 오류 본문을 Retrofit의 실패 처리에 넘긴다.
+            if (response.isPasswordMismatch()) return null
+
             if (response.responseCount >= 3) {
                 errorReporter.recordAuthContractViolation(AUTH_STAGE_RETRY_LIMIT)
                 runBlocking { authRepository.get().clearSession() }
@@ -70,6 +80,22 @@ class TokenAuthenticator
         }
     }
 
+/** 확인된 업무 오류만 제외한다. 알 수 없거나 파싱할 수 없는 401은 기존 갱신 경로를 따른다. */
+private fun Response.isPasswordMismatch(): Boolean {
+    val body = peekBody(MAX_ERROR_BODY_BYTES + 1)
+    if (body.contentLength() > MAX_ERROR_BODY_BYTES) return false
+    val parsed =
+        try {
+            Json.parseToJsonElement(body.bytes().decodeToString(throwOnInvalidSequence = true)) as? JsonObject
+        } catch (_: SerializationException) {
+            null
+        } catch (_: CharacterCodingException) {
+            null
+        }
+    val code = parsed?.get("code") as? JsonPrimitive
+    return code != null && !code.isString && code.intOrNull == CODE_PASSWORD_MISMATCH
+}
+
 private fun ErrorReporter.recordAuthContractViolation(authStage: String) {
     recordFailure(
         throwable = IllegalStateException("Token authenticator contract violation"),
@@ -101,3 +127,5 @@ private const val KEY_AUTH_STAGE = "auth_stage"
 private const val AUTH_STAGE_RETRY_LIMIT = "retry_limit"
 private const val AUTH_STAGE_MISSING_AUTH_HEADER = "missing_auth_header"
 private const val AUTH_STAGE_SAME_TOKEN = "same_token"
+private const val CODE_PASSWORD_MISMATCH = 1202
+private const val MAX_ERROR_BODY_BYTES = 64 * 1024L
diff --git a/core/network/src/main/kotlin/com/afternote/core/network/service/ReceiverInvitationApiService.kt b/core/network/src/main/kotlin/com/afternote/core/network/service/ReceiverInvitationApiService.kt
new file mode 100644
index 0000000000..59d627f3df
--- /dev/null
+++ b/core/network/src/main/kotlin/com/afternote/core/network/service/ReceiverInvitationApiService.kt
@@ -0,0 +1,33 @@
+package com.afternote.core.network.service
+
+import com.afternote.core.network.dto.ReceiverInvitationAcceptDto
+import com.afternote.core.network.dto.ReceiverInvitationCreateDto
+import com.afternote.core.network.dto.ReceiverInvitationLookupDto
+import com.afternote.core.network.model.BaseResponse
+import retrofit2.http.GET
+import retrofit2.http.POST
+import retrofit2.http.Path
+
+/**
+ * 카카오톡 수신자 초대 API (#944).
+ *
+ * 실패 봉투 code — 1000(401 미인증) · 1905(404 초대 없음) · 1906(410 만료) · 1907(409 다른 사용자가
+ * 이미 수락) · 1908(400 본인 초대 수락) · 1909(409 이미 그 초대자의 수신자). 번역은 core:data 가 한다.
+ */
+interface ReceiverInvitationApiService {
+    /** 인증 필요, 바디 없음. */
+    @POST("receiver-invitations")
+    suspend fun createInvitation(): BaseResponse<ReceiverInvitationCreateDto>
+
+    /** 비로그인 가능. 토큰은 경로 세그먼트라 Retrofit 이 인코딩한다(base64url 이라 실제로 바뀌는 문자는 없다). */
+    @GET("receiver-invitations/{token}")
+    suspend fun getInvitation(
+        @Path("token") token: String,
+    ): BaseResponse<ReceiverInvitationLookupDto>
+
+    /** 인증 필요, 바디 없음. 같은 사용자의 재수락은 200 이다. */
+    @POST("receiver-invitations/{token}/accept")
+    suspend fun acceptInvitation(
+        @Path("token") token: String,
+    ): BaseResponse<ReceiverInvitationAcceptDto>
+}
diff --git a/core/network/src/main/kotlin/com/afternote/core/network/token/TokenReissuer.kt b/core/network/src/main/kotlin/com/afternote/core/network/token/TokenReissuer.kt
index 69315032e1..b3952119a7 100644
--- a/core/network/src/main/kotlin/com/afternote/core/network/token/TokenReissuer.kt
+++ b/core/network/src/main/kotlin/com/afternote/core/network/token/TokenReissuer.kt
@@ -1,6 +1,7 @@
 package com.afternote.core.network.token
 
 import com.afternote.core.common.reporting.ErrorReporter
+import com.afternote.core.domain.error.SessionChangedException
 import com.afternote.core.domain.repository.auth.AuthRepository
 import com.afternote.core.network.model.ApiException
 import kotlinx.coroutines.runBlocking
@@ -25,6 +26,13 @@ import javax.inject.Singleton
  *  - **거절 결과를 그 액세스 토큰에 묶어 공유한다.** 같은 토큰으로 들어온 대기자는 재발급을
  *    치지 않고 같은 [Outcome.AuthenticationRejected] 를 받아, 한 번의 실패가 하나의 분류로
  *    확정된다. 일시 실패는 공유하지 않는다 — 재시도가 성립하는 실패라 캐시하면 복구를 막는다.
+ *
+ * 락은 로그인·로그아웃과 공유하지 않는다. 그래서 재발급 HTTP 가 떠 있는 동안 세션이 끝나거나 바뀔 수 있고,
+ * 늦게 온 결과는 시작한 세션에만 적용한다(#2237, #2238). 재발급을 시작할 때 세션 식별자를 잡아 두고
+ * 성공은 그 세션에만 저장하며([AuthRepository.rotateToken]), 거절은 그 세션일 때만 정리하고
+ * ([AuthRepository.clearSessionIfCurrent]), deadline 도 그 세션일 때만 지운다. 세션이 바뀌어 저장하지 못한
+ * 회전은 이전 토큰 호출자에게 [Outcome.AuthenticationRejected] 로 돌아간다. 새 세션의 토큰으로 이전 세션의
+ * 요청을 재시도하면 안 되기 때문이다.
  */
 @Singleton
 class TokenReissuer
@@ -90,25 +98,34 @@ class TokenReissuer
                 // 저장 토큰 비교보다 먼저다 — 세션 정리 뒤엔 저장 토큰이 비어 있어 아래 가드를 그냥 통과한다.
                 rejection?.let { if (expectedAccessToken == rejectedAccessToken) return it }
 
+                // 세션을 토큰보다 먼저 읽는다. 사이에 로그인이 끼면 토큰 비교에서 TokenAlreadyChanged 로 빠지고,
+                // 반대 순서면 이전 토큰 호출자가 새 세션의 회전을 치게 된다.
+                val sessionId = runBlocking { authRepository.get().getSessionId() }.getOrNull()
                 val currentToken = runBlocking { authRepository.get().getAccessToken() }.getOrNull()
                 if (!currentToken.isNullOrEmpty() && currentToken != expectedAccessToken) {
                     return Outcome.TokenAlreadyChanged(currentToken)
                 }
+                if (sessionId == null) {
+                    // 회전할 세션이 없다(로그아웃 뒤). 리프레시 토큰도 없으므로 재발급 HTTP 를 치지 않는다.
+                    val failure = Outcome.UnexpectedFailure(IllegalStateException("리프레시 토큰이 존재하지 않습니다."))
+                    reportObservableFailure(failure)
+                    return failure
+                }
 
-                val rotationResult = runBlocking { authRepository.get().rotateToken() }
+                val rotationResult = runBlocking { authRepository.get().rotateToken(sessionId) }
                 val rotationException = rotationResult.exceptionOrNull()
                 if (rotationException != null) {
-                    // 실패한 토큰의 deadline 을 지워 선제 재시도 반복을 막는다.
-                    expiryTracker.clear()
+                    // 실패한 토큰의 deadline 을 지워 선제 재시도 반복을 막는다. 세션이 바뀌었다면 남은 deadline 은 새 세션의 것이다.
+                    clearDeadlineIfCurrent(sessionId)
                     val failure = classifyFailure(rotationException)
-                    rememberIfRejected(expectedAccessToken, failure)
+                    rememberIfRejected(expectedAccessToken, sessionId, failure)
                     reportObservableFailure(failure)
                     return failure
                 }
 
                 val newBundle = rotationResult.getOrThrow()
                 if (newBundle.accessToken.isEmpty()) {
-                    expiryTracker.clear()
+                    clearDeadlineIfCurrent(sessionId)
                     val failure =
                         Outcome.UnexpectedFailure(
                             IllegalStateException("Token rotation returned an empty access token"),
@@ -125,11 +142,22 @@ class TokenReissuer
             }
         }
 
+        private fun clearDeadlineIfCurrent(sessionId: String) {
+            val currentSessionId = runBlocking { authRepository.get().getSessionId() }.getOrNull()
+            if (currentSessionId == sessionId) expiryTracker.clear()
+        }
+
         private fun classifyFailure(exception: Throwable): Outcome.Failure =
             when (exception) {
+                // 시작한 세션이 끝났다. 이전 토큰으로는 더 진행할 수 없으므로 거절과 같이 다룬다.
+                is SessionChangedException -> Outcome.AuthenticationRejected(exception)
+
                 is ApiException -> classifyApiFailure(exception)
+
                 is HttpException -> classifyHttpFailure(exception, exception.code())
+
                 is IOException -> Outcome.TransportFailure(exception)
+
                 else -> Outcome.UnexpectedFailure(exception)
             }
 
@@ -164,13 +192,17 @@ class TokenReissuer
          *
          * 정리를 락 밖(호출자)에 두면 락이 풀린 뒤 정리가 끝나기까지가 대기자의 재발급이
          * 빠져나가는 창이다. 일시 실패는 여기 들어오지 않는다 — 세션도 유지하고 캐시도 하지 않는다.
+         *
+         * 정리는 [sessionId] 가 아직 지금 세션일 때만 한다. 이 거절은 재발급을 시작한 세션에 대한 판정이고,
+         * 응답을 기다리는 사이 새로 로그인한 세션을 지우면 안 된다 (#2238).
          */
         private fun rememberIfRejected(
             expectedAccessToken: String,
+            sessionId: String,
             failure: Outcome.Failure,
         ) {
             if (failure !is Outcome.AuthenticationRejected) return
-            runBlocking { authRepository.get().clearSession() }
+            runBlocking { authRepository.get().clearSessionIfCurrent(sessionId) }
             rejectedAccessToken = expectedAccessToken
             rejection = failure
         }
diff --git a/core/network/src/test/kotlin/com/afternote/core/network/NetworkTestFakes.kt b/core/network/src/test/kotlin/com/afternote/core/network/NetworkTestFakes.kt
index 60419cafd8..6922300701 100644
--- a/core/network/src/test/kotlin/com/afternote/core/network/NetworkTestFakes.kt
+++ b/core/network/src/test/kotlin/com/afternote/core/network/NetworkTestFakes.kt
@@ -20,6 +20,7 @@ internal fun networkFakeAuthRepository(
 ): CoreFakeAuthRepository =
     CoreFakeAuthRepository.strict(accessToken = accessToken).apply {
         onGetAccessToken = null
+        onGetSessionId = null
         this.onRotateToken = onRotateToken
         this.onClearSession = { onClearSession(this) }
     }
diff --git a/core/network/src/test/kotlin/com/afternote/core/network/di/ConcurrentUnauthorizedReissueTest.kt b/core/network/src/test/kotlin/com/afternote/core/network/di/TokenAuthenticationPipelineTest.kt
similarity index 78%
rename from core/network/src/test/kotlin/com/afternote/core/network/di/ConcurrentUnauthorizedReissueTest.kt
rename to core/network/src/test/kotlin/com/afternote/core/network/di/TokenAuthenticationPipelineTest.kt
index b54bd99f68..3c993615d8 100644
--- a/core/network/src/test/kotlin/com/afternote/core/network/di/ConcurrentUnauthorizedReissueTest.kt
+++ b/core/network/src/test/kotlin/com/afternote/core/network/di/TokenAuthenticationPipelineTest.kt
@@ -7,6 +7,8 @@ import com.afternote.core.network.calladapter.ApiErrorCallAdapterFactory
 import com.afternote.core.network.dto.ReissueRequestDto
 import com.afternote.core.network.interceptor.AuthInterceptor
 import com.afternote.core.network.interceptor.TokenAuthenticator
+import com.afternote.core.network.model.ApiException
+import com.afternote.core.network.model.BaseResponse
 import com.afternote.core.network.service.TokenApiService
 import com.afternote.core.network.token.AccessTokenExpiryTracker
 import com.afternote.core.network.token.TokenReissuer
@@ -20,9 +22,12 @@ import okhttp3.Response
 import okhttp3.logging.HttpLoggingInterceptor
 import org.junit.After
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
 import org.junit.Assert.fail
 import org.junit.Test
 import retrofit2.create
+import retrofit2.http.POST
 import java.io.BufferedInputStream
 import java.io.ByteArrayOutputStream
 import java.io.IOException
@@ -34,6 +39,7 @@ import java.util.concurrent.ConcurrentLinkedQueue
 import java.util.concurrent.CountDownLatch
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.atomic.AtomicInteger
+import retrofit2.Call as RetrofitCall
 
 /**
  * 액세스 토큰이 만료된 채 콜드 스타트하면 같은 호스트로 동시에 나간 인증 요청이 전부 401 을 받는다.
@@ -43,11 +49,11 @@ import java.util.concurrent.atomic.AtomicInteger
  * Retrofit 을 그대로 쓰고, 기본 주소만 로컬 서버로 바꾼다. 요청 5건도 콜드 스타트 스레드 덤프에
  * 찍힌 경로 그대로다. 주간 리포트는 운영처럼 느린 경로용 파생 클라이언트를 탄다.
  *
- * 서버는 만료 토큰 요청이 [ColdStartServer.expiredBarrier] 수만큼 모일 때까지 401 을 쥐고 있는다.
+ * 서버는 만료 토큰 요청이 [AuthenticationServer.expiredBarrier] 수만큼 모일 때까지 401 을 쥐고 있는다.
  * 첫 401 이 재발급을 부르기 전에 요청 전부가 디스패처 실행 칸을 차지하게 해, 운 좋게 먼저 끝난
  * 요청이 칸을 비워 주는 경합을 없애기 위해서다.
  */
-class ConcurrentUnauthorizedReissueTest {
+class TokenAuthenticationPipelineTest {
     private val closeables = mutableListOf<AutoCloseable>()
 
     @After
@@ -65,9 +71,53 @@ class ConcurrentUnauthorizedReissueTest {
         assertColdStartCompletes(paths = COLD_START_PATHS.take(4))
     }
 
+    @Test
+    fun `비밀번호 불일치는 실제 요청 한 번으로 끝나고 Retrofit에 원래 오류를 전달한다`() {
+        assertPasswordChange(initialAccessToken = FRESH_ACCESS_TOKEN, responseStatus = 401, expectedReissues = 0)
+    }
+
+    @Test
+    fun `토큰 거절 1000 뒤 비밀번호 불일치는 실제 재발급 한 번으로 끝난다`() {
+        assertPasswordChange(initialAccessToken = EXPIRED_ACCESS_TOKEN, responseStatus = 401, expectedReissues = 1)
+    }
+
+    @Test
+    fun `정상 비밀번호 변경은 재발급 없이 성공한다`() {
+        assertPasswordChange(initialAccessToken = FRESH_ACCESS_TOKEN, responseStatus = 200, expectedReissues = 0)
+    }
+
+    private fun assertPasswordChange(
+        initialAccessToken: String,
+        responseStatus: Int,
+        expectedReissues: Int,
+    ) {
+        val server = AuthenticationServer(expiredBarrier = 1, passwordResponseStatus = responseStatus).also(closeables::add)
+        val wiring = AuthenticationWiring(server.baseUrl, initialAccessToken).also(closeables::add)
+
+        if (responseStatus == 401) {
+            val failure =
+                assertThrows(ApiException::class.java) {
+                    wiring.passwordApi.changePassword().execute()
+                }
+            assertEquals(401, failure.status)
+            assertEquals(1202, failure.code)
+            assertEquals("현재 비밀번호가 일치하지 않습니다.", failure.serverMessage)
+        } else {
+            val response = wiring.passwordApi.changePassword().execute()
+            assertEquals(200, response.body()?.status)
+        }
+
+        assertEquals(expectedReissues, server.reissueHits.get())
+        assertEquals(expectedReissues + 1, server.passwordHits.get())
+        assertEquals(0, wiring.repository.clearSessionCallCount)
+        assertTrue(wiring.repository.loggedIn)
+        assertEquals(FRESH_ACCESS_TOKEN, wiring.repository.accessToken)
+        assertEquals(0, wiring.reporter.writtenFailures.size)
+    }
+
     private fun assertColdStartCompletes(paths: List<ColdStartRequest>) {
-        val server = ColdStartServer(expiredBarrier = paths.size).also(closeables::add)
-        val wiring = ColdStartWiring(server.baseUrl).also(closeables::add)
+        val server = AuthenticationServer(expiredBarrier = paths.size).also(closeables::add)
+        val wiring = AuthenticationWiring(server.baseUrl).also(closeables::add)
 
         val finished = CountDownLatch(paths.size)
         val statuses = ConcurrentLinkedQueue<String>()
@@ -118,14 +168,15 @@ class ConcurrentUnauthorizedReissueTest {
     }
 
     /** 운영 [NetworkModule]·[ServiceModule] 조립을 그대로 따르되 기본 주소만 로컬 서버로 바꾼 묶음. */
-    private class ColdStartWiring(
+    private class AuthenticationWiring(
         baseUrl: String,
+        initialAccessToken: String = EXPIRED_ACCESS_TOKEN,
     ) : AutoCloseable {
         private val json = NetworkModule.provideJson()
         private val callAdapterFactory = ApiErrorCallAdapterFactory(json)
         private val loggingInterceptor = HttpLoggingInterceptor()
         private val tracker = AccessTokenExpiryTracker { 0L }
-        private val reporter = FakeErrorReporter()
+        val reporter = FakeErrorReporter()
 
         val baseClient: OkHttpClient = NetworkModule.provideBaseOkHttpClient()
         private val refreshClient: OkHttpClient = NetworkModule.provideRefreshOkHttpClient(baseClient, loggingInterceptor)
@@ -142,10 +193,10 @@ class ConcurrentUnauthorizedReissueTest {
                 .create<TokenApiService>()
 
         /** `AuthRepositoryImpl.rotateToken` 과 같은 순서: 저장 refresh 로 재발급을 치고 새 토큰을 저장한다. */
-        private val repository =
+        val repository =
             FakeAuthRepository(
                 loggedIn = true,
-                accessToken = EXPIRED_ACCESS_TOKEN,
+                accessToken = initialAccessToken,
                 refreshToken = STORED_REFRESH_TOKEN,
                 onRotateToken = {
                     runCatching {
@@ -170,13 +221,15 @@ class ConcurrentUnauthorizedReissueTest {
             )
 
         /** 운영 Retrofit 의 호출 팩토리 — 주간 리포트만 느린 경로용 파생 클라이언트로 가른다. */
-        val callFactory: Call.Factory =
+        private val retrofit =
             NetworkModule
                 .provideRetrofit(mainClient, json, callAdapterFactory)
                 .newBuilder()
                 .baseUrl(baseUrl)
                 .build()
-                .callFactory()
+
+        val callFactory: Call.Factory = retrofit.callFactory()
+        val passwordApi: PasswordApi = retrofit.create()
 
         override fun close() {
             // 재발급 클라이언트는 디스패처를 따로 쓴다(#2160) — 둘 다 닫아야 스레드가 남지 않는다.
@@ -188,6 +241,11 @@ class ConcurrentUnauthorizedReissueTest {
         }
     }
 
+    private interface PasswordApi {
+        @POST("auth/password/change")
+        fun changePassword(): RetrofitCall<BaseResponse<Unit>>
+    }
+
     private data class ColdStartRequest(
         val method: String,
         val path: String,
@@ -205,13 +263,15 @@ class ConcurrentUnauthorizedReissueTest {
      * 만료 토큰에는 401, 재발급에는 새 토큰, 새 토큰에는 200 으로 답하는 최소 HTTP/1.1 서버.
      * 새 테스트 의존성 없이 소켓 경계를 실제로 지나게 하려고 `java.net` 만 쓴다.
      */
-    private class ColdStartServer(
+    private class AuthenticationServer(
         expiredBarrier: Int,
+        private val passwordResponseStatus: Int = 200,
     ) : AutoCloseable {
         private val serverSocket = ServerSocket(0, BACKLOG, InetAddress.getLoopbackAddress())
         private val sockets = ConcurrentLinkedQueue<Socket>()
         private val expiredArrivals = CountDownLatch(expiredBarrier)
         val reissueHits = AtomicInteger()
+        val passwordHits = AtomicInteger()
         val baseUrl = "http://${serverSocket.inetAddress.hostAddress}:${serverSocket.localPort}/api/v1/"
 
         init {
@@ -262,15 +322,21 @@ class ConcurrentUnauthorizedReissueTest {
         private fun respond(
             requestLine: String,
             authorization: String?,
-        ): Pair<Int, String> =
-            when {
+        ): Pair<Int, String> {
+            val isPasswordChange = requestLine.startsWith("POST /api/v1/auth/password/change ")
+            if (isPasswordChange) passwordHits.incrementAndGet()
+            return when {
                 requestLine.startsWith("POST /api/v1/auth/reissue ") -> {
                     reissueHits.incrementAndGet()
                     200 to REISSUE_RESPONSE
                 }
 
                 authorization == "Bearer $FRESH_ACCESS_TOKEN" -> {
-                    200 to OK_RESPONSE
+                    if (isPasswordChange && passwordResponseStatus == 401) {
+                        401 to PASSWORD_MISMATCH_RESPONSE
+                    } else {
+                        200 to OK_RESPONSE
+                    }
                 }
 
                 else -> {
@@ -279,6 +345,7 @@ class ConcurrentUnauthorizedReissueTest {
                     401 to EXPIRED_RESPONSE
                 }
             }
+        }
 
         override fun close() {
             serverSocket.close()
@@ -308,7 +375,9 @@ class ConcurrentUnauthorizedReissueTest {
             )
 
         const val OK_RESPONSE = """{"status":200,"code":200,"message":"ok","data":null}"""
-        const val EXPIRED_RESPONSE = """{"status":401,"code":1106,"message":"expired"}"""
+        const val EXPIRED_RESPONSE = """{"status":401,"code":1000,"message":"expired"}"""
+        const val PASSWORD_MISMATCH_RESPONSE =
+            """{"status":401,"code":1202,"message":"현재 비밀번호가 일치하지 않습니다."}"""
         const val REISSUE_RESPONSE =
             """{"status":200,"code":200,"message":"ok",""" +
                 """"data":{"accessToken":"$FRESH_ACCESS_TOKEN","refreshToken":"fresh-refresh","expiresIn":3600}}"""
diff --git a/core/network/src/test/kotlin/com/afternote/core/network/interceptor/TokenAuthenticatorTest.kt b/core/network/src/test/kotlin/com/afternote/core/network/interceptor/TokenAuthenticatorTest.kt
index ead8b38dc5..95a762598d 100644
--- a/core/network/src/test/kotlin/com/afternote/core/network/interceptor/TokenAuthenticatorTest.kt
+++ b/core/network/src/test/kotlin/com/afternote/core/network/interceptor/TokenAuthenticatorTest.kt
@@ -11,6 +11,7 @@ import okhttp3.Protocol
 import okhttp3.Request
 import okhttp3.Response
 import okhttp3.ResponseBody.Companion.toResponseBody
+import org.junit.Assert.assertArrayEquals
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNull
 import org.junit.Assert.assertSame
@@ -48,6 +49,7 @@ class TokenAuthenticatorTest {
     private fun unauthorizedResponse(
         accessToken: String? = "old-token",
         priorCount: Int = 0,
+        body: String = "",
     ): Response {
         val requestBuilder = Request.Builder().url("https://afternote.kro.kr/api/v1/test")
         if (accessToken != null) requestBuilder.header("Authorization", "Bearer $accessToken")
@@ -72,9 +74,111 @@ class TokenAuthenticatorTest {
             .code(401)
             .message("Unauthorized")
             .priorResponse(prior)
+            .body(body.toResponseBody())
             .build()
     }
 
+    @Test
+    fun `비밀번호 불일치 1202는 갱신과 세션 정리 없이 원래 본문을 남긴다`() {
+        listOf(0, 1, 2).forEach { priorCount ->
+            val reporter = FakeErrorReporter()
+            val repository = networkFakeAuthRepository(accessToken = "old-token")
+            val body = """{"status":401,"code":1202,"message":"현재 비밀번호가 일치하지 않습니다."}"""
+            val response = unauthorizedResponse(priorCount = priorCount, body = body)
+
+            assertNull(authenticator(repository, reporter).authenticate(null, response))
+
+            assertEquals(0, repository.rotateCallCount)
+            assertEquals(0, repository.clearSessionCallCount)
+            assertEquals("old-token", repository.accessToken)
+            assertEquals(0, reporter.writtenFailures.size)
+            assertEquals(body, response.body.string())
+        }
+    }
+
+    @Test
+    fun `토큰 거절 1000과 미확인 또는 파싱 불가 401은 기존 갱신 경로를 따른다`() {
+        listOf(
+            """{"status":401,"code":1000}""",
+            """{"status":401,"code":2701}""",
+            """{"status":401,"code":9999}""",
+            """{"status":401}""",
+            """{"code":"1202"}""",
+            """{"code":1202.0}""",
+            """{"code":4294968498}""",
+            """{"code":{"value":1202}}""",
+            """{"code":1202""",
+            "not json",
+            "[]",
+            "",
+            """{"code":1202}""" + " ".repeat(64 * 1024) + "invalid suffix",
+        ).forEach { body ->
+            val repository =
+                networkFakeAuthRepository(
+                    accessToken = "old-token",
+                    onRotateToken = {
+                        accessToken = "fresh-token"
+                        Result.success(TokenBundle(accessToken = "fresh-token", refreshToken = "r"))
+                    },
+                )
+            val response = unauthorizedResponse(body = body)
+
+            val request = authenticator(repository).authenticate(null, response)
+
+            assertEquals(body, 1, repository.rotateCallCount)
+            assertEquals(body, "Bearer fresh-token", request?.header("Authorization"))
+            assertEquals(body, 0, repository.clearSessionCallCount)
+            assertEquals(body, response.body.string())
+        }
+    }
+
+    @Test
+    fun `잘못된 UTF-8 응답은 비밀번호 불일치로 단정하지 않고 원래 바이트를 보존한다`() {
+        val repository =
+            networkFakeAuthRepository(
+                accessToken = "old-token",
+                onRotateToken = {
+                    accessToken = "fresh-token"
+                    Result.success(TokenBundle(accessToken = "fresh-token", refreshToken = "r"))
+                },
+            )
+        val body = """{"code":1202,"message":"""".toByteArray() + byteArrayOf(0xC3.toByte()) + "\"}".toByteArray()
+        val response = unauthorizedResponse().newBuilder().body(body.toResponseBody()).build()
+
+        val request = authenticator(repository).authenticate(null, response)
+
+        assertEquals(1, repository.rotateCallCount)
+        assertEquals("Bearer fresh-token", request?.header("Authorization"))
+        assertEquals(0, repository.clearSessionCallCount)
+        assertArrayEquals(body, response.body.bytes())
+    }
+
+    @Test
+    fun `토큰 거절 뒤 갱신한 요청이 1202면 추가 갱신 없이 세션을 유지한다`() {
+        val reporter = FakeErrorReporter()
+        val repository =
+            networkFakeAuthRepository(
+                accessToken = "old-token",
+                onRotateToken = {
+                    accessToken = "fresh-token"
+                    Result.success(TokenBundle(accessToken = "fresh-token", refreshToken = "r"))
+                },
+            )
+        val authenticator = authenticator(repository, reporter)
+        val expiredResponse = unauthorizedResponse(body = """{"status":401,"code":1000}""")
+        val retry = authenticator.authenticate(null, expiredResponse)
+        val mismatchResponse =
+            unauthorizedResponse(accessToken = "fresh-token", priorCount = 1, body = """{"status":401,"code":1202}""")
+
+        assertEquals("Bearer fresh-token", retry?.header("Authorization"))
+        assertNull(authenticator.authenticate(null, mismatchResponse))
+
+        assertEquals(1, repository.rotateCallCount)
+        assertEquals(0, repository.clearSessionCallCount)
+        assertEquals("fresh-token", repository.accessToken)
+        assertEquals(0, reporter.writtenFailures.size)
+    }
+
     @Test
     fun `재시도 3회 도달 - 회전 없이 세션 정리 후 중단`() {
         val reporter = FakeErrorReporter()
diff --git a/core/network/src/test/kotlin/com/afternote/core/network/token/TokenReissuerTest.kt b/core/network/src/test/kotlin/com/afternote/core/network/token/TokenReissuerTest.kt
index 1b0ba0fb79..a8ee2986b6 100644
--- a/core/network/src/test/kotlin/com/afternote/core/network/token/TokenReissuerTest.kt
+++ b/core/network/src/test/kotlin/com/afternote/core/network/token/TokenReissuerTest.kt
@@ -1,5 +1,6 @@
 package com.afternote.core.network.token
 
+import com.afternote.core.domain.error.SessionChangedException
 import com.afternote.core.domain.testing.FakeAuthRepository
 import com.afternote.core.model.TokenBundle
 import com.afternote.core.network.FakeErrorReporter
@@ -268,18 +269,62 @@ class TokenReissuerTest {
     }
 
     @Test
-    fun `저장 토큰이 빈 값 - TokenAlreadyChanged 가 아니라 회전 시도로 진행`() {
+    fun `저장 토큰이 빈 값 - TokenAlreadyChanged 가 아니라 회전할 세션이 없는 실패로 끝난다`() {
+        val repository = networkFakeAuthRepository(accessToken = null)
+        val coordinator = reissuer(repository)
+
+        val outcome = coordinator.reissueOnce(expectedAccessToken = "old-token")
+
+        // 세션이 없으면 리프레시 토큰도 없다. 재발급 HTTP 없이 세션 유지 분류로 끝난다.
+        assertEquals(0, repository.rotateCallCount)
+        assertTrue(outcome is TokenReissuer.Outcome.UnexpectedFailure)
+    }
+
+    @Test
+    fun `재발급 시작 시점의 세션에 묶어 회전한다`() {
         val repository =
             networkFakeAuthRepository(
-                accessToken = null,
-                onRotateToken = { Result.failure(IllegalStateException("리프레시 토큰이 존재하지 않습니다.")) },
+                accessToken = "old-token",
+                onRotateToken = {
+                    accessToken = "fresh-token"
+                    Result.success(TokenBundle(accessToken = "fresh-token", refreshToken = "r"))
+                },
             )
-        val coordinator = reissuer(repository)
 
-        val outcome = coordinator.reissueOnce(expectedAccessToken = "old-token")
+        reissuer(repository).reissueOnce(expectedAccessToken = "old-token")
 
+        assertEquals(listOf(repository.sessionId), repository.rotatedSessionIds)
+    }
+
+    @Test
+    fun `세션이 바뀌어 저장하지 못한 회전 - Rotated 도 deadline 도 없이 이전 토큰 호출자에게 거절`() {
+        val reporter = FakeErrorReporter()
+        val repository =
+            networkFakeAuthRepository(
+                accessToken = "A-access",
+                onRotateToken = {
+                    // 응답을 기다리는 사이 로그아웃이 끝났고, 저장소가 이 회전을 쓰지 않았다.
+                    clearSession()
+                    Result.failure(SessionChangedException())
+                },
+                onClearSession = {
+                    accessToken = null
+                    refreshToken = null
+                    Result.success(Unit)
+                },
+            )
+        val coordinator = reissuer(repository, reporter)
+
+        val outcome = coordinator.reissueOnce(expectedAccessToken = "A-access")
+
+        assertTrue(outcome is TokenReissuer.Outcome.AuthenticationRejected)
+        assertTrue((outcome as TokenReissuer.Outcome.AuthenticationRejected).exception is SessionChangedException)
+        assertFalse(tracker.isExpiringSoon())
+        assertTrue(reporter.writtenFailures.isEmpty())
+        // 로그아웃 정리 1회뿐이고, 같은 토큰의 대기자는 재발급 없이 같은 결과를 받는다.
+        assertEquals(1, repository.clearSessionCallCount)
+        assertSame(outcome, coordinator.reissueOnce(expectedAccessToken = "A-access"))
         assertEquals(1, repository.rotateCallCount)
-        assertTrue(outcome is TokenReissuer.Outcome.UnexpectedFailure)
     }
 
     @Test
@@ -356,4 +401,70 @@ class TokenReissuerTest {
         assertEquals(TokenReissuer.Outcome.Rotated("rotated-token"), outcome)
         assertEquals(2, repository.rotateCallCount)
     }
+
+    @Test
+    fun `이전 세션의 늦은 확정 거절은 새로 로그인한 세션을 지우지 않는다`() {
+        listOf(
+            ApiException(status = 401, code = 1107, serverMessage = "무효 refresh", fallbackMessage = "무효 refresh"),
+            ApiException(status = 400, code = 1107, serverMessage = "무효 refresh", fallbackMessage = "무효 refresh"),
+        ).forEach { failure ->
+            tracker.clear()
+            val repository =
+                networkFakeAuthRepository(
+                    accessToken = "A-access",
+                    onRotateToken = {
+                        // 재발급 응답을 기다리는 사이 로그아웃과 B 로그인이 끝났다. 로그인은 발급 응답의 deadline 도 기록한다.
+                        clearSession()
+                        saveSession("B-access", "B-refresh")
+                        tracker.record(expiresInSeconds = 30)
+                        Result.failure(failure)
+                    },
+                    onClearSession = {
+                        accessToken = null
+                        refreshToken = null
+                        Result.success(Unit)
+                    },
+                ).apply { onSaveSession = null }
+            val coordinator = reissuer(repository)
+
+            val outcome = coordinator.reissueOnce(expectedAccessToken = "A-access")
+
+            assertTrue(outcome is TokenReissuer.Outcome.AuthenticationRejected)
+            assertSame(failure, (outcome as TokenReissuer.Outcome.AuthenticationRejected).exception)
+            assertEquals("${failure.status}/${failure.code} 거절이 B 를 지웠다", "B-access", repository.accessToken)
+            assertEquals("B-refresh", repository.refreshToken)
+            // 로그아웃 정리 1회뿐이다. 거절 처리가 정리를 더 부르면 그것이 B 를 지운다.
+            assertEquals(1, repository.clearSessionCallCount)
+            assertTrue("B 의 선제 갱신 deadline 이 지워졌다", tracker.isExpiringSoon())
+
+            // A 토큰으로 늦게 들어온 대기자는 재발급 없이 같은 거절을 받는다 (#1126).
+            assertSame(outcome, coordinator.reissueOnce(expectedAccessToken = "A-access"))
+            assertEquals(1, repository.rotateCallCount)
+        }
+    }
+
+    @Test
+    fun `이전 세션의 일시 실패는 새 세션의 deadline 을 지우지 않는다`() {
+        val repository =
+            networkFakeAuthRepository(
+                accessToken = "A-access",
+                onRotateToken = {
+                    clearSession()
+                    saveSession("B-access", "B-refresh")
+                    tracker.record(expiresInSeconds = 30)
+                    Result.failure(SocketTimeoutException("timeout"))
+                },
+                onClearSession = {
+                    accessToken = null
+                    refreshToken = null
+                    Result.success(Unit)
+                },
+            ).apply { onSaveSession = null }
+
+        val outcome = reissuer(repository).reissueOnce(expectedAccessToken = "A-access")
+
+        assertTrue(outcome is TokenReissuer.Outcome.TransportFailure)
+        assertEquals("B-access", repository.accessToken)
+        assertTrue(tracker.isExpiringSoon())
+    }
 }
diff --git a/core/ui/src/main/kotlin/com/afternote/core/ui/Route.kt b/core/ui/src/main/kotlin/com/afternote/core/ui/Route.kt
index 761c198e54..7bb5e91371 100644
--- a/core/ui/src/main/kotlin/com/afternote/core/ui/Route.kt
+++ b/core/ui/src/main/kotlin/com/afternote/core/ui/Route.kt
@@ -1,9 +1,10 @@
 package com.afternote.core.ui
 
+import androidx.navigation3.runtime.NavKey
 import kotlinx.serialization.Serializable
 
 @Serializable
-sealed interface Route {
+sealed interface Route : NavKey {
     @Serializable
     data object Onboarding : Route
 
@@ -53,6 +54,10 @@ sealed interface Route {
     @Serializable
     data object Receiver : Route
 
+    /** 카카오 수신자 초대 랜딩의 앱 루트 host (#944). 내부 화면은 수신자 피처 로컬 스택이 소유한다. */
+    @Serializable
+    data object ReceiverInvitation : Route
+
     /**
      * 설정 로컬 스택의 host destination (#1695).
      *
diff --git a/core/ui/src/main/kotlin/com/afternote/core/ui/auth/PasswordRuleItem.kt b/core/ui/src/main/kotlin/com/afternote/core/ui/auth/PasswordRuleItem.kt
new file mode 100644
index 0000000000..eff69da47f
--- /dev/null
+++ b/core/ui/src/main/kotlin/com/afternote/core/ui/auth/PasswordRuleItem.kt
@@ -0,0 +1,58 @@
+package com.afternote.core.ui.auth
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.semantics.clearAndSetSemantics
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.unit.dp
+import com.afternote.core.ui.theme.AfternoteDesign
+
+/**
+ * 비밀번호 규칙 안내 한 줄 — 불릿 + 문구 (#2191).
+ *
+ * 새 비밀번호를 받는 화면(회원가입 3단계·비밀번호 찾기의 변경·설정의 비밀번호 변경)이 같은 시안
+ * `2383:16789` 의 안내 줄을 쓴다. 조합 규칙 문구는 `core_ui_password_rule_combination` 이고, 판정은
+ * core:domain `NewPasswordRule` 이 갖는다.
+ *
+ * @param isSatisfied 규칙 충족 여부에 따라 색이 갈리는 줄만 넘긴다. null(기본)이면 상태 없는
+ *   안내 줄이라 항상 강조색이다 — "이전에 사용한 적 없는 비밀번호가 안전합니다." 처럼 클라가
+ *   판정할 수 없는 문구가 여기 해당한다.
+ */
+@Composable
+public fun PasswordRuleItem(
+    text: String,
+    modifier: Modifier = Modifier,
+    isSatisfied: Boolean? = null,
+) {
+    val color =
+        if (isSatisfied == false) {
+            AfternoteDesign.colors.gray5
+        } else {
+            AfternoteDesign.colors.b1
+        }
+    Row(
+        modifier =
+            modifier
+                .fillMaxWidth()
+                .semantics(mergeDescendants = true) {},
+        horizontalArrangement = Arrangement.spacedBy(6.dp),
+        verticalAlignment = Alignment.Top,
+    ) {
+        Text(
+            text = "•",
+            modifier = Modifier.clearAndSetSemantics {},
+            style = AfternoteDesign.typography.captionLargeB,
+            color = color,
+        )
+        Text(
+            text = text,
+            style = AfternoteDesign.typography.captionLargeB,
+            color = color,
+        )
+    }
+}
diff --git a/core/ui/src/main/kotlin/com/afternote/core/ui/button/AfternoteButton.kt b/core/ui/src/main/kotlin/com/afternote/core/ui/button/AfternoteButton.kt
index 70c982ddb5..5ffe21f649 100644
--- a/core/ui/src/main/kotlin/com/afternote/core/ui/button/AfternoteButton.kt
+++ b/core/ui/src/main/kotlin/com/afternote/core/ui/button/AfternoteButton.kt
@@ -61,6 +61,8 @@ private val AfternoteButtonVerticalPadding = 13.dp
  * @param isLoading true 면 라벨 대신 스피너를 그리고 클릭을 막는다 (네트워크 대기 등 진행 중 표시).
  *   dual-action 모드도 로딩 중엔 단일 스피너 바로 렌더되어 양쪽 클릭이 모두 막힌다.
  *   접근성 이름은 [text] 로 유지되고, 로딩 상태는 stateDescription 으로 노출된다.
+ * @param contentColor [type] 색 테이블 대신 쓸 라벨 색. [containerColor] 만 바꾸면 라벨이 타입 기본색으로
+ *   남아 카카오 노랑 위에 흰 글자가 되는 조합이 생긴다 — 브랜드 버튼은 둘을 함께 준다 (#944).
  */
 @Composable
 fun AfternoteButton(
@@ -71,6 +73,7 @@ fun AfternoteButton(
     isLoading: Boolean = false,
     secondaryText: String? = null,
     containerColor: Color? = null,
+    contentColor: Color? = null,
     onSecondaryClick: (() -> Unit)? = null,
     isSecondaryEnabled: Boolean = true,
 ) {
@@ -87,17 +90,18 @@ fun AfternoteButton(
             }
     // 바로 위 containerColor 와 같은 enum 이다 — else 로 닫으면 타입이 늘 때 배경색만 컴파일 에러로
     // 잡히고 글자색은 조용히 흰색으로 굳는다. 두 분기가 같은 시점에 깨지도록 항목을 모두 적는다.
-    val contentColor =
-        when (type) {
-            AfternoteButtonType.Plain -> AfternoteDesign.colors.gray9
+    val resolvedContentColor =
+        contentColor
+            ?: when (type) {
+                AfternoteButtonType.Plain -> AfternoteDesign.colors.gray9
 
-            AfternoteButtonType.Un -> AfternoteDesign.colors.gray5
+                AfternoteButtonType.Un -> AfternoteDesign.colors.gray5
 
-            AfternoteButtonType.Default,
-            AfternoteButtonType.Active,
-            AfternoteButtonType.Variant5,
-            -> AfternoteDesign.colors.white
-        }
+                AfternoteButtonType.Default,
+                AfternoteButtonType.Active,
+                AfternoteButtonType.Variant5,
+                -> AfternoteDesign.colors.white
+            }
     CompositionLocalProvider(
         LocalMinimumInteractiveComponentSize provides androidx.compose.ui.unit.Dp.Unspecified,
     ) {
@@ -111,7 +115,7 @@ fun AfternoteButton(
                 onSecondaryClick = onSecondaryClick,
                 isSecondaryEnabled = isSecondaryEnabled,
                 containerColor = resolvedContainerColor,
-                contentColor = contentColor,
+                contentColor = resolvedContentColor,
                 modifier = modifier,
             )
             return@CompositionLocalProvider
@@ -137,7 +141,7 @@ fun AfternoteButton(
             enabled = type != AfternoteButtonType.Un && !isLoading,
             shape = AfternoteButtonShape,
             color = resolvedContainerColor,
-            contentColor = contentColor,
+            contentColor = resolvedContentColor,
             border =
                 if (type == AfternoteButtonType.Plain || type == AfternoteButtonType.Un) {
                     BorderStroke(
@@ -158,7 +162,7 @@ fun AfternoteButton(
                     isLoading -> {
                         CircularProgressIndicator(
                             modifier = Modifier.size(18.dp),
-                            color = contentColor,
+                            color = resolvedContentColor,
                             strokeWidth = 2.dp,
                         )
                     }
diff --git a/core/ui/src/main/kotlin/com/afternote/core/ui/navigation/FeatureNavDisplay.kt b/core/ui/src/main/kotlin/com/afternote/core/ui/navigation/FeatureNavDisplay.kt
index 3d9bf8fe67..dc58e30707 100644
--- a/core/ui/src/main/kotlin/com/afternote/core/ui/navigation/FeatureNavDisplay.kt
+++ b/core/ui/src/main/kotlin/com/afternote/core/ui/navigation/FeatureNavDisplay.kt
@@ -1,5 +1,7 @@
 package com.afternote.core.ui.navigation
 
+import androidx.compose.animation.AnimatedContentTransitionScope
+import androidx.compose.animation.ContentTransform
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
@@ -12,7 +14,9 @@ import androidx.navigation3.runtime.NavEntry
 import androidx.navigation3.runtime.NavEntryDecorator
 import androidx.navigation3.runtime.NavKey
 import androidx.navigation3.runtime.rememberSaveableStateHolderNavEntryDecorator
+import androidx.navigation3.scene.Scene
 import androidx.navigation3.ui.NavDisplay
+import androidx.navigation3.ui.defaultPredictivePopTransitionSpec
 
 /**
  * 피처 하나가 소유하는 로컬 Navigation 3 스택의 표준 표시부.
@@ -40,6 +44,8 @@ import androidx.navigation3.ui.NavDisplay
  * `FeatureNavDisplayTest` 의 「back 은 스택만 줄이고 바닥에서는 이 표시부를 지나쳐 위로 흐른다」가
  * 이 갈림을 잠근다.
  *
+ * `predictivePopTransitionSpec` 은 Navigation 3 기본값이며, 루트는 #1702 이관 중 공용 전환을 지정한다.
+ *
  * #1996: 온보딩의 named argument 호환을 위해 `boundary` 이름을 소비처 전환까지 유지한다.
  */
 @Composable
@@ -47,6 +53,8 @@ public fun FeatureNavDisplay(
     backStack: NavBackStack<NavKey>,
     boundary: FeatureNavigationCallbacks,
     modifier: Modifier = Modifier,
+    predictivePopTransitionSpec: AnimatedContentTransitionScope<Scene<NavKey>>.(Int) -> ContentTransform =
+        defaultPredictivePopTransitionSpec(),
     entryProvider: (NavKey) -> NavEntry<NavKey>,
 ) {
     val currentNavigationCallbacks by rememberUpdatedState(boundary)
@@ -69,6 +77,7 @@ public fun FeatureNavDisplay(
                 currentNavigationCallbacks.exit()
             }
         },
+        predictivePopTransitionSpec = predictivePopTransitionSpec,
         entryDecorators = rememberStandardNavEntryDecorators(),
         entryProvider = entryProvider,
     )
diff --git a/core/ui/src/main/kotlin/com/afternote/core/ui/navigation/PredictiveBackTransitions.kt b/core/ui/src/main/kotlin/com/afternote/core/ui/navigation/PredictiveBackTransitions.kt
index 1adf08d5d4..2a5b9c7248 100644
--- a/core/ui/src/main/kotlin/com/afternote/core/ui/navigation/PredictiveBackTransitions.kt
+++ b/core/ui/src/main/kotlin/com/afternote/core/ui/navigation/PredictiveBackTransitions.kt
@@ -9,8 +9,8 @@ import androidx.compose.animation.scaleOut
 /**
  * predictive back 진행 중 두 화면을 그리는 전환 한 쌍 (#1869).
  *
- * 이 저장소는 네비게이션 엔진을 둘 쓴다 — 루트는 Navigation 2 `NavHost`, 각 피처의 로컬 스택은
- * Navigation 3 `NavDisplay` 다(#1698). **두 엔진의 기본값이 서로 다르다.**
+ * 이 저장소의 루트와 피처별 로컬 스택은 Navigation 3 `NavDisplay` 를 쓴다(#1702).
+ * 루트는 이 공용 전환을 명시적으로 전달하고, 로컬 스택은 같은 기본 전환을 사용한다.
  *
  * - Nav3 `NavDisplay` 는 `predictivePopTransitionSpec` 을 안 넘기면
  *   `defaultPredictivePopTransitionSpec()` 을 쓴다 — 아래 두 값과 같은 모양이다
@@ -20,10 +20,9 @@ import androidx.compose.animation.scaleOut
  *   (navigation-compose 2.9.8 `NavHost.kt:132`). 앞 화면이 줄지 않고 제자리에서 흐려지기만 해,
  *   진행 중에 두 화면이 같은 크기로 겹쳐 보인다 — #1869 가 실기기에서 잡은 증상이다.
  *
- * 그래서 **새 값을 정하지 않고 Nav3 기본값을 그대로 복제해** 두 엔진의 눈에 보이는 동작을 맞춘다.
- * 루트가 `NavDisplay` 로 바뀌면(#1702) 이 두 상수를 그대로
+ * 새 전환 값을 정하지 않고 Nav3 기본값과 같은 동작을 공유한다. 루트는
  * `predictivePopTransitionSpec = { ContentTransform(PredictiveBackPopEnter, PredictiveBackPopExit) }`
- * 에 넘겨, 이관 전후로 화면이 달라지지 않게 한다.
+ * 를 전달해 이 전환을 명시적으로 유지한다.
  *
  * ### 모서리 라운딩은 여기서 못 준다
  * `ExitTransition` 은 fade·scale·slide·shrink 만 표현한다 — clip 이나 shape 는 담을 수 없다.
diff --git a/core/ui/src/main/res/values/strings.xml b/core/ui/src/main/res/values/strings.xml
index 4bcc36bb95..95c0a1e416 100644
--- a/core/ui/src/main/res/values/strings.xml
+++ b/core/ui/src/main/res/values/strings.xml
@@ -87,4 +87,11 @@
     <string name="core_ui_media_sheet_voice">음성 추가하기</string>
     <string name="core_ui_media_sheet_file">파일 추가하기</string>
     <string name="core_ui_media_sheet_link">링크 추가하기</string>
+
+    <!--
+      새 비밀번호 조합 규칙 안내 문구 (#2191). 판정 정본 core:domain `NewPasswordRule` 과 짝이라
+      규칙이 바뀌면 이 문장도 함께 고친다. 설정과 온보딩(onboarding_signup_password_rule_combination)이
+      같은 값을 각자 갖고 있던 것을 core 정본으로 올린다. 온보딩 전환은 #2192.
+    -->
+    <string name="core_ui_password_rule_combination">8 ~ 15자의 영문, 숫자, 특수문자(@, $, !, %, *, #, ?, &amp;)를 각각 1자 이상 사용해 주세요.</string>
 </resources>
diff --git a/core/ui/src/test/kotlin/com/afternote/core/ui/testing/TouchTargetAssertionsTest.kt b/core/ui/src/test/kotlin/com/afternote/core/ui/testing/TouchTargetAssertionsTest.kt
index efbfe833a7..72ad59f58d 100644
--- a/core/ui/src/test/kotlin/com/afternote/core/ui/testing/TouchTargetAssertionsTest.kt
+++ b/core/ui/src/test/kotlin/com/afternote/core/ui/testing/TouchTargetAssertionsTest.kt
@@ -339,6 +339,32 @@ class TouchTargetAssertionsTest {
         assertTrue(targets.single { it.name == "No tab state" }.lacksRequiredState())
     }
 
+    /** 프레임워크 노드(예: ModalBottomSheet 스크림)를 빼도 나머지 위반은 그대로 잡혀야 한다. */
+    @Test
+    fun `excluded target is skipped but the rest of the sweep still fails`() {
+        composeRule.setContent {
+            Column(Modifier.padding(64.dp)) {
+                Box(Modifier.size(48.dp).clickable(role = Role.Button, onClick = {}).semantics { contentDescription = "OK" })
+                Box(
+                    Modifier
+                        .size(48.dp)
+                        .clickable(onClick = {})
+                        .semantics { contentDescription = "Framework scrim" },
+                )
+                Box(Modifier.size(48.dp).clickable(role = Role.Button, onClick = {}).testTag("unnamed"))
+            }
+        }
+
+        val error =
+            runCatching {
+                composeRule.assertAccessibleClickTargets(exclude = { it.name == "Framework scrim" })
+            }.exceptionOrNull()
+        assertTrue(error is AssertionError)
+        assertFalse(error?.message.orEmpty().contains("Role 누락"))
+        assertTrue(error?.message.orEmpty().contains("접근 가능한 이름 누락"))
+        assertTrue(error?.message.orEmpty().contains("unnamed"))
+    }
+
     @Test
     fun `assertion fails when there are zero enabled click targets`() {
         composeRule.setContent { Box(Modifier.fillMaxSize()) }
diff --git a/core/ui/src/testFixtures/kotlin/com/afternote/core/ui/testing/TouchTargetAssertions.kt b/core/ui/src/testFixtures/kotlin/com/afternote/core/ui/testing/TouchTargetAssertions.kt
index 0676742d3c..9c199412d2 100644
--- a/core/ui/src/testFixtures/kotlin/com/afternote/core/ui/testing/TouchTargetAssertions.kt
+++ b/core/ui/src/testFixtures/kotlin/com/afternote/core/ui/testing/TouchTargetAssertions.kt
@@ -115,9 +115,19 @@ fun SemanticsNodeInteractionsProvider.scanEnabledClickTargets(): List<EnabledCli
     }
 }
 
-/** 활성 클릭 타깃의 hit bounds, 이름, 역할, 상태 및 중첩 클릭 계약을 단언한다. */
-fun SemanticsNodeInteractionsProvider.assertAccessibleClickTargets(minimumSize: Dp = MinimumTouchTargetSize) {
-    val targets = scanEnabledClickTargets()
+/**
+ * 활성 클릭 타깃의 hit bounds, 이름, 역할, 상태 및 중첩 클릭 계약을 단언한다.
+ *
+ * [exclude] 는 우리 화면 코드가 아닌 프레임워크 노드를 스윕에서 빼는 용도다 — 예를 들어
+ * `ModalBottomSheet` 가 만드는 스크림은 이름만 있고 Role 이 없어 그대로 두면 시트 안 계약과
+ * 무관하게 실패한다. 제외한 노드 말고는 스윕이 그대로라, 시트째 띄운 테스트도 본문의
+ * 검색 입력·빈 결과 안내·행 전체를 계속 본다.
+ */
+fun SemanticsNodeInteractionsProvider.assertAccessibleClickTargets(
+    minimumSize: Dp = MinimumTouchTargetSize,
+    exclude: (EnabledClickTarget) -> Boolean = { false },
+) {
+    val targets = scanEnabledClickTargets().filterNot(exclude)
     if (targets.isEmpty()) {
         throw AssertionError("활성 클릭 semantics가 하나도 없습니다")
     }
diff --git a/docs/convention/mvi.md b/docs/convention/mvi.md
index 7e6209284e..544c997a42 100644
--- a/docs/convention/mvi.md
+++ b/docs/convention/mvi.md
@@ -171,27 +171,30 @@ ViewModel 테스트는 작업 결과 신호와 소비 후 초기화를, 화면 
 
 ## 강제
 
-`MviContractKonsistTest` 가 셋을 본다.
+`MviContractKonsistTest` 가 넷을 본다.
 
 | 규칙 | 내용 |
 | --- | --- |
 | A | `MviViewModel` 상속체는 `MutableStateFlow`·`MutableSharedFlow`·`Channel` 을 직접 선언하지 않는다 |
 | B | `feature/*/presentation` 의 ViewModel 은 `MviViewModel` 을 상속한다 |
 | C | `MviIntent`·`ReducerEvent` 를 직접 구현하는 타입은 `sealed interface` 다 |
+| D | 아직 전환하지 않은 `feature/*/presentation` ViewModel 도 이벤트용 `Channel`·`MutableSharedFlow` 를 새로 선언하지 않는다 (#1502) |
 
-규칙 B 는 아직 전환하지 않은 ViewModel 을 `PENDING_MVI_MIGRATION` 예외로 둔다(가드 도입 시점 49개, onboarding 파일럿 이후 46개). 모듈 전환 이슈가 닫힐 때마다 목록에서 빼고, **목록이 비면 예외 자체를 지운다.** `app` 의 ViewModel 2개는 규칙 B 의 대상이 아니다 — #1809 가 처리한다.
+규칙 B 는 아직 전환하지 않은 ViewModel 을 `PENDING_MVI_MIGRATION` 예외로 둔다(가드 도입 시점 49개). 전환할 때마다 목록에서 빼고, **목록이 비면 예외 자체를 지운다.** `app` 의 ViewModel 은 규칙 B 의 범위 밖이다.
 
-세 규칙은 **프로덕션 소스만** 본다. 테스트 더블이 `MviViewModel` 을 상속하며 보조 상태 홀더를 드는 것은
+규칙 D 는 규칙 B 의 예외에 든 ViewModel 이 전환 전까지 이벤트 스트림을 늘리지 못하게 한다. 규칙 A 는 전환한 ViewModel 만 보기 때문이다. 가드를 세울 때 이미 있던 선언은 `LEGACY_EVENT_STREAMS` 기준선으로 인정하고, 그 ViewModel 이 전환되거나 지워지면 기준선에서도 뺀다. 전환 전 상태 홀더인 `MutableStateFlow` 는 대상이 아니다.
+
+네 규칙은 **프로덕션 소스만** 본다. 테스트 더블이 `MviViewModel` 을 상속하며 보조 상태 홀더를 드는 것은
 규칙 A 의 대상이 아니다 — 더블은 계약을 지키는 대상이 아니라 계약을 흉내 내는 도구다.
 
-규칙 A·B 의 상속 판정은 **중간 추상 베이스를 낀 사슬까지** 따라간다. Konsist 의
+규칙 A·B·D 의 상속 판정은 **중간 추상 베이스를 낀 사슬까지** 따라간다. Konsist 의
 `parents(indirectParents = true)` 로는 안 되고(0.17.3 에서 이 스코프 구성으로는 직계와 같은 목록을
 돌려준다 — 실측), 스캔한 파일에서 이름 색인을 만들어 직접 걷는다.
 
 ### 가드가 «안» 보는 것
 
 - **`onIntent` 밖의 public 진입점.** 상속체가 `fun refreshOnReturn()` 같은 public 함수를 노출해도
-  세 규칙 어디도 막지 않는다. 화면이 ViewModel 을 직접 부르는 통로가 `onIntent` 하나여야 한다는 것은
+  네 규칙 어디도 막지 않는다. 화면이 ViewModel 을 직접 부르는 통로가 `onIntent` 하나여야 한다는 것은
   규약이지 CI 계약이 아니다. 리뷰에서 본다.
 - **`reduce` 밖의 전이.** 규칙 A 는 «상태 홀더 선언» 을 막을 뿐, `dispatch` 를 거치지 않는 다른 경로를
   전수로 잡지는 못한다.
diff --git a/docs/play-release.md b/docs/play-release.md
index 2478622b24..0bc3476558 100644
--- a/docs/play-release.md
+++ b/docs/play-release.md
@@ -28,7 +28,7 @@
 
 잠긴 사유는 하나로 모인다. 앱 만들기 버튼의 안내가 "새 앱을 만들려면 계정 확인을 완료하세요" 이고, 패키지 이름 등록도 "먼저 홈페이지에서 처리되지 않은 인증을 완료해야 합니다" 라고 같은 곳을 가리킨다.
 
-그래서 아래 "자동화 사전 준비" 는 1번(앱 등록)부터 대기 상태이고, 2~5번은 전부 1번에 매달려 있다.
+그래서 아래 "자동화 사전 준비" 는 1번(앱 등록)부터 대기 상태이고, Play Console 칸인 2번과 4번은 1번에 매달려 있다. 3번(Google Cloud)은 Play Console 과 무관해 2026-10-05 에 먼저 끝냈다(#852).
 
 ### 지금 막혀 있는 것과 푸는 사람
 
@@ -175,10 +175,21 @@ Android Publisher API는 **Console에서 최소 한 번 수동 업로드된 앱*
 
 **3. Google Cloud — API와 서비스 계정** (`console.cloud.google.com`)
 
-1. **API 및 서비스 → 라이브러리**에서 `Google Play Android Developer API`를 사용 설정한다.
-2. **IAM 및 관리자 → 서비스 계정 → 서비스 계정 만들기**: 이름 예 `play-internal-publisher`. **프로젝트 IAM 역할은 주지 않는다** — Play 권한은 Play Console에서 별도로 준다.
-3. Firebase 배포용 서비스 계정을 재사용하지 않는다. 두 채널의 자격을 분리해 두는 것이 이 이슈의 요구사항이다.
-4. **IAM 및 관리자 → Workload Identity 제휴**에서 기존 provider를 재사용하되, 새 서비스 계정에 `roles/iam.workloadIdentityUser`를 부여하면서 principal을 이 저장소로 한정한다.
+2026-10-05 에 끝냈다. Play Console 상태와 무관한 칸이라 1·2번을 기다리지 않았다. 아래는 그날 gcloud 로 확인한 프로젝트 `afternote-android`(번호 `918752702102`)의 구성이다([#852 코멘트](https://github.com/Afternote/Afternote-FE/issues/852#issuecomment-5993394780)).
+
+| 항목 | 상태 |
+|---|---|
+| `Google Play Android Developer API` | 사용 설정됨 |
+| 서비스 계정 | `play-internal-publisher@afternote-android.iam.gserviceaccount.com`. 프로젝트 IAM 역할 없음. Play 권한은 4번에서 Play Console 이 준다 |
+| WIF provider | `projects/918752702102/locations/global/workloadIdentityPools/github-actions/providers/afternote-fe` |
+| provider attribute condition | `repository` 가 `Afternote/Afternote-FE`, `ref` 가 `develop`·`main`, `workflow_ref` 가 `firebase-wif-canary.yml`·`release-distribution.yml`·`release-play-internal.yml` 로 시작하는 것만 허용 |
+| `play-internal-publisher` 의 `roles/iam.workloadIdentityUser` | principalSet `.../attribute.workflow_ref/Afternote/Afternote-FE/.github/workflows/release-play-internal.yml@refs/heads/main` 하나 |
+| Firebase 계정 `afternote-ci` 의 같은 역할 | `release-distribution.yml@refs/heads/main`, `firebase-wif-canary.yml@refs/heads/main`, `firebase-wif-canary.yml@refs/heads/develop` 셋 |
+
+- Firebase 배포용 서비스 계정을 재사용하지 않는다. 두 채널의 자격 분리가 #852 의 요구사항이다.
+- provider 는 Firebase 와 같은 것을 쓴다. 그래서 자격 분리는 provider 가 아니라 서비스 계정 바인딩이 맡는다. 바인딩을 저장소 전체(`attribute.repository`)로 걸면 provider 를 통과하는 다른 배포 워크플로도 그 계정을 빌릴 수 있다. 두 계정 모두 워크플로 단위(`attribute.workflow_ref`)로 묶은 이유다.
+- provider 를 새로 만들거나 attribute condition 을 바꿀 때는 condition 의 `workflow_ref` 허용 목록과 서비스 계정별 워크플로 단위 바인딩을 함께 맞춘다. 한쪽만 바꾸면 인증이 거부되거나, 반대로 허용한 워크플로가 남의 계정까지 빌릴 수 있게 된다. 배포 워크플로 파일 이름을 바꿀 때도 같다.
+- 시크릿에 넣을 비밀 아닌 값 두 개(`GCP_WORKLOAD_IDENTITY_PROVIDER`, `GCP_PLAY_SERVICE_ACCOUNT`)는 1Password 항목 `Afternote GCP Workload Identity`에 있다.
 
 **4. Play Console — 서비스 계정에 최소 권한 부여**
 
@@ -216,7 +227,7 @@ environment 와 보호 규칙, 변수는 2026-09-06 에 만들어 두었다. 남
 | `RELEASE_KEY_PASSWORD` | play-internal → Environment secrets | key 비밀번호 |
 | `PLAY_PACKAGE_NAME` | play-internal → Environment variables | `com.afternote.afternote_fe` |
 
-`KAKAO_NATIVE_APP_KEY`·`GOOGLE_WEB_CLIENT_ID`·`GOOGLE_SERVICES_JSON_B64`는 이미 저장소 secret으로 있어 그대로 쓴다. keystore·비밀번호·서비스 계정 값은 담당자가 직접 입력하며 저장소나 문서에 넣지 않는다.
+`KAKAO_NATIVE_APP_KEY`·`GOOGLE_WEB_CLIENT_ID`·`GOOGLE_SERVICES_JSON_B64`는 이미 저장소 secret으로 있어 그대로 쓴다. keystore·비밀번호는 담당자가 직접 입력하며 저장소나 문서에 넣지 않는다. `GCP_WORKLOAD_IDENTITY_PROVIDER`·`GCP_PLAY_SERVICE_ACCOUNT` 는 비밀이 아니고 실제 값은 3번과 1Password 항목 `Afternote GCP Workload Identity`에 있지만, secret 등록은 마찬가지로 손으로 한다.
 
 ### 실행
 
diff --git a/docs/release/distribution.md b/docs/release/distribution.md
index 7f5d608583..fc9e34a46f 100644
--- a/docs/release/distribution.md
+++ b/docs/release/distribution.md
@@ -79,7 +79,7 @@ PR 유형과 파일 단위 이력은 사용자 흐름의 의미를 완전히 표
 
 기존 `release-distribution.yml`의 `develop` 수동 배포(`workflow_dispatch`)는 #1029에서 제거했다. 도착지와 산출물 버전이 main 경로와 같아 실익이 PR 생성 한 단계뿐이었던 반면, release keystore와 service account를 임의 ref에 노출하는 표면이었다.
 
-예외적으로 [`firebase-wif-canary.yml`](../../.github/workflows/firebase-wif-canary.yml)은 `develop` 또는 `main`에서 보호 Environment 승인과 명시적 확인을 받은 뒤 실제 APK를 올리는 **수동 인증 호환성 검증 경로**다. 일반 릴리스나 임의 브랜치 배포 수단으로 사용하지 않으며, production JSON 자격을 WIF로 교체하기 전 판정 절차는 [WIF canary runbook](firebase-wif-canary.md)을 따른다.
+예외적으로 [`firebase-wif-canary.yml`](../../.github/workflows/firebase-wif-canary.yml)은 `develop` 또는 `main`에서 보호 Environment 승인과 명시적 확인을 받은 뒤 실제 APK를 올리는 **수동 인증 호환성 검증 경로**다. 일반 릴리스나 임의 브랜치 배포 수단으로 사용하지 않는다. production `release-distribution.yml`도 #1463부터 같은 WIF 경로로 인증하고, 장기 JSON 키 경로는 #1566에서 걷었다. canary 실행 조건은 [WIF canary runbook](firebase-wif-canary.md)을 따른다.
 
 `develop` → `main` 릴리스 PR 본문에 다음 섹션을 채운다.
 
@@ -106,15 +106,14 @@ CI가 사용하는 GitHub Secrets (Settings → Secrets and variables → Action
 | `RELEASE_STORE_PASSWORD` | keystore 비밀번호 |
 | `RELEASE_KEY_ALIAS` | key alias (`afternote-release`) |
 | `RELEASE_KEY_PASSWORD` | key 비밀번호 |
-| `FIREBASE_SERVICE_ACCOUNT_JSON` | App Distribution Admin 권한 부여된 service account JSON 원문 |
 | `KAKAO_NATIVE_APP_KEY` · `GOOGLE_WEB_CLIENT_ID` · `GOOGLE_SERVICES_JSON_B64` | release distribution·WIF canary·dependency audit가 쓰는 실서비스 앱 설정 |
-| `GCP_WORKLOAD_IDENTITY_PROVIDER` · `GCP_FIREBASE_SERVICE_ACCOUNT` | 수동 WIF canary 전용 OIDC 설정 ([runbook](firebase-wif-canary.md)) |
+| `GCP_WORKLOAD_IDENTITY_PROVIDER` · `GCP_FIREBASE_SERVICE_ACCOUNT` | release distribution과 WIF canary가 Firebase 업로드 직전에 쓰는 WIF 설정. 서비스 계정 `afternote-ci` 는 이 두 워크플로에만 묶여 있다([Play release runbook](../play-release.md) 사전 준비 3번) |
 
 > base64 인코딩: `base64 -i ~/afternote-release.jks | pbcopy` (macOS)
 
 PR 검증용 lint·unit-test·screenshot은 repository secret 대신
 `.github/actions/setup-ci-config`가 만드는 결정적 CI 전용 placeholder를 사용한다. 이 fixture는
-배포에 사용할 수 없으며, production `release-distribution.yml`은 계속 승인된 환경의 JSON 자격을 사용한다. WIF canary 성공만으로 이를 제거하지 않는다.
+배포에 사용할 수 없으며, production `release-distribution.yml`은 승인된 환경에서 WIF로 받은 단기 자격으로만 업로드한다.
 
 ### 배포 provenance: 이 APK 가 어느 commit·run 에서 나왔는지 (#851)
 
diff --git a/docs/release/firebase-wif-canary.md b/docs/release/firebase-wif-canary.md
index 1d7627d633..ad1feafc26 100644
--- a/docs/release/firebase-wif-canary.md
+++ b/docs/release/firebase-wif-canary.md
@@ -1,38 +1,46 @@
 # Firebase App Distribution WIF canary
 
-이 문서는 기존 `FIREBASE_SERVICE_ACCOUNT_JSON` 인증을 즉시 교체하지 않고, 별도 수동
-canary에서 GitHub OIDC와 Google Cloud Workload Identity Federation 호환성을 먼저 확인하는
-절차다. 저장소 workflow만 준비하며 Google Cloud·GitHub Settings 변경과 실제 업로드 실행은
-별도 승인 범위다.
+이 문서는 수동 canary에서 GitHub OIDC와 Google Cloud Workload Identity Federation으로
+Firebase App Distribution 업로드를 확인하는 절차다. 처음에는 장기 JSON 키를 WIF로 바꾸기 전의
+호환성 검증으로 만들었고, 전환은 끝났다. production `release-distribution.yml`은 #1463부터
+WIF로 인증하고, `FIREBASE_SERVICE_ACCOUNT_JSON` 롤백 경로는 #1566에서 걷었다.
 
 ## 현재 안전 경계
 
-- production `release-distribution.yml`은 기존 JSON 인증을 그대로 사용한다.
+- production `release-distribution.yml`도 같은 WIF 설정으로 인증한다. JSON 키 경로는 없다.
 - canary는 `develop` 또는 `main`의 수동 실행과 `release-distribution` Environment 승인을 모두
   요구한다.
 - signed APK는 인증 전에 빌드하고 같은 runner에서 바로 업로드한다. public Actions artifact로
   게시하지 않는다.
 - WIF 인증은 업로드 직전에만 수행한다. provider·service account 값, token, 생성된 ADC 상세는
   workflow summary나 별도 artifact에 기록하지 않는다.
-- canary 실패 시 production workflow나 기존 JSON secret을 변경·삭제하지 않는다.
+- canary 실패만으로 production workflow의 인증 설정을 바꾸지 않는다.
 
-## 별도 승인이 필요한 외부 준비
+## 외부 준비
 
-다음 항목은 이 PR에서 만들거나 수정하지 않는다.
+전환 때 갖춘 Google Cloud 쪽 준비다. provider와 서비스 계정 바인딩의 현재 값은
+[Play release runbook](../play-release.md) 사전 준비 3번에 있다.
 
 1. GitHub OIDC용 workload identity pool/provider와 Firebase App Distribution 전용 최소 권한
    service account를 준비한다.
-2. provider attribute mapping에 `repository`, `repository_owner`, `ref`, `workflow_ref`,
-   `environment` claim을 포함한다.
-3. attribute condition은 최소한 다음을 동시에 제한한다.
+2. provider attribute mapping은 `google.subject`(`sub`), `repository`, `repository_owner`, `ref`,
+   `workflow_ref`를 싣는다. `environment` claim은 매핑하지 않는다.
+3. attribute condition은 다음을 동시에 제한한다(2026-10-05 gcloud 조회).
    - repository: `Afternote/Afternote-FE`
-   - owner: `Afternote`
    - ref: `refs/heads/develop` 또는 `refs/heads/main`
-   - workflow: `.github/workflows/firebase-wif-canary.yml`
-   - environment: `release-distribution`
+   - workflow_ref: `firebase-wif-canary.yml`, `release-distribution.yml`, `release-play-internal.yml`
+     중 하나로 시작
+
+   owner와 environment는 조건에 없다. owner는 repository 전체 이름 일치가 대신하고, environment
+   승인은 provider가 아니라 각 워크플로의 GitHub Environment 보호 규칙이 건다. 워크플로별 자격 분리는
+   아래 5번의 서비스 계정 바인딩이 맡는다.
 4. 보호된 Environment에 `GCP_WORKLOAD_IDENTITY_PROVIDER`와
    `GCP_FIREBASE_SERVICE_ACCOUNT`를 masked secret으로 등록한다.
-5. 허용 branch canary 성공뿐 아니라 다른 branch·fork·workflow의 credential 발급 거부도
+5. Firebase 서비스 계정 `afternote-ci`의 `roles/iam.workloadIdentityUser`는 저장소 전체가 아니라
+   `release-distribution.yml@refs/heads/main`, `firebase-wif-canary.yml@refs/heads/main`,
+   `firebase-wif-canary.yml@refs/heads/develop` 셋의 `attribute.workflow_ref`에만 준다. 같은 provider를
+   Play 배포 워크플로도 통과하므로, 저장소 단위로 묶으면 그 워크플로가 Firebase 계정을 빌릴 수 있다.
+6. 허용 branch canary 성공뿐 아니라 다른 branch·fork·workflow의 credential 발급 거부도
    Google Cloud audit evidence로 확인한다.
 
 공식 근거:
@@ -42,14 +50,14 @@ canary에서 GitHub OIDC와 Google Cloud Workload Identity Federation 호환성
 - [Firebase App Distribution CI/CD와 WIF credential configuration](https://firebase.google.com/docs/app-distribution/best-practices-distributing-android-apps-to-qa-testers-with-ci-cd)
 - [google-github-actions/auth](https://github.com/google-github-actions/auth)
 
-## 전환 판정
+## 전환 판정 (완료)
 
-JSON 경로 제거는 아래가 모두 PASS인 별도 후속 변경에서만 한다.
+#1463·#1566 전환 때 쓴 기준이다. 인증 구성을 다시 바꿀 때도 같은 기준으로 확인한다.
 
 - 승인된 `develop` 또는 `main` canary APK가 WIF ADC로 1회 업로드된다.
 - Firebase release의 source SHA와 실행 URL이 해당 canary run과 일치한다.
 - 허용하지 않은 branch·fork·workflow의 credential 발급이 거부된다.
 - 대상 service account 권한이 Firebase App Distribution 업로드 최소 범위로 검토된다.
-- 실패 canary 뒤 기존 production JSON 경로가 정상 동작한다.
+- 실패 canary 뒤 production 배포 경로가 정상 동작한다.
 
-하나라도 확인되지 않으면 상태는 `UNVERIFIED`이며 기존 JSON secret을 유지한다.
+하나라도 확인되지 않으면 상태는 `UNVERIFIED`이며 production 인증 구성을 바꾸지 않는다.
diff --git a/feature/afternote/data/src/main/kotlin/com/afternote/feature/afternote/data/mapper/AfternoteDetailMapper.kt b/feature/afternote/data/src/main/kotlin/com/afternote/feature/afternote/data/mapper/AfternoteDetailMapper.kt
index 020b5e8587..0c7f247ce9 100644
--- a/feature/afternote/data/src/main/kotlin/com/afternote/feature/afternote/data/mapper/AfternoteDetailMapper.kt
+++ b/feature/afternote/data/src/main/kotlin/com/afternote/feature/afternote/data/mapper/AfternoteDetailMapper.kt
@@ -185,11 +185,15 @@ private fun AfternoteMemorialDto.toDraftMemorialContent() =
         media = toMemorialMedia(),
     )
 
+/**
+ * 미디어 URL 의 빈 값은 여기서 한 번만 `null` 로 맞춘다. 앱 안에서는 `null` 만 「없음」이다.
+ * BE `main` 은 빈 미디어를 `null` 로 저장하므로 빈 문자열은 옛 데이터에서만 온다.
+ */
 private fun AfternoteMemorialDto.toMemorialMedia() =
     MemorialMedia(
-        photoUrl = memorialPhotoUrl,
-        videoUrl = memorialVideo?.videoUrl,
-        thumbnailUrl = memorialVideo?.thumbnailUrl,
+        photoUrl = memorialPhotoUrl?.ifBlank { null },
+        videoUrl = memorialVideo?.videoUrl?.ifBlank { null },
+        thumbnailUrl = memorialVideo?.thumbnailUrl?.ifBlank { null },
     )
 
 private fun AfternoteDetailReceiverDto.toDomain(): DetailReceiver? =
diff --git a/feature/afternote/data/src/main/kotlin/com/afternote/feature/afternote/data/paging/AfternotePagingSource.kt b/feature/afternote/data/src/main/kotlin/com/afternote/feature/afternote/data/paging/AfternotePagingSource.kt
index 2963fbaa26..33aea24a29 100644
--- a/feature/afternote/data/src/main/kotlin/com/afternote/feature/afternote/data/paging/AfternotePagingSource.kt
+++ b/feature/afternote/data/src/main/kotlin/com/afternote/feature/afternote/data/paging/AfternotePagingSource.kt
@@ -2,7 +2,7 @@ package com.afternote.feature.afternote.data.paging
 
 import androidx.paging.PagingSource
 import androidx.paging.PagingState
-import com.afternote.core.common.result.runCatchingCancellable
+import com.afternote.core.domain.result.runCatchingCancellable
 import com.afternote.core.network.model.requireData
 import com.afternote.feature.afternote.data.mapper.toDomainList
 import com.afternote.feature.afternote.data.service.AfternoteApiService
diff --git a/feature/afternote/data/src/main/kotlin/com/afternote/feature/afternote/data/repositoryimpl/author/AfternoteRepositoryImpl.kt b/feature/afternote/data/src/main/kotlin/com/afternote/feature/afternote/data/repositoryimpl/author/AfternoteRepositoryImpl.kt
index a25a86d29d..38796b0cd1 100644
--- a/feature/afternote/data/src/main/kotlin/com/afternote/feature/afternote/data/repositoryimpl/author/AfternoteRepositoryImpl.kt
+++ b/feature/afternote/data/src/main/kotlin/com/afternote/feature/afternote/data/repositoryimpl/author/AfternoteRepositoryImpl.kt
@@ -3,7 +3,7 @@ package com.afternote.feature.afternote.data.repositoryimpl.author
 import androidx.paging.Pager
 import androidx.paging.PagingConfig
 import androidx.paging.PagingData
-import com.afternote.core.common.result.runCatchingCancellable
+import com.afternote.core.domain.result.runCatchingCancellable
 import com.afternote.core.network.model.requireData
 import com.afternote.core.network.model.requireStatus
 import com.afternote.feature.afternote.data.mapper.toBusinessRequest
diff --git a/feature/afternote/data/src/main/kotlin/com/afternote/feature/afternote/data/repositoryimpl/author/MemorialThumbnailUploadRepositoryImpl.kt b/feature/afternote/data/src/main/kotlin/com/afternote/feature/afternote/data/repositoryimpl/author/MemorialThumbnailUploadRepositoryImpl.kt
index 836ee4df64..2b58173a6c 100644
--- a/feature/afternote/data/src/main/kotlin/com/afternote/feature/afternote/data/repositoryimpl/author/MemorialThumbnailUploadRepositoryImpl.kt
+++ b/feature/afternote/data/src/main/kotlin/com/afternote/feature/afternote/data/repositoryimpl/author/MemorialThumbnailUploadRepositoryImpl.kt
@@ -1,7 +1,7 @@
 package com.afternote.feature.afternote.data.repositoryimpl.author
 
 import com.afternote.core.common.di.IoDispatcher
-import com.afternote.core.common.result.runCatchingCancellable
+import com.afternote.core.domain.result.runCatchingCancellable
 import com.afternote.core.network.dto.PresignedUrlRequestDto
 import com.afternote.core.network.model.requireData
 import com.afternote.core.network.service.ImageApiService
diff --git a/feature/afternote/data/src/main/kotlin/com/afternote/feature/afternote/data/repositoryimpl/author/MusicSearchRepositoryImpl.kt b/feature/afternote/data/src/main/kotlin/com/afternote/feature/afternote/data/repositoryimpl/author/MusicSearchRepositoryImpl.kt
index a6804fd17a..6400d78e50 100644
--- a/feature/afternote/data/src/main/kotlin/com/afternote/feature/afternote/data/repositoryimpl/author/MusicSearchRepositoryImpl.kt
+++ b/feature/afternote/data/src/main/kotlin/com/afternote/feature/afternote/data/repositoryimpl/author/MusicSearchRepositoryImpl.kt
@@ -1,6 +1,6 @@
 package com.afternote.feature.afternote.data.repositoryimpl.author
 
-import com.afternote.core.common.result.runCatchingCancellable
+import com.afternote.core.domain.result.runCatchingCancellable
 import com.afternote.feature.afternote.data.dto.MusicTrackDto
 import com.afternote.feature.afternote.data.service.MusicApiService
 import com.afternote.feature.afternote.domain.model.author.playlist.SearchedSong
diff --git a/feature/afternote/data/src/test/java/com/afternote/feature/afternote/data/mapper/AfternoteDetailMapperTest.kt b/feature/afternote/data/src/test/java/com/afternote/feature/afternote/data/mapper/AfternoteDetailMapperTest.kt
index 5040d7cc9f..afb4f1b250 100644
--- a/feature/afternote/data/src/test/java/com/afternote/feature/afternote/data/mapper/AfternoteDetailMapperTest.kt
+++ b/feature/afternote/data/src/test/java/com/afternote/feature/afternote/data/mapper/AfternoteDetailMapperTest.kt
@@ -19,7 +19,7 @@ import org.junit.Test
  * [AfternoteDetailDto.toDomain] 회귀 가드 (작성자 상세).
  * 핵심 경계: 공통 필드와 타입별 [DetailContent] 분리, 부분·부재 credentials 의 빈 값 강등,
  * receivers null→emptyList, receiver 필드 null→"", processingMethods null→emptyList,
- * memorialVideo null→video/thumbnail null.
+ * memorialVideo null→video/thumbnail null, 미디어 URL 빈 문자열→null.
  */
 class AfternoteDetailMapperTest {
     @Test
@@ -231,6 +231,30 @@ class AfternoteDetailMapperTest {
         assertEquals("a", memorial.songs.single().artist)
     }
 
+    @Test
+    fun `toDomain - 미디어 URL 의 빈 문자열은 없음으로 맞춘다`() {
+        val result =
+            Json
+                .decodeFromString<AfternoteDetailDto>(
+                    """
+                    {
+                      "afternoteId":1,"category":"PLAYLIST","title":"t","isDraft":false,
+                      "updatedAt":"$UPDATED_AT","receivers":[],
+                      "playlist":{
+                        "memorialPhotoUrl":"",
+                        "songs":[],
+                        "memorialVideo":{"videoUrl":" ","thumbnailUrl":""}
+                      }
+                    }
+                    """.trimIndent(),
+                ).toDomain()
+
+        val media = (result.content as DetailContent.Memorial).media
+        assertNull(media.photoUrl)
+        assertNull(media.videoUrl)
+        assertNull(media.thumbnailUrl)
+    }
+
     @Test
     fun `toDomain - playlist의 공통 leaveMessage도 보존한다`() {
         val result =
diff --git a/feature/afternote/domain/src/main/java/com/afternote/feature/afternote/domain/usecase/editor/SaveAfternoteUseCase.kt b/feature/afternote/domain/src/main/java/com/afternote/feature/afternote/domain/usecase/editor/SaveAfternoteUseCase.kt
new file mode 100644
index 0000000000..c937b3a6ba
--- /dev/null
+++ b/feature/afternote/domain/src/main/java/com/afternote/feature/afternote/domain/usecase/editor/SaveAfternoteUseCase.kt
@@ -0,0 +1,48 @@
+package com.afternote.feature.afternote.domain.usecase.editor
+
+import com.afternote.feature.afternote.domain.model.author.CreateAfternoteInput
+import com.afternote.feature.afternote.domain.model.author.SaveAfternoteCommand
+import com.afternote.feature.afternote.domain.repository.author.AfternoteRepository
+import javax.inject.Inject
+
+/**
+ * 완성된 [SaveAfternoteCommand] 를 해석하는 **단일 경계**.
+ *
+ * 도입 근거는 「비즈니스 로직이 많다」가 아니라 *해석의 소재지* 다. [SaveAfternoteCommand] 는 도메인이
+ * 소유한 닫힌(sealed) 명령이고, 그 5갈래(Create 4종 · Update)를 [AfternoteRepository] 의 어느 메서드로
+ * 보낼지는 명령 정의와 짝을 이루는 도메인 지식이다. 명령이 도메인에 있는 한 해석도 도메인에 있어야
+ * 명령에 갈래가 늘 때 고칠 곳이 한 곳으로 닫힌다 — 화면이 몇 개든, 호출부가 지금 하나든 상관없다.
+ *
+ * 과거 `#246` 은 이 UseCase 를 «Repository 프록시» 로 보고 제거했지만, 같은 `when` 은 사라지지 않고
+ * `AfternoteEditorViewModel` 로 옮겨갔을 뿐이었다. 즉 제거된 것은 중복이 아니라 경계였다 (`#1694`).
+ *
+ * 여기서 하지 않는 일 — 입력 검증, UI 폼 매핑, 미디어 입력 선택, 저장 상태·문구·네비게이션.
+ * 그 책임들은 명령을 *만드는* 쪽(presentation)에 그대로 남는다.
+ */
+class SaveAfternoteUseCase
+    @Inject
+    constructor(
+        private val afternoteRepository: AfternoteRepository,
+    ) {
+        /**
+         * Repository 의 [Result] 를 감싸거나 다시 던지지 않고 그대로 돌려준다 — 저장 실패의 해석은
+         * 호출부(에러 문구·재시도)의 몫이고, `runCatching` 을 두르지 않아 코루틴 취소도 삼키지 않는다.
+         *
+         * @return 생성·수정된 애프터노트 id.
+         */
+        suspend operator fun invoke(command: SaveAfternoteCommand): Result<Long> =
+            when (command) {
+                is SaveAfternoteCommand.Create -> {
+                    when (val input = command.input) {
+                        is CreateAfternoteInput.Social -> afternoteRepository.createSocial(input.payload)
+                        is CreateAfternoteInput.Business -> afternoteRepository.createBusiness(input.payload)
+                        is CreateAfternoteInput.Gallery -> afternoteRepository.createGallery(input.payload)
+                        is CreateAfternoteInput.Memorial -> afternoteRepository.createMemorial(input.payload)
+                    }
+                }
+
+                is SaveAfternoteCommand.Update -> {
+                    afternoteRepository.update(command.id, command.payload)
+                }
+            }
+    }
diff --git a/feature/afternote/domain/src/test/java/com/afternote/feature/afternote/domain/usecase/editor/SaveAfternoteUseCaseTest.kt b/feature/afternote/domain/src/test/java/com/afternote/feature/afternote/domain/usecase/editor/SaveAfternoteUseCaseTest.kt
new file mode 100644
index 0000000000..96dc4301f9
--- /dev/null
+++ b/feature/afternote/domain/src/test/java/com/afternote/feature/afternote/domain/usecase/editor/SaveAfternoteUseCaseTest.kt
@@ -0,0 +1,182 @@
+package com.afternote.feature.afternote.domain.usecase.editor
+
+import com.afternote.feature.afternote.domain.AfternoteType
+import com.afternote.feature.afternote.domain.model.author.CreateAccountPayload
+import com.afternote.feature.afternote.domain.model.author.CreateAfternoteInput
+import com.afternote.feature.afternote.domain.model.author.CreateGalleryPayload
+import com.afternote.feature.afternote.domain.model.author.CreateMemorialPayload
+import com.afternote.feature.afternote.domain.model.author.FieldPatch
+import com.afternote.feature.afternote.domain.model.author.MemorialPatchInput
+import com.afternote.feature.afternote.domain.model.author.MemorialWritePayload
+import com.afternote.feature.afternote.domain.model.author.SaveAfternoteCommand
+import com.afternote.feature.afternote.domain.model.author.UpdateAfternoteInput
+import com.afternote.feature.afternote.domain.testing.FakeAfternoteRepository
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertSame
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * [SaveAfternoteUseCase] 가 소유하는 것 — [SaveAfternoteCommand] 5갈래의 해석 경계.
+ *
+ * 고정하는 계약:
+ * 1. Create 4종(Social·Business·Gallery·Memorial)이 각각 *정확히 하나의* Repository 메서드로만 간다.
+ *    (기록 목록을 전부 세어, 목표 외 메서드가 0회임을 같이 단언한다 — 라우팅이 옆칸으로 새는 회귀를 잡는다)
+ * 2. payload 를 가공하지 않고 그대로 넘긴다. Update 는 id 와 payload 를 둘 다 바꾸지 않는다.
+ * 3. Repository 의 성공·실패 [Result] 를 감싸지 않고 그대로 돌려준다.
+ * 4. `runCatching` 을 두르지 않아 코루틴 취소를 [Result.failure] 로 삼키지 않는다.
+ */
+class SaveAfternoteUseCaseTest {
+    private val accountPayload =
+        CreateAccountPayload(
+            title = "인스타그램",
+            processingMethods = listOf("계정 삭제"),
+        )
+
+    private val galleryPayload =
+        CreateGalleryPayload(
+            title = "사진첩",
+            processingMethods = listOf("전달"),
+        )
+
+    private val memorialPayload =
+        CreateMemorialPayload(
+            title = "장례식",
+            memorial =
+                MemorialWritePayload(
+                    memorialPhotoUrl = null,
+                    songs = emptyList(),
+                    memorialVideo = null,
+                ),
+        )
+
+    @Test
+    fun `Social 생성은 createSocial 만 호출하고 payload 를 그대로 넘긴다`() {
+        val repository = FakeAfternoteRepository()
+
+        val result = repository.save(SaveAfternoteCommand.Create(CreateAfternoteInput.Social(accountPayload)))
+
+        assertTrue(result.isSuccess)
+        assertEquals(listOf(accountPayload), repository.socialPayloads)
+        repository.assertOnlyCalled(SOCIAL)
+    }
+
+    @Test
+    fun `Business 생성은 createBusiness 만 호출한다 - 같은 스키마의 createSocial 로 새지 않는다`() {
+        val repository = FakeAfternoteRepository()
+
+        val result = repository.save(SaveAfternoteCommand.Create(CreateAfternoteInput.Business(accountPayload)))
+
+        assertTrue(result.isSuccess)
+        assertEquals(listOf(accountPayload), repository.businessPayloads)
+        repository.assertOnlyCalled(BUSINESS)
+    }
+
+    @Test
+    fun `Gallery 생성은 createGallery 만 호출한다`() {
+        val repository = FakeAfternoteRepository()
+
+        val result = repository.save(SaveAfternoteCommand.Create(CreateAfternoteInput.Gallery(galleryPayload)))
+
+        assertTrue(result.isSuccess)
+        assertEquals(listOf(galleryPayload), repository.galleryPayloads)
+        repository.assertOnlyCalled(GALLERY)
+    }
+
+    @Test
+    fun `Memorial 생성은 createMemorial 만 호출한다`() {
+        val repository = FakeAfternoteRepository()
+
+        val result = repository.save(SaveAfternoteCommand.Create(CreateAfternoteInput.Memorial(memorialPayload)))
+
+        assertTrue(result.isSuccess)
+        assertEquals(listOf(memorialPayload), repository.memorialPayloads)
+        repository.assertOnlyCalled(MEMORIAL)
+    }
+
+    @Test
+    fun `Update 는 id 와 payload 를 바꾸지 않고 update 로만 보낸다`() {
+        val repository = FakeAfternoteRepository()
+        val payload =
+            UpdateAfternoteInput(
+                type = AfternoteType.MEMORIAL,
+                title = "바뀐 제목",
+                memorial =
+                    MemorialPatchInput(
+                        memorialPhotoUrl = FieldPatch.Unchanged,
+                        songs = emptyList(),
+                        memorialVideo = FieldPatch.Set(null),
+                    ),
+                isDraft = false,
+            )
+
+        // 기본 update 는 대상이 없으면 실패하므로 성공 Result 를 열어 라우팅만 본다.
+        repository.onUpdate = { _, _ -> Result.success(42L) }
+        val result = repository.save(SaveAfternoteCommand.Update(id = 42L, payload = payload))
+
+        assertEquals(42L, result.getOrNull())
+        assertEquals(listOf(42L to payload), repository.updateCalls)
+        assertSame(payload, repository.updateCalls.single().second)
+        repository.assertOnlyCalled(UPDATE)
+    }
+
+    @Test
+    fun `Repository 성공 id 를 그대로 돌려준다`() {
+        val repository = FakeAfternoteRepository().apply { onCreateGallery = { Result.success(7L) } }
+
+        val result = repository.save(SaveAfternoteCommand.Create(CreateAfternoteInput.Gallery(galleryPayload)))
+
+        assertEquals(7L, result.getOrNull())
+    }
+
+    @Test
+    fun `Repository 실패는 감싸지 않고 같은 예외로 돌려준다`() {
+        val failure = IllegalStateException("저장 실패")
+        val repository = FakeAfternoteRepository().apply { onCreateSocial = { Result.failure(failure) } }
+
+        val result = repository.save(SaveAfternoteCommand.Create(CreateAfternoteInput.Social(accountPayload)))
+
+        assertTrue(result.isFailure)
+        assertSame(failure, result.exceptionOrNull())
+    }
+
+    @Test
+    fun `취소는 실패 Result 로 삼키지 않고 그대로 전파한다`() {
+        val repository =
+            FakeAfternoteRepository().apply {
+                onCreateMemorial = { throw CancellationException("저장 중 화면 이탈") }
+            }
+
+        // 삼켰다면 Result.failure 로 정상 반환돼 assertThrows 가 실패한다.
+        assertThrows(CancellationException::class.java) {
+            repository.save(SaveAfternoteCommand.Create(CreateAfternoteInput.Memorial(memorialPayload)))
+        }
+    }
+
+    private fun FakeAfternoteRepository.save(command: SaveAfternoteCommand): Result<Long> =
+        runBlocking { SaveAfternoteUseCase(this@save)(command) }
+
+    /** [only] 로 지목한 저장 메서드만 1회 호출되고 나머지 4개는 0회임을 단언한다. */
+    private fun FakeAfternoteRepository.assertOnlyCalled(only: String) {
+        val calls =
+            mapOf(
+                SOCIAL to socialPayloads.size,
+                BUSINESS to businessPayloads.size,
+                GALLERY to galleryPayloads.size,
+                MEMORIAL to memorialPayloads.size,
+                UPDATE to updateCalls.size,
+            )
+        assertEquals(calls.keys.associateWith { if (it == only) 1 else 0 }, calls)
+    }
+
+    private companion object {
+        const val SOCIAL = "createSocial"
+        const val BUSINESS = "createBusiness"
+        const val GALLERY = "createGallery"
+        const val MEMORIAL = "createMemorial"
+        const val UPDATE = "update"
+    }
+}
diff --git a/feature/afternote/presentation/build.gradle.kts b/feature/afternote/presentation/build.gradle.kts
index 51fc3ec066..c826604969 100644
--- a/feature/afternote/presentation/build.gradle.kts
+++ b/feature/afternote/presentation/build.gradle.kts
@@ -9,6 +9,7 @@ plugins {
 android {
     namespace = "com.afternote.feature.afternote.presentation"
     resourcePrefix = "afternote_"
+    testFixtures.enable = true
     experimentalProperties["android.experimental.enableScreenshotTest"] = true
     buildFeatures {
         buildConfig = true
@@ -32,16 +33,23 @@ dependencies {
     implementation(libs.coil.network.okhttp)
     implementation(libs.coil.compose)
     implementation(libs.androidx.activity.compose)
-    implementation(libs.androidx.hilt.navigation.compose)
     implementation(libs.hilt.navigation)
     implementation(libs.androidx.lifecycle.viewmodel.ktx)
     implementation(libs.androidx.lifecycle.runtime.compose)
-    implementation(libs.androidx.biometric)
     implementation(libs.androidx.fragment.ktx)
     implementation(libs.androidx.paging.runtime)
     implementation(libs.androidx.paging.compose)
     implementation(libs.androidx.core.ktx)
 
+    // 앱 기기 테스트는 fixture를 통해 실제 화면을 열며 production ViewModel을 공개하지 않는다.
+    testFixturesImplementation(platform(libs.androidx.compose.bom))
+    testFixturesImplementation(libs.androidx.compose.runtime)
+    testFixturesImplementation(projects.feature.afternote.domain)
+    testFixturesImplementation(projects.feature.receiver.domain)
+    testFixturesImplementation(projects.core.common)
+    testFixturesImplementation(projects.core.ui)
+    testFixturesImplementation(libs.androidx.navigation3.runtime)
+
     testImplementation(libs.coroutines.test)
     testImplementation(testFixtures(projects.core.domain))
     testImplementation(testFixtures(projects.feature.afternote.domain))
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/AfternoteHostContract.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/AfternoteHostContract.kt
new file mode 100644
index 0000000000..89e0148dac
--- /dev/null
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/AfternoteHostContract.kt
@@ -0,0 +1,21 @@
+package com.afternote.feature.afternote.presentation
+
+import com.afternote.core.ui.mvi.MviIntent
+import com.afternote.core.ui.mvi.ReducerEvent
+import com.afternote.core.ui.mvi.UiState
+
+internal data class AfternoteHostUiState(
+    val isPasskeyRegistered: Boolean? = null,
+) : UiState
+
+internal sealed interface AfternoteHostIntent : MviIntent {
+    data object ObserveProfile : AfternoteHostIntent
+
+    data object StopObservingProfile : AfternoteHostIntent
+}
+
+internal sealed interface AfternoteHostReducerEvent : ReducerEvent {
+    data class PasskeyRegistrationChanged(
+        val registered: Boolean,
+    ) : AfternoteHostReducerEvent
+}
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/AfternoteHostViewModel.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/AfternoteHostViewModel.kt
index c2ae400e8e..2fa9243d76 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/AfternoteHostViewModel.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/AfternoteHostViewModel.kt
@@ -1,12 +1,12 @@
 package com.afternote.feature.afternote.presentation
 
-import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.afternote.core.domain.repository.UserProfileCacheRepository
+import com.afternote.core.ui.mvi.MviViewModel
 import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
 import javax.inject.Inject
 
 /**
@@ -17,19 +17,46 @@ import javax.inject.Inject
  * 에디터 flow 상태는 flow-scoped
  * [com.afternote.feature.afternote.presentation.editor.AfternoteEditorViewModel]이 담당한다.
  * 본 ViewModel은 애프터노트 로컬 스택 전체에서 공유하는 사용자 상태만 보유한다.
+ * 프로필 구독은 마지막 화면이 떠난 뒤 기존 WhileSubscribed와 같은 5초 유예를 둔다.
  */
 @HiltViewModel
-class AfternoteHostViewModel
+internal class AfternoteHostViewModel
     @Inject
     constructor(
-        userProfileRepository: UserProfileCacheRepository,
-    ) : ViewModel() {
-        val isPasskeyRegistered: StateFlow<Boolean?> =
-            userProfileRepository
-                .isPasskeyRegisteredFlow()
-                .stateIn(
-                    scope = viewModelScope,
-                    started = SharingStarted.WhileSubscribed(5_000),
-                    initialValue = null,
-                )
+        private val userProfileRepository: UserProfileCacheRepository,
+    ) : MviViewModel<AfternoteHostIntent, AfternoteHostUiState, AfternoteHostReducerEvent>(AfternoteHostUiState()) {
+        private var profileJob: Job? = null
+        private var stopJob: Job? = null
+
+        override fun onIntent(intent: AfternoteHostIntent) {
+            when (intent) {
+                AfternoteHostIntent.ObserveProfile -> {
+                    stopJob?.cancel()
+                    if (profileJob?.isActive == true) return
+                    profileJob =
+                        viewModelScope.launch {
+                            userProfileRepository.isPasskeyRegisteredFlow().collect {
+                                dispatch(AfternoteHostReducerEvent.PasskeyRegistrationChanged(it))
+                            }
+                        }
+                }
+
+                AfternoteHostIntent.StopObservingProfile -> {
+                    stopJob?.cancel()
+                    stopJob =
+                        viewModelScope.launch {
+                            delay(5_000)
+                            profileJob?.cancel()
+                        }
+                }
+            }
+        }
+
+        override fun reduce(
+            state: AfternoteHostUiState,
+            event: AfternoteHostReducerEvent,
+        ): AfternoteHostUiState =
+            when (event) {
+                is AfternoteHostReducerEvent.PasskeyRegistrationChanged -> state.copy(isPasskeyRegistered = event.registered)
+            }
     }
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/detail/AfternoteDetailContent.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/detail/AfternoteDetailContent.kt
new file mode 100644
index 0000000000..ec48b68095
--- /dev/null
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/detail/AfternoteDetailContent.kt
@@ -0,0 +1,161 @@
+package com.afternote.feature.afternote.presentation.detail
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.SnackbarHostState
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.LiveRegionMode
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.liveRegion
+import androidx.compose.ui.semantics.semantics
+import com.afternote.core.ui.loading.LoadingBody
+import com.afternote.core.ui.theme.AfternoteDesign
+import com.afternote.feature.afternote.domain.AfternoteType
+import com.afternote.feature.afternote.presentation.R
+import com.afternote.feature.afternote.presentation.detail.account.AccountDetailScreen
+import com.afternote.feature.afternote.presentation.shared.detail.DesignPendingDetailContent
+import com.afternote.feature.afternote.presentation.shared.detail.DetailLoadErrorContent
+
+/** 상세 상태의 모든 렌더 분기. 상태 수집과 일회성 결과 소비는 Navigation이 담당한다. */
+@Composable
+internal fun AfternoteDetailContent(
+    uiState: AfternoteDetailUiState,
+    onIntent: (AfternoteDetailIntent) -> Unit,
+    snackbarHostState: SnackbarHostState,
+    onNavigateBack: () -> Unit,
+    onNavigateToEditor: (Long, AfternoteType) -> Unit,
+    onVideoClick: (String) -> Unit,
+) {
+    when (val state = uiState) {
+        AfternoteDetailUiState.Loading -> {
+            LoadingBody()
+        }
+
+        is AfternoteDetailUiState.Error -> {
+            DetailLoadErrorContent(
+                messageRes = state.messageRes,
+                onBackClick = onNavigateBack,
+                onRetryClick = { onIntent(AfternoteDetailIntent.Retry) },
+            )
+        }
+
+        is AfternoteDetailUiState.Success -> {
+            AfternoteDetailSuccessContent(
+                state = state,
+                snackbarHostState = snackbarHostState,
+                onBackClick = onNavigateBack,
+                onNavigateToEditor = onNavigateToEditor,
+                onDeleteConfirm = { onIntent(AfternoteDetailIntent.Delete) },
+                onVideoClick = onVideoClick,
+            )
+        }
+    }
+}
+
+@Composable
+private fun AfternoteDetailSuccessContent(
+    state: AfternoteDetailUiState.Success,
+    snackbarHostState: SnackbarHostState,
+    onBackClick: () -> Unit,
+    onNavigateToEditor: (itemId: Long, type: AfternoteType) -> Unit,
+    onDeleteConfirm: () -> Unit,
+    onVideoClick: (String) -> Unit,
+) {
+    Box {
+        when (val model = state.contentUiModel) {
+            is DetailContentUiModel.SocialNetwork -> {
+                AccountDetailScreen(
+                    content = model.content,
+                    snackbarHostState = snackbarHostState,
+                    onBackClick = onBackClick,
+                    onEditClick = {
+                        onNavigateToEditor(state.detailId, model.type)
+                    },
+                    onDeleteConfirm = onDeleteConfirm,
+                )
+            }
+
+            is DetailContentUiModel.Business -> {
+                AccountDetailScreen(
+                    content = model.content,
+                    snackbarHostState = snackbarHostState,
+                    onBackClick = onBackClick,
+                    onEditClick = {
+                        onNavigateToEditor(state.detailId, model.type)
+                    },
+                    onDeleteConfirm = onDeleteConfirm,
+                )
+            }
+
+            is DetailContentUiModel.Gallery -> {
+                GalleryDetailScreen(
+                    content = model.content,
+                    snackbarHostState = snackbarHostState,
+                    onBackClick = onBackClick,
+                    onEditClick = {
+                        onNavigateToEditor(state.detailId, model.type)
+                    },
+                    onDeleteConfirm = onDeleteConfirm,
+                )
+            }
+
+            is DetailContentUiModel.Memorial -> {
+                MemorialDetailScreen(
+                    content = model.content,
+                    userName = state.authorDisplayName,
+                    snackbarHostState = snackbarHostState,
+                    onBackClick = onBackClick,
+                    onEditClick = {
+                        onNavigateToEditor(state.detailId, model.type)
+                    },
+                    onDeleteConfirm = onDeleteConfirm,
+                    onVideoClick = onVideoClick,
+                )
+            }
+
+            DetailContentUiModel.Unimplemented -> {
+                DesignPendingDetailContent(onBackClick = onBackClick)
+            }
+        }
+
+        if (state.isDeleting) {
+            DeleteInProgressOverlay()
+        }
+    }
+}
+
+/**
+ * 삭제 진행([AfternoteDetailUiState.Success.isDeleting]) 동안 상세 화면 위에 겹쳐 그리는 오버레이.
+ *
+ * 반투명 스크림 + 중앙 진행 인디케이터. 중복 delete 호출은 ViewModel 이 이미 가드하므로
+ * 여기서는 시각 표시와 입력 차단만 담당한다.
+ *
+ * 포인터 차단만으로는 부족하다 — 스크림에 semantics 가 없으면 접근성 트리에서 잘리지 않아
+ * 아래 상세 화면의 뒤로·수정·삭제 버튼이 스크린리더로는 그대로 탐색·활성화된다.
+ * 그래서 스크림 자체를 병합 노드로 만들어 모달성을 유지한다.
+ */
+@Composable
+private fun DeleteInProgressOverlay() {
+    val deletingDescription = stringResource(R.string.afternote_detail_deleting)
+    Box(
+        modifier =
+            Modifier
+                .fillMaxSize()
+                .background(AfternoteDesign.colors.black.copy(alpha = 0.3f))
+                .pointerInput(Unit) { detectTapGestures {} }
+                .semantics(mergeDescendants = true) {
+                    contentDescription = deletingDescription
+                    liveRegion = LiveRegionMode.Polite
+                },
+        contentAlignment = Alignment.Center,
+    ) {
+        CircularProgressIndicator()
+    }
+}
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/detail/AfternoteDetailContract.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/detail/AfternoteDetailContract.kt
new file mode 100644
index 0000000000..deb0e200b1
--- /dev/null
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/detail/AfternoteDetailContract.kt
@@ -0,0 +1,40 @@
+package com.afternote.feature.afternote.presentation.detail
+
+import com.afternote.core.ui.mvi.MviIntent
+import com.afternote.core.ui.mvi.ReducerEvent
+
+internal sealed interface AfternoteDetailIntent : MviIntent {
+    data object Retry : AfternoteDetailIntent
+
+    data object RefreshOnReturn : AfternoteDetailIntent
+
+    data object Delete : AfternoteDetailIntent
+
+    data object ConsumeDeleteResult : AfternoteDetailIntent
+}
+
+internal sealed interface AfternoteDetailReducerEvent : ReducerEvent {
+    data object Loading : AfternoteDetailReducerEvent
+
+    data class ContentLoaded(
+        val id: Long,
+        val content: DetailContentUiModel,
+        val authorName: String,
+    ) : AfternoteDetailReducerEvent
+
+    data class LoadFailed(
+        val keepsContent: Boolean,
+    ) : AfternoteDetailReducerEvent
+
+    data object DeleteStarted : AfternoteDetailReducerEvent
+
+    data class DeleteFinished(
+        val result: AfternoteDetailDeleteResult,
+    ) : AfternoteDetailReducerEvent
+
+    data object DeleteResultConsumed : AfternoteDetailReducerEvent
+
+    data class AuthorNameChanged(
+        val name: String,
+    ) : AfternoteDetailReducerEvent
+}
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/detail/AfternoteDetailRoute.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/detail/AfternoteDetailRoute.kt
index 75540b9afd..30b971f198 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/detail/AfternoteDetailRoute.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/detail/AfternoteDetailRoute.kt
@@ -1,80 +1,21 @@
 package com.afternote.feature.afternote.presentation.detail
 
-import androidx.annotation.StringRes
-import androidx.compose.foundation.background
-import androidx.compose.foundation.gestures.detectTapGestures
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.material3.CircularProgressIndicator
-import androidx.compose.material3.Scaffold
 import androidx.compose.material3.SnackbarHostState
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalResources
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.semantics.LiveRegionMode
-import androidx.compose.ui.semantics.contentDescription
-import androidx.compose.ui.semantics.liveRegion
-import androidx.compose.ui.semantics.semantics
-import androidx.compose.ui.unit.dp
-import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.compose.LifecycleEventEffect
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.afternote.core.common.media.launchMemorialVideo
-import com.afternote.core.ui.loading.LoadingBody
-import com.afternote.core.ui.theme.AfternoteDesign
-import com.afternote.core.ui.topbar.DetailTopBar
 import com.afternote.feature.afternote.domain.AfternoteType
 import com.afternote.feature.afternote.presentation.R
-import com.afternote.feature.afternote.presentation.detail.account.AccountDetailScreen
-import com.afternote.feature.afternote.presentation.shared.detail.DesignPendingDetailContent
-import com.afternote.feature.afternote.presentation.shared.detail.DetailLoadErrorContent
 import kotlinx.coroutines.launch
 
-/**
- * 삭제 진행([AfternoteDetailUiState.Success.isDeleting]) 동안 상세 화면 위에 겹쳐 그리는 오버레이.
- *
- * 반투명 스크림 + 중앙 진행 인디케이터. 중복 delete 호출은 ViewModel 이 이미 가드하므로
- * 여기서는 시각 표시와 입력 차단만 담당한다.
- *
- * 포인터 차단만으로는 부족하다 — 스크림에 semantics 가 없으면 접근성 트리에서 잘리지 않아
- * 아래 상세 화면의 뒤로·수정·삭제 버튼이 스크린리더로는 그대로 탐색·활성화된다.
- * 그래서 스크림 자체를 병합 노드로 만들어 모달성을 유지한다.
- */
-@Composable
-internal fun DeleteInProgressOverlay() {
-    val deletingDescription = stringResource(R.string.afternote_detail_deleting)
-    Box(
-        modifier =
-            Modifier
-                .fillMaxSize()
-                .background(AfternoteDesign.colors.black.copy(alpha = 0.3f))
-                .pointerInput(Unit) { detectTapGestures {} }
-                .semantics(mergeDescendants = true) {
-                    contentDescription = deletingDescription
-                    liveRegion = LiveRegionMode.Polite
-                },
-        contentAlignment = Alignment.Center,
-    ) {
-        CircularProgressIndicator()
-    }
-}
-
 /**
  * 삭제 실패 메시지를 [snackbarHostState] Snackbar 로 표출하는 [ObserveDeleteResult] 용 `onDeleteFailed` 핸들러.
  *
@@ -113,7 +54,7 @@ internal fun rememberDeleteFailedHandler(snackbarHostState: SnackbarHostState):
  * - [AfternoteDetailDeleteResult.Failed] → [onDeleteFailed] (에러 UI는 화면별 Snackbar/Dialog 책임.
  *   보통 [rememberDeleteFailedHandler] 를 전달한다. 무음 삼킴 방지를 위해 필수 파라미터.)
  *
- * 처리 후 [onConsumed] 콜백으로 ViewModel 의 [AfternoteDetailViewModel.onDeleteResultConsumed]
+ * 처리 후 [onConsumed] 콜백으로 ViewModel 의 [AfternoteDetailIntent.ConsumeDeleteResult]
  * 호출 → state reset (재합성 시 중복 처리 방지).
  */
 @Composable
@@ -158,112 +99,24 @@ internal fun AfternoteDetailNavigation(
     // 로딩을 방출하지 않는 refreshOnReturn() 을 쓴다. 첫 진입의 ON_RESUME 스킵(진입은 init
     // 로드가 담당)과 실행 중 로드와의 중복 차단은 VM 이 판단한다 — 결선부는 무조건 부른다.
     LifecycleEventEffect(Lifecycle.Event.ON_RESUME) {
-        viewModel.refreshOnReturn()
+        viewModel.onIntent(AfternoteDetailIntent.RefreshOnReturn)
     }
 
     ObserveDeleteResult(
         deleteResult = (uiState as? AfternoteDetailUiState.Success)?.deleteResult,
-        onConsumed = viewModel::onDeleteResultConsumed,
+        onConsumed = { viewModel.onIntent(AfternoteDetailIntent.ConsumeDeleteResult) },
         onDeleteSucceeded = onNavigateBack,
         onDeleteFailed = rememberDeleteFailedHandler(snackbarHostState),
     )
 
-    when (val state = uiState) {
-        AfternoteDetailUiState.Loading -> {
-            LoadingBody()
-        }
-
-        is AfternoteDetailUiState.Error -> {
-            DetailLoadErrorContent(
-                messageRes = state.messageRes,
-                onBackClick = onNavigateBack,
-                onRetryClick = viewModel::retry,
-            )
-        }
-
-        is AfternoteDetailUiState.Success -> {
-            AfternoteDetailSuccessContent(
-                state = state,
-                snackbarHostState = snackbarHostState,
-                onBackClick = onNavigateBack,
-                onNavigateToEditor = onNavigateToEditor,
-                onDeleteConfirm = viewModel::deleteAfternote,
-                onVideoClick = onVideoClick,
-            )
-        }
-    }
-}
-
-@Composable
-private fun AfternoteDetailSuccessContent(
-    state: AfternoteDetailUiState.Success,
-    snackbarHostState: SnackbarHostState,
-    onBackClick: () -> Unit,
-    onNavigateToEditor: (itemId: Long, type: AfternoteType) -> Unit,
-    onDeleteConfirm: () -> Unit,
-    onVideoClick: (String) -> Unit,
-) {
-    Box {
-        when (val model = state.contentUiModel) {
-            is DetailContentUiModel.SocialNetwork -> {
-                AccountDetailScreen(
-                    content = model.content,
-                    snackbarHostState = snackbarHostState,
-                    onBackClick = onBackClick,
-                    onEditClick = {
-                        onNavigateToEditor(state.detailId, model.type)
-                    },
-                    onDeleteConfirm = onDeleteConfirm,
-                )
-            }
-
-            is DetailContentUiModel.Business -> {
-                AccountDetailScreen(
-                    content = model.content,
-                    snackbarHostState = snackbarHostState,
-                    onBackClick = onBackClick,
-                    onEditClick = {
-                        onNavigateToEditor(state.detailId, model.type)
-                    },
-                    onDeleteConfirm = onDeleteConfirm,
-                )
-            }
-
-            is DetailContentUiModel.Gallery -> {
-                GalleryDetailScreen(
-                    content = model.content,
-                    snackbarHostState = snackbarHostState,
-                    onBackClick = onBackClick,
-                    onEditClick = {
-                        onNavigateToEditor(state.detailId, model.type)
-                    },
-                    onDeleteConfirm = onDeleteConfirm,
-                )
-            }
-
-            is DetailContentUiModel.Memorial -> {
-                MemorialDetailScreen(
-                    content = model.content,
-                    userName = state.authorDisplayName,
-                    snackbarHostState = snackbarHostState,
-                    onBackClick = onBackClick,
-                    onEditClick = {
-                        onNavigateToEditor(state.detailId, model.type)
-                    },
-                    onDeleteConfirm = onDeleteConfirm,
-                    onVideoClick = onVideoClick,
-                )
-            }
-
-            DetailContentUiModel.Unimplemented -> {
-                DesignPendingDetailContent(onBackClick = onBackClick)
-            }
-        }
-
-        if (state.isDeleting) {
-            DeleteInProgressOverlay()
-        }
-    }
+    AfternoteDetailContent(
+        uiState = uiState,
+        onIntent = viewModel::onIntent,
+        snackbarHostState = snackbarHostState,
+        onNavigateBack = onNavigateBack,
+        onNavigateToEditor = onNavigateToEditor,
+        onVideoClick = onVideoClick,
+    )
 }
 
 @Composable
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/detail/AfternoteDetailUiState.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/detail/AfternoteDetailUiState.kt
index bfee97b9af..52ea6d5c3b 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/detail/AfternoteDetailUiState.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/detail/AfternoteDetailUiState.kt
@@ -1,6 +1,7 @@
 package com.afternote.feature.afternote.presentation.detail
 
 import androidx.annotation.StringRes
+import com.afternote.core.ui.mvi.UiState
 
 /**
  * 애프터노트 상세 화면 UI 상태.
@@ -10,13 +11,13 @@ import androidx.annotation.StringRes
  *   작성자 표시명은 상세와 다른 출처(내 프로필)라 [DetailContentUiModel] 안에 섞지 않고 나란히 둔다 —
  *   섞으면 늦게 도착한 이름을 반영할 때 상세 원본으로 되돌아가 다시 매핑해야 한다.
  *   삭제 결과(성공/실패)는 [Success.deleteResult] 에 흡수 — UI 가 LaunchedEffect 로 소비 후
- *   [AfternoteDetailViewModel.onDeleteResultConsumed] 로 reset.
+ *   [AfternoteDetailIntent.ConsumeDeleteResult] 로 reset.
  * - [Error] 상세 데이터 조회 실패. 표시 문구는 [Error.messageRes] 하나로만 운반한다.
  *   예외 원문(`Throwable.message`)은 UI 에 싣지 않는다 — 서버 5xx 본문에 내부 SQL 이,
  *   역직렬화 실패 메시지에 응답 원문 발췌·DTO 클래스명이 섞여 오기 때문이다
  *   (`ApiException` 도 `message` 는 로그 전용이고 사용자 노출용으로 `serverMessage` 를 따로 둔다).
  */
-sealed interface AfternoteDetailUiState {
+internal sealed interface AfternoteDetailUiState : UiState {
     data object Loading : AfternoteDetailUiState
 
     data class Success(
@@ -28,7 +29,7 @@ sealed interface AfternoteDetailUiState {
          * 그때 화면은 이름 세그먼트를 생략해 렌더한다 (현재 소비처는 추억 노트 상세 제목 하나).
          */
         val authorDisplayName: String = "",
-        /** 삭제 결과 신호 — UI 가 LaunchedEffect 로 소비 후 [AfternoteDetailViewModel.onDeleteResultConsumed] 로 reset. */
+        /** 삭제 결과 신호 — UI 가 LaunchedEffect 로 소비 후 [AfternoteDetailIntent.ConsumeDeleteResult] 로 reset. */
         val deleteResult: AfternoteDetailDeleteResult? = null,
     ) : AfternoteDetailUiState
 
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/detail/AfternoteDetailViewModel.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/detail/AfternoteDetailViewModel.kt
index a2139a9fd8..53f79ec3db 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/detail/AfternoteDetailViewModel.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/detail/AfternoteDetailViewModel.kt
@@ -1,11 +1,11 @@
 package com.afternote.feature.afternote.presentation.detail
 
-import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.afternote.core.common.reporting.ErrorReporter
-import com.afternote.core.common.result.runCatchingCancellable
+import com.afternote.core.domain.repository.MyProfileRepository
 import com.afternote.core.domain.repository.UserProfileCacheRepository
-import com.afternote.core.domain.repository.UserRepository
+import com.afternote.core.domain.result.runCatchingCancellable
+import com.afternote.core.ui.mvi.MviViewModel
 import com.afternote.feature.afternote.domain.repository.author.AfternoteRepository
 import com.afternote.feature.afternote.presentation.R
 import com.afternote.feature.afternote.presentation.navigation.model.AfternoteRoute
@@ -17,10 +17,6 @@ import dagger.assisted.AssistedInject
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.ensureActive
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 
 /**
@@ -29,33 +25,87 @@ import kotlinx.coroutines.launch
  * - 상세 조회: GET /api/afternotes/{id}
  * - 삭제: DELETE /api/afternotes/{id}
  * - 작성자 표시명: [UserProfileCacheRepository.getCachedUserName] 으로 즉시 채우고
- *   [UserRepository.getMyProfile] 로 재검증한다 (네비게이션 인자로 전달하지 않음)
+ *   [MyProfileRepository.getMyProfile] 로 재검증한다 (네비게이션 인자로 전달하지 않음)
  * - 상세 ID: entry 가 assisted 로 넘긴 [AfternoteRoute.DetailRoute]의 `itemId`. Nav3 entry 의
  *   SavedStateHandle 에는 NavKey 필드가 실리지 않으므로 `toRoute` 로 읽을 수 없다 (#2168).
  *
  * [AfternoteDetailUiState] 를 그대로 들고 [uiState] 로 노출한다 — Loading/Success/Error 3분기.
  * 삭제 결과(성공/실패)는 [AfternoteDetailUiState.Success.deleteResult] nullable 필드에 흡수한다 —
- * UI 가 LaunchedEffect 로 소비한 뒤 [onDeleteResultConsumed] 로 reset.
+ * UI 가 LaunchedEffect 로 소비한 뒤 [AfternoteDetailIntent.ConsumeDeleteResult] 로 reset.
  *
  * 사용자 가시 메시지는 VM 에 하드코딩하지 않고 [androidx.annotation.StringRes] id 로만 노출한다.
  * 실패 시 예외 원문(`Throwable.message`)은 UI 로 넘기지 않는다 — 서버 5xx 본문·역직렬화 예외에
  * 내부 SQL·응답 원문 발췌가 섞여 오므로 사용자에게 노출하면 안 된다.
  */
 @HiltViewModel(assistedFactory = AfternoteDetailViewModel.Factory::class)
-class AfternoteDetailViewModel
+internal class AfternoteDetailViewModel
     @AssistedInject
     constructor(
         @Assisted private val route: AfternoteRoute.DetailRoute,
         private val afternoteRepository: AfternoteRepository,
-        private val userRepository: UserRepository,
+        private val myProfileRepository: MyProfileRepository,
         private val userProfileRepository: UserProfileCacheRepository,
         private val errorReporter: ErrorReporter,
-    ) : ViewModel() {
+    ) : MviViewModel<AfternoteDetailIntent, AfternoteDetailUiState, AfternoteDetailReducerEvent>(AfternoteDetailUiState.Loading) {
         private val afternoteIdFromNav: Long =
             route.itemId
 
-        private val _uiState = MutableStateFlow<AfternoteDetailUiState>(AfternoteDetailUiState.Loading)
-        val uiState: StateFlow<AfternoteDetailUiState> = _uiState.asStateFlow()
+        override fun onIntent(intent: AfternoteDetailIntent) {
+            when (intent) {
+                AfternoteDetailIntent.Retry -> retry()
+                AfternoteDetailIntent.RefreshOnReturn -> refreshOnReturn()
+                AfternoteDetailIntent.Delete -> deleteAfternote()
+                AfternoteDetailIntent.ConsumeDeleteResult -> dispatch(AfternoteDetailReducerEvent.DeleteResultConsumed)
+            }
+        }
+
+        override fun reduce(
+            state: AfternoteDetailUiState,
+            event: AfternoteDetailReducerEvent,
+        ): AfternoteDetailUiState =
+            when (event) {
+                AfternoteDetailReducerEvent.Loading -> {
+                    AfternoteDetailUiState.Loading
+                }
+
+                is AfternoteDetailReducerEvent.ContentLoaded -> {
+                    if (state is AfternoteDetailUiState.Success) {
+                        state.copy(detailId = event.id, contentUiModel = event.content, authorDisplayName = event.authorName)
+                    } else {
+                        AfternoteDetailUiState.Success(
+                            detailId = event.id,
+                            contentUiModel = event.content,
+                            authorDisplayName = event.authorName,
+                        )
+                    }
+                }
+
+                is AfternoteDetailReducerEvent.LoadFailed -> {
+                    if (event.keepsContent &&
+                        state is AfternoteDetailUiState.Success
+                    ) {
+                        state
+                    } else {
+                        AfternoteDetailUiState.Error(R.string.afternote_detail_load_error)
+                    }
+                }
+
+                AfternoteDetailReducerEvent.DeleteStarted -> {
+                    state.withSuccess { it.copy(isDeleting = true) }
+                }
+
+                is AfternoteDetailReducerEvent.DeleteFinished -> {
+                    state.withSuccess { it.copy(isDeleting = false, deleteResult = event.result) }
+                }
+
+                AfternoteDetailReducerEvent.DeleteResultConsumed -> {
+                    state.withSuccess { it.copy(deleteResult = null) }
+                }
+
+                is AfternoteDetailReducerEvent.AuthorNameChanged -> {
+                    state.withSuccess { it.copy(authorDisplayName = event.name) }
+                }
+            }
 
         /**
          * 작성자 표시명 — 상세와 별도로 조회된다. 도착 전에는 빈 문자열이고, 도착하면 보고 있는 Success 와
@@ -101,7 +151,7 @@ class AfternoteDetailViewModel
                 ?.takeIf { it.isNotBlank() }
                 ?.let(::applyAuthorDisplayName)
 
-            runCatchingCancellable { userRepository.getMyProfile() }
+            runCatchingCancellable { myProfileRepository.getMyProfile() }
                 .onSuccess { profile ->
                     applyAuthorDisplayName(profile.name)
                     runCatchingCancellable { userProfileRepository.saveUserName(profile.name) }
@@ -116,7 +166,7 @@ class AfternoteDetailViewModel
          * [refreshOnReturn] 과 달리 사용자가 직접 누른 동작이라, 진행 중인 로드가 있어도 건너뛰지 않는다 —
          * 누른 결과가 조용히 사라지면 안 되므로 그 로드를 자르고 새로 시작한다.
          */
-        fun retry() {
+        private fun retry() {
             loadDetail(afternoteIdFromNav, LoadTrigger.UserRequested)
         }
 
@@ -131,7 +181,7 @@ class AfternoteDetailViewModel
          * 첫 ON_RESUME(진입 자체)은 [isFirstResume] 로 스킵하고, 그 이후의 resume 이 실행 중인
          * 로드와 겹치면(빠른 resume 연타 등) 진행 중인 Job 으로 건너뛴다.
          */
-        fun refreshOnReturn() {
+        private fun refreshOnReturn() {
             if (isFirstResume) {
                 isFirstResume = false
                 return
@@ -171,7 +221,7 @@ class AfternoteDetailViewModel
             loadJob =
                 viewModelScope.launch {
                     if (showsLoading) {
-                        _uiState.value = AfternoteDetailUiState.Loading
+                        dispatch(AfternoteDetailReducerEvent.Loading)
                     }
                     val result = afternoteRepository.getDetail(id = afternoteId)
                     // 잘린 로드가 값을 들고 돌아와 새 화면을 덮는 창을 닫는다. repository 는 취소를 다시
@@ -181,37 +231,12 @@ class AfternoteDetailViewModel
                         .onSuccess { detail ->
                             // 매핑은 update 밖에서 한 번만 한다 — update 의 람다는 경합 시 재실행된다.
                             val contentUiModel = detail.toDetailContentUiModel()
-                            _uiState.update { current ->
-                                // 갱신은 «상세 부분만» 바꾼다. 진행 중인 삭제(isDeleting)와 미소비 삭제
-                                // 결과(deleteResult)는 이 로드와 무관한 다른 작업의 상태라, 새 Success 로
-                                // 덮으면 그 기본값이 삭제 진행 표시를 풀고 결과 안내를 지운다.
-                                if (current is AfternoteDetailUiState.Success) {
-                                    current.copy(
-                                        detailId = detail.id,
-                                        contentUiModel = contentUiModel,
-                                        authorDisplayName = authorDisplayName,
-                                    )
-                                } else {
-                                    AfternoteDetailUiState.Success(
-                                        detailId = detail.id,
-                                        contentUiModel = contentUiModel,
-                                        authorDisplayName = authorDisplayName,
-                                    )
-                                }
-                            }
+                            dispatch(AfternoteDetailReducerEvent.ContentLoaded(detail.id, contentUiModel, authorDisplayName))
                         }.onFailure { e ->
                             // 화면을 유지하는 자동 갱신 실패도 기록한다 — 사용자에게 안 보이는 만큼
                             // 콘솔이 유일한 관측 지점이다.
                             errorReporter.recordAfternoteFailure(AfternoteFailureStage.DETAIL_LOAD, e)
-                            _uiState.update { current ->
-                                if (keepsStateOnFailure && current is AfternoteDetailUiState.Success) {
-                                    current
-                                } else {
-                                    AfternoteDetailUiState.Error(
-                                        messageRes = R.string.afternote_detail_load_error,
-                                    )
-                                }
-                            }
+                            dispatch(AfternoteDetailReducerEvent.LoadFailed(keepsStateOnFailure))
                         }
                 }
         }
@@ -219,7 +244,7 @@ class AfternoteDetailViewModel
         /**
          * 삭제는 상세를 보고 있을 때만 뜻이 있다 — 그 전제를 상태에서 직접 확인한다.
          *
-         * 상태 갱신은 [updateSuccess] 가 Success 밖에서 no-op 이라 이미 안전하지만, **서버 호출은 아니다.**
+         * 상태 갱신은 [reduce] 가 Success 밖에서 no-op 이라 이미 안전하지만, **서버 호출은 아니다.**
          * Success 가 아닐 때 이 함수가 불리면 노트는 지워지는데 UI 는 아무것도 모른다(진행 표시도,
          * 결과 안내도, 화면 pop 도 없다). 중복 호출 가드도 non-Success 에서는 늘 통과한다.
          * 지금은 결선상 Success 에서만 호출되지만, 그 불변식은 VM 밖(내비게이션 분기)에 있다.
@@ -227,40 +252,27 @@ class AfternoteDetailViewModel
          * 지울 id 도 인자로 받지 않고 그 Success 에서 꺼낸다 — 화면에 보이는 것과 다른 항목을 지우는
          * 경우를 시그니처에서 없앤다. 호출부가 넘기던 값도 같은 Success 의 `detailId` 였다.
          */
-        fun deleteAfternote() {
-            val current = _uiState.value as? AfternoteDetailUiState.Success ?: return
+        private fun deleteAfternote() {
+            val current = currentState as? AfternoteDetailUiState.Success ?: return
             if (current.isDeleting) return
             val afternoteId = current.detailId
             viewModelScope.launch {
-                updateSuccess { it.copy(isDeleting = true) }
+                dispatch(AfternoteDetailReducerEvent.DeleteStarted)
                 afternoteRepository
                     .delete(id = afternoteId)
                     .onSuccess {
-                        updateSuccess {
-                            it.copy(
-                                isDeleting = false,
-                                deleteResult = AfternoteDetailDeleteResult.Succeeded(afternoteId),
-                            )
-                        }
+                        dispatch(AfternoteDetailReducerEvent.DeleteFinished(AfternoteDetailDeleteResult.Succeeded(afternoteId)))
                     }.onFailure { e ->
                         errorReporter.recordAfternoteFailure(AfternoteFailureStage.DETAIL_DELETE, e)
-                        updateSuccess {
-                            it.copy(
-                                isDeleting = false,
-                                deleteResult =
-                                    AfternoteDetailDeleteResult.Failed(
-                                        messageRes = R.string.afternote_detail_delete_failed,
-                                    ),
-                            )
-                        }
+                        dispatch(
+                            AfternoteDetailReducerEvent.DeleteFinished(
+                                AfternoteDetailDeleteResult.Failed(R.string.afternote_detail_delete_failed),
+                            ),
+                        )
                     }
             }
         }
 
-        fun onDeleteResultConsumed() {
-            updateSuccess { it.copy(deleteResult = null) }
-        }
-
         // endregion
 
         // region State shaping
@@ -268,18 +280,7 @@ class AfternoteDetailViewModel
         /** 늦게 도착한 작성자 표시명을 반영한다. 아직 Loading 이면 필드에만 남아 다음 Success 에 실린다. */
         private fun applyAuthorDisplayName(name: String) {
             authorDisplayName = name
-            updateSuccess { it.copy(authorDisplayName = name) }
-        }
-
-        /** 삭제 진행·결과는 Success 에만 존재하므로, 그 외 상태에서는 갱신하지 않는다. */
-        private fun updateSuccess(transform: (AfternoteDetailUiState.Success) -> AfternoteDetailUiState) {
-            _uiState.update { current ->
-                if (current is AfternoteDetailUiState.Success) {
-                    transform(current)
-                } else {
-                    current
-                }
-            }
+            dispatch(AfternoteDetailReducerEvent.AuthorNameChanged(name))
         }
 
         // endregion
@@ -289,3 +290,8 @@ class AfternoteDetailViewModel
             fun create(route: AfternoteRoute.DetailRoute): AfternoteDetailViewModel
         }
     }
+
+/** 상세 재조회가 삭제 진행·미소비 결과를 덮지 않도록 Success의 해당 필드만 바꾼다. */
+private inline fun AfternoteDetailUiState.withSuccess(
+    transform: (AfternoteDetailUiState.Success) -> AfternoteDetailUiState,
+): AfternoteDetailUiState = if (this is AfternoteDetailUiState.Success) transform(this) else this
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorContent.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorContent.kt
index 7f6f2f6e06..fcfc5fc495 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorContent.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorContent.kt
@@ -44,7 +44,7 @@ import com.afternote.feature.afternote.presentation.editor.state.AfternoteEditor
 import com.afternote.feature.afternote.presentation.editor.state.EditorFormState
 
 @Composable
-internal fun EditorContent(
+private fun EditorContent(
     state: AfternoteEditorState,
     form: EditorFormState,
     typeContent: @Composable () -> Unit,
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorContract.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorContract.kt
new file mode 100644
index 0000000000..0237e5c269
--- /dev/null
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorContract.kt
@@ -0,0 +1,252 @@
+package com.afternote.feature.afternote.presentation.editor
+
+import com.afternote.core.ui.mvi.MviIntent
+import com.afternote.core.ui.mvi.ReducerEvent
+import com.afternote.feature.afternote.domain.AfternoteType
+import com.afternote.feature.afternote.presentation.editor.memorial.Song
+import com.afternote.feature.afternote.presentation.editor.model.EditorFormPrefill
+import com.afternote.feature.afternote.presentation.editor.model.RegisterAfternotePayload
+import com.afternote.feature.afternote.presentation.editor.receiver.AfternoteEditorReceiver
+import com.afternote.feature.afternote.presentation.editor.state.AfternoteEditorError
+import com.afternote.feature.afternote.presentation.editor.state.AfternoteEditorErrorEvent
+import com.afternote.feature.afternote.presentation.editor.state.EditorFormState
+
+/** 편집기 공유 흐름이 ViewModel에 보내는 변경·소비 의도. */
+internal sealed interface AfternoteEditorIntent : MviIntent {
+    data class SetType(
+        val type: AfternoteType,
+    ) : AfternoteEditorIntent
+
+    data class SetService(
+        val service: String,
+    ) : AfternoteEditorIntent
+
+    data class SetMemorialPhoto(
+        val uri: String,
+    ) : AfternoteEditorIntent
+
+    data object RemoveMemorialPhoto : AfternoteEditorIntent
+
+    data class SetMemorialVideo(
+        val url: String,
+    ) : AfternoteEditorIntent
+
+    data object RemoveMemorialVideo : AfternoteEditorIntent
+
+    data class SetMemorialThumbnail(
+        val dataUrl: String,
+    ) : AfternoteEditorIntent
+
+    data class AddMemorialPlaylistSongs(
+        val songs: List<Song>,
+    ) : AfternoteEditorIntent
+
+    data class RemoveMemorialPlaylistSongs(
+        val selectionKeys: Set<String>,
+    ) : AfternoteEditorIntent
+
+    data object ClearMemorialPlaylistSongs : AfternoteEditorIntent
+
+    data class DeleteReceiver(
+        val receiverId: Long,
+    ) : AfternoteEditorIntent
+
+    data class AddReceiverIfAbsent(
+        val receiverId: Long,
+        val name: String,
+        val label: String,
+    ) : AfternoteEditorIntent
+
+    data class ReplaceReceiversIfEmpty(
+        val receivers: List<AfternoteEditorReceiver>,
+    ) : AfternoteEditorIntent
+
+    data class ApplyPrefill(
+        val prefill: EditorFormPrefill,
+    ) : AfternoteEditorIntent
+
+    data class InitializeProcessingMethodDefaults(
+        val type: AfternoteType,
+        val methods: List<String>,
+    ) : AfternoteEditorIntent
+
+    data class AddProcessingMethod(
+        val text: String,
+    ) : AfternoteEditorIntent
+
+    data class DeleteProcessingMethod(
+        val localId: Int,
+    ) : AfternoteEditorIntent
+
+    data class EditProcessingMethod(
+        val localId: Int,
+        val newText: String,
+    ) : AfternoteEditorIntent
+
+    data object RefreshAuthorReceivers : AfternoteEditorIntent
+
+    data class UploadMemorialThumbnail(
+        val jpegBytes: ByteArray?,
+    ) : AfternoteEditorIntent
+
+    data class MemorialThumbnailExtractionFailed(
+        val throwable: Throwable,
+    ) : AfternoteEditorIntent
+
+    data object RetryMemorialThumbnail : AfternoteEditorIntent
+
+    data class MemorialCaptureLaunchFailed(
+        val throwable: Throwable,
+    ) : AfternoteEditorIntent
+
+    data class Save(
+        val payload: RegisterAfternotePayload,
+        val selectedReceiverIds: List<Long>,
+        val memorialMedia: SaveAfternoteMemorialMedia,
+    ) : AfternoteEditorIntent
+
+    data object RetryPrefill : AfternoteEditorIntent
+
+    data object ConsumePrefill : AfternoteEditorIntent
+
+    data object ConsumeSaveSuccess : AfternoteEditorIntent
+
+    data object ConsumeThumbnailUploaded : AfternoteEditorIntent
+
+    data class ConsumeError(
+        val consumed: AfternoteEditorErrorEvent,
+    ) : AfternoteEditorIntent
+
+    data class ReceiversSelected(
+        val receiverIds: List<Long>,
+    ) : AfternoteEditorIntent
+
+    data object ApplyPendingReceiverSelection : AfternoteEditorIntent
+}
+
+/** ViewModel의 작업 결과와 순수 폼 전이. */
+internal sealed interface AfternoteEditorReducerEvent : ReducerEvent {
+    data class TypeChanged(
+        val type: AfternoteType,
+    ) : AfternoteEditorReducerEvent
+
+    data class ServiceChanged(
+        val service: String,
+    ) : AfternoteEditorReducerEvent
+
+    data class MemorialPhotoChanged(
+        val uri: String,
+    ) : AfternoteEditorReducerEvent
+
+    data object MemorialPhotoRemoved : AfternoteEditorReducerEvent
+
+    data class MemorialVideoChanged(
+        val url: String,
+    ) : AfternoteEditorReducerEvent
+
+    data object MemorialVideoRemoved : AfternoteEditorReducerEvent
+
+    data class MemorialThumbnailChanged(
+        val dataUrl: String,
+    ) : AfternoteEditorReducerEvent
+
+    data class PlaylistSongsAdded(
+        val songs: List<Song>,
+    ) : AfternoteEditorReducerEvent
+
+    data class PlaylistSongsRemoved(
+        val selectionKeys: Set<String>,
+    ) : AfternoteEditorReducerEvent
+
+    data object PlaylistSongsCleared : AfternoteEditorReducerEvent
+
+    data class ReceiverDeleted(
+        val receiverId: Long,
+    ) : AfternoteEditorReducerEvent
+
+    data class ReceiverAdded(
+        val receiverId: Long,
+        val name: String,
+        val label: String,
+    ) : AfternoteEditorReducerEvent
+
+    data class EmptyReceiversReplaced(
+        val receivers: List<AfternoteEditorReceiver>,
+    ) : AfternoteEditorReducerEvent
+
+    data class PrefillApplied(
+        val prefill: EditorFormPrefill,
+    ) : AfternoteEditorReducerEvent
+
+    data class ProcessingMethodsInitialized(
+        val type: AfternoteType,
+        val methods: List<String>,
+    ) : AfternoteEditorReducerEvent
+
+    data class ProcessingMethodAdded(
+        val text: String,
+    ) : AfternoteEditorReducerEvent
+
+    data class ProcessingMethodDeleted(
+        val localId: Int,
+    ) : AfternoteEditorReducerEvent
+
+    data class ProcessingMethodEdited(
+        val localId: Int,
+        val newText: String,
+    ) : AfternoteEditorReducerEvent
+
+    data class Initialized(
+        val form: EditorFormState,
+        val originalType: AfternoteType?,
+        val isPrefillLoading: Boolean,
+    ) : AfternoteEditorReducerEvent
+
+    data class AuthorReceiversLoaded(
+        val receivers: List<AfternoteEditorReceiver>,
+    ) : AfternoteEditorReducerEvent
+
+    data class ThumbnailUploaded(
+        val url: String,
+    ) : AfternoteEditorReducerEvent
+
+    data object ThumbnailExtractionRetried : AfternoteEditorReducerEvent
+
+    data class ErrorRaised(
+        val error: AfternoteEditorError,
+    ) : AfternoteEditorReducerEvent
+
+    data object SaveStarted : AfternoteEditorReducerEvent
+
+    data class SaveSucceeded(
+        val id: Long,
+    ) : AfternoteEditorReducerEvent
+
+    data class SaveFailed(
+        val error: AfternoteEditorError,
+    ) : AfternoteEditorReducerEvent
+
+    data object PrefillStarted : AfternoteEditorReducerEvent
+
+    data class PrefillLoaded(
+        val prefill: EditorFormPrefill,
+        val baseline: AfternoteEditorSnapshot,
+        val preserveRestoredForm: Boolean,
+    ) : AfternoteEditorReducerEvent
+
+    data object PrefillFailed : AfternoteEditorReducerEvent
+
+    data class SelectedReceiversApplied(
+        val receivers: List<AfternoteEditorReceiver>,
+    ) : AfternoteEditorReducerEvent
+
+    data object PrefillConsumed : AfternoteEditorReducerEvent
+
+    data object SaveSuccessConsumed : AfternoteEditorReducerEvent
+
+    data object ThumbnailUploadConsumed : AfternoteEditorReducerEvent
+
+    data class ErrorConsumed(
+        val consumed: AfternoteEditorErrorEvent,
+    ) : AfternoteEditorReducerEvent
+}
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorFormMapper.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorFormMapper.kt
index 4763274635..1bb1f767b3 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorFormMapper.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorFormMapper.kt
@@ -117,28 +117,12 @@ internal object AfternoteEditorFormMapper {
         memorialPhotoUrl: String? = null,
         memorialVideoUrl: String? = null,
         memorialThumbnailUrl: String? = null,
-    ): MemorialWritePayload {
-        val songs =
-            playlistSongs.map { song ->
-                MemorialSongPayload(
-                    title = song.title,
-                    artist = song.artist,
-                    coverUrl = song.albumCoverUrl,
-                )
-            }
-        val memorialVideo =
-            memorialVideoUrl?.ifBlank { null }?.let { url ->
-                MemorialVideoPayload(
-                    videoUrl = url,
-                    thumbnailUrl = memorialThumbnailUrl?.ifBlank { null },
-                )
-            }
-        return MemorialWritePayload(
-            memorialPhotoUrl = memorialPhotoUrl?.ifBlank { null },
-            songs = songs,
-            memorialVideo = memorialVideo,
+    ): MemorialWritePayload =
+        MemorialWritePayload(
+            memorialPhotoUrl = memorialPhotoUrl,
+            songs = playlistSongs.map { it.toMemorialSongPayload() },
+            memorialVideo = memorialVideoPayload(videoUrl = memorialVideoUrl, thumbnailUrl = memorialThumbnailUrl),
         )
-    }
 
     fun buildCreateInput(
         type: AfternoteType,
@@ -384,7 +368,7 @@ internal object AfternoteEditorFormMapper {
                 MemorialSnapshot(
                     title = title,
                     leaveMessageBlocks = leaveMessageBlocks,
-                    photoUrl = content.media.photoUrl?.ifBlank { null },
+                    photoUrl = content.media.photoUrl,
                     video = content.media.toVideoPayload(),
                     songs =
                         content.songs.map { song ->
@@ -444,12 +428,9 @@ internal object AfternoteEditorFormMapper {
                 MemorialSnapshot(
                     title = title,
                     leaveMessageBlocks = leaveMessageBlocks,
-                    photoUrl = memorialMediaUrls.memorialPhotoUrl?.ifBlank { null },
+                    photoUrl = memorialMediaUrls.memorialPhotoUrl,
                     video = memorialMediaUrls.toVideoPayload(),
-                    songs =
-                        playlistSongs.map { song ->
-                            MemorialSongPayload(title = song.title, artist = song.artist, coverUrl = song.albumCoverUrl)
-                        },
+                    songs = playlistSongs.map { it.toMemorialSongPayload() },
                 )
             }
 
@@ -466,15 +447,22 @@ internal object AfternoteEditorFormMapper {
     private fun RegisterAfternotePayload.toCredentialsSnapshot() =
         CredentialsSnapshot(id = accountId.ifBlank { null }, password = password.ifBlank { null })
 
+    private fun Song.toMemorialSongPayload() = MemorialSongPayload(title = title, artist = artist, coverUrl = albumCoverUrl)
+
     private fun MemorialMedia.toVideoPayload(): MemorialVideoPayload? =
-        videoUrl?.ifBlank { null }?.let { url ->
-            MemorialVideoPayload(videoUrl = url, thumbnailUrl = thumbnailUrl?.ifBlank { null })
-        }
+        memorialVideoPayload(videoUrl = videoUrl, thumbnailUrl = thumbnailUrl)
 
     private fun MemorialMediaUrls.toVideoPayload(): MemorialVideoPayload? =
-        memorialVideoUrl?.ifBlank { null }?.let { url ->
-            MemorialVideoPayload(videoUrl = url, thumbnailUrl = memorialThumbnailUrl?.ifBlank { null })
-        }
+        memorialVideoPayload(videoUrl = memorialVideoUrl, thumbnailUrl = memorialThumbnailUrl)
+
+    /**
+     * 영상 주소가 없으면 영상 슬롯 자체가 없다. 썸네일만 남은 값은 싣지 않는다.
+     * 빈 문자열은 입구(상세 data 매퍼, 폼의 `MediaInput` 판정과 영상 첨부)에서 이미 `null` 로 맞춰져 들어온다.
+     */
+    private fun memorialVideoPayload(
+        videoUrl: String?,
+        thumbnailUrl: String?,
+    ): MemorialVideoPayload? = videoUrl?.let { url -> MemorialVideoPayload(videoUrl = url, thumbnailUrl = thumbnailUrl) }
 }
 
 /**
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorRoute.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorRoute.kt
index 23fb0f67b7..b67cb534b5 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorRoute.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorRoute.kt
@@ -32,21 +32,32 @@ internal fun AfternoteEditorNavigation(
     val uiState by editViewModel.uiState.collectAsStateWithLifecycle()
     val state =
         rememberAfternoteEditorState(
-            getCurrentForm = editViewModel::currentForm,
-            setType = editViewModel::setType,
-            setService = editViewModel::setService,
-            setMemorialPhoto = editViewModel::setMemorialPhoto,
-            removeMemorialPhoto = editViewModel::removeMemorialPhoto,
-            setMemorialVideo = editViewModel::setMemorialVideo,
-            removeMemorialVideo = editViewModel::removeMemorialVideo,
-            addReceiverIfAbsent = editViewModel::addReceiverIfAbsent,
-            applyPrefill = editViewModel::applyPrefill,
-            setMemorialThumbnail = editViewModel::setMemorialThumbnail,
-            deleteReceiver = editViewModel::deleteReceiver,
-            replaceReceiversIfEmpty = editViewModel::replaceReceiversIfEmpty,
-            addProcessingMethod = editViewModel::addProcessingMethod,
-            deleteProcessingMethod = editViewModel::deleteProcessingMethod,
-            editProcessingMethod = editViewModel::editProcessingMethod,
+            getCurrentForm = { editViewModel.uiState.value.form },
+            setType = { type -> editViewModel.onIntent(AfternoteEditorIntent.SetType(type)) },
+            setService = { service -> editViewModel.onIntent(AfternoteEditorIntent.SetService(service)) },
+            setMemorialPhoto = { uri -> editViewModel.onIntent(AfternoteEditorIntent.SetMemorialPhoto(uri)) },
+            removeMemorialPhoto = { editViewModel.onIntent(AfternoteEditorIntent.RemoveMemorialPhoto) },
+            setMemorialVideo = { url -> editViewModel.onIntent(AfternoteEditorIntent.SetMemorialVideo(url)) },
+            removeMemorialVideo = { editViewModel.onIntent(AfternoteEditorIntent.RemoveMemorialVideo) },
+            addReceiverIfAbsent = {
+                receiverId,
+                name,
+                label,
+                ->
+                editViewModel.onIntent(AfternoteEditorIntent.AddReceiverIfAbsent(receiverId, name, label))
+            },
+            applyPrefill = { prefill -> editViewModel.onIntent(AfternoteEditorIntent.ApplyPrefill(prefill)) },
+            setMemorialThumbnail = { dataUrl -> editViewModel.onIntent(AfternoteEditorIntent.SetMemorialThumbnail(dataUrl)) },
+            deleteReceiver = { receiverId -> editViewModel.onIntent(AfternoteEditorIntent.DeleteReceiver(receiverId)) },
+            replaceReceiversIfEmpty = { receivers -> editViewModel.onIntent(AfternoteEditorIntent.ReplaceReceiversIfEmpty(receivers)) },
+            addProcessingMethod = { text -> editViewModel.onIntent(AfternoteEditorIntent.AddProcessingMethod(text)) },
+            deleteProcessingMethod = { localId -> editViewModel.onIntent(AfternoteEditorIntent.DeleteProcessingMethod(localId)) },
+            editProcessingMethod = {
+                localId,
+                newText,
+                ->
+                editViewModel.onIntent(AfternoteEditorIntent.EditProcessingMethod(localId, newText))
+            },
         )
 
     val selectedType = uiState.form.selectedType
@@ -55,14 +66,16 @@ internal fun AfternoteEditorNavigation(
     val isProcessingMethodDefaultsInitializing = remember(selectedType) { mutableStateOf(true) }
 
     LaunchedEffect(selectedType) {
-        editViewModel.initializeProcessingMethodDefaults(
-            type = selectedType,
-            methods = defaultProcessingMethods,
+        editViewModel.onIntent(
+            AfternoteEditorIntent.InitializeProcessingMethodDefaults(
+                type = selectedType,
+                methods = defaultProcessingMethods,
+            ),
         )
         isProcessingMethodDefaultsInitializing.value = false
     }
 
-    LaunchedEffect(Unit) { editViewModel.refreshAuthorReceivers() }
+    LaunchedEffect(Unit) { editViewModel.onIntent(AfternoteEditorIntent.RefreshAuthorReceivers) }
 
     LaunchedEffect(uiState.authorReceivers, editViewModel.isEditing) {
         if (!editViewModel.isEditing) {
@@ -72,29 +85,27 @@ internal fun AfternoteEditorNavigation(
 
     // 선택 화면이 위에 쌓이는 동안 이 화면은 컴포지션에서 빠지므로, 복귀할 때마다 다시 돈다.
     LaunchedEffect(Unit) {
-        tryApplyReceiverSelection(
-            editViewModel,
-        )
+        editViewModel.onIntent(AfternoteEditorIntent.ApplyPendingReceiverSelection)
     }
 
     LaunchedEffect(uiState.pendingSaveSuccessId) {
         if (uiState.pendingSaveSuccessId != null) {
             onSaveSuccessNavigateHome()
-            editViewModel.onSaveSuccessConsumed()
+            editViewModel.onIntent(AfternoteEditorIntent.ConsumeSaveSuccess)
         }
     }
     val pendingThumbnailUrl = uiState.pendingThumbnailUrl
     LaunchedEffect(pendingThumbnailUrl) {
         if (pendingThumbnailUrl != null) {
             state.setMemorialThumbnail(pendingThumbnailUrl)
-            editViewModel.onThumbnailUploadedConsumed()
+            editViewModel.onIntent(AfternoteEditorIntent.ConsumeThumbnailUploaded)
         }
     }
     val pendingPrefill = uiState.pendingPrefill
     LaunchedEffect(pendingPrefill) {
         if (pendingPrefill != null) {
             state.applyFormPrefill(pendingPrefill)
-            editViewModel.onPrefillConsumed()
+            editViewModel.onIntent(AfternoteEditorIntent.ConsumePrefill)
         }
     }
 
@@ -132,7 +143,7 @@ internal fun AfternoteEditorNavigation(
         if (errorEvent?.error?.offersMemorialThumbnailRetry() == true) {
             EditorSnackbarAction(
                 label = stringResource(R.string.afternote_editor_thumbnail_retry),
-                onPerform = editViewModel::retryMemorialThumbnail,
+                onPerform = { editViewModel.onIntent(AfternoteEditorIntent.RetryMemorialThumbnail) },
             )
         } else {
             null
@@ -144,27 +155,31 @@ internal fun AfternoteEditorNavigation(
         snackbarMessage = snackbarMessage,
         snackbarAction = thumbnailRetryAction,
         onSnackbarMessageConsumed = {
-            errorEvent?.let(editViewModel::onErrorConsumed)
+            errorEvent?.let({ consumed -> editViewModel.onIntent(AfternoteEditorIntent.ConsumeError(consumed)) })
         },
         validationMessage = validationMessage,
         onValidationMessageConsumed = {
-            errorEvent?.let(editViewModel::onErrorConsumed)
+            errorEvent?.let({ consumed -> editViewModel.onIntent(AfternoteEditorIntent.ConsumeError(consumed)) })
         },
         content = { snackbarHostState ->
             // prefill 을 못 읽었으면 폼을 세우지 않는다 (#705) — 빈 폼으로 저장되면 서버가 기존 기록을
             // 그 빈 값으로 덮는다. 이 갈래에서는 사유와 재시도만 노출하고 «등록» 도 함께 잠근다.
             if (uiState.isPrefillFailed) {
-                EditorPrefillErrorBody(onRetry = editViewModel::retryPrefill)
+                EditorPrefillErrorBody(onRetry = { editViewModel.onIntent(AfternoteEditorIntent.RetryPrefill) })
             } else {
                 AfternoteEditorBody(
                     state = state,
                     form = uiState.form,
                     onNavigateToMemorialPlaylist = onNavigateToMemorialPlaylist,
                     onNavigateToSelectReceiver = onNavigateToSelectReceiver,
-                    onThumbnailBytesReady = editViewModel::uploadMemorialThumbnail,
-                    onThumbnailExtractionFailed = editViewModel::onMemorialThumbnailExtractionFailed,
+                    onThumbnailBytesReady = { jpegBytes ->
+                        editViewModel.onIntent(AfternoteEditorIntent.UploadMemorialThumbnail(jpegBytes))
+                    },
+                    onThumbnailExtractionFailed = { throwable ->
+                        editViewModel.onIntent(AfternoteEditorIntent.MemorialThumbnailExtractionFailed(throwable))
+                    },
                     thumbnailRetryToken = uiState.memorialThumbnailRetryToken,
-                    onCaptureFailed = editViewModel::onMemorialCaptureLaunchFailed,
+                    onCaptureFailed = { throwable -> editViewModel.onIntent(AfternoteEditorIntent.MemorialCaptureLaunchFailed(throwable)) },
                     snackbarHostState = snackbarHostState,
                     isPrefillLoading = uiState.isPrefillLoading,
                     isTypeSelectionEnabled = !editViewModel.isEditing,
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorRouteHelpers.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorRouteHelpers.kt
index f69fa525ac..517276782f 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorRouteHelpers.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorRouteHelpers.kt
@@ -4,6 +4,7 @@ import androidx.annotation.StringRes
 import com.afternote.feature.afternote.presentation.R
 import com.afternote.feature.afternote.presentation.editor.state.AfternoteEditorError
 import com.afternote.feature.afternote.presentation.editor.state.AfternoteEditorState
+import com.afternote.feature.afternote.presentation.editor.state.EditableMemorialPhoto
 import com.afternote.feature.afternote.presentation.editor.state.EditableMemorialVideo
 
 // 에디터 조립부가 쓰는 순수 헬퍼들이다. Route 파일에는 조립만 남긴다 (#1514).
@@ -33,6 +34,10 @@ internal fun AfternoteEditorError.messageResId(): Int =
             R.string.afternote_editor_prefill_not_ready
         }
 
+        AfternoteEditorError.MediaSizeExceeded -> {
+            R.string.afternote_editor_media_size_exceeded
+        }
+
         is AfternoteEditorError.Upload -> {
             when (target) {
                 AfternoteEditorError.Upload.Target.THUMBNAIL -> R.string.afternote_editor_thumbnail_upload_failed
@@ -58,19 +63,6 @@ internal fun AfternoteEditorError.offersMemorialThumbnailRetry(): Boolean =
             AfternoteEditorError.Upload.Target.SAVE_MEDIA -> false
         }
 
-/**
- * 수신자 선택 화면이 남긴 id 전체를 폼에 반영한다 (#1426).
- *
- * 결과는 흐름 공유 ViewModel 이 1회 소비로 나른다 (#1698) — Nav2 의 «이전 엔트리 SavedStateHandle»
- * 자리다. 소비할 값이 없으면 선택 화면을 거치지 않은 복귀라 아무것도 하지 않는다. 값이 있으면 그게
- * 곧 확정된 수신자 전체이므로 반영은 [AfternoteEditorViewModel.applySelectedReceivers] 에 맡긴다
- * («추가» 가 아니라 «교체» 인 이유는 그 KDoc 참고).
- */
-internal suspend fun tryApplyReceiverSelection(viewModel: AfternoteEditorViewModel) {
-    val selectedIds = viewModel.consumeSelectedReceiverIds() ?: return
-    viewModel.applySelectedReceivers(selectedIds)
-}
-
 internal fun buildOnRegisterClick(
     editViewModel: AfternoteEditorViewModel,
     state: AfternoteEditorState,
@@ -89,15 +81,16 @@ internal fun buildOnRegisterClick(
                     state.passwordState.text
                         .toString(),
             )
-        editViewModel.saveAfternote(
-            payload = payload,
-            selectedReceiverIds = form.afternoteEditReceivers.map { it.id },
-            memorialMedia =
-                SaveAfternoteMemorialMedia(
-                    memorialVideo = form.memorialVideo ?: EditableMemorialVideo.empty(),
-                    memorialPhotoUrl = form.memorialPhotoUrl,
-                    pickedMemorialPhotoUri = form.pickedMemorialPhotoUri,
-                ),
+        editViewModel.onIntent(
+            AfternoteEditorIntent.Save(
+                payload = payload,
+                selectedReceiverIds = form.afternoteEditReceivers.map { it.id },
+                memorialMedia =
+                    SaveAfternoteMemorialMedia(
+                        memorialVideo = form.memorialVideo ?: EditableMemorialVideo.empty(),
+                        memorialPhoto = form.memorialPhoto ?: EditableMemorialPhoto.empty(),
+                    ),
+            ),
         )
     }
 
@@ -121,7 +114,7 @@ internal fun shouldDeferEditorBaselineCapture(
  * 폼이 기본 빈 값이라, 느린 상세 GET 을 앞질러 저장하면 수정(PATCH)이 그 빈 값으로 나가 기존
  * 기록을 덮는다. `isPrefillLoading` 은 편집 진입에서만 true 라 신규 작성은 영향받지 않는다.
  *
- * ViewModel 의 [AfternoteEditorViewModel.saveAfternote] 진입 가드와 **같은 규칙을 두 겹으로** 둔다 —
+ * ViewModel 의 [AfternoteEditorIntent.Save] 진입 가드와 **같은 규칙을 두 겹으로** 둔다 —
  * 화면이 막는 것은 사용자 경험이고, 저장 진입점에서 막는 것은 계약이다.
  */
 internal fun isEditorSubmitEnabled(
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorScreen.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorScreen.kt
index c399b5f489..00195994f5 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorScreen.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorScreen.kt
@@ -215,7 +215,7 @@ private const val NO_ENTERED_CONTENT = "\u0003"
  * 카테고리 전용 입력은 판별자 없이 "넣은 값" 으로만 싣는다 — 구경은 되돌리는 비용이 탭 한 번이라
  * 잃을 것이 없고, 값을 넣은 카테고리를 떠나면 그 값은 전환 시점에 이미 폐기되므로 지문이 달라진다.
  */
-internal fun editorContentSignature(
+private fun editorContentSignature(
     form: EditorFormState,
     state: AfternoteEditorState,
 ): String {
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorViewModel.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorViewModel.kt
index fe9f6aa5b2..6a92b45b88 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorViewModel.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorViewModel.kt
@@ -2,19 +2,20 @@ package com.afternote.feature.afternote.presentation.editor
 
 import android.util.Log
 import androidx.lifecycle.SavedStateHandle
-import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.afternote.core.common.reporting.ErrorReporter
-import com.afternote.core.common.result.runCatchingCancellable
-import com.afternote.core.domain.repository.UserRepository
+import com.afternote.core.domain.error.FileUploadFailure
+import com.afternote.core.domain.repository.UserReceiverRepository
+import com.afternote.core.domain.result.runCatchingCancellable
+import com.afternote.core.ui.mvi.MviViewModel
 import com.afternote.feature.afternote.domain.AfternoteType
 import com.afternote.feature.afternote.domain.error.AfternoteFailure
-import com.afternote.feature.afternote.domain.model.author.CreateAfternoteInput
 import com.afternote.feature.afternote.domain.model.author.SaveAfternoteCommand
 import com.afternote.feature.afternote.domain.repository.author.AfternoteRepository
 import com.afternote.feature.afternote.domain.repository.author.MediaInput
 import com.afternote.feature.afternote.domain.repository.author.MemorialThumbnailUploadRepository
 import com.afternote.feature.afternote.domain.usecase.editor.ResolveMemorialMediaForSaveUseCase
+import com.afternote.feature.afternote.domain.usecase.editor.SaveAfternoteUseCase
 import com.afternote.feature.afternote.presentation.editor.mapper.toAfternoteEditorReceivers
 import com.afternote.feature.afternote.presentation.editor.memorial.Song
 import com.afternote.feature.afternote.presentation.editor.model.EditorFormPrefill
@@ -25,6 +26,7 @@ import com.afternote.feature.afternote.presentation.editor.state.AfternoteEditor
 import com.afternote.feature.afternote.presentation.editor.state.AfternoteEditorErrorEvent
 import com.afternote.feature.afternote.presentation.editor.state.AfternoteEditorUiState
 import com.afternote.feature.afternote.presentation.editor.state.AfternoteTypeForm
+import com.afternote.feature.afternote.presentation.editor.state.EditableMemorialPhoto
 import com.afternote.feature.afternote.presentation.editor.state.EditableMemorialVideo
 import com.afternote.feature.afternote.presentation.editor.state.EditorFormState
 import com.afternote.feature.afternote.presentation.editor.state.withMemorialPhoto
@@ -53,18 +55,15 @@ import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.Job
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.stateIn
-import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.ensureActive
 import kotlinx.coroutines.launch
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.Json
 
 private const val EDITOR_FORM_SNAPSHOT_KEY = "editor_form_snapshot_v6"
 private const val INITIALIZED_ACTION_TEMPLATE_TYPE_KEY = "initialized_action_template_type"
+private const val PREFILL_SEEDED_ITEM_ID_KEY = "editor_prefill_seeded_item_id"
 
 private const val TAG = "AfternoteEditorViewModel"
 
@@ -84,6 +83,7 @@ private data class ProcessingMethodSnap(
 /**
  * [SavedStateHandle]에 JSON으로 넣는 폼 스냅샷. 번들 전체 크기는 대략 500KB~1MB를 넘기지 않도록 설계해야 하며,
  * 그렇지 않으면 [android.os.TransactionTooLargeException]이 날 수 있다. 큰 Base64/data URL은 폼에 넣지 말고 URL·URI 문자열만 저장한다.
+ * 사진 값 객체는 기존 `pickedMemorialPhotoUri`·`memorialPhotoUrl` 두 키로 변환해 사진 필드의 JSON 호환성을 유지한다.
  *
  * **wire 형태는 키에 박힌 버전과 함께 움직인다.** [EditableMemorialVideo]가 sealed 로 바뀌면서(#1901)
  * `memorialVideo` 에 판별자가 붙었고(v5), 상태가 넷에서 셋으로 줄면서(#2114) 판별자 값이
@@ -129,9 +129,8 @@ private data class EditorFormSnapshot(
 
             AfternoteType.MEMORIAL -> {
                 AfternoteTypeForm.Memorial(
-                    pickedPhotoUri = pickedMemorialPhotoUri,
+                    photo = EditableMemorialPhoto.fromSnapshot(memorialPhotoUrl, pickedMemorialPhotoUri),
                     video = memorialVideo ?: EditableMemorialVideo.empty(),
-                    photoUrl = memorialPhotoUrl,
                     playlistSongs = memorialPlaylistSongs,
                 )
             }
@@ -152,9 +151,9 @@ private data class EditorFormSnapshot(
                         ReceiverSnap(id = it.id, name = it.name, label = it.label)
                     },
                 processingMethods = form.processingMethods.map { ProcessingMethodSnap(it.localId, it.text) },
-                pickedMemorialPhotoUri = form.pickedMemorialPhotoUri,
+                pickedMemorialPhotoUri = form.memorialPhoto?.toSnapshot()?.selection,
                 memorialVideo = form.memorialVideo,
-                memorialPhotoUrl = form.memorialPhotoUrl,
+                memorialPhotoUrl = form.memorialPhoto?.toSnapshot()?.persisted,
                 memorialPlaylistSongs = form.memorialPlaylistSongs,
             )
     }
@@ -163,7 +162,7 @@ private data class EditorFormSnapshot(
 /**
  * 애프터노트 생성/수정 ViewModel.
  *
- * **SSOT:** 일반 폼은 [internalState]의 [EditorFormState], Compose 텍스트 입력은
+ * **SSOT:** 일반 폼은 [uiState]의 [EditorFormState], Compose 텍스트 입력은
  * [com.afternote.feature.afternote.presentation.editor.state.AfternoteEditorState]가 소유한다.
  * 추억 플레이리스트 화면과 곡 추가 화면은 같은 flow-scoped ViewModel의 폼을 사용한다.
  *
@@ -171,163 +170,389 @@ private data class EditorFormSnapshot(
  * 저장 API 의 HTTP·에러 바디 해석은 [AfternoteRepository] 구현이 도메인 예외로 변환한다.
  */
 @HiltViewModel(assistedFactory = AfternoteEditorViewModel.Factory::class)
-class AfternoteEditorViewModel
+internal class AfternoteEditorViewModel
     @AssistedInject
     constructor(
         @Assisted private val route: AfternoteRoute.EditorFlowRoute,
         private val savedStateHandle: SavedStateHandle,
-        private val userRepository: UserRepository,
+        private val userReceiverRepository: UserReceiverRepository,
         private val afternoteRepository: AfternoteRepository,
         private val memorialThumbnailUploadRepository: MemorialThumbnailUploadRepository,
         private val resolveMemorialMediaForSave: ResolveMemorialMediaForSaveUseCase,
+        // 이 클래스에 동명의 `saveAfternote(...)` 진입점이 이미 있어 `UseCase` 접미사를 남긴다.
+        private val saveAfternoteUseCase: SaveAfternoteUseCase,
         private val errorReporter: ErrorReporter,
-    ) : ViewModel() {
+    ) : MviViewModel<AfternoteEditorIntent, AfternoteEditorUiState, AfternoteEditorReducerEvent>(AfternoteEditorUiState()) {
         /** 진행 중인 prefill 조회 — 재시도가 이전 조회를 자르기 위한 핸들. */
         private var prefillJob: Job? = null
 
+        /** 새 선택이 이전 수신자 조회와 폼 반영을 취소한다. */
+        private var receiverSelectionJob: Job? = null
+
         private val formSnapshotJson =
             Json {
                 ignoreUnknownKeys = true
                 encodeDefaults = true
             }
 
-        private val internalState =
-            MutableStateFlow(
-                InternalState(
-                    form = readFormSnapshotOrDefault(),
-                    originalType = route.initialType.takeIf { route.itemId != null },
-                    isPrefillLoading = readEditItemId() != null,
-                ),
-            )
-
-        val uiState: StateFlow<AfternoteEditorUiState> =
-            internalState
-                .map { it.toUiState() }
-                .stateIn(
-                    scope = viewModelScope,
-                    started = SharingStarted.WhileSubscribed(5_000),
-                    initialValue = AfternoteEditorUiState(form = internalState.value.form),
-                )
+        private val restoredForm: RestoredForm = readFormSnapshotOrDefault()
 
-        /** 파사드/페이로드 빌더 등이 콜백 시점에 최신 폼 스냅샷을 읽기 위한 접근자. */
-        fun currentForm(): EditorFormState = internalState.value.form
+        /**
+         * 상세 prefill을 적용했던 폼이 성공적으로 복원된 경우 사용자의 미저장 입력을 보존한다.
+         * 표식만 남거나 디코딩이 실패했을 때는 서버 prefill을 받아 빈 폼으로 저장하는 일을 막는다.
+         * 계정 정보와 남기실 말씀은 화면이 복원하므로 폼 값 비교로 적용 여부를 대신하지 않는다.
+         */
+        private val restoredFromSeededSnapshot: Boolean =
+            route.itemId != null &&
+                restoredForm.fromSnapshot &&
+                savedStateHandle.get<Long>(PREFILL_SEEDED_ITEM_ID_KEY) == route.itemId
 
         val isEditing: Boolean get() = route.itemId != null
 
-        /**
-         * 폼 SSOT 갱신의 유일한 통로. SavedState 스냅샷 직렬화도 함께 수행한다.
-         * 어떤 필드를 어떻게 바꿀지는 `EditorFormMutations.kt` 의 변환 규칙이 정한다.
-         */
-        private fun mutateForm(block: (EditorFormState) -> EditorFormState) {
-            internalState.update { prev -> prev.copy(form = block(prev.form)) }
-            persistFormSnapshot(internalState.value.form)
-        }
+        override fun onIntent(intent: AfternoteEditorIntent) {
+            when (intent) {
+                is AfternoteEditorIntent.SetType -> {
+                    if (currentState.form.selectedType != intent.type) savedStateHandle.remove<String>(INITIALIZED_ACTION_TEMPLATE_TYPE_KEY)
+                    dispatchForm(AfternoteEditorReducerEvent.TypeChanged(intent.type))
+                }
 
-        fun setType(type: AfternoteType) {
-            if (currentForm().selectedType != type) {
-                savedStateHandle.remove<String>(INITIALIZED_ACTION_TEMPLATE_TYPE_KEY)
-            }
-            mutateForm { it.withType(type) }
-        }
+                is AfternoteEditorIntent.SetService -> {
+                    dispatchForm(AfternoteEditorReducerEvent.ServiceChanged(intent.service))
+                }
 
-        fun setService(service: String) = mutateForm { it.withService(service) }
+                is AfternoteEditorIntent.SetMemorialPhoto -> {
+                    dispatchForm(AfternoteEditorReducerEvent.MemorialPhotoChanged(intent.uri))
+                }
 
-        fun setMemorialPhoto(uri: String) = mutateForm { it.withMemorialPhoto(uri) }
+                AfternoteEditorIntent.RemoveMemorialPhoto -> {
+                    dispatchForm(AfternoteEditorReducerEvent.MemorialPhotoRemoved)
+                }
 
-        /** 시트의 사진 삭제 항목. 슬롯을 비운다 — 서버 삭제는 저장 시 명시적 `null` 로 나간다(#1597, #1717). */
-        fun removeMemorialPhoto() = mutateForm { it.withMemorialPhotoRemoved() }
+                is AfternoteEditorIntent.SetMemorialVideo -> {
+                    pendingThumbnailBytes = null
+                    dispatchForm(AfternoteEditorReducerEvent.MemorialVideoChanged(intent.url))
+                }
 
-        fun setMemorialVideo(url: String) {
-            // 영상이 갈리면 이전 영상의 썸네일 실패도 함께 무효다 — 남은 바이트로 재시도하면 다른
-            // 영상의 그림이 붙는다.
-            pendingThumbnailBytes = null
-            mutateForm { it.withMemorialVideo(url) }
-        }
+                AfternoteEditorIntent.RemoveMemorialVideo -> {
+                    pendingThumbnailBytes = null
+                    dispatchForm(AfternoteEditorReducerEvent.MemorialVideoRemoved)
+                }
 
-        /** 시트의 영상 삭제 항목. 표시된 영상이 사라지므로 그 영상의 썸네일 재시도 바이트도 함께 버린다. */
-        fun removeMemorialVideo() {
-            pendingThumbnailBytes = null
-            mutateForm { it.withMemorialVideoRemoved() }
-        }
+                is AfternoteEditorIntent.SetMemorialThumbnail -> {
+                    dispatchForm(AfternoteEditorReducerEvent.MemorialThumbnailChanged(intent.dataUrl))
+                }
+
+                is AfternoteEditorIntent.AddMemorialPlaylistSongs -> {
+                    if (intent.songs.isEmpty()) return
+                    dispatchForm(AfternoteEditorReducerEvent.PlaylistSongsAdded(intent.songs))
+                }
 
-        fun setMemorialThumbnail(dataUrl: String) = mutateForm { it.withMemorialThumbnail(dataUrl) }
+                is AfternoteEditorIntent.RemoveMemorialPlaylistSongs -> {
+                    if (intent.selectionKeys.isEmpty()) return
+                    dispatchForm(AfternoteEditorReducerEvent.PlaylistSongsRemoved(intent.selectionKeys))
+                }
 
-        fun addMemorialPlaylistSongs(songs: List<Song>) {
-            if (songs.isEmpty()) return
-            mutateForm { form ->
-                form.withMemorialPlaylistSongs(form.memorialPlaylistSongs + songs)
-            }
-        }
+                AfternoteEditorIntent.ClearMemorialPlaylistSongs -> {
+                    dispatchForm(AfternoteEditorReducerEvent.PlaylistSongsCleared)
+                }
 
-        fun removeMemorialPlaylistSongs(selectionKeys: Set<String>) {
-            if (selectionKeys.isEmpty()) return
-            mutateForm { form ->
-                form.withMemorialPlaylistSongs(
-                    form.memorialPlaylistSongs.filterNot { it.selectionKey in selectionKeys },
-                )
+                is AfternoteEditorIntent.DeleteReceiver -> {
+                    dispatchForm(AfternoteEditorReducerEvent.ReceiverDeleted(intent.receiverId))
+                }
+
+                is AfternoteEditorIntent.AddReceiverIfAbsent -> {
+                    dispatchForm(AfternoteEditorReducerEvent.ReceiverAdded(intent.receiverId, intent.name, intent.label))
+                }
+
+                is AfternoteEditorIntent.ReplaceReceiversIfEmpty -> {
+                    dispatchForm(AfternoteEditorReducerEvent.EmptyReceiversReplaced(intent.receivers))
+                }
+
+                is AfternoteEditorIntent.ApplyPrefill -> {
+                    readEditItemId()?.let { savedStateHandle[PREFILL_SEEDED_ITEM_ID_KEY] = it }
+                    dispatchForm(AfternoteEditorReducerEvent.PrefillApplied(intent.prefill))
+                }
+
+                is AfternoteEditorIntent.InitializeProcessingMethodDefaults -> {
+                    if (isEditing || currentState.form.selectedType != intent.type) return
+                    if (savedStateHandle.get<String>(INITIALIZED_ACTION_TEMPLATE_TYPE_KEY) == intent.type.name) return
+                    savedStateHandle[INITIALIZED_ACTION_TEMPLATE_TYPE_KEY] = intent.type.name
+                    if (intent.methods.isEmpty() || currentState.form.processingMethods.isNotEmpty()) return
+                    dispatchForm(AfternoteEditorReducerEvent.ProcessingMethodsInitialized(intent.type, intent.methods))
+                }
+
+                is AfternoteEditorIntent.AddProcessingMethod -> {
+                    dispatchForm(AfternoteEditorReducerEvent.ProcessingMethodAdded(intent.text))
+                }
+
+                is AfternoteEditorIntent.DeleteProcessingMethod -> {
+                    dispatchForm(AfternoteEditorReducerEvent.ProcessingMethodDeleted(intent.localId))
+                }
+
+                is AfternoteEditorIntent.EditProcessingMethod -> {
+                    dispatchForm(AfternoteEditorReducerEvent.ProcessingMethodEdited(intent.localId, intent.newText))
+                }
+
+                AfternoteEditorIntent.RefreshAuthorReceivers -> {
+                    refreshAuthorReceivers()
+                }
+
+                is AfternoteEditorIntent.UploadMemorialThumbnail -> {
+                    uploadMemorialThumbnail(intent.jpegBytes)
+                }
+
+                is AfternoteEditorIntent.MemorialThumbnailExtractionFailed -> {
+                    onMemorialThumbnailExtractionFailed(intent.throwable)
+                }
+
+                AfternoteEditorIntent.RetryMemorialThumbnail -> {
+                    retryMemorialThumbnail()
+                }
+
+                is AfternoteEditorIntent.MemorialCaptureLaunchFailed -> {
+                    onMemorialCaptureLaunchFailed(intent.throwable)
+                }
+
+                is AfternoteEditorIntent.Save -> {
+                    saveAfternote(intent.payload, intent.selectedReceiverIds, intent.memorialMedia)
+                }
+
+                AfternoteEditorIntent.RetryPrefill -> {
+                    retryPrefill()
+                }
+
+                AfternoteEditorIntent.ConsumePrefill -> {
+                    dispatch(AfternoteEditorReducerEvent.PrefillConsumed)
+                }
+
+                AfternoteEditorIntent.ConsumeSaveSuccess -> {
+                    dispatch(AfternoteEditorReducerEvent.SaveSuccessConsumed)
+                }
+
+                AfternoteEditorIntent.ConsumeThumbnailUploaded -> {
+                    dispatch(AfternoteEditorReducerEvent.ThumbnailUploadConsumed)
+                }
+
+                is AfternoteEditorIntent.ConsumeError -> {
+                    dispatch(AfternoteEditorReducerEvent.ErrorConsumed(intent.consumed))
+                }
+
+                is AfternoteEditorIntent.ReceiversSelected -> {
+                    receiverSelectionJob?.cancel()
+                    savedStateHandle[SELECTED_RECEIVER_IDS_KEY] = intent.receiverIds.toLongArray()
+                }
+
+                AfternoteEditorIntent.ApplyPendingReceiverSelection -> {
+                    val selectedIds = savedStateHandle.remove<LongArray>(SELECTED_RECEIVER_IDS_KEY)?.toList() ?: return
+                    receiverSelectionJob?.cancel()
+                    receiverSelectionJob = viewModelScope.launch { applySelectedReceivers(selectedIds) }
+                }
             }
         }
 
-        fun clearMemorialPlaylistSongs() {
-            mutateForm { it.withMemorialPlaylistSongs(emptyList()) }
-        }
+        override fun reduce(
+            state: AfternoteEditorUiState,
+            event: AfternoteEditorReducerEvent,
+        ): AfternoteEditorUiState =
+            when (event) {
+                is AfternoteEditorReducerEvent.TypeChanged -> {
+                    state.copy(form = state.form.withType(event.type))
+                }
 
-        fun deleteReceiver(receiverId: Long) = mutateForm { it.withReceiverDeleted(receiverId) }
+                is AfternoteEditorReducerEvent.ServiceChanged -> {
+                    state.copy(form = state.form.withService(event.service))
+                }
 
-        fun addReceiverIfAbsent(
-            receiverId: Long,
-            name: String,
-            label: String,
-        ) = mutateForm { it.withReceiverAddedIfAbsent(receiverId = receiverId, name = name, label = label) }
+                is AfternoteEditorReducerEvent.MemorialPhotoChanged -> {
+                    state.copy(form = state.form.withMemorialPhoto(event.uri))
+                }
 
-        fun replaceReceiversIfEmpty(receivers: List<AfternoteEditorReceiver>) = mutateForm { it.withReceiversReplacedIfEmpty(receivers) }
+                AfternoteEditorReducerEvent.MemorialPhotoRemoved -> {
+                    state.copy(form = state.form.withMemorialPhotoRemoved())
+                }
 
-        fun applyPrefill(prefill: EditorFormPrefill) = mutateForm { it.withPrefillApplied(prefill) }
+                is AfternoteEditorReducerEvent.MemorialVideoChanged -> {
+                    state.copy(form = state.form.withMemorialVideo(event.url))
+                }
 
-        /**
-         * 신규 작성 화면의 카테고리 추천 처리 방법을 최초 한 번만 채운다.
-         *
-         * 초기화 표식을 폼 스냅샷과 같은 [SavedStateHandle]에 남겨, 사용자가 추천을 전부 지운 뒤
-         * 재구성·프로세스 복원이 일어나도 다시 삽입하지 않는다. 카테고리를 실제로 바꾸면
-         * [setType]이 표식을 지워 새 카테고리의 추천을 받을 수 있게 한다.
-         */
-        fun initializeProcessingMethodDefaults(
-            type: AfternoteType,
-            methods: List<String>,
-        ) {
-            if (isEditing || currentForm().selectedType != type) return
-            if (savedStateHandle.get<String>(INITIALIZED_ACTION_TEMPLATE_TYPE_KEY) == type.name) return
+                AfternoteEditorReducerEvent.MemorialVideoRemoved -> {
+                    state.copy(form = state.form.withMemorialVideoRemoved())
+                }
 
-            savedStateHandle[INITIALIZED_ACTION_TEMPLATE_TYPE_KEY] = type.name
-            if (methods.isEmpty() || currentForm().processingMethods.isNotEmpty()) return
-            mutateForm { it.withProcessingMethodsInitialized(methods) }
-        }
+                is AfternoteEditorReducerEvent.MemorialThumbnailChanged -> {
+                    state.copy(form = state.form.withMemorialThumbnail(event.dataUrl))
+                }
+
+                is AfternoteEditorReducerEvent.PlaylistSongsAdded -> {
+                    state.copy(
+                        form =
+                            state.form.withMemorialPlaylistSongs(state.form.memorialPlaylistSongs + event.songs),
+                    )
+                }
+
+                is AfternoteEditorReducerEvent.PlaylistSongsRemoved -> {
+                    state.copy(
+                        form =
+                            state.form.withMemorialPlaylistSongs(
+                                state.form.memorialPlaylistSongs.filterNot {
+                                    it.selectionKey in
+                                        event.selectionKeys
+                                },
+                            ),
+                    )
+                }
+
+                AfternoteEditorReducerEvent.PlaylistSongsCleared -> {
+                    state.copy(form = state.form.withMemorialPlaylistSongs(emptyList()))
+                }
+
+                is AfternoteEditorReducerEvent.ReceiverDeleted -> {
+                    state.copy(form = state.form.withReceiverDeleted(event.receiverId))
+                }
+
+                is AfternoteEditorReducerEvent.ReceiverAdded -> {
+                    state.copy(form = state.form.withReceiverAddedIfAbsent(event.receiverId, event.name, event.label))
+                }
 
-        fun addProcessingMethod(text: String) = mutateForm { it.withProcessingMethodAdded(text) }
+                is AfternoteEditorReducerEvent.EmptyReceiversReplaced -> {
+                    state.copy(form = state.form.withReceiversReplacedIfEmpty(event.receivers))
+                }
+
+                is AfternoteEditorReducerEvent.PrefillApplied -> {
+                    state.copy(form = state.form.withPrefillApplied(event.prefill))
+                }
+
+                is AfternoteEditorReducerEvent.ProcessingMethodsInitialized -> {
+                    state.copy(form = state.form.withProcessingMethodsInitialized(event.methods))
+                }
+
+                is AfternoteEditorReducerEvent.ProcessingMethodAdded -> {
+                    state.copy(form = state.form.withProcessingMethodAdded(event.text))
+                }
+
+                is AfternoteEditorReducerEvent.ProcessingMethodDeleted -> {
+                    state.copy(form = state.form.withProcessingMethodDeleted(event.localId))
+                }
+
+                is AfternoteEditorReducerEvent.ProcessingMethodEdited -> {
+                    state.copy(form = state.form.withProcessingMethodEdited(event.localId, event.newText))
+                }
+
+                is AfternoteEditorReducerEvent.Initialized -> {
+                    state.copy(form = event.form, originalType = event.originalType, isPrefillLoading = event.isPrefillLoading)
+                }
+
+                is AfternoteEditorReducerEvent.AuthorReceiversLoaded -> {
+                    state.copy(authorReceivers = event.receivers)
+                }
+
+                is AfternoteEditorReducerEvent.ThumbnailUploaded -> {
+                    state.copy(pendingThumbnailUrl = event.url)
+                }
+
+                AfternoteEditorReducerEvent.ThumbnailExtractionRetried -> {
+                    state.copy(memorialThumbnailRetryToken = state.memorialThumbnailRetryToken + 1)
+                }
+
+                is AfternoteEditorReducerEvent.ErrorRaised -> {
+                    state.withError(event.error)
+                }
+
+                AfternoteEditorReducerEvent.SaveStarted -> {
+                    state.copy(isSaving = true, errorEvent = null)
+                }
+
+                is AfternoteEditorReducerEvent.SaveSucceeded -> {
+                    state.copy(isSaving = false, savedId = event.id, pendingSaveSuccessId = event.id)
+                }
+
+                is AfternoteEditorReducerEvent.SaveFailed -> {
+                    state.copy(isSaving = false).withError(event.error)
+                }
+
+                AfternoteEditorReducerEvent.PrefillStarted -> {
+                    state.copy(isPrefillLoading = true, isPrefillFailed = false)
+                }
+
+                is AfternoteEditorReducerEvent.PrefillLoaded -> {
+                    state.copy(
+                        originalType = event.prefill.type,
+                        pendingPrefill = if (event.preserveRestoredForm) null else event.prefill,
+                        isPrefillLoading =
+                            state.isPrefillLoading && !event.preserveRestoredForm,
+                        updateBaseline = event.baseline,
+                    )
+                }
+
+                AfternoteEditorReducerEvent.PrefillFailed -> {
+                    state.copy(isPrefillLoading = false, isPrefillFailed = true)
+                }
+
+                is AfternoteEditorReducerEvent.SelectedReceiversApplied -> {
+                    state.copy(form = state.form.withReceiversReplaced(event.receivers))
+                }
+
+                AfternoteEditorReducerEvent.PrefillConsumed -> {
+                    state.copy(isPrefillLoading = false, pendingPrefill = null)
+                }
+
+                AfternoteEditorReducerEvent.SaveSuccessConsumed -> {
+                    state.copy(pendingSaveSuccessId = null)
+                }
+
+                AfternoteEditorReducerEvent.ThumbnailUploadConsumed -> {
+                    state.copy(pendingThumbnailUrl = null)
+                }
+
+                is AfternoteEditorReducerEvent.ErrorConsumed -> {
+                    if (state.errorEvent == event.consumed) state.copy(errorEvent = null) else state
+                }
+            }
 
-        fun deleteProcessingMethod(localId: Int) = mutateForm { it.withProcessingMethodDeleted(localId) }
+        /** 폼 전이가 끝난 뒤 저장한다. 재실행될 수 있는 reducer에는 IO를 두지 않는다. */
+        private fun dispatchForm(event: AfternoteEditorReducerEvent) {
+            dispatch(event)
+            persistFormSnapshot(currentState.form)
+        }
 
-        fun editProcessingMethod(
-            localId: Int,
-            newText: String,
-        ) = mutateForm { it.withProcessingMethodEdited(localId = localId, newText = newText) }
+        private fun currentForm(): EditorFormState = currentState.form
 
         init {
+            dispatch(
+                AfternoteEditorReducerEvent.Initialized(
+                    restoredForm.form,
+                    route.initialType.takeIf { route.itemId != null },
+                    readEditItemId() != null,
+                ),
+            )
             readEditItemId()?.let(::loadExistingAfternoteForEdit)
         }
 
         private fun readEditItemId(): Long? = route.itemId
 
-        private fun readFormSnapshotOrDefault(): EditorFormState {
+        /** 빈 기본 폼과 성공적으로 복원된 폼을 구분한다. */
+        private fun readFormSnapshotOrDefault(): RestoredForm {
             val defaultForm = EditorFormState().withType(route.initialType)
-            val raw = savedStateHandle.get<String>(EDITOR_FORM_SNAPSHOT_KEY) ?: return defaultForm
+            val raw =
+                savedStateHandle.get<String>(EDITOR_FORM_SNAPSHOT_KEY)
+                    ?: return RestoredForm(form = defaultForm, fromSnapshot = false)
             return runCatching {
-                formSnapshotJson
-                    .decodeFromString(EditorFormSnapshot.serializer(), raw)
-                    .toEditorFormState()
-            }.getOrElse { defaultForm }
+                RestoredForm(
+                    form =
+                        formSnapshotJson
+                            .decodeFromString(EditorFormSnapshot.serializer(), raw)
+                            .toEditorFormState(),
+                    fromSnapshot = true,
+                )
+            }.getOrElse { RestoredForm(form = defaultForm, fromSnapshot = false) }
         }
 
+        /** [readFormSnapshotOrDefault]의 폼과 실제 복원 성공 여부. */
+        private data class RestoredForm(
+            val form: EditorFormState,
+            val fromSnapshot: Boolean,
+        )
+
         /** [EditorFormSnapshot] 직렬화. 실패 시 무시한다(용량 초과 등은 [EditorFormSnapshot] KDoc 참고). */
         private fun persistFormSnapshot(form: EditorFormState) {
             runCatching {
@@ -337,22 +562,23 @@ class AfternoteEditorViewModel
         }
 
         /**
-         * 작성자가 등록한 수신자 전체를 받아 [InternalState.authorReceivers] 에 채운다.
+         * 작성자가 등록한 수신자 전체를 받아 [AfternoteEditorUiState.authorReceivers] 에 채운다.
          *
          * 에디터 화면이 컴포지션에 들어올 때마다(수신자 선택 화면에서 돌아올 때 포함) 호출된다. 신규 작성에서
          * 폼이 비어 있으면 화면이 이 목록으로 수신자를 채우고
-         * (`AfternoteEditorNavigation` 의 `replaceReceiversIfEmpty`), 사용자는 불필요한 수신자를 지운다.
+         * (`AfternoteEditorNavigation` 의 `AfternoteEditorIntent.ReplaceReceiversIfEmpty`), 사용자는 불필요한 수신자를 지운다.
          * 수정 진입은 상세 응답 prefill 이 지정 수신자를 채우므로 빈 폼 채우기에는 이 목록을 쓰지 않는다.
          * 선택 화면이 돌려준 새 id 를 해석할 때([resolveSelectedReceiver])는 작성·수정 모두 이 목록을 쓴다.
          */
-        fun refreshAuthorReceivers() {
+        private fun refreshAuthorReceivers() {
             viewModelScope.launch { loadAuthorReceivers() }
         }
 
         private suspend fun loadAuthorReceivers() {
-            runCatchingCancellable { userRepository.getReceivers() }
+            runCatchingCancellable { userReceiverRepository.getReceivers() }
                 .onSuccess { receivers ->
-                    internalState.update { it.copy(authorReceivers = receivers.toAfternoteEditorReceivers()) }
+                    currentCoroutineContext().ensureActive()
+                    dispatch(AfternoteEditorReducerEvent.AuthorReceiversLoaded(receivers.toAfternoteEditorReceivers()))
                 }.onFailure { e ->
                     errorReporter.recordAfternoteFailure(AfternoteFailureStage.AUTHOR_RECEIVER_LOAD, e)
                 }
@@ -366,7 +592,7 @@ class AfternoteEditorViewModel
          */
         private var pendingThumbnailBytes: ByteArray? = null
 
-        fun uploadMemorialThumbnail(jpegBytes: ByteArray?) {
+        private fun uploadMemorialThumbnail(jpegBytes: ByteArray?) {
             if (jpegBytes == null) return
             pendingThumbnailBytes = jpegBytes
             viewModelScope.launch {
@@ -375,12 +601,14 @@ class AfternoteEditorViewModel
                     .onSuccess { url ->
                         Log.d(TAG, "uploadMemorialThumbnail: success, url=$url")
                         pendingThumbnailBytes = null
-                        internalState.update { it.copy(pendingThumbnailUrl = url) }
+                        dispatch(AfternoteEditorReducerEvent.ThumbnailUploaded(url))
                     }.onFailure { e ->
                         errorReporter.recordAfternoteFailure(AfternoteFailureStage.MEMORIAL_THUMBNAIL_UPLOAD, e)
-                        internalState.update {
-                            it.withError(AfternoteEditorError.Upload(AfternoteEditorError.Upload.Target.THUMBNAIL))
-                        }
+                        dispatch(
+                            AfternoteEditorReducerEvent.ErrorRaised(
+                                AfternoteEditorError.Upload(AfternoteEditorError.Upload.Target.THUMBNAIL),
+                            ),
+                        )
                     }
             }
         }
@@ -391,13 +619,13 @@ class AfternoteEditorViewModel
          * 로컬 디코딩이라 [uploadMemorialThumbnail] 경로를 타지 않는다. 종전에는 기록만 하고 화면에는
          * 아무 신호도 없어, 사용자는 썸네일 자리가 빈 이유도 되돌릴 방법도 알 수 없었다.
          */
-        fun onMemorialThumbnailExtractionFailed(throwable: Throwable) {
+        private fun onMemorialThumbnailExtractionFailed(throwable: Throwable) {
             errorReporter.recordAfternoteFailure(AfternoteFailureStage.MEMORIAL_THUMBNAIL_EXTRACT, throwable)
             // 뽑지 못했으니 재업로드할 바이트가 없다 — 재시도는 추출부터 다시 돌아야 한다.
             pendingThumbnailBytes = null
-            internalState.update {
-                it.withError(AfternoteEditorError.Upload(AfternoteEditorError.Upload.Target.THUMBNAIL_EXTRACT))
-            }
+            dispatch(
+                AfternoteEditorReducerEvent.ErrorRaised(AfternoteEditorError.Upload(AfternoteEditorError.Upload.Target.THUMBNAIL_EXTRACT)),
+            )
         }
 
         /**
@@ -406,13 +634,13 @@ class AfternoteEditorViewModel
          * 손에 바이트가 있으면(업로드 실패) 그대로 다시 올리고, 없으면(추출 실패) 토큰을 올려 화면이
          * 프레임 추출부터 다시 돌게 한다. 어느 쪽이든 사용자가 고른 영상은 그대로 둔다.
          */
-        fun retryMemorialThumbnail() {
+        private fun retryMemorialThumbnail() {
             val bytes = pendingThumbnailBytes
             if (bytes != null) {
                 uploadMemorialThumbnail(bytes)
                 return
             }
-            internalState.update { it.copy(memorialThumbnailRetryToken = it.memorialThumbnailRetryToken + 1) }
+            dispatch(AfternoteEditorReducerEvent.ThumbnailExtractionRetried)
         }
 
         /**
@@ -438,16 +666,16 @@ class AfternoteEditorViewModel
          * 화면에는 "카메라를 사용할 수 없습니다" 한 줄만 나가고 사유가 지워지므로, UI 가 예외를
          * 넘겨주지 않으면 저장공간 문제인지 카메라 앱 부재인지 콘솔에서 가를 수 없다.
          */
-        fun onMemorialCaptureLaunchFailed(throwable: Throwable) {
+        private fun onMemorialCaptureLaunchFailed(throwable: Throwable) {
             errorReporter.recordAfternoteFailure(AfternoteFailureStage.MEMORIAL_CAPTURE_LAUNCH, throwable)
         }
 
-        internal fun saveAfternote(
+        private fun saveAfternote(
             payload: RegisterAfternotePayload,
             selectedReceiverIds: List<Long>,
             memorialMedia: SaveAfternoteMemorialMedia,
         ) {
-            val editorState = internalState.value
+            val editorState = currentState
             if (editorState.isSaving) return
             // prefill 을 못 읽은 채로 저장하면 서버가 빈 폼 값으로 기존 기록을 덮는다 (#705).
             // 화면이 이미 저장 액션을 막지만, 저장 진입점은 여기 하나뿐이라 규칙도 여기서 지킨다.
@@ -461,11 +689,11 @@ class AfternoteEditorViewModel
             // 못했다」 이고 진행 중은 「곧 도착한다」 다 — 한 갈래로 뭉치면 아직 읽는 중인
             // 사용자에게 실패했다고 말하게 된다.
             if (editorState.isPrefillFailed) {
-                internalState.update { it.withError(AfternoteEditorError.PrefillUnavailable) }
+                dispatch(AfternoteEditorReducerEvent.ErrorRaised(AfternoteEditorError.PrefillUnavailable))
                 return
             }
             if (editorState.isPrefillLoading) {
-                internalState.update { it.withError(AfternoteEditorError.PrefillNotReady) }
+                dispatch(AfternoteEditorReducerEvent.ErrorRaised(AfternoteEditorError.PrefillNotReady))
                 return
             }
 
@@ -480,9 +708,7 @@ class AfternoteEditorViewModel
                     payload = payload,
                 )
             if (validationError != null) {
-                internalState.update {
-                    it.withError(AfternoteEditorError.Validation(validationError))
-                }
+                dispatch(AfternoteEditorReducerEvent.ErrorRaised(AfternoteEditorError.Validation(validationError)))
                 return
             }
 
@@ -493,14 +719,12 @@ class AfternoteEditorViewModel
             // 「전부 지움」을 가릴 수 없어 빈 폼이 그대로 삭제 지시가 된다 (#1617).
             val updateBaseline = editorState.updateBaseline
             if (editingId != null && updateBaseline == null) {
-                internalState.update { it.withError(AfternoteEditorError.PrefillUnavailable) }
+                dispatch(AfternoteEditorReducerEvent.ErrorRaised(AfternoteEditorError.PrefillUnavailable))
                 return
             }
 
             viewModelScope.launch {
-                internalState.update {
-                    it.copy(isSaving = true, errorEvent = null)
-                }
+                dispatch(AfternoteEditorReducerEvent.SaveStarted)
                 // 썸네일 URL 이 비어 있고 업로드에 실패한 바이트가 남아 있으면, payload 를 만들기 전에 그
                 // 바이트를 한 번 더 업로드해 본다. 여기서 놓치면 썸네일 없는 영상이 그대로 확정되고,
                 // 재편집으로 들어와도 원격 URL 이라 프레임을 다시 뽑지 않는다 (#1550). 실패해도 저장은
@@ -523,15 +747,9 @@ class AfternoteEditorViewModel
                     updateBaseline = updateBaseline,
                 ).fold(
                     onSuccess = { command ->
-                        executeSaveCommand(command).fold(
+                        saveAfternoteUseCase(command).fold(
                             onSuccess = { id ->
-                                internalState.update {
-                                    it.copy(
-                                        isSaving = false,
-                                        savedId = id,
-                                        pendingSaveSuccessId = id,
-                                    )
-                                }
+                                dispatch(AfternoteEditorReducerEvent.SaveSucceeded(id))
                             },
                             onFailure = { e -> handleSaveFailure(e) },
                         )
@@ -541,39 +759,6 @@ class AfternoteEditorViewModel
             }
         }
 
-        /**
-         * [SaveAfternoteCommand] 분기에 따라 [AfternoteRepository] 의 적합한 메서드를 직접 호출한다.
-         *
-         * 과거에는 별도 `SaveAfternoteUseCase` 로 분리돼 있었으나, 단일 Repository 내 메서드 라우팅
-         * 외에 비즈니스 로직이 없어 *약한 UseCase* (`#246`) 로 판단해 ViewModel 로 흡수.
-         */
-        private suspend fun executeSaveCommand(command: SaveAfternoteCommand): Result<Long> =
-            when (command) {
-                is SaveAfternoteCommand.Create -> {
-                    when (val input = command.input) {
-                        is CreateAfternoteInput.Social -> afternoteRepository.createSocial(input.payload)
-                        is CreateAfternoteInput.Business -> afternoteRepository.createBusiness(input.payload)
-                        is CreateAfternoteInput.Gallery -> afternoteRepository.createGallery(input.payload)
-                        is CreateAfternoteInput.Memorial -> afternoteRepository.createMemorial(input.payload)
-                    }
-                }
-
-                is SaveAfternoteCommand.Update -> {
-                    afternoteRepository.update(command.id, command.payload)
-                }
-            }
-
-        // 영정 사진: 새로 고른 로컬 픽 우선 → 없으면 기존 원격 → 둘 다 없으면 없음.
-        private fun photoMediaInput(
-            picked: String?,
-            existing: String?,
-        ): MediaInput =
-            when {
-                !picked.isNullOrBlank() -> MediaInput.Local(picked)
-                !existing.isNullOrBlank() -> MediaInput.Remote(existing)
-                else -> MediaInput.None
-            }
-
         private suspend fun buildSaveCommand(
             editingId: Long?,
             typeForSave: AfternoteType,
@@ -586,11 +771,7 @@ class AfternoteEditorViewModel
             val resolved =
                 resolveMemorialMediaForSave(
                     video = memorialMedia.memorialVideo.toMediaInput(),
-                    photo =
-                        photoMediaInput(
-                            picked = memorialMedia.pickedMemorialPhotoUri,
-                            existing = memorialMedia.memorialPhotoUrl,
-                        ),
+                    photo = memorialMedia.memorialPhoto.toMediaInput(),
                 ).getOrElse { return Result.failure(it) }
 
             val command =
@@ -637,7 +818,7 @@ class AfternoteEditorViewModel
          * 뒤라면 부를 일이 없고(화면이 오류 상태에서만 버튼을 그린다), 신규 작성 진입은 [readEditItemId]
          * 가 null 이라 아무 일도 하지 않는다.
          */
-        fun retryPrefill() {
+        private fun retryPrefill() {
             val afternoteId = readEditItemId() ?: return
             loadExistingAfternoteForEdit(afternoteId)
         }
@@ -646,7 +827,7 @@ class AfternoteEditorViewModel
          * 수정 진입 시 기존 애프터노트를 읽어 폼에 실을 prefill 을 만든다.
          *
          * 실패를 «빈 폼» 으로 흘려보내지 않는다 (#705) — 서버 수정(PATCH)은 보낸 값으로 기존 기록을
-         * 덮으므로, 못 읽은 상태의 빈 폼이 저장되면 기록이 소실된다. 그래서 실패는 [InternalState.isPrefillFailed]
+         * 덮으므로, 못 읽은 상태의 빈 폼이 저장되면 기록이 소실된다. 그래서 실패는 [AfternoteEditorUiState.isPrefillFailed]
          * 로 남겨 화면이 오류·재시도를 그리고 [saveAfternote] 가 저장을 막게 한다.
          */
         private fun loadExistingAfternoteForEdit(afternoteId: Long) {
@@ -654,28 +835,30 @@ class AfternoteEditorViewModel
             prefillJob?.cancel()
             prefillJob =
                 viewModelScope.launch {
-                    internalState.update { it.copy(isPrefillLoading = true, isPrefillFailed = false) }
+                    dispatch(AfternoteEditorReducerEvent.PrefillStarted)
                     afternoteRepository
                         .getDetail(id = afternoteId)
                         .onSuccess { detail ->
                             val prefill = AfternoteEditorFormMapper.buildEditorFormPrefill(detail)
                             // UI 레이어 파사드가 TextFieldState·SnapshotStateList 등 UI 상태를 갱신하도록 위임.
-                            // skeleton 종료는 UI 가 prefill 적용을 마친 뒤 [onPrefillConsumed] 로 통보한다
+                            // skeleton 종료는 UI 가 prefill 적용을 마친 뒤 [AfternoteEditorIntent.ConsumePrefill] 로 통보한다
                             // (uiState 갱신 시점에 prefill 도착했어도 UI 가 form·TextFieldState 에 반영하기 전이라
                             //  여기서 끄면 skeleton 사라짐 → 빈 폼 → prefill 깜빡임 발생).
-                            internalState.update {
-                                it.copy(
-                                    originalType = prefill.type,
-                                    pendingPrefill = prefill,
-                                    // 화면에 뿌릴 prefill 과 별개로, 가공 전 원본을 저장 때 견줄 기준으로 남긴다.
-                                    // 이 값은 폼 변경을 따라가지 않는다 — 따라가면 비교할 대상이 사라진다 (#1617).
-                                    updateBaseline = AfternoteEditorFormMapper.buildUpdateBaseline(detail),
-                                )
-                            }
+                            //
+                            // 복원된 편집이 있으면 프리필을 싣지 않는다 (#1732). 서버 조회는 유지한다.
+                            // 기준 스냅샷([AfternoteEditorUiState.updateBaseline])이 없으면 저장이 막히고, 카테고리도
+                            // 서버가 아는 값이어야 한다. 복원된 입력에 대한 덮어쓰기만 생략한다.
+                            dispatch(
+                                AfternoteEditorReducerEvent.PrefillLoaded(
+                                    prefill = prefill,
+                                    baseline = AfternoteEditorFormMapper.buildUpdateBaseline(detail),
+                                    preserveRestoredForm = restoredFromSeededSnapshot,
+                                ),
+                            )
                         }.onFailure { e ->
                             errorReporter.recordAfternoteFailure(AfternoteFailureStage.PREFILL_LOAD, e)
                             // skeleton 은 걷되 빈 폼으로 넘기지 않는다 — 오류·재시도 상태로 남긴다.
-                            internalState.update { it.copy(isPrefillLoading = false, isPrefillFailed = true) }
+                            dispatch(AfternoteEditorReducerEvent.PrefillFailed)
                         }
                 }
         }
@@ -684,10 +867,6 @@ class AfternoteEditorViewModel
          * UI 가 [AfternoteEditorUiState.pendingPrefill] 신호를 받아 폼·TextFieldState 에 모두 반영한 직후 호출.
          * skeleton 종료([AfternoteEditorUiState.isPrefillLoading] = false) + 신호 reset (pendingPrefill = null) 동시 처리.
          */
-        fun onPrefillConsumed() {
-            internalState.update { it.copy(isPrefillLoading = false, pendingPrefill = null) }
-        }
-
         private fun handleSaveFailure(e: Throwable) {
             val editorError = e.toAfternoteEditorError()
             // 필수 필드 검증에 걸린 실패(수신자 미선택 등)는 사용자가 채우면 풀리는 정상 경로라 기록하지 않는다 —
@@ -696,9 +875,7 @@ class AfternoteEditorViewModel
             if (editorError !is AfternoteEditorError.Validation) {
                 errorReporter.recordAfternoteFailure(AfternoteFailureStage.SAVE, e)
             }
-            internalState.update {
-                it.copy(isSaving = false).withError(editorError)
-            }
+            dispatch(AfternoteEditorReducerEvent.SaveFailed(editorError))
         }
 
         /**
@@ -708,11 +885,11 @@ class AfternoteEditorViewModel
          * 그래도 못 찾으면 [AfternoteEditorError.ReceiverSelectionUnavailable] 을 세워 화면이 알리게 한다.
          * 이 신호가 없으면 사용자가 고른 수신자가 아무 표시 없이 사라진다 (#1405).
          */
-        suspend fun resolveSelectedReceiver(id: Long): AfternoteEditorReceiver? {
+        private suspend fun resolveSelectedReceiver(id: Long): AfternoteEditorReceiver? {
             findReceiverById(id)?.let { return it }
             loadAuthorReceivers()
             return findReceiverById(id) ?: run {
-                internalState.update { it.withError(AfternoteEditorError.ReceiverSelectionUnavailable) }
+                dispatch(AfternoteEditorReducerEvent.ErrorRaised(AfternoteEditorError.ReceiverSelectionUnavailable))
                 null
             }
         }
@@ -727,97 +904,20 @@ class AfternoteEditorViewModel
          * 새로 들어온 id 만 [resolveSelectedReceiver] 로 해석하고, 해석 실패는 그쪽이 오류 이벤트로
          * 알린다 — 그 id 만 빠지고 나머지 선택은 반영된다 (#1405).
          */
-        suspend fun applySelectedReceivers(receiverIds: List<Long>) {
+        private suspend fun applySelectedReceivers(receiverIds: List<Long>) {
             val alreadyInForm = currentForm().afternoteEditReceivers.associateBy { it.id }
             val next = receiverIds.mapNotNull { id -> alreadyInForm[id] ?: resolveSelectedReceiver(id) }
-            mutateForm { it.withReceiversReplaced(next) }
+            currentCoroutineContext().ensureActive()
+            dispatchForm(AfternoteEditorReducerEvent.SelectedReceiversApplied(next))
         }
 
-        private fun findReceiverById(id: Long): AfternoteEditorReceiver? = internalState.value.authorReceivers.find { it.id == id }
-
-        // region Internal state shaping
+        private fun findReceiverById(id: Long): AfternoteEditorReceiver? = currentState.authorReceivers.find { it.id == id }
 
-        /**
-         * VM 내부에서만 다루는 평탄한 상태.
-         * public [AfternoteEditorUiState] 는 이 값을 [toUiState] 로 매핑해 노출한다.
-         */
-        private data class InternalState(
-            val form: EditorFormState = EditorFormState(),
-            val originalType: AfternoteType? = null,
-            val authorReceivers: List<AfternoteEditorReceiver> = emptyList(),
-            val isSaving: Boolean = false,
-            val isPrefillLoading: Boolean = false,
-            val isPrefillFailed: Boolean = false,
-            val savedId: Long? = null,
-            val errorEvent: AfternoteEditorErrorEvent? = null,
-            val errorOccurrence: Long = 0L,
-            val pendingSaveSuccessId: Long? = null,
-            val pendingThumbnailUrl: String? = null,
-            val memorialThumbnailRetryToken: Int = 0,
-            val pendingPrefill: EditorFormPrefill? = null,
-            /**
-             * 수정 진입 시 받은 상세를 그대로 옮긴 **pristine baseline** (#1617).
-             *
-             * 저장 시 현재 폼과 견줘 **달라진 필드만** 요청에 싣는 기준이다. `null` 이면 기준이 없다는
-             * 뜻이라(신규 작성이거나 상세 로드 실패) 종전처럼 전량을 싣는다.
-             */
-            val updateBaseline: AfternoteEditorSnapshot? = null,
-        )
-
-        private fun InternalState.toUiState(): AfternoteEditorUiState =
-            AfternoteEditorUiState(
-                form = form,
-                authorReceivers = authorReceivers,
-                isSaving = isSaving,
-                isPrefillLoading = isPrefillLoading,
-                isPrefillFailed = isPrefillFailed,
-                savedId = savedId,
-                errorEvent = errorEvent,
-                pendingSaveSuccessId = pendingSaveSuccessId,
-                pendingThumbnailUrl = pendingThumbnailUrl,
-                memorialThumbnailRetryToken = memorialThumbnailRetryToken,
-                pendingPrefill = pendingPrefill,
-            )
-
-        fun onSaveSuccessConsumed() {
-            internalState.update { it.copy(pendingSaveSuccessId = null) }
-        }
-
-        fun onThumbnailUploadedConsumed() {
-            internalState.update { it.copy(pendingThumbnailUrl = null) }
-        }
-
-        private fun InternalState.withError(error: AfternoteEditorError): InternalState {
+        private fun AfternoteEditorUiState.withError(error: AfternoteEditorError): AfternoteEditorUiState {
             val nextOccurrence = errorOccurrence + 1L
-            return copy(
-                errorEvent = AfternoteEditorErrorEvent(error, nextOccurrence),
-                errorOccurrence = nextOccurrence,
-            )
+            return copy(errorEvent = AfternoteEditorErrorEvent(error, nextOccurrence), errorOccurrence = nextOccurrence)
         }
 
-        fun onErrorConsumed(consumed: AfternoteEditorErrorEvent) {
-            internalState.update { current ->
-                if (current.errorEvent == consumed) current.copy(errorEvent = null) else current
-            }
-        }
-
-        // endregion
-
-        /**
-         * 수신자 선택 화면이 고른 id 를 에디터로 돌려준다.
-         *
-         * Nav2 에서는 선택 화면이 **이전 백스택 엔트리**(에디터)의 `SavedStateHandle` 에 직접 썼다.
-         * Nav3 엔 "이전 엔트리" 개념이 없으므로, 두 화면이 이미 공유하는 이 ViewModel 을 통로로
-         * 삼는다. 저장 위치는 같은 [SavedStateHandle] 이라 프로세스 재생성 성질도 그대로다.
-         */
-        fun onReceiversSelected(receiverIds: List<Long>) {
-            // Bundle 이 그대로 담을 수 있는 LongArray 로 넘긴다 (#1426).
-            savedStateHandle[SELECTED_RECEIVER_IDS_KEY] = receiverIds.toLongArray()
-        }
-
-        /** 남아 있는 선택 결과를 읽고 **지운다** — 같은 선택이 두 번 반영되지 않는다. */
-        fun consumeSelectedReceiverIds(): List<Long>? = savedStateHandle.remove<LongArray>(SELECTED_RECEIVER_IDS_KEY)?.toList()
-
         @AssistedFactory
         interface Factory {
             fun create(route: AfternoteRoute.EditorFlowRoute): AfternoteEditorViewModel
@@ -830,13 +930,17 @@ class AfternoteEditorViewModel
  * [AfternoteFailure] 는 루트로 받아 `when` 을 exhaustive 하게 만든다 — 실패 유형이 늘면 여기가
  * 컴파일 에러로 잡힌다. `else` 로 뭉개 두면 새 유형이 조용히 서버 오류로 흘러간다.
  */
-internal fun Throwable.toAfternoteEditorError(): AfternoteEditorError =
+private fun Throwable.toAfternoteEditorError(): AfternoteEditorError =
     when (this) {
         is AfternoteFailure -> {
             when (this) {
-                // 미디어 해석 실패는 사용자가 입력을 고쳐 푸는 검증 실패가 아니라 업로드 장애다.
+                // 크기 초과는 같은 파일의 재전송으로 풀리지 않으므로 일반 업로드 실패와 구분한다.
                 is AfternoteFailure.MediaSave -> {
-                    AfternoteEditorError.Upload(AfternoteEditorError.Upload.Target.SAVE_MEDIA)
+                    if (cause is FileUploadFailure.FileSizeExceeded) {
+                        AfternoteEditorError.MediaSizeExceeded
+                    } else {
+                        AfternoteEditorError.Upload(AfternoteEditorError.Upload.Target.SAVE_MEDIA)
+                    }
                 }
 
                 is AfternoteFailure.NetworkUnavailable -> {
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/SaveAfternoteMemorialMedia.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/SaveAfternoteMemorialMedia.kt
index 8a7920d876..ca6ebec2d0 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/SaveAfternoteMemorialMedia.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/SaveAfternoteMemorialMedia.kt
@@ -1,12 +1,12 @@
 package com.afternote.feature.afternote.presentation.editor
 
+import com.afternote.feature.afternote.presentation.editor.state.EditableMemorialPhoto
 import com.afternote.feature.afternote.presentation.editor.state.EditableMemorialVideo
 
-/** 저장 시 추억 노트 미디어 필드. 영상의 출처와 기준값은 [memorialVideo]가 보존한다. */
+/** 저장 시 추억 노트 미디어 필드. 사진과 영상의 출처·기준값은 각 값 객체가 보존한다. */
 internal data class SaveAfternoteMemorialMedia(
     val memorialVideo: EditableMemorialVideo = EditableMemorialVideo.empty(),
-    val memorialPhotoUrl: String? = null,
-    val pickedMemorialPhotoUri: String? = null,
+    val memorialPhoto: EditableMemorialPhoto = EditableMemorialPhoto.empty(),
 )
 
 /**
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongContract.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongContract.kt
new file mode 100644
index 0000000000..6a0e9a2fd9
--- /dev/null
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongContract.kt
@@ -0,0 +1,29 @@
+package com.afternote.feature.afternote.presentation.editor.memorial
+
+import com.afternote.core.ui.mvi.MviIntent
+import com.afternote.core.ui.mvi.ReducerEvent
+import com.afternote.feature.afternote.presentation.shared.model.PlaylistSongDisplay
+
+internal sealed interface AddSongIntent : MviIntent {
+    data class Search(
+        val query: String,
+    ) : AddSongIntent
+
+    data object ConsumeError : AddSongIntent
+}
+
+internal sealed interface AddSongReducerEvent : ReducerEvent {
+    data class QueryChanged(
+        val query: String,
+    ) : AddSongReducerEvent
+
+    data object SearchStarted : AddSongReducerEvent
+
+    data class SongsLoaded(
+        val songs: List<PlaylistSongDisplay>,
+    ) : AddSongReducerEvent
+
+    data object SearchFailed : AddSongReducerEvent
+
+    data object ErrorConsumed : AddSongReducerEvent
+}
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongEntry.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongEntry.kt
index c6c8b708c7..0a5665f424 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongEntry.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongEntry.kt
@@ -1,9 +1,15 @@
 package com.afternote.feature.afternote.presentation.editor.memorial
 
+import androidx.compose.material3.SnackbarHostState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalResources
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.afternote.core.ui.mvi.ObserveSignal
+import kotlinx.coroutines.launch
 
 /**
  * 노래 추가 Entry.
@@ -11,7 +17,7 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
  * ViewModel에서 데이터를 로드·가공하고, Screen에 전달만 합니다.
  */
 @Composable
-fun AddSongEntry(
+internal fun AddSongEntry(
     viewModel: AddSongViewModel,
     onBackClick: () -> Unit,
     onSongsAdded: (List<Song>) -> Unit,
@@ -19,10 +25,21 @@ fun AddSongEntry(
 ) {
     val uiState by viewModel.uiState.collectAsStateWithLifecycle()
 
+    val snackbarHostState = remember { SnackbarHostState() }
+    val resources = LocalResources.current
+    val scope = rememberCoroutineScope()
+    ObserveSignal(
+        signal = uiState.errorRes,
+        consumed = AddSongIntent.ConsumeError,
+        onIntent = viewModel::onIntent,
+    ) { errorRes ->
+        scope.launch { snackbarHostState.showSnackbar(resources.getString(errorRes), withDismissAction = true) }
+    }
+
     AddSongScreen(
         uiState = uiState,
-        onSearchQueryChange = viewModel::onSearchQueryChange,
-        onErrorConsumed = viewModel::onErrorConsumed,
+        onIntent = viewModel::onIntent,
+        snackbarHostState = snackbarHostState,
         onBackClick = onBackClick,
         onSongsAdded = onSongsAdded,
         modifier = modifier,
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongScreen.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongScreen.kt
index a90bc843d2..0822c5699e 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongScreen.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongScreen.kt
@@ -7,10 +7,7 @@ import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.SnackbarHost
 import androidx.compose.material3.SnackbarHostState
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
@@ -21,39 +18,16 @@ import com.afternote.feature.afternote.presentation.shared.detail.SongPlaylistSc
 import com.afternote.feature.afternote.presentation.shared.detail.SongSearchSection
 import com.afternote.feature.afternote.presentation.shared.model.PlaylistSongDisplay
 
-/**
- * 노래 추가하기 화면 (API 검색 연동).
- *
- * 공용 부품([SongPlaylistScaffold] + selectable 본문 [SelectableSongListBody])을 직접 조립하고, 이 기능
- * 고유의 것(VM 상태·검색 실패 Snackbar·PlaylistSongDisplay↔Song 매핑)을 얹는 소비자 계층이다.
- *
- * ViewModel 의존성 없이 순수하게 UI만 그립니다. [AddSongUiState.errorRes] 는 문자열 리소스 ID 라
- * UI 레이어가 [stringResource] 로 해석한 뒤 Snackbar 표출 → [onErrorConsumed] 로 VM 에 nullify
- * 신호. VM 이 Android Framework (Context/Resources) 를 의존하지 않도록 string resolve 는 본
- * 레이어에서만 수행 (#267). 예외 원문을 실어 오던 갈래는 제거했다 — 검색 실패는 원인과 무관하게
- * 고정 안내 문구로만 노출한다 (#664). Snackbar 채택은 repo convention (Toast 2건 vs Snackbar 19건) +
- * `showSnackbar` suspend 큐 의미로 같은 리소스 ID 가 연속 발화해도 표출 누락 회피.
- */
+/** 검색 결과를 그린다. 상태 수집과 실패 신호 소비는 [AddSongEntry]가 담당한다. */
 @Composable
-fun AddSongScreen(
+internal fun AddSongScreen(
     uiState: AddSongUiState,
-    onSearchQueryChange: (String) -> Unit,
-    onErrorConsumed: () -> Unit,
+    onIntent: (AddSongIntent) -> Unit,
+    snackbarHostState: SnackbarHostState = remember { SnackbarHostState() },
     onBackClick: () -> Unit,
     onSongsAdded: (List<Song>) -> Unit,
     modifier: Modifier = Modifier,
 ) {
-    val currentOnErrorConsumed by rememberUpdatedState(onErrorConsumed)
-    val snackbarHostState = remember { SnackbarHostState() }
-
-    uiState.errorRes?.let { errorRes ->
-        val message = stringResource(errorRes)
-        LaunchedEffect(errorRes) {
-            snackbarHostState.showSnackbar(message = message, withDismissAction = true)
-            currentOnErrorConsumed()
-        }
-    }
-
     Box(modifier = modifier.fillMaxSize()) {
         SongPlaylistScaffold(
             title = stringResource(R.string.afternote_editor_playlist_add_screen_title),
@@ -70,7 +44,7 @@ fun AddSongScreen(
                     header = {
                         SongSearchSection(
                             searchQuery = uiState.searchQuery,
-                            onSearchQueryChange = onSearchQueryChange,
+                            onSearchQueryChange = { onIntent(AddSongIntent.Search(it)) },
                         )
                     },
                     initialSelectedSongKeys = emptySet(),
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongUiState.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongUiState.kt
index 261448b412..db588e1ecf 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongUiState.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongUiState.kt
@@ -1,6 +1,7 @@
 package com.afternote.feature.afternote.presentation.editor.memorial
 
 import androidx.annotation.StringRes
+import com.afternote.core.ui.mvi.UiState
 import com.afternote.feature.afternote.presentation.shared.model.PlaylistSongDisplay
 
 /**
@@ -10,9 +11,9 @@ import com.afternote.feature.afternote.presentation.shared.model.PlaylistSongDis
  * 예외 원문·서버 응답 본문 같은 임의 문자열이 화면까지 실려 갈 경로를 타입 차원에서 없앤다 (#664).
  * Composable 측에서 `stringResource` 로 변환.
  */
-data class AddSongUiState(
+internal data class AddSongUiState(
     val songs: List<PlaylistSongDisplay> = emptyList(),
     val searchQuery: String = "",
     val isLoading: Boolean = false,
     @param:StringRes val errorRes: Int? = null,
-)
+) : UiState
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongViewModel.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongViewModel.kt
index 01fa2704ce..f92b900f4c 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongViewModel.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongViewModel.kt
@@ -1,8 +1,8 @@
 package com.afternote.feature.afternote.presentation.editor.memorial
 
-import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.afternote.core.common.reporting.ErrorReporter
+import com.afternote.core.ui.mvi.MviViewModel
 import com.afternote.feature.afternote.domain.repository.author.MusicSearchRepository
 import com.afternote.feature.afternote.presentation.R
 import com.afternote.feature.afternote.presentation.reporting.AfternoteFailureStage
@@ -10,10 +10,7 @@ import com.afternote.feature.afternote.presentation.reporting.recordAfternoteFai
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.ensureActive
 import kotlinx.coroutines.launch
 import javax.inject.Inject
 import kotlin.time.Duration.Companion.milliseconds
@@ -21,56 +18,72 @@ import kotlin.time.Duration.Companion.milliseconds
 private const val SEARCH_DEBOUNCE_MS = 300L
 
 @HiltViewModel
-class AddSongViewModel
+internal class AddSongViewModel
     @Inject
     constructor(
         private val musicSearchRepository: MusicSearchRepository,
         private val errorReporter: ErrorReporter,
-    ) : ViewModel() {
-        private val _uiState = MutableStateFlow(AddSongUiState())
-        val uiState: StateFlow<AddSongUiState> = _uiState.asStateFlow()
-
+    ) : MviViewModel<AddSongIntent, AddSongUiState, AddSongReducerEvent>(AddSongUiState()) {
         private var searchJob: Job? = null
 
-        fun onSearchQueryChange(query: String) {
-            _uiState.update { it.copy(searchQuery = query, errorRes = null) }
+        override fun onIntent(intent: AddSongIntent) {
+            when (intent) {
+                is AddSongIntent.Search -> search(intent.query)
+                AddSongIntent.ConsumeError -> dispatch(AddSongReducerEvent.ErrorConsumed)
+            }
+        }
+
+        private fun search(query: String) {
+            dispatch(AddSongReducerEvent.QueryChanged(query))
             searchJob?.cancel()
             searchJob =
                 viewModelScope.launch {
                     delay(SEARCH_DEBOUNCE_MS.milliseconds)
                     val trimmed = query.trim()
                     if (trimmed.isEmpty()) {
-                        _uiState.update { it.copy(songs = emptyList(), isLoading = false) }
+                        dispatch(AddSongReducerEvent.SongsLoaded(emptyList()))
                         return@launch
                     }
-                    _uiState.update { it.copy(isLoading = true) }
-                    musicSearchRepository
-                        .search(trimmed)
+                    dispatch(AddSongReducerEvent.SearchStarted)
+                    val result = musicSearchRepository.search(trimmed)
+                    ensureActive()
+                    result
                         .onSuccess { list ->
-                            _uiState.update {
-                                it.copy(
-                                    songs = list.map { item -> item.toDisplay() },
-                                    isLoading = false,
-                                    errorRes = null,
-                                )
-                            }
-                        }.onFailure { e ->
-                            // 예외 원문은 서버 5xx 본문(내부 SQL)·역직렬화 예외(응답 원문 발췌·DTO 클래스명)를
-                            // 그대로 실어 오므로 화면에 싣지 않는다. 사용자에겐 원인과 무관하게 고정 안내만 노출.
-                            errorReporter.recordAfternoteFailure(AfternoteFailureStage.MUSIC_SEARCH, e)
-                            _uiState.update {
-                                it.copy(
-                                    songs = emptyList(),
-                                    isLoading = false,
-                                    errorRes = R.string.afternote_editor_search_failed_generic,
-                                )
-                            }
+                            dispatch(AddSongReducerEvent.SongsLoaded(list.map { it.toDisplay() }))
+                        }.onFailure { error ->
+                            errorReporter.recordAfternoteFailure(AfternoteFailureStage.MUSIC_SEARCH, error)
+                            dispatch(AddSongReducerEvent.SearchFailed)
                         }
                 }
         }
 
-        /** UI 가 [AddSongUiState.errorRes] 를 사용자에게 노출 직후 호출 → state nullify. */
-        fun onErrorConsumed() {
-            _uiState.update { it.copy(errorRes = null) }
-        }
+        override fun reduce(
+            state: AddSongUiState,
+            event: AddSongReducerEvent,
+        ): AddSongUiState =
+            when (event) {
+                is AddSongReducerEvent.QueryChanged -> {
+                    state.copy(searchQuery = event.query, errorRes = null)
+                }
+
+                AddSongReducerEvent.SearchStarted -> {
+                    state.copy(isLoading = true)
+                }
+
+                is AddSongReducerEvent.SongsLoaded -> {
+                    state.copy(songs = event.songs, isLoading = false, errorRes = null)
+                }
+
+                AddSongReducerEvent.SearchFailed -> {
+                    state.copy(
+                        songs = emptyList(),
+                        isLoading = false,
+                        errorRes = R.string.afternote_editor_search_failed_generic,
+                    )
+                }
+
+                AddSongReducerEvent.ErrorConsumed -> {
+                    state.copy(errorRes = null)
+                }
+            }
     }
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/MemorialMediaSourceBottomSheet.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/MemorialMediaSourceBottomSheet.kt
index c4441cc354..8ef108dadf 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/MemorialMediaSourceBottomSheet.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/MemorialMediaSourceBottomSheet.kt
@@ -34,7 +34,7 @@ internal enum class MemorialMediaTarget {
  */
 internal fun EditorFormState.removableMemorialMediaTargets(): Set<MemorialMediaTarget> =
     buildSet {
-        if (!displayMemorialPhotoUri().isNullOrBlank()) add(MemorialMediaTarget.PHOTO)
+        if (memorialPhoto?.canRemove == true) add(MemorialMediaTarget.PHOTO)
         if (canRemoveMemorialVideo) add(MemorialMediaTarget.VIDEO)
     }
 
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/MemorialPlaylistEntry.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/MemorialPlaylistEntry.kt
index 0927de9396..c1c664a57c 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/MemorialPlaylistEntry.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/MemorialPlaylistEntry.kt
@@ -1,14 +1,11 @@
 package com.afternote.feature.afternote.presentation.editor.memorial
 
 import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
-import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -20,9 +17,9 @@ import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import com.afternote.core.ui.button.FAB.PenFloatingActionButton
-import com.afternote.core.ui.theme.AfternoteDesign
 import com.afternote.feature.afternote.presentation.R
 import com.afternote.feature.afternote.presentation.shared.detail.PlaylistEmptyContent
+import com.afternote.feature.afternote.presentation.shared.detail.PlaylistSongCountHeader
 import com.afternote.feature.afternote.presentation.shared.detail.PlaylistSongList
 import com.afternote.feature.afternote.presentation.shared.detail.SelectableSongListBody
 import com.afternote.feature.afternote.presentation.shared.detail.SongPlaylistFloatingActionSlot
@@ -43,8 +40,8 @@ import com.afternote.feature.afternote.presentation.shared.model.PlaylistSongDis
  *   selectable 본문에 상시 노출 파라미터를 되살려 스왑.
  *
  * 이 조립을 흐름 호스트(`AfternoteEditorFlowHost`)의 entry 블록에 인라인하지 않고 Entry로 빼는 이유:
- * (1) 공용 SongPlaylist 화면 계열(shared/detail/song)은 여러 화면이 공유하는 범용 부품이라
- *     이 화면 전용 지식([Song] 도메인 매핑, 타이틀, 모드 전환·"총 N곡" 헤더·삭제 라벨·콜백)을 넣을 수 없고,
+ * (1) 공용 SongPlaylist 화면 계열(shared/detail)은 여러 화면이 공유하는 범용 부품이라
+ *     이 화면 전용 지식([Song] 도메인 매핑, 타이틀, 모드 전환·삭제 라벨·콜백)을 넣을 수 없고,
  * (2) 그 전용 지식을 entry 블록에 인라인하면 ViewModel 없이 렌더할 수 없어
  *     Preview·스크린샷 테스트가 막힌다.
  * Entry가 둘 사이에서 도메인→표시 모델 매핑과 화면 전용 크롬 주입을 맡는 어댑터다.
@@ -100,7 +97,7 @@ fun MemorialPlaylistEntry(
                 modifier = Modifier.padding(paddingValues),
                 songs = displaySongs,
                 header = {
-                    MemorialPlaylistListHeader(songCount = displaySongs.size)
+                    PlaylistSongCountHeader(songCount = displaySongs.size)
                 },
                 initialSelectedSongKeys = initialSelectedSongKeys,
                 actionLabel = stringResource(R.string.afternote_editor_playlist_delete_all),
@@ -114,7 +111,7 @@ fun MemorialPlaylistEntry(
                     modifier = Modifier.fillMaxSize(),
                     songs = displaySongs,
                     header = {
-                        MemorialPlaylistListHeader(songCount = displaySongs.size)
+                        PlaylistSongCountHeader(songCount = displaySongs.size)
                     },
                 )
                 if (displaySongs.isEmpty()) {
@@ -130,28 +127,3 @@ fun MemorialPlaylistEntry(
         }
     }
 }
-
-/**
- * MemorialPlaylistList 화면 상단 헤더: 모드와 무관하게 항상 "총 N곡"만 왼쪽에 표시.
- */
-@Composable
-private fun MemorialPlaylistListHeader(
-    songCount: Int,
-    modifier: Modifier = Modifier,
-) {
-    // 헤더 상단 간격은 헤더별로 달라(검색 16 / 곡 수 8) 리스트가 아닌 각 헤더가 top 여백을 소유한다.
-    Column(
-        modifier =
-            modifier
-                .fillMaxWidth()
-                .padding(top = 8.dp),
-    ) {
-        Text(
-            text = stringResource(R.string.afternote_editor_playlist_song_count_format, songCount),
-            style =
-                AfternoteDesign.typography.bodySmallR.copy(
-                    color = AfternoteDesign.colors.gray9,
-                ),
-        )
-    }
-}
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/receiver/SelectReceiverContract.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/receiver/SelectReceiverContract.kt
new file mode 100644
index 0000000000..73c4fdefe9
--- /dev/null
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/receiver/SelectReceiverContract.kt
@@ -0,0 +1,34 @@
+package com.afternote.feature.afternote.presentation.editor.receiver
+
+import com.afternote.core.ui.mvi.MviIntent
+import com.afternote.core.ui.mvi.ReducerEvent
+
+internal sealed interface SelectReceiverIntent : MviIntent {
+    data class ApplyPreselection(
+        val receiverIds: List<Long>,
+    ) : SelectReceiverIntent
+
+    data object Refresh : SelectReceiverIntent
+
+    data class ToggleReceiver(
+        val receiverId: Long,
+    ) : SelectReceiverIntent
+}
+
+internal sealed interface SelectReceiverReducerEvent : ReducerEvent {
+    data class PreselectionApplied(
+        val receiverIds: List<Long>,
+    ) : SelectReceiverReducerEvent
+
+    data object Loading : SelectReceiverReducerEvent
+
+    data class ReceiversLoaded(
+        val receivers: List<AfternoteEditorReceiver>,
+    ) : SelectReceiverReducerEvent
+
+    data object LoadFailed : SelectReceiverReducerEvent
+
+    data class ReceiverToggled(
+        val receiverId: Long,
+    ) : SelectReceiverReducerEvent
+}
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/receiver/SelectReceiverRoute.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/receiver/SelectReceiverRoute.kt
index 8550cd8b1d..ef28cf2fd0 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/receiver/SelectReceiverRoute.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/receiver/SelectReceiverRoute.kt
@@ -9,13 +9,13 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 /**
  * 수신자 선택 화면 진입점 (#540).
  *
- * 확정한 수신자 id 전체는 [onReceiversConfirmed] 로 나간다 — 흐름 호스트가 흐름이 공유하는 에디터 ViewModel 의
- * [com.afternote.feature.afternote.presentation.editor.AfternoteEditorViewModel.onReceiversSelected] 에 넘기고
- * pop 하면, 에디터의 [com.afternote.feature.afternote.presentation.editor.tryApplyReceiverSelection] 이
- * 복귀 시 소비해 폼에 반영한다.
+ * 확정한 수신자 id 전체는 [onReceiversConfirmed]로 나간다. 흐름 호스트가 공유 에디터의
+ * [com.afternote.feature.afternote.presentation.editor.AfternoteEditorIntent.ReceiversSelected]에 넘기고,
+ * 에디터 복귀 시 [com.afternote.feature.afternote.presentation.editor.AfternoteEditorIntent.ApplyPendingReceiverSelection]로
+ * 폼에 반영한다.
  *
- * [preselectedReceiverIds] 는 에디터 폼에 이미 들어 있는 수신자다. 화면을 그 선택 상태로 열어야
- * 사용자가 «이미 지정한 사람» 을 다시 고르거나 풀 수 있다 (#1426).
+ * [preselectedReceiverIds]는 에디터 폼에 이미 들어 있는 수신자다. 화면을 그 선택 상태로 열어
+ * 사용자가 이미 지정한 사람을 다시 고르거나 해제할 수 있게 한다 (#1426).
  */
 @Composable
 internal fun AfternoteSelectReceiverNavigation(
@@ -28,13 +28,13 @@ internal fun AfternoteSelectReceiverNavigation(
 
     // 진입 시점의 폼에 담겨 있던 수신자만 체크한다. 회전·재진입으로 컴포지션이 새로 만들어지면 이 효과도
     // 다시 돌지만, ViewModel 이 최초 1회만 받아 사용자가 푼 체크가 되살아나지 않는다.
-    LaunchedEffect(Unit) { viewModel.applyPreselection(preselectedReceiverIds) }
+    LaunchedEffect(Unit) { viewModel.onIntent(SelectReceiverIntent.ApplyPreselection(preselectedReceiverIds)) }
 
     SelectReceiverScreen(
         uiState = uiState,
         onBackClick = onPopBackStack,
-        onReceiverToggle = viewModel::toggleReceiverSelection,
-        onRetryClick = viewModel::refresh,
+        onReceiverToggle = { viewModel.onIntent(SelectReceiverIntent.ToggleReceiver(it)) },
+        onRetryClick = { viewModel.onIntent(SelectReceiverIntent.Refresh) },
         onConfirmClick = onReceiversConfirmed,
     )
 }
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/receiver/SelectReceiverViewModel.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/receiver/SelectReceiverViewModel.kt
index 4db416b73d..05c6b972f0 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/receiver/SelectReceiverViewModel.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/receiver/SelectReceiverViewModel.kt
@@ -1,24 +1,21 @@
 package com.afternote.feature.afternote.presentation.editor.receiver
 
 import androidx.lifecycle.SavedStateHandle
-import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.afternote.core.common.reporting.ErrorReporter
-import com.afternote.core.common.result.runCatchingCancellable
-import com.afternote.core.domain.repository.UserRepository
+import com.afternote.core.domain.repository.UserReceiverRepository
+import com.afternote.core.domain.result.runCatchingCancellable
+import com.afternote.core.ui.mvi.MviViewModel
+import com.afternote.core.ui.mvi.UiState
 import com.afternote.feature.afternote.presentation.editor.mapper.toAfternoteEditorReceivers
 import com.afternote.feature.afternote.presentation.reporting.AfternoteFailureStage
 import com.afternote.feature.afternote.presentation.reporting.recordAfternoteFailure
 import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import javax.inject.Inject
 
 /** 수신자 선택 화면 UI 상태. */
-data class SelectReceiverUiState(
+internal data class SelectReceiverUiState(
     val isLoading: Boolean = false,
     val loadFailed: Boolean = false,
     /** 서버에서 불러온 내 수신자 목록 — 설정 › 수신자 관리에서 등록한 그 사람들. 화면의 행이다. */
@@ -32,13 +29,13 @@ data class SelectReceiverUiState(
      * 빈 목록이 «아무도 선택하지 않음» 이다. null 로 없음을 표현하지 않는다 (#1426).
      */
     val selectedReceiverIds: List<Long> = emptyList(),
-)
+) : UiState
 
 /**
  * 애프터노트 에디터의 수신자 선택 화면 ViewModel (#540).
  *
  * 서버 `GET users/receivers` 는 액세스 토큰으로 호출자를 식별하므로 파라미터가 없다 —
- * 별도의 userId 없이 [UserRepository.getReceivers] 를 그대로 쓴다.
+ * 별도의 userId 없이 [UserReceiverRepository.getReceivers] 를 그대로 쓴다.
  *
  * 선택은 복수다 (#1426): 한 번 진입해 여러 명을 고르고, 완료 시 확정된 id 전체를
  * `SELECTED_RECEIVER_IDS_KEY` 로 에디터에 돌려준다. 화면은 에디터 폼에 이미 담겨 있던 수신자를
@@ -46,24 +43,71 @@ data class SelectReceiverUiState(
  * 화면에서 체크를 푼 수신자는 폼에서도 빠진다.
  *
  * 화면 내 선택과 «폼 수신자는 이미 넣었다» 는 사실은 [SavedStateHandle] 에 적어 둔다 (#1427). 백그라운드에서
- * 프로세스가 재생성돼도 선택이 그대로 복원되고, 복귀 시 다시 도는 [applyPreselection] 이 사용자가 푼
+ * 프로세스가 재생성돼도 선택이 복원되고, 복귀 시 프리필이 사용자가 푼
  * 폼 수신자를 되살리지 않는다.
  */
 @HiltViewModel
-class SelectReceiverViewModel
+internal class SelectReceiverViewModel
     @Inject
     constructor(
-        private val userRepository: UserRepository,
+        private val userReceiverRepository: UserReceiverRepository,
         private val errorReporter: ErrorReporter,
         private val savedStateHandle: SavedStateHandle,
-    ) : ViewModel() {
-        private val _uiState =
-            MutableStateFlow(
-                SelectReceiverUiState(
-                    selectedReceiverIds = savedStateHandle.get<LongArray>(SELECTED_RECEIVER_IDS_STATE_KEY)?.toList().orEmpty(),
-                ),
-            )
-        val uiState: StateFlow<SelectReceiverUiState> = _uiState.asStateFlow()
+    ) : MviViewModel<SelectReceiverIntent, SelectReceiverUiState, SelectReceiverReducerEvent>(
+            SelectReceiverUiState(
+                selectedReceiverIds = savedStateHandle.get<LongArray>(SELECTED_RECEIVER_IDS_STATE_KEY)?.toList().orEmpty(),
+            ),
+        ) {
+        override fun onIntent(intent: SelectReceiverIntent) {
+            when (intent) {
+                is SelectReceiverIntent.ApplyPreselection -> applyPreselection(intent.receiverIds)
+                SelectReceiverIntent.Refresh -> refresh()
+                is SelectReceiverIntent.ToggleReceiver -> toggleReceiverSelection(intent.receiverId)
+            }
+        }
+
+        override fun reduce(
+            state: SelectReceiverUiState,
+            event: SelectReceiverReducerEvent,
+        ): SelectReceiverUiState =
+            when (event) {
+                is SelectReceiverReducerEvent.PreselectionApplied -> {
+                    state.copy(
+                        selectedReceiverIds =
+                            (
+                                event.receiverIds +
+                                    state.selectedReceiverIds
+                            ).distinct(),
+                    )
+                }
+
+                SelectReceiverReducerEvent.Loading -> {
+                    state.copy(isLoading = true, loadFailed = false)
+                }
+
+                is SelectReceiverReducerEvent.ReceiversLoaded -> {
+                    state.copy(
+                        isLoading = false,
+                        receivers = event.receivers,
+                        selectedReceiverIds = state.selectedReceiverIds.filter { selected -> event.receivers.any { it.id == selected } },
+                    )
+                }
+
+                SelectReceiverReducerEvent.LoadFailed -> {
+                    state.copy(isLoading = false, loadFailed = true)
+                }
+
+                is SelectReceiverReducerEvent.ReceiverToggled -> {
+                    state.copy(
+                        selectedReceiverIds =
+                            if (event.receiverId in state.selectedReceiverIds) {
+                                state.selectedReceiverIds - event.receiverId
+                            } else {
+                                state.selectedReceiverIds + event.receiverId
+                            },
+                    )
+                }
+            }
 
         private var isPreselectionApplied: Boolean
             get() = savedStateHandle[PRESELECTION_APPLIED_STATE_KEY] ?: false
@@ -86,52 +130,33 @@ class SelectReceiverViewModel
          * 폼의 id 는 화면이 뜨자마자 오고 목록은 서버 응답이라 그보다 늦다. 목록에 없는 id 는 [refresh] 가
          * 목록을 받으며 뺀다.
          */
-        fun applyPreselection(formReceiverIds: List<Long>) {
+        private fun applyPreselection(formReceiverIds: List<Long>) {
             if (isPreselectionApplied) return
             isPreselectionApplied = true
             if (formReceiverIds.isEmpty()) return
-            _uiState.update { state ->
-                state.copy(selectedReceiverIds = (formReceiverIds + state.selectedReceiverIds).distinct())
-            }
-            persistSelection(_uiState.value.selectedReceiverIds)
+            dispatch(SelectReceiverReducerEvent.PreselectionApplied(formReceiverIds))
+            persistSelection(currentState.selectedReceiverIds)
         }
 
         /** 수신자 목록을 (재)조회한다. 실패 화면의 "다시 시도" 도 여기로 온다. */
-        fun refresh() {
+        private fun refresh() {
             viewModelScope.launch {
-                _uiState.update { it.copy(isLoading = true, loadFailed = false) }
-                runCatchingCancellable { userRepository.getReceivers() }
+                dispatch(SelectReceiverReducerEvent.Loading)
+                runCatchingCancellable { userReceiverRepository.getReceivers() }
                     .onSuccess { receivers ->
-                        _uiState.update { state ->
-                            state.copy(
-                                isLoading = false,
-                                receivers = receivers.toAfternoteEditorReceivers(),
-                                // 목록에 없는 수신자 선택은 해제한다 — 폼에서 넘어왔지만 설정에서 지워진 id,
-                                // 재조회로 사라진 id. 남겨 두면 완료 버튼이 이미 없는 id 를 에디터로 돌려보낸다.
-                                selectedReceiverIds =
-                                    state.selectedReceiverIds.filter { selected ->
-                                        receivers.any { it.receiverId == selected }
-                                    },
-                            )
-                        }
-                        persistSelection(_uiState.value.selectedReceiverIds)
+                        dispatch(SelectReceiverReducerEvent.ReceiversLoaded(receivers.toAfternoteEditorReceivers()))
+                        persistSelection(currentState.selectedReceiverIds)
                     }.onFailure { e ->
                         errorReporter.recordAfternoteFailure(AfternoteFailureStage.RECEIVER_SELECT_LOAD, e)
-                        _uiState.update { it.copy(isLoading = false, loadFailed = true) }
+                        dispatch(SelectReceiverReducerEvent.LoadFailed)
                     }
             }
         }
 
         /** 탭한 수신자를 선택 목록에 더하고, 이미 선택된 수신자를 다시 탭하면 그 항목만 뺀다 (#1426). */
-        fun toggleReceiverSelection(receiverId: Long) {
-            _uiState.update { state ->
-                val selected = state.selectedReceiverIds
-                state.copy(
-                    selectedReceiverIds =
-                        if (receiverId in selected) selected - receiverId else selected + receiverId,
-                )
-            }
-            persistSelection(_uiState.value.selectedReceiverIds)
+        private fun toggleReceiverSelection(receiverId: Long) {
+            dispatch(SelectReceiverReducerEvent.ReceiverToggled(receiverId))
+            persistSelection(currentState.selectedReceiverIds)
         }
 
         private fun persistSelection(receiverIds: List<Long>) {
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/selection/EditorServiceSelectionSheet.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/selection/EditorServiceSelectionSheet.kt
index ccb4da7ef5..82b1e40676 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/selection/EditorServiceSelectionSheet.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/selection/EditorServiceSelectionSheet.kt
@@ -29,6 +29,7 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.LocalInspectionMode
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.Role
@@ -110,14 +111,7 @@ internal fun EditorServiceSelectionSheet(
 ) {
     if (!visible) return
     val titleRes = type.serviceSelectionSheetTitleResOrNull() ?: return
-    val sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = true)
-
-    ModalBottomSheet(
-        onDismissRequest = onDismissRequest,
-        sheetState = sheetState,
-        containerColor = AfternoteDesign.colors.white,
-        dragHandle = null,
-    ) {
+    val content: @Composable () -> Unit = {
         EditorServiceSelectionSheetContent(
             title = stringResource(titleRes),
             type = type,
@@ -126,11 +120,25 @@ internal fun EditorServiceSelectionSheet(
             onServiceSelected = onServiceSelected,
         )
     }
+    // Layoutlib Preview는 ModalBottomSheet의 별도 창을 캡처하지 못하므로 같은 본문을 직접 렌더한다.
+    if (LocalInspectionMode.current) {
+        content()
+        return
+    }
+    val sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = true)
+    ModalBottomSheet(
+        onDismissRequest = onDismissRequest,
+        sheetState = sheetState,
+        containerColor = AfternoteDesign.colors.white,
+        dragHandle = null,
+    ) {
+        content()
+    }
 }
 
-/** Popup 윈도 밖에서도 Preview·Robolectric 검증이 가능한 시트 본문. */
+/** 서비스 선택 시트의 검색 입력과 목록. */
 @Composable
-internal fun EditorServiceSelectionSheetContent(
+private fun EditorServiceSelectionSheetContent(
     title: String,
     type: AfternoteType,
     services: List<String>,
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/state/AfternoteSaveState.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/state/AfternoteSaveState.kt
index ea20f34cf9..42252bce9b 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/state/AfternoteSaveState.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/state/AfternoteSaveState.kt
@@ -1,7 +1,10 @@
 package com.afternote.feature.afternote.presentation.editor.state
 
 import androidx.annotation.StringRes
+import com.afternote.core.ui.mvi.UiState
+import com.afternote.feature.afternote.domain.AfternoteType
 import com.afternote.feature.afternote.presentation.R
+import com.afternote.feature.afternote.presentation.editor.AfternoteEditorSnapshot
 import com.afternote.feature.afternote.presentation.editor.model.EditorFormPrefill
 import com.afternote.feature.afternote.presentation.editor.receiver.AfternoteEditorReceiver
 
@@ -68,6 +71,9 @@ sealed interface AfternoteEditorError {
      */
     data object PrefillNotReady : AfternoteEditorError
 
+    /** 사진·영상 파일이 서버의 업로드 한도를 초과했다. 같은 파일의 재시도를 안내하지 않는다. */
+    data object MediaSizeExceeded : AfternoteEditorError
+
     data class Upload(
         val target: Target,
     ) : AfternoteEditorError {
@@ -98,13 +104,13 @@ data class AfternoteEditorErrorEvent(
 /**
  * 에디터 화면의 단일 UI 상태.
  *
- * 일회성 신호(`pending*`)를 Channel 이 아니라 상태로 둔 건 configuration change·process death 뒤
- * 재구독에서도 마지막 신호가 살아남아야 해서다. non-null 이면 UI 가 처리 후 `on*Consumed()` 로 되돌린다.
+ * 일회성 신호(`pending*`)는 같은 ViewModel을 다시 구독할 때까지 유지한다.
+ * non-null 이면 UI가 처리 후 `Intent.ConsumeXxx`로 되돌린다. 프로세스 복원용 폼은 SavedStateHandle에 별도로 저장한다.
  *
  * 에디터 오류는 [errorEvent] 한 필드에서 종류와 발생 순서를 보존한다. 5xx 본문에 내부 SQL 이 섞여 올 수 있으므로
  * 서버 raw 메시지는 상태에 싣지 않고, UI가 오류 종류를 안전한 로컬 문구로 변환한다.
  */
-data class AfternoteEditorUiState(
+internal data class AfternoteEditorUiState(
     val form: EditorFormState = EditorFormState(),
     val authorReceivers: List<AfternoteEditorReceiver> = emptyList(),
     val isSaving: Boolean = false,
@@ -123,9 +129,9 @@ data class AfternoteEditorUiState(
     val isPrefillFailed: Boolean = false,
     val savedId: Long? = null,
     val errorEvent: AfternoteEditorErrorEvent? = null,
-    /** 저장 성공 신호 — UI 가 nav 후 `onSaveSuccessConsumed` 로 reset. */
+    /** 저장 성공 신호 — UI 가 nav 후 `ConsumeSaveSuccess` 로 reset. */
     val pendingSaveSuccessId: Long? = null,
-    /** 장례식에 남길 영상 썸네일 업로드 완료 신호 — UI 파사드가 form 에 url 적용 후 `onThumbnailUploadedConsumed` 로 reset. */
+    /** 장례식에 남길 영상 썸네일 업로드 완료 신호 — UI 파사드가 form 에 url 적용 후 `ConsumeThumbnailUploaded` 로 reset. */
     val pendingThumbnailUrl: String? = null,
     /**
      * 추출부터 다시 돌리기 위한 키. 바뀌면 UI 가 프레임 추출을 재발화한다 (#1550).
@@ -135,9 +141,13 @@ data class AfternoteEditorUiState(
      * 실패의 복구 경로는 영상을 처음부터 다시 고르는 것뿐이다.
      */
     val memorialThumbnailRetryToken: Int = 0,
-    /** 수정 모드 prefill 데이터 — UI 파사드가 form 에 적용 후 `onPrefillApplied` 로 reset (skeleton 종료 동시). */
+    /** 수정 모드 prefill 데이터 — UI 파사드가 form 에 적용 후 `ConsumePrefill` 로 reset (skeleton 종료 동시). */
     val pendingPrefill: EditorFormPrefill? = null,
-) {
+    /** 저장 시 기준과 오류 식별도 같은 reducer가 관리한다. */
+    val originalType: AfternoteType? = null,
+    val updateBaseline: AfternoteEditorSnapshot? = null,
+    val errorOccurrence: Long = 0L,
+) : UiState {
     val error: AfternoteEditorError?
         get() = errorEvent?.error
 }
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/state/AfternoteTypeForm.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/state/AfternoteTypeForm.kt
index dd1a627f24..c16c890ad6 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/state/AfternoteTypeForm.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/state/AfternoteTypeForm.kt
@@ -81,18 +81,17 @@ sealed interface AfternoteTypeForm {
      * 카테고리 전용 필드. 영상이 서버에 있는지·새로 골라 올려야 하는지는 [EditableMemorialVideo]가 감춘다.
      *
      * 시트의 삭제는 슬롯을 비운다 — 교체분과 서버 값을 함께. 비어 있는 서버 값은 저장 시 PATCH `null`
-     * 로 이어진다(#1597). 사진은 `pickedPhotoUri`·`photoUrl` 두 칸이 같은 규칙을 따른다.
+     * 로 이어진다(#1597). 사진도 [EditableMemorialPhoto]가 같은 규칙을 닫는다.
      */
     @ConsistentCopyVisibility
     data class Memorial internal constructor(
-        val pickedPhotoUri: String? = null,
+        internal val photo: EditableMemorialPhoto = EditableMemorialPhoto.empty(),
         internal val video: EditableMemorialVideo = EditableMemorialVideo.empty(),
-        val photoUrl: String? = null,
         val playlistSongs: List<Song> = emptyList(),
     ) : AfternoteTypeForm {
         override val type = AfternoteType.MEMORIAL
 
-        fun displayPhotoUri(): String? = pickedPhotoUri ?: photoUrl
+        internal fun displayPhotoUri(): String? = photo.displayed
 
         /**
          * 미디어는 수정 진입 기준선과 비교해야 서버 원본 삭제도 미저장 변경으로 잡힌다(#1597). 영상은
@@ -149,7 +148,7 @@ sealed interface AfternoteTypeForm {
                                     thumbnailUrl = content.thumbnailUrl,
                                 ),
                             ),
-                        photoUrl = content.photoUrl,
+                        photo = EditableMemorialPhoto.fromPersisted(content.photoUrl),
                         playlistSongs = content.playlistSongs,
                     )
                 }
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/state/EditableMemorialPhoto.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/state/EditableMemorialPhoto.kt
new file mode 100644
index 0000000000..3349d3216c
--- /dev/null
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/state/EditableMemorialPhoto.kt
@@ -0,0 +1,87 @@
+package com.afternote.feature.afternote.presentation.editor.state
+
+import com.afternote.feature.afternote.domain.repository.author.MediaInput
+
+/**
+ * 영정사진의 서버 기준값과 미저장 선택. 표시·삭제·업로드 출처를 한 경계에서 결정한다.
+ * 교체 전 서버 값은 이탈 가드와 기존 SavedStateHandle 스냅샷의 동일성을 위해 보존한다.
+ * 삭제는 [empty]로 두 층을 함께 비우며, 서버 값으로 되돌리는 동작은 없다.
+ */
+internal sealed class EditableMemorialPhoto private constructor() {
+    private data object Empty : EditableMemorialPhoto()
+
+    private data class ServerOnly(
+        val persisted: String,
+    ) : EditableMemorialPhoto()
+
+    private data class SelectionOnly(
+        val selection: String,
+    ) : EditableMemorialPhoto()
+
+    private data class Replaced(
+        val persisted: String,
+        val selection: String,
+    ) : EditableMemorialPhoto()
+
+    internal val displayed: String?
+        get() =
+            when (this) {
+                Empty -> null
+                is ServerOnly -> persisted
+                is SelectionOnly -> selection
+                is Replaced -> selection
+            }
+
+    internal val canRemove: Boolean
+        get() =
+            when (this) {
+                Empty -> false
+                is ServerOnly -> persisted.isNotBlank()
+                is SelectionOnly -> selection.isNotBlank()
+                is Replaced -> selection.isNotBlank()
+            }
+
+    internal fun withSelection(uri: String): EditableMemorialPhoto =
+        when (this) {
+            Empty -> SelectionOnly(uri)
+            is ServerOnly -> Replaced(persisted, uri)
+            is SelectionOnly -> SelectionOnly(uri)
+            is Replaced -> Replaced(persisted, uri)
+        }
+
+    /** 기존 빈 문자열 처리도 유지하며 URL 형태로 출처를 재추론하지 않는다. */
+    internal fun toMediaInput(): MediaInput =
+        when (this) {
+            Empty -> MediaInput.None
+            is ServerOnly -> persisted.asRemoteInput()
+            is SelectionOnly -> if (selection.isBlank()) MediaInput.None else MediaInput.Local(selection)
+            is Replaced -> if (selection.isBlank()) persisted.asRemoteInput() else MediaInput.Local(selection)
+        }
+
+    /** 기존 JSON의 두 키를 유지하는 직렬화 경계. UI와 저장 명령은 이 표현을 사용하지 않는다. */
+    internal fun toSnapshot(): Snapshot =
+        when (this) {
+            Empty -> Snapshot(null, null)
+            is ServerOnly -> Snapshot(persisted, null)
+            is SelectionOnly -> Snapshot(null, selection)
+            is Replaced -> Snapshot(persisted, selection)
+        }
+
+    internal data class Snapshot(
+        val persisted: String?,
+        val selection: String?,
+    )
+
+    internal companion object {
+        internal fun empty(): EditableMemorialPhoto = Empty
+
+        internal fun fromPersisted(uri: String?): EditableMemorialPhoto = if (uri == null) Empty else ServerOnly(uri)
+
+        internal fun fromSnapshot(
+            persisted: String?,
+            selection: String?,
+        ): EditableMemorialPhoto = fromPersisted(persisted).let { photo -> selection?.let(photo::withSelection) ?: photo }
+    }
+}
+
+private fun String.asRemoteInput(): MediaInput = if (isBlank()) MediaInput.None else MediaInput.Remote(this)
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/state/EditableMemorialVideo.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/state/EditableMemorialVideo.kt
index 1097c2836a..9c7cbfcba1 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/state/EditableMemorialVideo.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/state/EditableMemorialVideo.kt
@@ -59,12 +59,12 @@ internal sealed class EditableMemorialVideo {
     /** 새 선택으로 교체한다. 이전 선택의 썸네일은 물려주지 않는다. 빈 문자열은 [MemorialVideoAttachment.ofOrNull] 규칙대로 첨부 없음이다. */
     internal fun withSelection(url: String): EditableMemorialVideo = MemorialVideoAttachment.ofOrNull(url)?.let(::PendingUpload) ?: NoVideo
 
-    /** 미저장 선택에서 파생된 썸네일만 갱신한다. 선택이 사라졌다면 늦은 결과를 버린다. */
+    /** 미저장 선택에서 파생된 썸네일만 갱신한다. 선택이 사라졌다면 늦은 결과를 버린다. 빈 문자열은 썸네일 없음이다. */
     internal fun withSelectionThumbnail(url: String): EditableMemorialVideo =
         when (this) {
             NoVideo -> this
             is Uploaded -> this
-            is PendingUpload -> PendingUpload(video.copy(thumbnailUrl = url))
+            is PendingUpload -> PendingUpload(video.copy(thumbnailUrl = url.ifBlank { null }))
         }
 
     /**
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/state/EditorFormMutations.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/state/EditorFormMutations.kt
index 0e7a2f31a0..dae1c395d5 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/state/EditorFormMutations.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/state/EditorFormMutations.kt
@@ -31,15 +31,15 @@ internal fun EditorFormState.withType(type: AfternoteType): EditorFormState =
 
 internal fun EditorFormState.withService(service: String): EditorFormState = mapServiceForm { it.withService(service) }
 
-/** 사진 선택은 `picked` 층에 실린다. 서버 사진은 `photoUrl` 에 그대로 남는다 — 저장 없이 나가면 그것이 사실이고, 이탈 가드가 기준선과 비교한다. */
-internal fun EditorFormState.withMemorialPhoto(uri: String): EditorFormState = mapMemorial { it.copy(pickedPhotoUri = uri) }
+/** 사진 선택은 값 객체 안의 미저장 층을 교체하며, 서버 기준값은 이탈 가드 비교를 위해 유지한다. */
+internal fun EditorFormState.withMemorialPhoto(uri: String): EditorFormState = mapMemorial { it.copy(photo = it.photo.withSelection(uri)) }
 
 /**
  * 시트의 사진 삭제(#1114). 슬롯을 비운다 — 로컬 교체분과 서버 사진을 함께. 서버 삭제는 여기서 일어나지
  * 않는다 — 두 칸이 빈 폼을 저장이 PATCH `null` 로 보낼 뿐이다(#1597). 저장 없이 나가면 서버 사진은
  * 그대로다(이탈 가드).
  */
-internal fun EditorFormState.withMemorialPhotoRemoved(): EditorFormState = mapMemorial { it.copy(pickedPhotoUri = null, photoUrl = null) }
+internal fun EditorFormState.withMemorialPhotoRemoved(): EditorFormState = mapMemorial { it.copy(photo = EditableMemorialPhoto.empty()) }
 
 /**
  * 영상 첨부는 통째로 갈린다 — 새 영상에는 썸네일이 아직 없고, 이전 영상의 썸네일을 물려주면 다른
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/state/EditorFormState.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/state/EditorFormState.kt
index c06199e32a..089c400f95 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/state/EditorFormState.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/state/EditorFormState.kt
@@ -27,7 +27,7 @@ data class EditorFormState(
 
     internal val memorialForm: AfternoteTypeForm.Memorial? get() = typeForm as? AfternoteTypeForm.Memorial
 
-    val pickedMemorialPhotoUri: String? get() = memorialForm?.pickedPhotoUri
+    internal val memorialPhoto: EditableMemorialPhoto? get() = memorialForm?.photo
 
     /** 서버 기준값과 이번 폼의 미저장 교체분을 함께 가진 영상 편집 상태. */
     internal val memorialVideo: EditableMemorialVideo? get() = memorialForm?.video
@@ -36,7 +36,6 @@ data class EditorFormState(
 
     /** 시트에 영상 삭제 항목을 내놓을지 — 표시된 층이 있으면 출처와 무관하게 지울 수 있다(#1597). */
     internal val canRemoveMemorialVideo: Boolean get() = memorialVideo?.canRemove == true
-    val memorialPhotoUrl: String? get() = memorialForm?.photoUrl
     val memorialPlaylistSongs: List<Song> get() = memorialForm?.playlistSongs.orEmpty()
 
     fun displayMemorialPhotoUri(): String? = memorialForm?.displayPhotoUri()
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/home/AfternoteHomeContract.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/home/AfternoteHomeContract.kt
new file mode 100644
index 0000000000..12391bc0d2
--- /dev/null
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/home/AfternoteHomeContract.kt
@@ -0,0 +1,28 @@
+package com.afternote.feature.afternote.presentation.home
+
+import com.afternote.core.ui.mvi.MviIntent
+import com.afternote.core.ui.mvi.ReducerEvent
+import com.afternote.core.ui.mvi.UiState
+import com.afternote.feature.afternote.domain.AfternoteType
+
+internal data class AfternoteHomeUiState(
+    val selectedType: AfternoteType? = null,
+) : UiState
+
+internal sealed interface AfternoteHomeIntent : MviIntent {
+    data class SelectType(
+        val type: AfternoteType?,
+    ) : AfternoteHomeIntent
+
+    data class ListLoadFailed(
+        val throwable: Throwable,
+    ) : AfternoteHomeIntent
+
+    data object ListLoadSucceeded : AfternoteHomeIntent
+}
+
+internal sealed interface AfternoteHomeReducerEvent : ReducerEvent {
+    data class TypeSelected(
+        val type: AfternoteType?,
+    ) : AfternoteHomeReducerEvent
+}
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/home/AfternoteHomeEntry.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/home/AfternoteHomeEntry.kt
index c003437ab3..a9bcf4f309 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/home/AfternoteHomeEntry.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/home/AfternoteHomeEntry.kt
@@ -26,13 +26,14 @@ import com.afternote.feature.afternote.presentation.R
  * 중복 억제는 VM 이 맡는다.
  */
 @Composable
-fun AfternoteHomeEntry(
+internal fun AfternoteHomeEntry(
     navigateToDetail: (Long) -> Unit,
     navigateToAdd: (AfternoteType) -> Unit,
     onSettingClick: () -> Unit,
     viewModel: AfternoteHomeViewModel = hiltViewModel(),
 ) {
-    val selectedType by viewModel.selectedType.collectAsStateWithLifecycle()
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+    val selectedType = uiState.selectedType
     val items = viewModel.pagedAfternotes.collectAsLazyPagingItems()
     val snackbarHostState = remember { SnackbarHostState() }
 
@@ -40,7 +41,7 @@ fun AfternoteHomeEntry(
     val appendErrorMessage = stringResource(R.string.afternote_home_append_error)
     LaunchedEffect(appendState) {
         if (appendState is LoadState.Error) {
-            viewModel.onListLoadFailed(appendState.error)
+            viewModel.onIntent(AfternoteHomeIntent.ListLoadFailed(appendState.error))
             snackbarHostState.showSnackbar(message = appendErrorMessage)
         }
     }
@@ -48,10 +49,10 @@ fun AfternoteHomeEntry(
     val refreshState = items.loadState.refresh
     LaunchedEffect(refreshState) {
         when (refreshState) {
-            is LoadState.Error -> viewModel.onListLoadFailed(refreshState.error)
+            is LoadState.Error -> viewModel.onIntent(AfternoteHomeIntent.ListLoadFailed(refreshState.error))
 
             // 성공한 로드가 실패 구간을 닫는다 — 다음 실패는 새 사건으로 다시 기록된다.
-            is LoadState.NotLoading -> viewModel.onListLoadSucceeded()
+            is LoadState.NotLoading -> viewModel.onIntent(AfternoteHomeIntent.ListLoadSucceeded)
 
             is LoadState.Loading -> Unit
         }
@@ -61,7 +62,7 @@ fun AfternoteHomeEntry(
         items = items,
         selectedType = selectedType,
         snackbarHostState = snackbarHostState,
-        onTypeSelected = viewModel::selectTab,
+        onTypeSelected = { viewModel.onIntent(AfternoteHomeIntent.SelectType(it)) },
         onListItemClick = { id, type ->
             when (type) {
                 AfternoteType.SOCIAL_NETWORK,
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/home/AfternoteHomeViewModel.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/home/AfternoteHomeViewModel.kt
index d533f5a94b..c5b03ac398 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/home/AfternoteHomeViewModel.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/home/AfternoteHomeViewModel.kt
@@ -1,12 +1,11 @@
 package com.afternote.feature.afternote.presentation.home
 
-import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import androidx.paging.PagingData
 import androidx.paging.cachedIn
 import androidx.paging.map
 import com.afternote.core.common.reporting.ErrorReporter
-import com.afternote.feature.afternote.domain.AfternoteType
+import com.afternote.core.ui.mvi.MviViewModel
 import com.afternote.feature.afternote.domain.model.author.ListItem
 import com.afternote.feature.afternote.domain.repository.author.AfternoteRepository
 import com.afternote.feature.afternote.presentation.reporting.AfternoteFailureStage
@@ -16,9 +15,7 @@ import com.afternote.feature.afternote.presentation.shared.util.getIconResForSer
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.map
 import javax.inject.Inject
@@ -28,30 +25,39 @@ import javax.inject.Inject
  * CUD 후 목록 갱신은 Repository 내부에서 자동 처리되므로 수동 refresh는 불필요하다.
  */
 @HiltViewModel
-class AfternoteHomeViewModel
+internal class AfternoteHomeViewModel
     @Inject
     constructor(
         private val afternoteRepository: AfternoteRepository,
         private val errorReporter: ErrorReporter,
-    ) : ViewModel() {
-        /** 선택된 종류 필터. `null` 은 전체다. */
-        private val _selectedType = MutableStateFlow<AfternoteType?>(null)
-        val selectedType: StateFlow<AfternoteType?> = _selectedType.asStateFlow()
-
+    ) : MviViewModel<AfternoteHomeIntent, AfternoteHomeUiState, AfternoteHomeReducerEvent>(AfternoteHomeUiState()) {
         @OptIn(ExperimentalCoroutinesApi::class)
         val pagedAfternotes: Flow<PagingData<ListItemUiModel>> =
-            _selectedType
+            uiState
+                .map { it.selectedType }
+                .distinctUntilChanged()
                 .flatMapLatest { type ->
                     afternoteRepository
                         .getPagedAfternotes(type)
                         .map { pagingData -> pagingData.map { it.toUiModel() } }
                 }.cachedIn(viewModelScope)
 
-        fun selectTab(tab: AfternoteType?) {
-            if (_selectedType.value == tab) return
-            _selectedType.value = tab
+        override fun onIntent(intent: AfternoteHomeIntent) {
+            when (intent) {
+                is AfternoteHomeIntent.SelectType -> dispatch(AfternoteHomeReducerEvent.TypeSelected(intent.type))
+                is AfternoteHomeIntent.ListLoadFailed -> onListLoadFailed(intent.throwable)
+                AfternoteHomeIntent.ListLoadSucceeded -> onListLoadSucceeded()
+            }
         }
 
+        override fun reduce(
+            state: AfternoteHomeUiState,
+            event: AfternoteHomeReducerEvent,
+        ): AfternoteHomeUiState =
+            when (event) {
+                is AfternoteHomeReducerEvent.TypeSelected -> state.copy(selectedType = event.type)
+            }
+
         /**
          * 마지막으로 기록한 목록 실패의 예외 타입. 같은 장애가 이어지는 동안 재기록을 막는 기준이다 —
          * 예외 «인스턴스» 로 비교하면 Paging 이 재시도마다 새 예외를 만들어 중복 억제가 성립하지 않는다.
@@ -67,7 +73,7 @@ class AfternoteHomeViewModel
          * 그래서 «장애가 이어지는 동안 한 번» 만 기록하고, 로드가 성공하면([onListLoadSucceeded])
          * 다음 실패를 새 사건으로 다시 받는다.
          */
-        fun onListLoadFailed(throwable: Throwable) {
+        private fun onListLoadFailed(throwable: Throwable) {
             val failureType = throwable.javaClass.name
             if (lastReportedFailureType == failureType) return
             lastReportedFailureType = failureType
@@ -75,7 +81,7 @@ class AfternoteHomeViewModel
         }
 
         /** 목록 로드가 성공해 실패 구간이 끝났음을 알린다 — 다음 실패는 새 사건으로 기록된다. */
-        fun onListLoadSucceeded() {
+        private fun onListLoadSucceeded() {
             lastReportedFailureType = null
         }
     }
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/navigation/AfternoteEditorFlowHost.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/navigation/AfternoteEditorFlowHost.kt
index 4c6a15373a..e95731fe45 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/navigation/AfternoteEditorFlowHost.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/navigation/AfternoteEditorFlowHost.kt
@@ -9,6 +9,7 @@ import androidx.navigation3.runtime.entryProvider
 import androidx.navigation3.runtime.rememberNavBackStack
 import com.afternote.core.ui.navigation.FeatureNavDisplay
 import com.afternote.core.ui.navigation.FeatureNavigationCallbacks
+import com.afternote.feature.afternote.presentation.editor.AfternoteEditorIntent
 import com.afternote.feature.afternote.presentation.editor.AfternoteEditorNavigation
 import com.afternote.feature.afternote.presentation.editor.AfternoteEditorViewModel
 import com.afternote.feature.afternote.presentation.editor.memorial.AddSongViewModel
@@ -50,7 +51,7 @@ internal fun AfternoteEditorFlowHost(
             AfternoteEditorFlowLocalNavActions(
                 flowStack = flowStack,
                 navigationCallbacks = navigationCallbacks,
-                onReceiversSelected = editorViewModel::onReceiversSelected,
+                onReceiversSelected = { receiverIds -> editorViewModel.onIntent(AfternoteEditorIntent.ReceiversSelected(receiverIds)) },
                 onSaveSuccessNavigateHome = onSaveSuccessNavigateHome,
             )
         }
@@ -87,8 +88,10 @@ internal fun AfternoteEditorFlowHost(
                         songs = editorUiState.form.memorialPlaylistSongs,
                         onBackClick = actions::popBack,
                         onNavigateToAddSongScreen = actions::navigateToAddSong,
-                        onClearAllSongs = editorViewModel::clearMemorialPlaylistSongs,
-                        onRemoveSongs = editorViewModel::removeMemorialPlaylistSongs,
+                        onClearAllSongs = { editorViewModel.onIntent(AfternoteEditorIntent.ClearMemorialPlaylistSongs) },
+                        onRemoveSongs = { selectionKeys ->
+                            editorViewModel.onIntent(AfternoteEditorIntent.RemoveMemorialPlaylistSongs(selectionKeys))
+                        },
                     )
                 }
 
@@ -96,7 +99,7 @@ internal fun AfternoteEditorFlowHost(
                     val addSongViewModel: AddSongViewModel = hiltViewModel()
                     AfternoteAddSongNavigation(
                         onPopBackStack = actions::popBack,
-                        onSongsAdded = editorViewModel::addMemorialPlaylistSongs,
+                        onSongsAdded = { songs -> editorViewModel.onIntent(AfternoteEditorIntent.AddMemorialPlaylistSongs(songs)) },
                         viewModel = addSongViewModel,
                     )
                 }
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/navigation/AfternoteNavHost.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/navigation/AfternoteNavHost.kt
index 8e3aa08220..a2ef6e2a46 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/navigation/AfternoteNavHost.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/navigation/AfternoteNavHost.kt
@@ -1,21 +1,27 @@
 package com.afternote.feature.afternote.presentation.navigation
 
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.compose.LocalLifecycleOwner
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.lifecycle.repeatOnLifecycle
 import androidx.navigation3.runtime.entryProvider
 import androidx.navigation3.runtime.rememberNavBackStack
 import com.afternote.core.ui.navigation.FeatureNavDisplay
 import com.afternote.core.ui.navigation.FeatureNavigationCallbacks
+import com.afternote.feature.afternote.presentation.AfternoteHostIntent
 import com.afternote.feature.afternote.presentation.AfternoteHostViewModel
 import com.afternote.feature.afternote.presentation.detail.AfternoteDetailNavigation
 import com.afternote.feature.afternote.presentation.detail.AfternoteDetailViewModel
 import com.afternote.feature.afternote.presentation.home.AfternoteHomeNavigation
 import com.afternote.feature.afternote.presentation.navigation.model.AfternoteRoute
 import com.afternote.feature.afternote.presentation.shared.fingerprint.AfternoteFingerprintLoginNavigation
+import kotlinx.coroutines.awaitCancellation
 
 /**
  * 애프터노트 작성자 피처가 소유하는 로컬 Navigation 3 스택.
@@ -55,7 +61,19 @@ public fun AfternoteNavHost(
             entryProvider {
                 entry<AfternoteRoute.FingerprintLoginRoute> {
                     AfternoteLightTheme {
-                        val isPasskeyRegistered by hostViewModel.isPasskeyRegistered.collectAsStateWithLifecycle()
+                        val hostState by hostViewModel.uiState.collectAsStateWithLifecycle()
+                        val isPasskeyRegistered = hostState.isPasskeyRegistered
+                        val lifecycleOwner = LocalLifecycleOwner.current
+                        LaunchedEffect(hostViewModel, lifecycleOwner) {
+                            lifecycleOwner.lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) {
+                                hostViewModel.onIntent(AfternoteHostIntent.ObserveProfile)
+                                try {
+                                    awaitCancellation()
+                                } finally {
+                                    hostViewModel.onIntent(AfternoteHostIntent.StopObservingProfile)
+                                }
+                            }
+                        }
                         AfternoteFingerprintLoginNavigation(
                             isPasskeyRegistered = isPasskeyRegistered,
                             onAuthenticationSuccess = actions::replaceFingerprintLoginWithAfternoteHome,
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/afternotelist/ReceiverAfternoteHomeContract.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/afternotelist/ReceiverAfternoteHomeContract.kt
new file mode 100644
index 0000000000..4c78df5f1f
--- /dev/null
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/afternotelist/ReceiverAfternoteHomeContract.kt
@@ -0,0 +1,22 @@
+package com.afternote.feature.afternote.presentation.receiver.afternotelist
+
+import com.afternote.core.ui.mvi.MviIntent
+import com.afternote.core.ui.mvi.ReducerEvent
+import com.afternote.core.ui.mvi.UiState
+import com.afternote.feature.afternote.domain.AfternoteType
+
+internal data class ReceiverAfternoteHomeUiState(
+    val selectedTab: AfternoteType? = null,
+) : UiState
+
+internal sealed interface ReceiverAfternoteHomeIntent : MviIntent {
+    data class SelectType(
+        val type: AfternoteType?,
+    ) : ReceiverAfternoteHomeIntent
+}
+
+internal sealed interface ReceiverAfternoteHomeReducerEvent : ReducerEvent {
+    data class TypeSelected(
+        val type: AfternoteType?,
+    ) : ReceiverAfternoteHomeReducerEvent
+}
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/afternotelist/ReceiverAfternoteHomeEntry.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/afternotelist/ReceiverAfternoteHomeEntry.kt
index 4181b29014..cdfed6651b 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/afternotelist/ReceiverAfternoteHomeEntry.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/afternotelist/ReceiverAfternoteHomeEntry.kt
@@ -7,9 +7,11 @@ import androidx.compose.ui.res.stringResource
 import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.paging.LoadState
+import androidx.paging.compose.LazyPagingItems
 import androidx.paging.compose.collectAsLazyPagingItems
 import com.afternote.feature.afternote.presentation.R
 import com.afternote.feature.afternote.presentation.home.AfternoteHomeScreen
+import com.afternote.feature.afternote.presentation.shared.component.ListItemUiModel
 import com.afternote.core.ui.R as CoreUiR
 
 /**
@@ -28,13 +30,25 @@ import com.afternote.core.ui.R as CoreUiR
  *   수신자는 로그인 사용자가 아니고 남길 기록을 쓰는 주체도 아니다.
  */
 @Composable
-fun ReceiverAfternoteHomeEntry(
+internal fun ReceiverAfternoteHomeEntry(
     navigateToDetail: (Long) -> Unit,
     modifier: Modifier = Modifier,
     viewModel: ReceiverAfternoteHomeViewModel = hiltViewModel(),
 ) {
-    val selectedTab by viewModel.selectedTab.collectAsStateWithLifecycle()
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
     val items = viewModel.pagedAfternotes.collectAsLazyPagingItems()
+    ReceiverAfternoteHomeContent(uiState, items, viewModel::onIntent, navigateToDetail, modifier)
+}
+
+@Composable
+private fun ReceiverAfternoteHomeContent(
+    state: ReceiverAfternoteHomeUiState,
+    items: LazyPagingItems<ListItemUiModel>,
+    onIntent: (ReceiverAfternoteHomeIntent) -> Unit,
+    navigateToDetail: (Long) -> Unit,
+    modifier: Modifier,
+) {
+    val selectedTab = state.selectedTab
     // 이미 그려 둔 목록이 있으면 유지한다 — 전면 교체는 보여 줄 것이 전무할 때만 (작성자 화면과 같은 규칙).
     val refreshState = items.loadState.refresh
     val listError =
@@ -70,7 +84,7 @@ fun ReceiverAfternoteHomeEntry(
             AfternoteHomeScreen(
                 items = items,
                 selectedType = selectedTab,
-                onTypeSelected = viewModel::selectTab,
+                onTypeSelected = { onIntent(ReceiverAfternoteHomeIntent.SelectType(it)) },
                 onListItemClick = { id, _ -> navigateToDetail(id) },
                 headerDescription = stringResource(R.string.afternote_receiver_afternote_list_header_description),
                 // NEXT STEP 은 «내가 남길 기록» 을 재촉하는 발신자용 카드다. 수신자 목록에는 없다.
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/afternotelist/ReceiverAfternoteHomeViewModel.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/afternotelist/ReceiverAfternoteHomeViewModel.kt
index db3786537c..7e9b1148f8 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/afternotelist/ReceiverAfternoteHomeViewModel.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/afternotelist/ReceiverAfternoteHomeViewModel.kt
@@ -1,12 +1,11 @@
 package com.afternote.feature.afternote.presentation.receiver.afternotelist
 
-import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import androidx.paging.PagingData
 import androidx.paging.cachedIn
 import androidx.paging.filter
 import androidx.paging.map
-import com.afternote.feature.afternote.domain.AfternoteType
+import com.afternote.core.ui.mvi.MviViewModel
 import com.afternote.feature.afternote.presentation.shared.component.ListItemUiModel
 import com.afternote.feature.afternote.presentation.shared.util.getIconResForService
 import com.afternote.feature.receiver.domain.model.AfterNoteListItem
@@ -14,9 +13,7 @@ import com.afternote.feature.receiver.domain.repository.ReceiverRepository
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.map
 import javax.inject.Inject
@@ -29,18 +26,18 @@ import javax.inject.Inject
  * 서버 파라미터가 없어 클라이언트 사이드 [PagingData.filter]로 적용한다.
  */
 @HiltViewModel
-class ReceiverAfternoteHomeViewModel
+internal class ReceiverAfternoteHomeViewModel
     @Inject
     constructor(
         private val receiverRepository: ReceiverRepository,
-    ) : ViewModel() {
-        /** 선택된 종류 필터. `null` 은 전체다. */
-        private val _selectedTab = MutableStateFlow<AfternoteType?>(null)
-        val selectedTab: StateFlow<AfternoteType?> = _selectedTab.asStateFlow()
-
+    ) : MviViewModel<ReceiverAfternoteHomeIntent, ReceiverAfternoteHomeUiState, ReceiverAfternoteHomeReducerEvent>(
+            ReceiverAfternoteHomeUiState(),
+        ) {
         @OptIn(ExperimentalCoroutinesApi::class)
         val pagedAfternotes: Flow<PagingData<ListItemUiModel>> =
-            _selectedTab
+            uiState
+                .map { it.selectedTab }
+                .distinctUntilChanged()
                 .flatMapLatest { tab ->
                     receiverRepository
                         .getPagedReceivedAfternotes()
@@ -51,10 +48,19 @@ class ReceiverAfternoteHomeViewModel
                         }
                 }.cachedIn(viewModelScope)
 
-        fun selectTab(tab: AfternoteType?) {
-            if (_selectedTab.value == tab) return
-            _selectedTab.value = tab
+        override fun onIntent(intent: ReceiverAfternoteHomeIntent) {
+            when (intent) {
+                is ReceiverAfternoteHomeIntent.SelectType -> dispatch(ReceiverAfternoteHomeReducerEvent.TypeSelected(intent.type))
+            }
         }
+
+        override fun reduce(
+            state: ReceiverAfternoteHomeUiState,
+            event: ReceiverAfternoteHomeReducerEvent,
+        ): ReceiverAfternoteHomeUiState =
+            when (event) {
+                is ReceiverAfternoteHomeReducerEvent.TypeSelected -> state.copy(selectedTab = event.type)
+            }
     }
 
 /** 카드 주 텍스트는 서비스명이, 미등록 서비스 아이콘과 필터 탭은 종류가 결정한다. */
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/detail/ReceivedAfternoteDetailContract.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/detail/ReceivedAfternoteDetailContract.kt
new file mode 100644
index 0000000000..8f8289a37f
--- /dev/null
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/detail/ReceivedAfternoteDetailContract.kt
@@ -0,0 +1,23 @@
+package com.afternote.feature.afternote.presentation.receiver.detail
+
+import com.afternote.core.ui.mvi.MviIntent
+import com.afternote.core.ui.mvi.ReducerEvent
+
+internal sealed interface ReceivedAfternoteDetailIntent : MviIntent {
+    data object Retry : ReceivedAfternoteDetailIntent
+
+    data object RefreshOnReturn : ReceivedAfternoteDetailIntent
+}
+
+internal sealed interface ReceivedAfternoteDetailReducerEvent : ReducerEvent {
+    data object Loading : ReceivedAfternoteDetailReducerEvent
+
+    data class ContentLoaded(
+        val id: Long,
+        val content: ReceivedDetailContentUiModel,
+    ) : ReceivedAfternoteDetailReducerEvent
+
+    data class LoadFailed(
+        val keepsContent: Boolean,
+    ) : ReceivedAfternoteDetailReducerEvent
+}
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/detail/ReceivedAfternoteDetailRoute.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/detail/ReceivedAfternoteDetailRoute.kt
index ef241af4c6..2f248b99dc 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/detail/ReceivedAfternoteDetailRoute.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/detail/ReceivedAfternoteDetailRoute.kt
@@ -2,7 +2,6 @@ package com.afternote.feature.afternote.presentation.receiver.detail
 
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
-import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.compose.LifecycleEventEffect
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
@@ -27,7 +26,7 @@ import com.afternote.feature.afternote.presentation.shared.detail.DetailLoadErro
  * 실패를 이쪽으로 보내면 서버·네트워크 오류가 "디자인 예정" 으로 표시되고 재시도 수단도 사라진다 (#713).
  */
 @Composable
-fun ReceivedAfternoteDetailRoute(
+internal fun ReceivedAfternoteDetailRoute(
     onNavigateBack: () -> Unit,
     onNavigateToFullList: () -> Unit,
     onNavigateToPlaylist: (afternoteId: Long) -> Unit,
@@ -43,9 +42,20 @@ fun ReceivedAfternoteDetailRoute(
     // 방출하지 않는 refreshOnReturn() 을 쓴다. 첫 진입의 ON_RESUME 스킵(진입은 init 로드가
     // 담당)과 실행 중 로드와의 중복 차단은 VM 이 판단한다 — 결선부는 무조건 부른다.
     LifecycleEventEffect(Lifecycle.Event.ON_RESUME) {
-        viewModel.refreshOnReturn()
+        viewModel.onIntent(ReceivedAfternoteDetailIntent.RefreshOnReturn)
     }
 
+    ReceivedAfternoteDetailContent(uiState, viewModel::onIntent, onNavigateBack, onNavigateToFullList, onNavigateToPlaylist)
+}
+
+@Composable
+private fun ReceivedAfternoteDetailContent(
+    uiState: ReceivedAfternoteDetailUiState,
+    onIntent: (ReceivedAfternoteDetailIntent) -> Unit,
+    onNavigateBack: () -> Unit,
+    onNavigateToFullList: () -> Unit,
+    onNavigateToPlaylist: (Long) -> Unit,
+) {
     when (val state = uiState) {
         ReceivedAfternoteDetailUiState.Loading -> {
             LoadingBody()
@@ -55,7 +65,7 @@ fun ReceivedAfternoteDetailRoute(
             DetailLoadErrorContent(
                 messageRes = state.messageRes,
                 onBackClick = onNavigateBack,
-                onRetryClick = viewModel::retry,
+                onRetryClick = { onIntent(ReceivedAfternoteDetailIntent.Retry) },
             )
         }
 
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/detail/ReceivedAfternoteDetailUiState.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/detail/ReceivedAfternoteDetailUiState.kt
index a2a58e17ff..48821c0e69 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/detail/ReceivedAfternoteDetailUiState.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/detail/ReceivedAfternoteDetailUiState.kt
@@ -1,8 +1,9 @@
 package com.afternote.feature.afternote.presentation.receiver.detail
 
 import androidx.annotation.StringRes
+import com.afternote.core.ui.mvi.UiState
 
-sealed interface ReceivedAfternoteDetailUiState {
+internal sealed interface ReceivedAfternoteDetailUiState : UiState {
     data object Loading : ReceivedAfternoteDetailUiState
 
     data class Success(
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/detail/ReceivedAfternoteDetailViewModel.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/detail/ReceivedAfternoteDetailViewModel.kt
index 9299629625..a8d456466c 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/detail/ReceivedAfternoteDetailViewModel.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/detail/ReceivedAfternoteDetailViewModel.kt
@@ -1,8 +1,8 @@
 package com.afternote.feature.afternote.presentation.receiver.detail
 
-import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.afternote.core.common.reporting.ErrorReporter
+import com.afternote.core.ui.mvi.MviViewModel
 import com.afternote.feature.afternote.presentation.R
 import com.afternote.feature.afternote.presentation.receiver.navigation.ReceivedAfternoteRoute
 import com.afternote.feature.afternote.presentation.reporting.AfternoteFailureStage
@@ -14,10 +14,6 @@ import dagger.assisted.AssistedInject
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.ensureActive
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 
 /**
@@ -32,19 +28,48 @@ import kotlinx.coroutines.launch
  * 수정·삭제·작성자 표시명·수신자 목록은 보유하지 않는다.
  */
 @HiltViewModel(assistedFactory = ReceivedAfternoteDetailViewModel.Factory::class)
-class ReceivedAfternoteDetailViewModel
+internal class ReceivedAfternoteDetailViewModel
     @AssistedInject
     constructor(
         @Assisted private val route: ReceivedAfternoteRoute.DetailRoute,
         private val receiverRepository: ReceiverRepository,
         private val errorReporter: ErrorReporter,
-    ) : ViewModel() {
+    ) : MviViewModel<ReceivedAfternoteDetailIntent, ReceivedAfternoteDetailUiState, ReceivedAfternoteDetailReducerEvent>(
+            ReceivedAfternoteDetailUiState.Loading,
+        ) {
         private val afternoteIdFromNav: Long =
             route.afternoteId
 
-        private val _uiState =
-            MutableStateFlow<ReceivedAfternoteDetailUiState>(ReceivedAfternoteDetailUiState.Loading)
-        val uiState: StateFlow<ReceivedAfternoteDetailUiState> = _uiState.asStateFlow()
+        override fun onIntent(intent: ReceivedAfternoteDetailIntent) {
+            when (intent) {
+                ReceivedAfternoteDetailIntent.Retry -> retry()
+                ReceivedAfternoteDetailIntent.RefreshOnReturn -> refreshOnReturn()
+            }
+        }
+
+        override fun reduce(
+            state: ReceivedAfternoteDetailUiState,
+            event: ReceivedAfternoteDetailReducerEvent,
+        ): ReceivedAfternoteDetailUiState =
+            when (event) {
+                ReceivedAfternoteDetailReducerEvent.Loading -> {
+                    ReceivedAfternoteDetailUiState.Loading
+                }
+
+                is ReceivedAfternoteDetailReducerEvent.ContentLoaded -> {
+                    ReceivedAfternoteDetailUiState.Success(detailId = event.id, contentUiModel = event.content)
+                }
+
+                is ReceivedAfternoteDetailReducerEvent.LoadFailed -> {
+                    if (event.keepsContent &&
+                        state is ReceivedAfternoteDetailUiState.Success
+                    ) {
+                        state
+                    } else {
+                        ReceivedAfternoteDetailUiState.Error(R.string.afternote_detail_load_error)
+                    }
+                }
+            }
 
         /** 진행 중인 상세 조회 — 첫 진입 이후의 ON_RESUME 이 실행 중인 로드와 겹치면 건너뛰기 위한 가드. */
         private var loadJob: Job? = null
@@ -62,7 +87,7 @@ class ReceivedAfternoteDetailViewModel
             loadDetail(afternoteIdFromNav)
         }
 
-        fun retry() {
+        private fun retry() {
             loadDetail(afternoteIdFromNav)
         }
 
@@ -73,7 +98,7 @@ class ReceivedAfternoteDetailViewModel
          * 첫 ON_RESUME(진입 자체)은 [isFirstResume] 로 스킵하고, 그 이후의 resume 이 실행 중인
          * 로드와 겹치면 진행 중인 Job 으로 건너뛴다.
          */
-        fun refreshOnReturn() {
+        private fun refreshOnReturn() {
             if (isFirstResume) {
                 isFirstResume = false
                 return
@@ -91,7 +116,7 @@ class ReceivedAfternoteDetailViewModel
             loadJob =
                 viewModelScope.launch {
                     if (showsLoading) {
-                        _uiState.value = ReceivedAfternoteDetailUiState.Loading
+                        dispatch(ReceivedAfternoteDetailReducerEvent.Loading)
                     }
                     val result = receiverRepository.getReceivedAfternoteDetail(afternoteId = afternoteId)
                     // 새 로드가 이 Job 을 취소했다면 화면은 그쪽이 결정한다. repository 는
@@ -101,23 +126,13 @@ class ReceivedAfternoteDetailViewModel
                     ensureActive()
                     result
                         .onSuccess { detail ->
-                            _uiState.value =
-                                ReceivedAfternoteDetailUiState.Success(
-                                    detailId = afternoteId,
-                                    contentUiModel = detail.toReceivedDetailContentUiModel(),
-                                )
+                            dispatch(
+                                ReceivedAfternoteDetailReducerEvent.ContentLoaded(afternoteId, detail.toReceivedDetailContentUiModel()),
+                            )
                         }.onFailure { e ->
                             // 화면을 유지하는 자동 갱신 실패도 기록한다 — 콘솔이 유일한 관측 지점이다.
                             errorReporter.recordAfternoteFailure(AfternoteFailureStage.RECEIVED_DETAIL_LOAD, e)
-                            _uiState.update { current ->
-                                if (keepsStateOnFailure && current is ReceivedAfternoteDetailUiState.Success) {
-                                    current
-                                } else {
-                                    ReceivedAfternoteDetailUiState.Error(
-                                        messageRes = R.string.afternote_detail_load_error,
-                                    )
-                                }
-                            }
+                            dispatch(ReceivedAfternoteDetailReducerEvent.LoadFailed(keepsStateOnFailure))
                         }
                 }
         }
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/navigation/ReceivedAfternoteNavHost.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/navigation/ReceivedAfternoteNavHost.kt
index bd4d986688..ac35d757ae 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/navigation/ReceivedAfternoteNavHost.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/navigation/ReceivedAfternoteNavHost.kt
@@ -1,26 +1,19 @@
 package com.afternote.feature.afternote.presentation.receiver.navigation
 
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
-import androidx.lifecycle.Lifecycle
-import androidx.lifecycle.compose.LifecycleEventEffect
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.navigation3.runtime.entryProvider
 import androidx.navigation3.runtime.rememberNavBackStack
-import com.afternote.core.ui.loading.LoadingBody
 import com.afternote.core.ui.navigation.FeatureNavDisplay
 import com.afternote.core.ui.navigation.FeatureNavigationCallbacks
 import com.afternote.feature.afternote.presentation.navigation.AfternoteLightTheme
 import com.afternote.feature.afternote.presentation.receiver.afternotelist.ReceiverAfternoteHomeEntry
 import com.afternote.feature.afternote.presentation.receiver.detail.ReceivedAfternoteDetailRoute
 import com.afternote.feature.afternote.presentation.receiver.detail.ReceivedAfternoteDetailViewModel
-import com.afternote.feature.afternote.presentation.receiver.playlist.MemorialPlaylistScreen
-import com.afternote.feature.afternote.presentation.receiver.playlist.ReceiverMemorialPlaylistUiState
+import com.afternote.feature.afternote.presentation.receiver.playlist.ReceiverMemorialPlaylistRoute
 import com.afternote.feature.afternote.presentation.receiver.playlist.ReceiverMemorialPlaylistViewModel
-import com.afternote.feature.afternote.presentation.shared.detail.DetailLoadErrorContent
 
 /**
  * 수신 애프터노트(목록·상세·추억 플레이리스트)가 소유하는 로컬 Navigation 3 스택.
@@ -72,36 +65,7 @@ public fun ReceivedAfternoteNavHost(
                             hiltViewModel<ReceiverMemorialPlaylistViewModel, ReceiverMemorialPlaylistViewModel.Factory>(
                                 creationCallback = { factory -> factory.create(key) },
                             )
-                        val playlistUiState by playlistViewModel.uiState.collectAsStateWithLifecycle()
-
-                        // 화면을 떠났다 돌아오면 다시 조회한다 — 백스택에 살아 있는 동안 옛 값이 남지 않게
-                        // 한다 (#701). 로딩을 방출하지 않는 refreshOnReturn() 을 쓴다. 첫 진입의 ON_RESUME
-                        // 스킵(진입은 init 로드가 담당)과 실행 중 로드와의 중복 차단은 VM 이 판단한다.
-                        LifecycleEventEffect(Lifecycle.Event.ON_RESUME) {
-                            playlistViewModel.refreshOnReturn()
-                        }
-
-                        when (val state = playlistUiState) {
-                            ReceiverMemorialPlaylistUiState.Loading -> {
-                                LoadingBody()
-                            }
-
-                            is ReceiverMemorialPlaylistUiState.Error -> {
-                                DetailLoadErrorContent(
-                                    messageRes = state.messageRes,
-                                    onBackClick = actions::popBack,
-                                    onRetryClick = playlistViewModel::retry,
-                                )
-                            }
-
-                            is ReceiverMemorialPlaylistUiState.Success -> {
-                                MemorialPlaylistScreen(
-                                    senderName = state.senderName,
-                                    songs = state.songs,
-                                    onBackClick = actions::popBack,
-                                )
-                            }
-                        }
+                        ReceiverMemorialPlaylistRoute(viewModel = playlistViewModel, onBackClick = actions::popBack)
                     }
                 }
             },
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/playlist/ReceiverMemorialPlaylistContract.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/playlist/ReceiverMemorialPlaylistContract.kt
new file mode 100644
index 0000000000..fa7eea5711
--- /dev/null
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/playlist/ReceiverMemorialPlaylistContract.kt
@@ -0,0 +1,22 @@
+package com.afternote.feature.afternote.presentation.receiver.playlist
+
+import com.afternote.core.ui.mvi.MviIntent
+import com.afternote.core.ui.mvi.ReducerEvent
+
+internal sealed interface ReceiverMemorialPlaylistIntent : MviIntent {
+    data object Retry : ReceiverMemorialPlaylistIntent
+
+    data object RefreshOnReturn : ReceiverMemorialPlaylistIntent
+}
+
+internal sealed interface ReceiverMemorialPlaylistReducerEvent : ReducerEvent {
+    data object Loading : ReceiverMemorialPlaylistReducerEvent
+
+    data class ContentLoaded(
+        val content: ReceiverMemorialPlaylistUiState.Success,
+    ) : ReceiverMemorialPlaylistReducerEvent
+
+    data class LoadFailed(
+        val keepsContent: Boolean,
+    ) : ReceiverMemorialPlaylistReducerEvent
+}
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/playlist/ReceiverMemorialPlaylistRoute.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/playlist/ReceiverMemorialPlaylistRoute.kt
new file mode 100644
index 0000000000..331495a4c1
--- /dev/null
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/playlist/ReceiverMemorialPlaylistRoute.kt
@@ -0,0 +1,46 @@
+package com.afternote.feature.afternote.presentation.receiver.playlist
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.compose.LifecycleEventEffect
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.afternote.core.ui.loading.LoadingBody
+import com.afternote.feature.afternote.presentation.shared.detail.DetailLoadErrorContent
+
+@Composable
+internal fun ReceiverMemorialPlaylistRoute(
+    viewModel: ReceiverMemorialPlaylistViewModel,
+    onBackClick: () -> Unit,
+) {
+    val state by viewModel.uiState.collectAsStateWithLifecycle()
+    LifecycleEventEffect(Lifecycle.Event.ON_RESUME) {
+        viewModel.onIntent(ReceiverMemorialPlaylistIntent.RefreshOnReturn)
+    }
+    ReceiverMemorialPlaylistContent(state, viewModel::onIntent, onBackClick)
+}
+
+@Composable
+private fun ReceiverMemorialPlaylistContent(
+    state: ReceiverMemorialPlaylistUiState,
+    onIntent: (ReceiverMemorialPlaylistIntent) -> Unit,
+    onBackClick: () -> Unit,
+) {
+    when (state) {
+        ReceiverMemorialPlaylistUiState.Loading -> {
+            LoadingBody()
+        }
+
+        is ReceiverMemorialPlaylistUiState.Error -> {
+            DetailLoadErrorContent(
+                messageRes = state.messageRes,
+                onBackClick = onBackClick,
+                onRetryClick = { onIntent(ReceiverMemorialPlaylistIntent.Retry) },
+            )
+        }
+
+        is ReceiverMemorialPlaylistUiState.Success -> {
+            MemorialPlaylistScreen(senderName = state.senderName, songs = state.songs, onBackClick = onBackClick)
+        }
+    }
+}
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/playlist/ReceiverMemorialPlaylistUiState.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/playlist/ReceiverMemorialPlaylistUiState.kt
index 76770e43a7..b507e72a27 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/playlist/ReceiverMemorialPlaylistUiState.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/playlist/ReceiverMemorialPlaylistUiState.kt
@@ -1,9 +1,10 @@
 package com.afternote.feature.afternote.presentation.receiver.playlist
 
 import androidx.annotation.StringRes
+import com.afternote.core.ui.mvi.UiState
 import com.afternote.feature.afternote.presentation.shared.model.PlaylistSongDisplay
 
-sealed interface ReceiverMemorialPlaylistUiState {
+internal sealed interface ReceiverMemorialPlaylistUiState : UiState {
     data object Loading : ReceiverMemorialPlaylistUiState
 
     data class Success(
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/playlist/ReceiverMemorialPlaylistViewModel.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/playlist/ReceiverMemorialPlaylistViewModel.kt
index 75de8acdaa..a66eaec293 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/playlist/ReceiverMemorialPlaylistViewModel.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/playlist/ReceiverMemorialPlaylistViewModel.kt
@@ -1,8 +1,8 @@
 package com.afternote.feature.afternote.presentation.receiver.playlist
 
-import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.afternote.core.common.reporting.ErrorReporter
+import com.afternote.core.ui.mvi.MviViewModel
 import com.afternote.feature.afternote.presentation.R
 import com.afternote.feature.afternote.presentation.receiver.navigation.ReceivedAfternoteRoute
 import com.afternote.feature.afternote.presentation.reporting.AfternoteFailureStage
@@ -14,10 +14,6 @@ import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.Job
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 
 /**
@@ -27,19 +23,48 @@ import kotlinx.coroutines.launch
  * `X-Auth-Code` 헤더는 ReceiverAuthInterceptor가 자동 부착합니다.
  */
 @HiltViewModel(assistedFactory = ReceiverMemorialPlaylistViewModel.Factory::class)
-class ReceiverMemorialPlaylistViewModel
+internal class ReceiverMemorialPlaylistViewModel
     @AssistedInject
     constructor(
         @Assisted private val route: ReceivedAfternoteRoute.MemorialPlaylistRoute,
         private val receiverRepository: ReceiverRepository,
         private val errorReporter: ErrorReporter,
-    ) : ViewModel() {
+    ) : MviViewModel<ReceiverMemorialPlaylistIntent, ReceiverMemorialPlaylistUiState, ReceiverMemorialPlaylistReducerEvent>(
+            ReceiverMemorialPlaylistUiState.Loading,
+        ) {
         private val afternoteIdFromNav: Long =
             route.afternoteId
 
-        private val _uiState =
-            MutableStateFlow<ReceiverMemorialPlaylistUiState>(ReceiverMemorialPlaylistUiState.Loading)
-        val uiState: StateFlow<ReceiverMemorialPlaylistUiState> = _uiState.asStateFlow()
+        override fun onIntent(intent: ReceiverMemorialPlaylistIntent) {
+            when (intent) {
+                ReceiverMemorialPlaylistIntent.Retry -> retry()
+                ReceiverMemorialPlaylistIntent.RefreshOnReturn -> refreshOnReturn()
+            }
+        }
+
+        override fun reduce(
+            state: ReceiverMemorialPlaylistUiState,
+            event: ReceiverMemorialPlaylistReducerEvent,
+        ): ReceiverMemorialPlaylistUiState =
+            when (event) {
+                ReceiverMemorialPlaylistReducerEvent.Loading -> {
+                    ReceiverMemorialPlaylistUiState.Loading
+                }
+
+                is ReceiverMemorialPlaylistReducerEvent.ContentLoaded -> {
+                    event.content
+                }
+
+                is ReceiverMemorialPlaylistReducerEvent.LoadFailed -> {
+                    if (event.keepsContent &&
+                        state is ReceiverMemorialPlaylistUiState.Success
+                    ) {
+                        state
+                    } else {
+                        ReceiverMemorialPlaylistUiState.Error(R.string.afternote_receiver_memorial_playlist_load_error)
+                    }
+                }
+            }
 
         /** 진행 중인 조회 — 첫 진입 이후의 ON_RESUME 이 실행 중인 로드와 겹치면 건너뛰기 위한 가드. */
         private var loadJob: Job? = null
@@ -57,7 +82,7 @@ class ReceiverMemorialPlaylistViewModel
             loadPlaylist(afternoteIdFromNav)
         }
 
-        fun retry() {
+        private fun retry() {
             loadPlaylist(afternoteIdFromNav)
         }
 
@@ -68,7 +93,7 @@ class ReceiverMemorialPlaylistViewModel
          * 첫 ON_RESUME(진입 자체)은 [isFirstResume] 로 스킵하고, 그 이후의 resume 이 실행 중인
          * 로드와 겹치면 진행 중인 Job 으로 건너뛴다.
          */
-        fun refreshOnReturn() {
+        private fun refreshOnReturn() {
             if (isFirstResume) {
                 isFirstResume = false
                 return
@@ -84,7 +109,7 @@ class ReceiverMemorialPlaylistViewModel
         ) {
             loadJob?.cancel()
             if (showsLoading) {
-                _uiState.value = ReceiverMemorialPlaylistUiState.Loading
+                dispatch(ReceiverMemorialPlaylistReducerEvent.Loading)
             }
             loadJob =
                 viewModelScope.launch {
@@ -103,25 +128,20 @@ class ReceiverMemorialPlaylistViewModel
                                             albumImageUrl = song.coverUrl,
                                         )
                                     }.orEmpty()
-                            _uiState.value =
-                                ReceiverMemorialPlaylistUiState.Success(
-                                    senderName = detail.senderName,
-                                    songs = songs,
-                                    memorialVideoUrl = playlist?.memorialVideoUrl,
-                                    memorialThumbnailUrl = playlist?.memorialThumbnailUrl,
-                                )
+                            dispatch(
+                                ReceiverMemorialPlaylistReducerEvent.ContentLoaded(
+                                    ReceiverMemorialPlaylistUiState.Success(
+                                        senderName = detail.senderName,
+                                        songs = songs,
+                                        memorialVideoUrl = playlist?.memorialVideoUrl,
+                                        memorialThumbnailUrl = playlist?.memorialThumbnailUrl,
+                                    ),
+                                ),
+                            )
                         }.onFailure { e ->
                             // 화면을 유지하는 자동 갱신 실패도 기록한다 — 콘솔이 유일한 관측 지점이다.
                             errorReporter.recordAfternoteFailure(AfternoteFailureStage.RECEIVED_PLAYLIST_LOAD, e)
-                            _uiState.update { current ->
-                                if (keepsStateOnFailure && current is ReceiverMemorialPlaylistUiState.Success) {
-                                    current
-                                } else {
-                                    ReceiverMemorialPlaylistUiState.Error(
-                                        messageRes = R.string.afternote_receiver_memorial_playlist_load_error,
-                                    )
-                                }
-                            }
+                            dispatch(ReceiverMemorialPlaylistReducerEvent.LoadFailed(keepsStateOnFailure))
                         }
                 }
         }
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/playlist/ReceiverPlayListScreen.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/playlist/ReceiverPlayListScreen.kt
index ac4b8264f7..55ff069f26 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/playlist/ReceiverPlayListScreen.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/receiver/playlist/ReceiverPlayListScreen.kt
@@ -1,18 +1,14 @@
 package com.afternote.feature.afternote.presentation.receiver.playlist
 
 import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
-import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.unit.dp
-import com.afternote.core.ui.theme.AfternoteDesign
 import com.afternote.feature.afternote.presentation.R
 import com.afternote.feature.afternote.presentation.shared.detail.PlaylistEmptyContent
+import com.afternote.feature.afternote.presentation.shared.detail.PlaylistSongCountHeader
 import com.afternote.feature.afternote.presentation.shared.detail.PlaylistSongList
 import com.afternote.feature.afternote.presentation.shared.detail.SongPlaylistScaffold
 import com.afternote.feature.afternote.presentation.shared.model.PlaylistSongDisplay
@@ -24,7 +20,7 @@ import com.afternote.feature.afternote.presentation.shared.model.PlaylistSongDis
  * (발신자 화면의 "추억 플레이리스트" 와 달리 유족 관점, #274).
  *
  * 공용 부품([SongPlaylistScaffold] + [PlaylistSongList])을 직접 조립한다. 헤더는 발신자 열람 화면
- * (MemorialPlaylistEntry 목록 모드)과 같은 "총 N곡" 이다 — 곡 검색 헤더는 곡을 골라 담는 화면
+ * (MemorialPlaylistEntry 목록 모드)과 같은 [PlaylistSongCountHeader] 다 — 곡 검색 헤더는 곡을 골라 담는 화면
  * (AddSongScreen)의 것이라, 열람만 하는 수신자에게는 고인의 플레이리스트에 곡을 더할 수 있는 것처럼
  * 보였다 (#620).
  */
@@ -49,7 +45,7 @@ fun MemorialPlaylistScreen(
             PlaylistSongList(
                 modifier = Modifier.fillMaxSize(),
                 songs = songs,
-                header = { ReceiverPlaylistSongCountHeader(songCount = songs.size) },
+                header = { PlaylistSongCountHeader(songCount = songs.size) },
             )
             if (songs.isEmpty()) {
                 PlaylistEmptyContent(
@@ -60,26 +56,3 @@ fun MemorialPlaylistScreen(
         }
     }
 }
-
-/** 발신자 열람 화면의 "총 N곡" 헤더와 같은 자리·같은 문안. 모듈이 달라 사본을 둔다. */
-@Composable
-private fun ReceiverPlaylistSongCountHeader(
-    songCount: Int,
-    modifier: Modifier = Modifier,
-) {
-    // 헤더 상단 간격은 헤더별로 다르다 — 곡 수 헤더는 8dp (발신자 화면과 동일).
-    Column(
-        modifier =
-            modifier
-                .fillMaxWidth()
-                .padding(top = 8.dp),
-    ) {
-        Text(
-            text = stringResource(R.string.afternote_receiver_playlist_song_count_format, songCount),
-            style =
-                AfternoteDesign.typography.bodySmallR.copy(
-                    color = AfternoteDesign.colors.gray9,
-                ),
-        )
-    }
-}
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/shared/detail/PlaylistSongList.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/shared/detail/PlaylistSongList.kt
index 9af5bbf120..783a85d809 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/shared/detail/PlaylistSongList.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/shared/detail/PlaylistSongList.kt
@@ -36,7 +36,7 @@ import com.afternote.feature.afternote.presentation.shared.model.PlaylistSongDis
  *
  * 이 리스트는 필터도 검색도 소유하지 않는다 — [songs] 를 받은 그대로 그리고, 상단 헤더는 호출부가
  * [header] 로 주입한다(필수 — 모든 호출부가 헤더를 가진다). 곡을 골라 담는 화면(AddSong)은
- * [SongSearchSection] 을 헤더로 주입하고, 열람·관리 화면은 "총 N곡" 헤더를 주입한다 — 즉 검색은 "여러
+ * [SongSearchSection] 을 헤더로 주입하고, 열람·관리 화면은 [PlaylistSongCountHeader] 를 주입한다 — 즉 검색은 "여러
  * 헤더 중 하나"일 뿐 리스트의 고정 지식이 아니다. 리스트가 내부 필터·검색을 갖던 시절엔 API 결과
  * 이중 필터·죽은 검색 바인딩 문제가 있어 둘 다 호출부로 넘겼다 (2026-07).
  * 구명 SearchableSongList — addsong 패키지 태생이라 "추가용 검색" 함의가 남아
@@ -110,7 +110,7 @@ private fun rememberSongSearchFieldState(
 
 /**
  * 곡 검색 헤더 (label + 입력창). [PlaylistSongList] 의 헤더 슬롯에 주입해 쓰는 여러 헤더 중 하나 —
- * view-only(수신자 열람)·selectable(노래 추가)이 주입한다. 관리 모드는 대신 "총 N곡" 헤더를 주입한다.
+ * selectable(노래 추가)이 주입한다. 열람·관리 화면은 대신 [PlaylistSongCountHeader] 를 주입한다.
  */
 @Composable
 fun SongSearchSection(
@@ -144,4 +144,32 @@ fun SongSearchSection(
     }
 }
 
+/**
+ * "총 N곡" 헤더. [PlaylistSongList] 의 헤더 슬롯에 주입해 쓰는 여러 헤더 중 하나 — 발신자 추억
+ * 플레이리스트(MemorialPlaylistEntry 목록·편집 모드)와 수신자 플레이리스트 전체보기
+ * (MemorialPlaylistScreen)가 주입한다. 수신자 헤더는 발신자 열람 헤더와 같아야 해서(#620)
+ * 두 화면이 이 하나를 쓴다.
+ */
+@Composable
+internal fun PlaylistSongCountHeader(
+    songCount: Int,
+    modifier: Modifier = Modifier,
+) {
+    // 헤더 상단 간격은 헤더별로 달라(검색 16 / 곡 수 8) 리스트가 아닌 각 헤더가 top 여백을 소유한다.
+    Column(
+        modifier =
+            modifier
+                .fillMaxWidth()
+                .padding(top = 8.dp),
+    ) {
+        Text(
+            text = stringResource(R.string.afternote_playlist_song_count_format, songCount),
+            style =
+                AfternoteDesign.typography.bodySmallR.copy(
+                    color = AfternoteDesign.colors.gray9,
+                ),
+        )
+    }
+}
+
 // endregion
diff --git a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/shared/fingerprint/FingerprintLoginRoute.kt b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/shared/fingerprint/FingerprintLoginRoute.kt
index 5cc3dcfcf2..e617f5b2cd 100644
--- a/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/shared/fingerprint/FingerprintLoginRoute.kt
+++ b/feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/shared/fingerprint/FingerprintLoginRoute.kt
@@ -10,6 +10,9 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.fragment.app.FragmentActivity
+import com.afternote.core.common.biometric.BiometricAuthResult
+import com.afternote.core.common.biometric.BiometricMessages
+import com.afternote.core.common.biometric.authenticateBiometric
 import com.afternote.core.ui.findActivity
 import com.afternote.feature.afternote.presentation.R
 import kotlinx.coroutines.launch
diff --git a/feature/afternote/presentation/src/main/res/values/strings.xml b/feature/afternote/presentation/src/main/res/values/strings.xml
index 60ba2a0a99..195f92e311 100644
--- a/feature/afternote/presentation/src/main/res/values/strings.xml
+++ b/feature/afternote/presentation/src/main/res/values/strings.xml
@@ -3,6 +3,7 @@
     <string name="afternote_home_title">애프터노트</string>
     <string name="afternote_song_search_label">노래 검색</string>
     <string name="afternote_song_search_placeholder">노래 검색하기</string>
+    <string name="afternote_playlist_song_count_format">총 %1$d곡</string>
     <string name="afternote_add_button">추가하기</string>
 
     <string name="afternote_content_description_album_cover">앨범 커버</string>
@@ -133,7 +134,6 @@
     <string name="afternote_editor_service_search_empty">검색 결과가 없습니다.</string>
     <string name="afternote_editor_playlist_screen_title">추억 플레이리스트</string>
     <string name="afternote_editor_playlist_add_screen_title">플레이리스트 추가</string>
-    <string name="afternote_editor_playlist_song_count_format">총 %1$d곡</string>
     <string name="afternote_editor_playlist_empty_message">아직 추가한 곡이 없어요.\n아래 연필 버튼을 눌러 곡을 추가해 보세요.</string>
     <string name="afternote_editor_playlist_delete_all">전체 삭제</string>
     <string name="afternote_editor_playlist_delete_selected">선택 삭제</string>
@@ -156,6 +156,7 @@
          말하지 않는다 — 곧 도착하므로 기다리면 저장할 수 있다. -->
     <string name="afternote_editor_prefill_not_ready">기존 내용을 불러오는 중입니다.\n잠시 후 다시 시도해 주세요.</string>
     <string name="afternote_editor_prefill_retry">다시 불러오기</string>
+    <string name="afternote_editor_media_size_exceeded">파일 크기가 업로드 허용 한도를 초과했습니다.</string>
     <string name="afternote_editor_thumbnail_upload_failed">영상 미리보기를 올리지 못했습니다.</string>
     <string name="afternote_editor_thumbnail_extract_failed">영상에서 미리보기를 만들지 못했습니다.</string>
     <string name="afternote_editor_thumbnail_retry">다시 시도</string>
@@ -191,5 +192,4 @@
     <string name="afternote_receiver_memorial_playlist_load_error">플레이리스트를 불러오지 못했습니다.</string>
     <string name="afternote_receiver_memorial_playlist_screen_title">%1$s님의 플레이리스트</string>
     <string name="afternote_receiver_playlist_empty_message">고인이 남긴 곡이 없어요.</string>
-    <string name="afternote_receiver_playlist_song_count_format">총 %1$d곡</string>
 </resources>
diff --git a/feature/afternote/presentation/src/screenshotTest/kotlin/com/afternote/feature/afternote/presentation/detail/DeleteInProgressOverlayScreenshotTest.kt b/feature/afternote/presentation/src/screenshotTest/kotlin/com/afternote/feature/afternote/presentation/detail/DeleteInProgressOverlayScreenshotTest.kt
deleted file mode 100644
index 08188dd016..0000000000
--- a/feature/afternote/presentation/src/screenshotTest/kotlin/com/afternote/feature/afternote/presentation/detail/DeleteInProgressOverlayScreenshotTest.kt
+++ /dev/null
@@ -1,31 +0,0 @@
-package com.afternote.feature.afternote.presentation.detail
-
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.tooling.preview.Preview
-import com.afternote.core.ui.theme.AfternoteTheme
-import com.android.tools.screenshot.PreviewTest
-
-/**
- * [DeleteInProgressOverlay] 는 상세 화면 위에 겹쳐 그리는 반투명 스크림이라
- * 하위 콘텐츠를 어둡게 덮는 alpha 효과가 핵심이다. 뒤에 더미 콘텐츠를 깔고
- * 그 위에 오버레이를 얹어 스크림 대비와 중앙 인디케이터를 함께 회귀 검증한다.
- */
-@PreviewTest
-@Preview(showBackground = true)
-@Composable
-internal fun deleteInProgressOverlayScreenshot() {
-    AfternoteTheme {
-        Box(
-            modifier = Modifier.fillMaxSize(),
-            contentAlignment = Alignment.Center,
-        ) {
-            Text(text = "상세 콘텐츠")
-            DeleteInProgressOverlay()
-        }
-    }
-}
diff --git a/feature/afternote/presentation/src/screenshotTest/kotlin/com/afternote/feature/afternote/presentation/editor/EditorPrefillSkeletonScreenshotTest.kt b/feature/afternote/presentation/src/screenshotTest/kotlin/com/afternote/feature/afternote/presentation/editor/EditorPrefillSkeletonScreenshotTest.kt
index d2769262ff..2df608e3ef 100644
--- a/feature/afternote/presentation/src/screenshotTest/kotlin/com/afternote/feature/afternote/presentation/editor/EditorPrefillSkeletonScreenshotTest.kt
+++ b/feature/afternote/presentation/src/screenshotTest/kotlin/com/afternote/feature/afternote/presentation/editor/EditorPrefillSkeletonScreenshotTest.kt
@@ -1,6 +1,8 @@
 package com.afternote.feature.afternote.presentation.editor
 
+import androidx.compose.material3.SnackbarHostState
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
 import androidx.compose.ui.tooling.preview.Preview
 import com.afternote.core.ui.theme.AfternoteTheme
 import com.afternote.feature.afternote.domain.AfternoteType
@@ -37,10 +39,16 @@ private fun EditorPrefillSkeletonScreenshotFixture(type: AfternoteType) {
             state.currentForm().copy(
                 typeForm = AfternoteTypeForm.pristineFor(type),
             )
-        EditorContent(
+        AfternoteEditorBody(
             state = state,
             form = form,
-            typeContent = {},
+            onNavigateToMemorialPlaylist = {},
+            onNavigateToSelectReceiver = {},
+            onThumbnailBytesReady = {},
+            onThumbnailExtractionFailed = {},
+            thumbnailRetryToken = 0,
+            onCaptureFailed = {},
+            snackbarHostState = remember { SnackbarHostState() },
             isPrefillLoading = true,
         )
     }
diff --git a/feature/afternote/presentation/src/screenshotTest/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongScreenScreenshotTest.kt b/feature/afternote/presentation/src/screenshotTest/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongScreenScreenshotTest.kt
index d613340591..dc892b50a0 100644
--- a/feature/afternote/presentation/src/screenshotTest/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongScreenScreenshotTest.kt
+++ b/feature/afternote/presentation/src/screenshotTest/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongScreenScreenshotTest.kt
@@ -25,8 +25,7 @@ internal fun addSongScreenScreenshot() {
     AfternoteTheme {
         AddSongScreen(
             uiState = AddSongUiState(songs = SAMPLE_SONGS),
-            onSearchQueryChange = {},
-            onErrorConsumed = {},
+            onIntent = {},
             onBackClick = {},
             onSongsAdded = {},
         )
@@ -45,8 +44,7 @@ internal fun addSongScreenCompactScreenshot() {
     AfternoteTheme {
         AddSongScreen(
             uiState = AddSongUiState(songs = SAMPLE_SONGS),
-            onSearchQueryChange = {},
-            onErrorConsumed = {},
+            onIntent = {},
             onBackClick = {},
             onSongsAdded = {},
         )
diff --git a/feature/afternote/presentation/src/screenshotTest/kotlin/com/afternote/feature/afternote/presentation/editor/selection/EditorServiceSelectionSheetScreenshotTest.kt b/feature/afternote/presentation/src/screenshotTest/kotlin/com/afternote/feature/afternote/presentation/editor/selection/EditorServiceSelectionSheetScreenshotTest.kt
index 65048ea255..df12945e2f 100644
--- a/feature/afternote/presentation/src/screenshotTest/kotlin/com/afternote/feature/afternote/presentation/editor/selection/EditorServiceSelectionSheetScreenshotTest.kt
+++ b/feature/afternote/presentation/src/screenshotTest/kotlin/com/afternote/feature/afternote/presentation/editor/selection/EditorServiceSelectionSheetScreenshotTest.kt
@@ -17,8 +17,9 @@ import com.android.tools.screenshot.PreviewTest
 @Composable
 internal fun editorServiceSelectionSheetScreenshot() {
     AfternoteTheme {
-        EditorServiceSelectionSheetContent(
-            title = "소셜 네트워크 서비스 선택",
+        EditorServiceSelectionSheet(
+            visible = true,
+            onDismissRequest = {},
             type = AfternoteType.SOCIAL_NETWORK,
             services = AfternoteServiceCatalog.socialServices,
             searchQueryState = rememberTextFieldState(),
@@ -32,8 +33,9 @@ internal fun editorServiceSelectionSheetScreenshot() {
 @Composable
 internal fun editorServiceSelectionSheetEmptySearchScreenshot() {
     AfternoteTheme {
-        EditorServiceSelectionSheetContent(
-            title = "갤러리 및 파일 서비스 선택",
+        EditorServiceSelectionSheet(
+            visible = true,
+            onDismissRequest = {},
             type = AfternoteType.GALLERY_AND_FILES,
             services = AfternoteServiceCatalog.galleryServices,
             searchQueryState = rememberTextFieldState("없는 서비스"),
diff --git a/feature/afternote/presentation/src/screenshotTestDebug/reference/com/afternote/feature/afternote/presentation/detail/DeleteInProgressOverlayScreenshotTestKt/deleteInProgressOverlayScreenshot_748aa731_0.png b/feature/afternote/presentation/src/screenshotTestDebug/reference/com/afternote/feature/afternote/presentation/detail/DeleteInProgressOverlayScreenshotTestKt/deleteInProgressOverlayScreenshot_748aa731_0.png
deleted file mode 100644
index b48725f942..0000000000
Binary files a/feature/afternote/presentation/src/screenshotTestDebug/reference/com/afternote/feature/afternote/presentation/detail/DeleteInProgressOverlayScreenshotTestKt/deleteInProgressOverlayScreenshot_748aa731_0.png and /dev/null differ
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/AfternoteAuthorExtendedTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/AfternoteAuthorExtendedTest.kt
index f9be259976..c41a4669fd 100644
--- a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/AfternoteAuthorExtendedTest.kt
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/AfternoteAuthorExtendedTest.kt
@@ -44,13 +44,16 @@ import com.afternote.feature.afternote.domain.repository.author.MemorialMediaUpl
 import com.afternote.feature.afternote.domain.repository.author.MemorialThumbnailUploadRepository
 import com.afternote.feature.afternote.domain.testing.FakeAfternoteRepository
 import com.afternote.feature.afternote.domain.usecase.editor.ResolveMemorialMediaForSaveUseCase
+import com.afternote.feature.afternote.domain.usecase.editor.SaveAfternoteUseCase
 import com.afternote.feature.afternote.presentation.R
 import com.afternote.feature.afternote.presentation.detail.AfternoteDetailDeleteResult
+import com.afternote.feature.afternote.presentation.detail.AfternoteDetailIntent
 import com.afternote.feature.afternote.presentation.detail.AfternoteDetailUiState
 import com.afternote.feature.afternote.presentation.detail.AfternoteDetailViewModel
 import com.afternote.feature.afternote.presentation.detail.DetailContentUiModel
 import com.afternote.feature.afternote.presentation.detail.account.AccountDetailScreen
 import com.afternote.feature.afternote.presentation.editor.AfternoteEditorBody
+import com.afternote.feature.afternote.presentation.editor.AfternoteEditorIntent
 import com.afternote.feature.afternote.presentation.editor.AfternoteEditorScreen
 import com.afternote.feature.afternote.presentation.editor.AfternoteEditorViewModel
 import com.afternote.feature.afternote.presentation.editor.SaveAfternoteMemorialMedia
@@ -132,7 +135,7 @@ class AfternoteAuthorExtendedTest {
             .onNode(hasSetTextAction() and hasText("old@example.test"))
             .performTextReplacement("edited@example.test")
         composeRule.runOnIdle {
-            checkNotNull(editorViewModel).editProcessingMethod(1, "계정 보존")
+            checkNotNull(editorViewModel).onIntent(AfternoteEditorIntent.EditProcessingMethod(1, "계정 보존"))
         }
         composeRule.onNodeWithText("계정 보존").performScrollTo().assertIsDisplayed()
         val topBarRegister =
@@ -190,7 +193,7 @@ class AfternoteAuthorExtendedTest {
 
         composeRule.runOnIdle { checkNotNull(editorState).dismissServiceSelectionSheet() }
         composeRule.onNodeWithText("소셜 네트워크 서비스 선택").assertDoesNotExist()
-        assertEquals("Instagram", viewModel.currentForm().selectedService)
+        assertEquals("Instagram", viewModel.uiState.value.form.selectedService)
         assertEquals("", checkNotNull(editorState).serviceSearchQueryState.text.toString())
 
         composeRule.onNodeWithText("Instagram").performClick()
@@ -200,7 +203,7 @@ class AfternoteAuthorExtendedTest {
 
         composeRule.onNodeWithText("소셜 네트워크 서비스 선택").assertDoesNotExist()
         composeRule.onNodeWithText("페이스북").assertIsDisplayed()
-        assertEquals("페이스북", viewModel.currentForm().selectedService)
+        assertEquals("페이스북", viewModel.uiState.value.form.selectedService)
         assertEquals("", checkNotNull(editorState).serviceSearchQueryState.text.toString())
     }
 
@@ -357,21 +360,27 @@ private fun AuthorEditorForUpdate(
     val uiState by viewModel.uiState.collectAsStateWithLifecycle()
     val state =
         rememberAfternoteEditorState(
-            getCurrentForm = viewModel::currentForm,
-            setType = viewModel::setType,
-            setService = viewModel::setService,
-            setMemorialPhoto = viewModel::setMemorialPhoto,
-            removeMemorialPhoto = viewModel::removeMemorialPhoto,
-            setMemorialVideo = viewModel::setMemorialVideo,
-            removeMemorialVideo = viewModel::removeMemorialVideo,
-            addReceiverIfAbsent = viewModel::addReceiverIfAbsent,
-            applyPrefill = viewModel::applyPrefill,
-            setMemorialThumbnail = viewModel::setMemorialThumbnail,
-            deleteReceiver = viewModel::deleteReceiver,
-            replaceReceiversIfEmpty = viewModel::replaceReceiversIfEmpty,
-            addProcessingMethod = viewModel::addProcessingMethod,
-            deleteProcessingMethod = viewModel::deleteProcessingMethod,
-            editProcessingMethod = viewModel::editProcessingMethod,
+            getCurrentForm = { viewModel.uiState.value.form },
+            setType = { type -> viewModel.onIntent(AfternoteEditorIntent.SetType(type)) },
+            setService = { service -> viewModel.onIntent(AfternoteEditorIntent.SetService(service)) },
+            setMemorialPhoto = { uri -> viewModel.onIntent(AfternoteEditorIntent.SetMemorialPhoto(uri)) },
+            removeMemorialPhoto = { viewModel.onIntent(AfternoteEditorIntent.RemoveMemorialPhoto) },
+            setMemorialVideo = { url -> viewModel.onIntent(AfternoteEditorIntent.SetMemorialVideo(url)) },
+            removeMemorialVideo = { viewModel.onIntent(AfternoteEditorIntent.RemoveMemorialVideo) },
+            addReceiverIfAbsent = {
+                receiverId,
+                name,
+                label,
+                ->
+                viewModel.onIntent(AfternoteEditorIntent.AddReceiverIfAbsent(receiverId, name, label))
+            },
+            applyPrefill = { prefill -> viewModel.onIntent(AfternoteEditorIntent.ApplyPrefill(prefill)) },
+            setMemorialThumbnail = { dataUrl -> viewModel.onIntent(AfternoteEditorIntent.SetMemorialThumbnail(dataUrl)) },
+            deleteReceiver = { receiverId -> viewModel.onIntent(AfternoteEditorIntent.DeleteReceiver(receiverId)) },
+            replaceReceiversIfEmpty = { receivers -> viewModel.onIntent(AfternoteEditorIntent.ReplaceReceiversIfEmpty(receivers)) },
+            addProcessingMethod = { text -> viewModel.onIntent(AfternoteEditorIntent.AddProcessingMethod(text)) },
+            deleteProcessingMethod = { localId -> viewModel.onIntent(AfternoteEditorIntent.DeleteProcessingMethod(localId)) },
+            editProcessingMethod = { localId, newText -> viewModel.onIntent(AfternoteEditorIntent.EditProcessingMethod(localId, newText)) },
         )
     onStateReady(state)
 
@@ -379,7 +388,7 @@ private fun AuthorEditorForUpdate(
     LaunchedEffect(pendingPrefill) {
         if (pendingPrefill != null) {
             state.applyFormPrefill(pendingPrefill)
-            viewModel.onPrefillConsumed()
+            viewModel.onIntent(AfternoteEditorIntent.ConsumePrefill)
         }
     }
 
@@ -398,10 +407,12 @@ private fun AuthorEditorForUpdate(
                     password = state.passwordState.text.toString(),
                     date = LocalDate.of(2026, 8, 22),
                 )
-            viewModel.saveAfternote(
-                payload = payload,
-                selectedReceiverIds = form.afternoteEditReceivers.map { it.id.toLong() },
-                memorialMedia = SaveAfternoteMemorialMedia(),
+            viewModel.onIntent(
+                AfternoteEditorIntent.Save(
+                    payload = payload,
+                    selectedReceiverIds = form.afternoteEditReceivers.map { it.id.toLong() },
+                    memorialMedia = SaveAfternoteMemorialMedia(),
+                ),
             )
         },
         snackbarMessage = null,
@@ -410,10 +421,10 @@ private fun AuthorEditorForUpdate(
                 stringResource(it.reason.messageResId)
             },
         onSnackbarMessageConsumed = {
-            errorEvent?.let(viewModel::onErrorConsumed)
+            errorEvent?.let({ consumed -> viewModel.onIntent(AfternoteEditorIntent.ConsumeError(consumed)) })
         },
         onValidationMessageConsumed = {
-            errorEvent?.let(viewModel::onErrorConsumed)
+            errorEvent?.let({ consumed -> viewModel.onIntent(AfternoteEditorIntent.ConsumeError(consumed)) })
         },
         content = { editorSnackbarHostState ->
             AfternoteEditorBody(
@@ -453,12 +464,12 @@ private fun AuthorDetailForDelete(
                         result.messageRes ?: AfternoteFeatureR.string.afternote_detail_delete_failed,
                     )
                 scope.launch { snackbarHostState.showSnackbar(message) }
-                viewModel.onDeleteResultConsumed()
+                viewModel.onIntent(AfternoteDetailIntent.ConsumeDeleteResult)
             }
 
             is AfternoteDetailDeleteResult.Succeeded -> {
                 deletedIds += result.id
-                viewModel.onDeleteResultConsumed()
+                viewModel.onIntent(AfternoteDetailIntent.ConsumeDeleteResult)
             }
 
             null -> {
@@ -483,7 +494,7 @@ private fun AuthorDetailForDelete(
                 content = account.content,
                 snackbarHostState = snackbarHostState,
                 onEditClick = {},
-                onDeleteConfirm = viewModel::deleteAfternote,
+                onDeleteConfirm = { viewModel.onIntent(AfternoteDetailIntent.Delete) },
             )
         }
     }
@@ -496,7 +507,7 @@ private fun detailViewModel(
     AfternoteDetailViewModel(
         route = AfternoteRoute.DetailRoute(itemId = itemId),
         afternoteRepository = repository,
-        userRepository = afternoteAuthorUserRepository(),
+        myProfileRepository = afternoteAuthorMyProfileRepository(),
         userProfileRepository = afternoteAuthorUserProfileRepository(),
         errorReporter = NoopAuthorErrorReporter,
     )
@@ -516,7 +527,7 @@ private fun editorViewModel(
                 initialType = AfternoteType.SOCIAL_NETWORK,
                 itemId = itemId,
             ),
-        userRepository = afternoteAuthorUserRepository(),
+        userReceiverRepository = afternoteAuthorUserReceiverRepository(),
         afternoteRepository = repository,
         memorialThumbnailUploadRepository =
             MemorialThumbnailUploadRepository {
@@ -546,6 +557,7 @@ private fun editorViewModel(
                         )
                     },
             ),
+        saveAfternoteUseCase = SaveAfternoteUseCase(repository),
         errorReporter = NoopAuthorErrorReporter,
     )
 
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/AfternoteAuthorImplementedCoverageTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/AfternoteAuthorImplementedCoverageTest.kt
index 463ef7ca6a..4240744f34 100644
--- a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/AfternoteAuthorImplementedCoverageTest.kt
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/AfternoteAuthorImplementedCoverageTest.kt
@@ -21,11 +21,14 @@ import com.afternote.feature.afternote.domain.repository.author.MemorialMediaUpl
 import com.afternote.feature.afternote.domain.repository.author.MemorialThumbnailUploadRepository
 import com.afternote.feature.afternote.domain.testing.FakeAfternoteRepository
 import com.afternote.feature.afternote.domain.usecase.editor.ResolveMemorialMediaForSaveUseCase
+import com.afternote.feature.afternote.domain.usecase.editor.SaveAfternoteUseCase
+import com.afternote.feature.afternote.presentation.editor.AfternoteEditorIntent
 import com.afternote.feature.afternote.presentation.editor.AfternoteEditorViewModel
 import com.afternote.feature.afternote.presentation.editor.SaveAfternoteMemorialMedia
 import com.afternote.feature.afternote.presentation.editor.memorial.Song
 import com.afternote.feature.afternote.presentation.editor.message.EditorMessageTextBlock
 import com.afternote.feature.afternote.presentation.editor.model.RegisterAfternotePayload
+import com.afternote.feature.afternote.presentation.editor.state.EditableMemorialPhoto
 import com.afternote.feature.afternote.presentation.editor.state.EditableMemorialVideo
 import com.afternote.feature.afternote.presentation.editor.state.MemorialVideoAttachment
 import org.junit.Assert.assertEquals
@@ -54,21 +57,23 @@ class AfternoteAuthorImplementedCoverageTest {
         collectSaveState(viewModel)
 
         composeRule.runOnIdle {
-            viewModel.setType(AfternoteType.GALLERY_AND_FILES)
-            viewModel.saveAfternote(
-                payload =
-                    RegisterAfternotePayload(
-                        serviceName = "Google Drive",
-                        date = "2026.08.22",
-                        messageBlocks =
-                            listOf(
-                                EditorMessageTextBlock(" 사진 ", " 여행 사진을 보관해 줘 "),
-                                EditorMessageTextBlock("", ""),
-                            ),
-                        processingMethods = listOf("가족에게 폴더 전달"),
-                    ),
-                selectedReceiverIds = listOf(7L, 8L),
-                memorialMedia = SaveAfternoteMemorialMedia(),
+            viewModel.onIntent(AfternoteEditorIntent.SetType(AfternoteType.GALLERY_AND_FILES))
+            viewModel.onIntent(
+                AfternoteEditorIntent.Save(
+                    payload =
+                        RegisterAfternotePayload(
+                            serviceName = "Google Drive",
+                            date = "2026.08.22",
+                            messageBlocks =
+                                listOf(
+                                    EditorMessageTextBlock(" 사진 ", " 여행 사진을 보관해 줘 "),
+                                    EditorMessageTextBlock("", ""),
+                                ),
+                            processingMethods = listOf("가족에게 폴더 전달"),
+                        ),
+                    selectedReceiverIds = listOf(7L, 8L),
+                    memorialMedia = SaveAfternoteMemorialMedia(),
+                ),
             )
         }
 
@@ -99,19 +104,21 @@ class AfternoteAuthorImplementedCoverageTest {
         collectSaveState(viewModel)
 
         composeRule.runOnIdle {
-            viewModel.setType(AfternoteType.BUSINESS)
-            viewModel.saveAfternote(
-                payload =
-                    RegisterAfternotePayload(
-                        serviceName = "회사 그룹웨어",
-                        date = "2026.08.22",
-                        accountId = "employee@example.test",
-                        password = "business-password",
-                        messageBlocks = listOf(EditorMessageTextBlock("인수인계", "팀장에게 전달해 줘")),
-                        processingMethods = listOf("계정 인계"),
-                    ),
-                selectedReceiverIds = listOf(8L),
-                memorialMedia = SaveAfternoteMemorialMedia(),
+            viewModel.onIntent(AfternoteEditorIntent.SetType(AfternoteType.BUSINESS))
+            viewModel.onIntent(
+                AfternoteEditorIntent.Save(
+                    payload =
+                        RegisterAfternotePayload(
+                            serviceName = "회사 그룹웨어",
+                            date = "2026.08.22",
+                            accountId = "employee@example.test",
+                            password = "business-password",
+                            messageBlocks = listOf(EditorMessageTextBlock("인수인계", "팀장에게 전달해 줘")),
+                            processingMethods = listOf("계정 인계"),
+                        ),
+                    selectedReceiverIds = listOf(8L),
+                    memorialMedia = SaveAfternoteMemorialMedia(),
+                ),
             )
         }
 
@@ -157,25 +164,30 @@ class AfternoteAuthorImplementedCoverageTest {
             )
 
         composeRule.runOnIdle {
-            viewModel.setType(AfternoteType.MEMORIAL)
-            viewModel.addMemorialPlaylistSongs(songs)
-            viewModel.saveAfternote(
-                payload =
-                    RegisterAfternotePayload(
-                        serviceName = "추억 노트",
-                        date = "2026.08.22",
-                    ),
-                selectedReceiverIds = listOf(7L),
-                memorialMedia =
-                    SaveAfternoteMemorialMedia(
-                        memorialVideo =
-                            EditableMemorialVideo
-                                .empty()
-                                .withSelection("content://videos/farewell")
-                                .withSelectionThumbnail("https://cdn.test/thumbnail.jpg"),
-                        memorialPhotoUrl = "https://cdn.test/old-photo.jpg",
-                        pickedMemorialPhotoUri = "content://photos/new-portrait",
-                    ),
+            viewModel.onIntent(AfternoteEditorIntent.SetType(AfternoteType.MEMORIAL))
+            viewModel.onIntent(AfternoteEditorIntent.AddMemorialPlaylistSongs(songs))
+            viewModel.onIntent(
+                AfternoteEditorIntent.Save(
+                    payload =
+                        RegisterAfternotePayload(
+                            serviceName = "추억 노트",
+                            date = "2026.08.22",
+                        ),
+                    selectedReceiverIds = listOf(7L),
+                    memorialMedia =
+                        SaveAfternoteMemorialMedia(
+                            memorialVideo =
+                                EditableMemorialVideo
+                                    .empty()
+                                    .withSelection("content://videos/farewell")
+                                    .withSelectionThumbnail("https://cdn.test/thumbnail.jpg"),
+                            memorialPhoto =
+                                EditableMemorialPhoto
+                                    .fromPersisted(
+                                        "https://cdn.test/old-photo.jpg",
+                                    ).withSelection("content://photos/new-portrait"),
+                        ),
+                ),
             )
         }
 
@@ -230,16 +242,18 @@ class AfternoteAuthorImplementedCoverageTest {
         composeRule.setContent { AfternoteTheme {} }
 
         composeRule.runOnIdle {
-            first.setType(AfternoteType.MEMORIAL)
-            first.setMemorialVideo("content://videos/farewell")
-            first.setMemorialPhoto("content://photos/portrait")
-            first.setMemorialThumbnail("https://cdn.test/thumbnail.jpg")
-            first.addMemorialPlaylistSongs(
-                listOf(Song("91", "첫 번째 노래", "가수 A", "https://cdn.test/cover.jpg")),
+            first.onIntent(AfternoteEditorIntent.SetType(AfternoteType.MEMORIAL))
+            first.onIntent(AfternoteEditorIntent.SetMemorialVideo("content://videos/farewell"))
+            first.onIntent(AfternoteEditorIntent.SetMemorialPhoto("content://photos/portrait"))
+            first.onIntent(AfternoteEditorIntent.SetMemorialThumbnail("https://cdn.test/thumbnail.jpg"))
+            first.onIntent(
+                AfternoteEditorIntent.AddMemorialPlaylistSongs(
+                    listOf(Song("91", "첫 번째 노래", "가수 A", "https://cdn.test/cover.jpg")),
+                ),
             )
         }
 
-        val restored = implementedCoverageViewModel(implementedCoverageRepository(), handle).currentForm()
+        val restored = implementedCoverageViewModel(implementedCoverageRepository(), handle).uiState.value.form
         assertEquals(AfternoteType.MEMORIAL, restored.selectedType)
         assertEquals(
             MemorialVideoAttachment(
@@ -248,7 +262,7 @@ class AfternoteAuthorImplementedCoverageTest {
             ),
             restored.displayedMemorialVideo,
         )
-        assertEquals("content://photos/portrait", restored.pickedMemorialPhotoUri)
+        assertEquals("content://photos/portrait", restored.memorialPhoto?.toSnapshot()?.selection)
         assertEquals(
             listOf(Song("91", "첫 번째 노래", "가수 A", "https://cdn.test/cover.jpg")),
             restored.memorialPlaylistSongs,
@@ -283,7 +297,7 @@ private fun implementedCoverageViewModel(
     AfternoteEditorViewModel(
         route = savedStateHandle.editorFlowRoute(),
         savedStateHandle = savedStateHandle,
-        userRepository = afternoteAuthorUserRepository(),
+        userReceiverRepository = afternoteAuthorUserReceiverRepository(),
         afternoteRepository = repository,
         memorialThumbnailUploadRepository =
             MemorialThumbnailUploadRepository {
@@ -317,5 +331,6 @@ private fun implementedCoverageViewModel(
                         )
                     },
             ),
+        saveAfternoteUseCase = SaveAfternoteUseCase(repository),
         errorReporter = NoopAuthorErrorReporter,
     )
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/AfternoteAuthorTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/AfternoteAuthorTest.kt
index cf1abb0655..bb23b67937 100644
--- a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/AfternoteAuthorTest.kt
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/AfternoteAuthorTest.kt
@@ -13,6 +13,8 @@ import com.afternote.feature.afternote.domain.repository.author.MemorialMediaUpl
 import com.afternote.feature.afternote.domain.repository.author.MemorialThumbnailUploadRepository
 import com.afternote.feature.afternote.domain.testing.FakeAfternoteRepository
 import com.afternote.feature.afternote.domain.usecase.editor.ResolveMemorialMediaForSaveUseCase
+import com.afternote.feature.afternote.domain.usecase.editor.SaveAfternoteUseCase
+import com.afternote.feature.afternote.presentation.editor.AfternoteEditorIntent
 import com.afternote.feature.afternote.presentation.editor.AfternoteEditorViewModel
 import com.afternote.feature.afternote.presentation.editor.SaveAfternoteMemorialMedia
 import com.afternote.feature.afternote.presentation.editor.message.EditorMessageTextBlock
@@ -47,11 +49,13 @@ class AfternoteAuthorTest {
         }
 
         composeRule.runOnIdle {
-            viewModel.setType(AfternoteType.SOCIAL_NETWORK)
-            viewModel.saveAfternote(
-                payload = validSocialPayload(),
-                selectedReceiverIds = emptyList(),
-                memorialMedia = SaveAfternoteMemorialMedia(),
+            viewModel.onIntent(AfternoteEditorIntent.SetType(AfternoteType.SOCIAL_NETWORK))
+            viewModel.onIntent(
+                AfternoteEditorIntent.Save(
+                    payload = validSocialPayload(),
+                    selectedReceiverIds = emptyList(),
+                    memorialMedia = SaveAfternoteMemorialMedia(),
+                ),
             )
         }
         composeRule.waitUntil(timeoutMillis = 5_000) { viewModel.uiState.value.savedId == 41L }
@@ -81,15 +85,15 @@ class AfternoteAuthorTest {
         val payload = validSocialPayload()
 
         composeRule.runOnIdle {
-            viewModel.setType(AfternoteType.SOCIAL_NETWORK)
-            viewModel.saveAfternote(payload, listOf(7L), SaveAfternoteMemorialMedia())
+            viewModel.onIntent(AfternoteEditorIntent.SetType(AfternoteType.SOCIAL_NETWORK))
+            viewModel.onIntent(AfternoteEditorIntent.Save(payload, listOf(7L), SaveAfternoteMemorialMedia()))
         }
         composeRule.waitUntil(timeoutMillis = 5_000) { viewModel.uiState.value.error != null }
         assertNull(viewModel.uiState.value.savedId)
 
         composeRule.runOnIdle {
-            viewModel.setType(AfternoteType.SOCIAL_NETWORK)
-            viewModel.saveAfternote(payload, listOf(7L), SaveAfternoteMemorialMedia())
+            viewModel.onIntent(AfternoteEditorIntent.SetType(AfternoteType.SOCIAL_NETWORK))
+            viewModel.onIntent(AfternoteEditorIntent.Save(payload, listOf(7L), SaveAfternoteMemorialMedia()))
         }
         composeRule.waitUntil(timeoutMillis = 5_000) { viewModel.uiState.value.savedId == 42L }
 
@@ -108,13 +112,13 @@ class AfternoteAuthorTest {
         val first = viewModel(FakeAfternoteRepository.strict(), handle)
         composeRule.setContent { AfternoteTheme {} }
         composeRule.runOnIdle {
-            first.setType(AfternoteType.GALLERY_AND_FILES)
-            first.setService("Google Photos")
-            first.addReceiverIfAbsent(7L, "김수신", "가족")
-            first.addProcessingMethod("전체 파일 전달")
+            first.onIntent(AfternoteEditorIntent.SetType(AfternoteType.GALLERY_AND_FILES))
+            first.onIntent(AfternoteEditorIntent.SetService("Google Photos"))
+            first.onIntent(AfternoteEditorIntent.AddReceiverIfAbsent(7L, "김수신", "가족"))
+            first.onIntent(AfternoteEditorIntent.AddProcessingMethod("전체 파일 전달"))
         }
 
-        val restored = viewModel(FakeAfternoteRepository.strict(), handle).currentForm()
+        val restored = viewModel(FakeAfternoteRepository.strict(), handle).uiState.value.form
 
         assertEquals(AfternoteType.GALLERY_AND_FILES, restored.selectedType)
         assertEquals("Google Photos", restored.selectedService)
@@ -139,7 +143,7 @@ class AfternoteAuthorTest {
         AfternoteEditorViewModel(
             route = savedStateHandle.editorFlowRoute(),
             savedStateHandle = savedStateHandle,
-            userRepository = afternoteAuthorUserRepository(),
+            userReceiverRepository = afternoteAuthorUserReceiverRepository(),
             afternoteRepository = repository,
             memorialThumbnailUploadRepository = MemorialThumbnailUploadRepository { Result.success("https://cdn.test/thumb.jpg") },
             resolveMemorialMediaForSave =
@@ -166,6 +170,7 @@ class AfternoteAuthorTest {
                             )
                         },
                 ),
+            saveAfternoteUseCase = SaveAfternoteUseCase(repository),
             errorReporter = NoopAuthorErrorReporter,
         )
 }
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/AfternoteAuthorTestFixtures.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/AfternoteAuthorTestFixtures.kt
index 13dc4b63ec..fd55b62314 100644
--- a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/AfternoteAuthorTestFixtures.kt
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/AfternoteAuthorTestFixtures.kt
@@ -2,8 +2,9 @@ package com.afternote.feature.afternote.presentation
 
 import androidx.lifecycle.SavedStateHandle
 import com.afternote.core.common.reporting.ErrorReporter
+import com.afternote.core.domain.testing.FakeMyProfileRepository
 import com.afternote.core.domain.testing.FakeUserProfileCacheRepository
-import com.afternote.core.domain.testing.FakeUserRepository
+import com.afternote.core.domain.testing.FakeUserReceiverRepository
 import com.afternote.core.model.user.Receiver
 import com.afternote.core.model.user.User
 import com.afternote.feature.afternote.domain.AfternoteType
@@ -33,17 +34,18 @@ internal fun afternoteEditorSavedStateHandle(
         },
     )
 
-/** app androidTest 공용 helper가 열어 두던 UserRepository 경계만 그대로 허용한다. */
-internal fun afternoteAuthorUserRepository(): FakeUserRepository =
-    FakeUserRepository.strict().apply {
-        profile = TEST_USER
+/** 에디터·수신자 선택이 사용하는 수신자 조회 계약만 허용한다. */
+internal fun afternoteAuthorUserReceiverRepository(): FakeUserReceiverRepository =
+    FakeUserReceiverRepository.strict().apply {
         receiverState.value = listOf(TEST_RECEIVER)
-
-        onReceiverListFlow = null
         onGetReceivers = null
-        onCreateReceiver = null
+    }
+
+/** 작성자 상세가 사용하는 프로필 조회 계약만 허용한다. */
+internal fun afternoteAuthorMyProfileRepository(): FakeMyProfileRepository =
+    FakeMyProfileRepository.strict().apply {
+        profile = TEST_USER
         onGetMyProfile = null
-        onUpdateMyProfile = null
     }
 
 /**
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/AfternoteHostViewModelTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/AfternoteHostViewModelTest.kt
new file mode 100644
index 0000000000..2c1b78e828
--- /dev/null
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/AfternoteHostViewModelTest.kt
@@ -0,0 +1,61 @@
+package com.afternote.feature.afternote.presentation
+
+import com.afternote.core.domain.testing.FakeUserProfileCacheRepository
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.advanceTimeBy
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runCurrent
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class AfternoteHostViewModelTest {
+    @After
+    fun resetDispatcher() = Dispatchers.resetMain()
+
+    @Test
+    fun `프로필은 화면 구독 때 시작하고 빠른 복귀는 기존 구독을 유지한다`() =
+        runTest {
+            Dispatchers.setMain(StandardTestDispatcher(testScheduler))
+            val repository = FakeUserProfileCacheRepository()
+            val viewModel = AfternoteHostViewModel(repository)
+            assertNull(viewModel.uiState.value.isPasskeyRegistered)
+            assertEquals(0, repository.isPasskeyRegisteredFlowCalls)
+
+            viewModel.onIntent(AfternoteHostIntent.ObserveProfile)
+            runCurrent()
+            assertEquals(false, viewModel.uiState.value.isPasskeyRegistered)
+            assertEquals(1, repository.passkeyRegisteredState.subscriptionCount.value)
+
+            viewModel.onIntent(AfternoteHostIntent.StopObservingProfile)
+            runCurrent()
+            advanceTimeBy(4_999)
+            viewModel.onIntent(AfternoteHostIntent.ObserveProfile)
+            repository.passkeyRegisteredState.value = true
+            runCurrent()
+            assertEquals(true, viewModel.uiState.value.isPasskeyRegistered)
+            assertEquals(1, repository.isPasskeyRegisteredFlowCalls)
+
+            viewModel.onIntent(AfternoteHostIntent.StopObservingProfile)
+            runCurrent()
+            advanceTimeBy(5_000)
+            runCurrent()
+            assertEquals(0, repository.passkeyRegisteredState.subscriptionCount.value)
+            assertEquals(true, viewModel.uiState.value.isPasskeyRegistered)
+
+            repository.passkeyRegisteredState.value = false
+            viewModel.onIntent(AfternoteHostIntent.ObserveProfile)
+            runCurrent()
+            assertEquals(false, viewModel.uiState.value.isPasskeyRegistered)
+            assertEquals(2, repository.isPasskeyRegisteredFlowCalls)
+            viewModel.onIntent(AfternoteHostIntent.StopObservingProfile)
+            advanceTimeBy(5_001)
+            runCurrent()
+        }
+}
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/detail/AfternoteDetailContentTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/detail/AfternoteDetailContentTest.kt
new file mode 100644
index 0000000000..b944299d21
--- /dev/null
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/detail/AfternoteDetailContentTest.kt
@@ -0,0 +1,67 @@
+package com.afternote.feature.afternote.presentation.detail
+
+import androidx.activity.ComponentActivity
+import androidx.compose.material3.SnackbarHostState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.click
+import androidx.compose.ui.test.junit4.v2.createAndroidComposeRule
+import androidx.compose.ui.test.onNodeWithContentDescription
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performTouchInput
+import com.afternote.core.ui.theme.AfternoteTheme
+import com.afternote.feature.afternote.presentation.R
+import org.junit.Assert.assertEquals
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [35])
+class AfternoteDetailContentTest {
+    @get:Rule
+    val composeRule = createAndroidComposeRule<ComponentActivity>()
+
+    @Test
+    fun `실제 상세 상태가 삭제 진행 표시를 올리고 완료하면 제거한다`() {
+        var state by mutableStateOf<AfternoteDetailUiState>(
+            AfternoteDetailUiState.Success(
+                detailId = 73L,
+                contentUiModel = DetailContentUiModel.Memorial(MemorialDetailContent()),
+                authorDisplayName = "서영",
+                isDeleting = true,
+            ),
+        )
+        val intents = mutableListOf<AfternoteDetailIntent>()
+        var backClicks = 0
+        composeRule.setContent {
+            AfternoteTheme {
+                AfternoteDetailContent(
+                    uiState = state,
+                    onIntent = intents::add,
+                    snackbarHostState = SnackbarHostState(),
+                    onNavigateBack = { backClicks++ },
+                    onNavigateToEditor = { _, _ -> },
+                    onVideoClick = {},
+                )
+            }
+        }
+        val deleting = composeRule.activity.getString(R.string.afternote_detail_deleting)
+        composeRule.onNodeWithText("추억 노트에 대한\n서영님의 기록").assertExists()
+        composeRule.onNodeWithContentDescription(deleting).assertIsDisplayed()
+        val back = composeRule.activity.getString(com.afternote.core.ui.R.string.core_ui_content_description_back)
+        composeRule.onNodeWithContentDescription(back).performTouchInput { click() }
+        composeRule.runOnIdle {
+            assertEquals(emptyList<AfternoteDetailIntent>(), intents)
+            assertEquals(0, backClicks)
+            state = (state as AfternoteDetailUiState.Success).copy(isDeleting = false)
+        }
+        composeRule.onNodeWithContentDescription(deleting).assertDoesNotExist()
+        composeRule.onNodeWithContentDescription(back).performTouchInput { click() }
+        composeRule.runOnIdle { assertEquals(1, backClicks) }
+    }
+}
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/detail/AfternoteDetailViewModelTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/detail/AfternoteDetailViewModelTest.kt
index 118ea4a8d7..09f80d8b9c 100644
--- a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/detail/AfternoteDetailViewModelTest.kt
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/detail/AfternoteDetailViewModelTest.kt
@@ -2,16 +2,16 @@ package com.afternote.feature.afternote.presentation.detail
 
 import androidx.lifecycle.SavedStateHandle
 import com.afternote.core.common.reporting.ErrorReporter
+import com.afternote.core.domain.testing.FakeMyProfileRepository
 import com.afternote.core.domain.testing.FakeUserProfileCacheRepository
-import com.afternote.core.domain.testing.FakeUserRepository
 import com.afternote.feature.afternote.domain.model.author.Detail
 import com.afternote.feature.afternote.domain.model.author.DetailContent
 import com.afternote.feature.afternote.domain.model.author.DetailCredentials
 import com.afternote.feature.afternote.domain.model.author.DetailTimestamps
 import com.afternote.feature.afternote.domain.testing.FakeAfternoteRepository
 import com.afternote.feature.afternote.presentation.NoopAuthorErrorReporter
+import com.afternote.feature.afternote.presentation.afternoteAuthorMyProfileRepository
 import com.afternote.feature.afternote.presentation.afternoteAuthorUserProfileRepository
-import com.afternote.feature.afternote.presentation.afternoteAuthorUserRepository
 import com.afternote.feature.afternote.presentation.navigation.model.AfternoteRoute
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.Dispatchers
@@ -72,7 +72,7 @@ class AfternoteDetailViewModelTest {
             val states = recordStates(viewModel)
 
             // 첫 진입 화면의 ON_RESUME (init 로드는 이미 실패로 종료됨).
-            viewModel.refreshOnReturn()
+            viewModel.onIntent(AfternoteDetailIntent.RefreshOnReturn)
 
             assertEquals(listOf(73L), repository.requestedDetailIds)
             assertTrue(states.last() is AfternoteDetailUiState.Error)
@@ -93,8 +93,8 @@ class AfternoteDetailViewModelTest {
             val states = recordStates(viewModel)
 
             // init 로드가 아직 도는 중 — 첫 resume(스킵) 뒤 또 한 번 resume 이 와도 중복이 없어야 한다.
-            viewModel.refreshOnReturn()
-            viewModel.refreshOnReturn()
+            viewModel.onIntent(AfternoteDetailIntent.RefreshOnReturn)
+            viewModel.onIntent(AfternoteDetailIntent.RefreshOnReturn)
             gate.complete(Unit)
 
             assertEquals(listOf(73L), repository.requestedDetailIds)
@@ -118,8 +118,8 @@ class AfternoteDetailViewModelTest {
             val viewModel = viewModel(repository)
             val states = recordStates(viewModel)
 
-            viewModel.refreshOnReturn() // 첫 진입의 ON_RESUME — 스킵
-            viewModel.refreshOnReturn() // 백스택 복귀의 ON_RESUME
+            viewModel.onIntent(AfternoteDetailIntent.RefreshOnReturn) // 첫 진입의 ON_RESUME — 스킵
+            viewModel.onIntent(AfternoteDetailIntent.RefreshOnReturn) // 백스택 복귀의 ON_RESUME
 
             assertEquals(listOf(73L, 73L), repository.requestedDetailIds)
             assertEquals("Facebook", states.last().serviceNameOrNull())
@@ -146,8 +146,8 @@ class AfternoteDetailViewModelTest {
             val viewModel = viewModel(repository, errorReporter = reporter)
             val states = recordStates(viewModel)
 
-            viewModel.refreshOnReturn() // 첫 진입의 ON_RESUME — 스킵
-            viewModel.refreshOnReturn() // 백스택 복귀의 ON_RESUME
+            viewModel.onIntent(AfternoteDetailIntent.RefreshOnReturn) // 첫 진입의 ON_RESUME — 스킵
+            viewModel.onIntent(AfternoteDetailIntent.RefreshOnReturn) // 백스택 복귀의 ON_RESUME
 
             // 잘 보고 있던 상세가 에러 화면으로 대체되지 않는다.
             assertEquals("Instagram", states.last().serviceNameOrNull())
@@ -162,8 +162,8 @@ class AfternoteDetailViewModelTest {
             // 상세와 표시명은 출처가 다른 두 요청이라 도착 순서가 뒤집힌다. 이름이 늦는 쪽이 실제 경로 —
             // 그때 이미 그려진 Success 에 이름이 실려야 제목의 이름 세그먼트가 뒤늦게라도 채워진다.
             val profileGate = CompletableDeferred<Unit>()
-            val userRepository =
-                afternoteAuthorUserRepository().apply {
+            val myProfileRepository =
+                afternoteAuthorMyProfileRepository().apply {
                     onGetMyProfile = {
                         profileGate.await()
                         profile
@@ -173,7 +173,7 @@ class AfternoteDetailViewModelTest {
                 FakeAfternoteRepository.strict().apply {
                     onGetDetail = { Result.success(detail(serviceName = "Instagram")) }
                 }
-            val viewModel = viewModel(repository, userRepository = userRepository)
+            val viewModel = viewModel(repository, myProfileRepository = myProfileRepository)
             val states = recordStates(viewModel)
 
             // 이름이 도착하기 전 — 화면은 이미 상세를 그리고 있고 이름 자리는 비어 있다.
@@ -181,7 +181,7 @@ class AfternoteDetailViewModelTest {
 
             profileGate.complete(Unit)
 
-            assertEquals(userRepository.profile.name, states.last().authorDisplayNameOrNull())
+            assertEquals(myProfileRepository.profile.name, states.last().authorDisplayNameOrNull())
         }
 
     @Test
@@ -198,16 +198,16 @@ class AfternoteDetailViewModelTest {
                 FakeAfternoteRepository.strict().apply {
                     onGetDetail = { results.removeFirst() }
                 }
-            val userRepository = afternoteAuthorUserRepository()
-            val viewModel = viewModel(repository, userRepository = userRepository)
+            val myProfileRepository = afternoteAuthorMyProfileRepository()
+            val viewModel = viewModel(repository, myProfileRepository = myProfileRepository)
             val states = recordStates(viewModel)
 
-            viewModel.refreshOnReturn() // 첫 진입의 ON_RESUME — 스킵
-            viewModel.refreshOnReturn() // 백스택 복귀의 ON_RESUME
+            viewModel.onIntent(AfternoteDetailIntent.RefreshOnReturn) // 첫 진입의 ON_RESUME — 스킵
+            viewModel.onIntent(AfternoteDetailIntent.RefreshOnReturn) // 백스택 복귀의 ON_RESUME
 
             // 갱신이 만든 새 Success 도 이름을 들고 있어야 제목이 «…에 대한 기록» 으로 되돌아가지 않는다.
             assertEquals("Threads", states.last().serviceNameOrNull())
-            assertEquals(userRepository.profile.name, states.last().authorDisplayNameOrNull())
+            assertEquals(myProfileRepository.profile.name, states.last().authorDisplayNameOrNull())
         }
 
     @Test
@@ -215,8 +215,8 @@ class AfternoteDetailViewModelTest {
         runTest {
             // 원격만 쓰면 왕복이 끝나야 이름 세그먼트가 채워져, 진입마다 제목이 눈앞에서 다시 쓰인다.
             val profileGate = CompletableDeferred<Unit>()
-            val userRepository =
-                afternoteAuthorUserRepository().apply {
+            val myProfileRepository =
+                afternoteAuthorMyProfileRepository().apply {
                     onGetMyProfile = {
                         profileGate.await()
                         profile.copy(name = "서버 이름")
@@ -228,7 +228,7 @@ class AfternoteDetailViewModelTest {
                     FakeAfternoteRepository.strict().apply {
                         onGetDetail = { Result.success(detail(serviceName = "Instagram")) }
                     },
-                    userRepository = userRepository,
+                    myProfileRepository = myProfileRepository,
                     userProfileRepository = userProfileRepository,
                 )
             val states = recordStates(viewModel)
@@ -250,18 +250,18 @@ class AfternoteDetailViewModelTest {
                 afternoteAuthorUserProfileRepository().apply {
                     onGetCachedUserName = { throw IOException("DataStore 읽기 실패") }
                 }
-            val userRepository = afternoteAuthorUserRepository()
+            val myProfileRepository = afternoteAuthorMyProfileRepository()
             val viewModel =
                 viewModel(
                     FakeAfternoteRepository.strict().apply {
                         onGetDetail = { Result.success(detail(serviceName = "Instagram")) }
                     },
-                    userRepository = userRepository,
+                    myProfileRepository = myProfileRepository,
                     userProfileRepository = userProfileRepository,
                 )
             val states = recordStates(viewModel)
 
-            assertEquals(userRepository.profile.name, states.last().authorDisplayNameOrNull())
+            assertEquals(myProfileRepository.profile.name, states.last().authorDisplayNameOrNull())
         }
 
     @Test
@@ -272,18 +272,18 @@ class AfternoteDetailViewModelTest {
                 afternoteAuthorUserProfileRepository().apply {
                     onSaveUserName = { throw IOException("DataStore 쓰기 실패") }
                 }
-            val userRepository = afternoteAuthorUserRepository()
+            val myProfileRepository = afternoteAuthorMyProfileRepository()
             val viewModel =
                 viewModel(
                     FakeAfternoteRepository.strict().apply {
                         onGetDetail = { Result.success(detail(serviceName = "Instagram")) }
                     },
-                    userRepository = userRepository,
+                    myProfileRepository = myProfileRepository,
                     userProfileRepository = userProfileRepository,
                 )
             val states = recordStates(viewModel)
 
-            assertEquals(userRepository.profile.name, states.last().authorDisplayNameOrNull())
+            assertEquals(myProfileRepository.profile.name, states.last().authorDisplayNameOrNull())
             assertTrue(states.last() is AfternoteDetailUiState.Success)
         }
 
@@ -307,9 +307,9 @@ class AfternoteDetailViewModelTest {
             val viewModel = viewModel(repository)
             val states = recordStates(viewModel)
 
-            viewModel.deleteAfternote()
-            viewModel.refreshOnReturn() // 첫 진입의 ON_RESUME — 스킵
-            viewModel.refreshOnReturn() // 백스택 복귀의 ON_RESUME
+            viewModel.onIntent(AfternoteDetailIntent.Delete)
+            viewModel.onIntent(AfternoteDetailIntent.RefreshOnReturn) // 첫 진입의 ON_RESUME — 스킵
+            viewModel.onIntent(AfternoteDetailIntent.RefreshOnReturn) // 백스택 복귀의 ON_RESUME
 
             val last = states.last() as AfternoteDetailUiState.Success
             assertEquals("Threads", states.last().serviceNameOrNull())
@@ -338,7 +338,7 @@ class AfternoteDetailViewModelTest {
 
             assertTrue(states.last() is AfternoteDetailUiState.Error)
 
-            viewModel.retry()
+            viewModel.onIntent(AfternoteDetailIntent.Retry)
 
             // 응답이 오기 전 — 사용자가 누른 동작이므로 기다림을 표시한다(자동 갱신과 갈리는 지점).
             assertTrue(states.last() is AfternoteDetailUiState.Loading)
@@ -365,7 +365,7 @@ class AfternoteDetailViewModelTest {
                             }
 
                             2 -> {
-                                viewModelRef.retry()
+                                viewModelRef.onIntent(AfternoteDetailIntent.Retry)
                                 Result.success(detail(serviceName = "Stale"))
                             }
 
@@ -379,8 +379,8 @@ class AfternoteDetailViewModelTest {
             viewModelRef = viewModel
             val states = recordStates(viewModel)
 
-            viewModel.refreshOnReturn() // 첫 진입의 ON_RESUME — 스킵
-            viewModel.refreshOnReturn() // 백스택 복귀의 ON_RESUME — 이 로드가 재시도에 잘린다
+            viewModel.onIntent(AfternoteDetailIntent.RefreshOnReturn) // 첫 진입의 ON_RESUME — 스킵
+            viewModel.onIntent(AfternoteDetailIntent.RefreshOnReturn) // 백스택 복귀의 ON_RESUME — 이 로드가 재시도에 잘린다
 
             assertEquals("Retry", states.last().serviceNameOrNull())
         }
@@ -402,7 +402,7 @@ class AfternoteDetailViewModelTest {
             val viewModel = viewModel(repository)
             val states = recordStates(viewModel)
 
-            viewModel.deleteAfternote()
+            viewModel.onIntent(AfternoteDetailIntent.Delete)
 
             assertTrue(states.last() is AfternoteDetailUiState.Error)
             assertEquals(emptyList<Long>(), deletedIds)
@@ -419,13 +419,13 @@ class AfternoteDetailViewModelTest {
     private fun viewModel(
         repository: FakeAfternoteRepository,
         errorReporter: ErrorReporter = NoopAuthorErrorReporter,
-        userRepository: FakeUserRepository = afternoteAuthorUserRepository(),
+        myProfileRepository: FakeMyProfileRepository = afternoteAuthorMyProfileRepository(),
         userProfileRepository: FakeUserProfileCacheRepository = afternoteAuthorUserProfileRepository(),
     ): AfternoteDetailViewModel =
         AfternoteDetailViewModel(
             route = AfternoteRoute.DetailRoute(itemId = 73L),
             afternoteRepository = repository,
-            userRepository = userRepository,
+            myProfileRepository = myProfileRepository,
             userProfileRepository = userProfileRepository,
             errorReporter = errorReporter,
         )
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorErrorTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorErrorTest.kt
index c655d9cf38..883f97345e 100644
--- a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorErrorTest.kt
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorErrorTest.kt
@@ -1,45 +1,103 @@
 package com.afternote.feature.afternote.presentation.editor
 
+import androidx.lifecycle.SavedStateHandle
+import com.afternote.feature.afternote.domain.AfternoteType
 import com.afternote.feature.afternote.domain.error.AfternoteFailure
 import com.afternote.feature.afternote.domain.repository.author.MediaKind
+import com.afternote.feature.afternote.domain.repository.author.MemorialMediaUploadRepository
+import com.afternote.feature.afternote.domain.repository.author.MemorialThumbnailUploadRepository
+import com.afternote.feature.afternote.domain.testing.FakeAfternoteRepository
+import com.afternote.feature.afternote.domain.usecase.editor.ResolveMemorialMediaForSaveUseCase
+import com.afternote.feature.afternote.domain.usecase.editor.SaveAfternoteUseCase
+import com.afternote.feature.afternote.presentation.NoopAuthorErrorReporter
+import com.afternote.feature.afternote.presentation.afternoteAuthorUserReceiverRepository
+import com.afternote.feature.afternote.presentation.editor.model.RegisterAfternotePayload
 import com.afternote.feature.afternote.presentation.editor.state.AfternoteEditorError
+import com.afternote.feature.afternote.presentation.navigation.model.AfternoteRoute
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runCurrent
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
+import org.junit.After
 import org.junit.Assert.assertEquals
+import org.junit.Before
 import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
 import java.io.IOException
 
+@OptIn(ExperimentalCoroutinesApi::class)
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [35])
 class AfternoteEditorErrorTest {
-    @Test
-    fun `네트워크 단절은 Network로 변환`() {
-        val failure = AfternoteFailure.NetworkUnavailable(IOException("timeout"))
+    private val dispatcher = StandardTestDispatcher()
 
-        assertEquals(AfternoteEditorError.Network, failure.toAfternoteEditorError())
-    }
+    @Before
+    fun setUp() = Dispatchers.setMain(dispatcher)
+
+    @After
+    fun tearDown() = Dispatchers.resetMain()
 
     @Test
-    fun `저장 중 영상 업로드 실패는 SAVE_MEDIA Upload로 변환`() {
-        val failure = AfternoteFailure.MediaSave(MediaKind.VIDEO, IOException("upload failed"))
+    fun `네트워크 단절은 저장 오류 Network로 표시한다`() =
+        assertSaveError(AfternoteFailure.NetworkUnavailable(IOException("timeout")), AfternoteEditorError.Network)
 
-        assertEquals(
+    @Test
+    fun `영상 업로드 실패는 저장 미디어 오류로 표시한다`() =
+        assertSaveError(
+            AfternoteFailure.MediaSave(MediaKind.VIDEO, IOException("upload failed")),
             AfternoteEditorError.Upload(AfternoteEditorError.Upload.Target.SAVE_MEDIA),
-            failure.toAfternoteEditorError(),
         )
-    }
 
     @Test
-    fun `저장 중 사진 업로드 실패는 SAVE_MEDIA Upload로 변환`() {
-        val failure = AfternoteFailure.MediaSave(MediaKind.PHOTO, IOException("upload failed"))
-
-        assertEquals(
+    fun `사진 업로드 실패는 저장 미디어 오류로 표시한다`() =
+        assertSaveError(
+            AfternoteFailure.MediaSave(MediaKind.PHOTO, IOException("upload failed")),
             AfternoteEditorError.Upload(AfternoteEditorError.Upload.Target.SAVE_MEDIA),
-            failure.toAfternoteEditorError(),
         )
-    }
 
     @Test
-    fun `그 밖의 저장 실패는 Server로 변환`() {
-        assertEquals(
-            AfternoteEditorError.Server,
-            IllegalStateException("failed").toAfternoteEditorError(),
+    fun `그 밖의 저장 실패는 서버 오류로 표시한다`() = assertSaveError(IllegalStateException("failed"), AfternoteEditorError.Server)
+
+    private fun assertSaveError(
+        failure: Throwable,
+        expected: AfternoteEditorError,
+    ) = runTest(dispatcher) {
+        val repository = FakeAfternoteRepository.strict().apply { onCreateSocial = { Result.failure(failure) } }
+        val viewModel =
+            AfternoteEditorViewModel(
+                route = AfternoteRoute.EditorFlowRoute(initialType = AfternoteType.SOCIAL_NETWORK),
+                savedStateHandle = SavedStateHandle(),
+                userReceiverRepository = afternoteAuthorUserReceiverRepository(),
+                afternoteRepository = repository,
+                memorialThumbnailUploadRepository = MemorialThumbnailUploadRepository { error("unused") },
+                resolveMemorialMediaForSave =
+                    ResolveMemorialMediaForSaveUseCase(
+                        MemorialMediaUploadRepository { _, _ -> Result.success(null) },
+                    ),
+                saveAfternoteUseCase = SaveAfternoteUseCase(repository),
+                errorReporter = NoopAuthorErrorReporter,
+            )
+        viewModel.onIntent(
+            AfternoteEditorIntent.Save(
+                payload =
+                    RegisterAfternotePayload(
+                        serviceName = "인스타그램",
+                        date = "2026.09.08",
+                        accountId = "account",
+                        password = "password",
+                        processingMethods = listOf("계정 삭제"),
+                    ),
+                selectedReceiverIds = listOf(1L),
+                memorialMedia = SaveAfternoteMemorialMedia(),
+            ),
         )
+        runCurrent()
+        assertEquals(expected, viewModel.uiState.value.error)
+        assertEquals(false, viewModel.uiState.value.isSaving)
     }
 }
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorMediaSizeExceededTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorMediaSizeExceededTest.kt
new file mode 100644
index 0000000000..66b382e47e
--- /dev/null
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorMediaSizeExceededTest.kt
@@ -0,0 +1,196 @@
+package com.afternote.feature.afternote.presentation.editor
+
+import com.afternote.core.domain.error.FileUploadFailure
+import com.afternote.feature.afternote.domain.AfternoteType
+import com.afternote.feature.afternote.domain.repository.author.MediaInput
+import com.afternote.feature.afternote.domain.repository.author.MediaKind
+import com.afternote.feature.afternote.domain.repository.author.MemorialMediaUploadRepository
+import com.afternote.feature.afternote.domain.repository.author.MemorialThumbnailUploadRepository
+import com.afternote.feature.afternote.domain.testing.FakeAfternoteRepository
+import com.afternote.feature.afternote.domain.usecase.editor.ResolveMemorialMediaForSaveUseCase
+import com.afternote.feature.afternote.domain.usecase.editor.SaveAfternoteUseCase
+import com.afternote.feature.afternote.presentation.NoopAuthorErrorReporter
+import com.afternote.feature.afternote.presentation.R
+import com.afternote.feature.afternote.presentation.afternoteAuthorUserReceiverRepository
+import com.afternote.feature.afternote.presentation.afternoteEditorSavedStateHandle
+import com.afternote.feature.afternote.presentation.editor.model.RegisterAfternotePayload
+import com.afternote.feature.afternote.presentation.editor.state.AfternoteEditorError
+import com.afternote.feature.afternote.presentation.editor.state.EditableMemorialPhoto
+import com.afternote.feature.afternote.presentation.editor.state.EditableMemorialVideo
+import com.afternote.feature.afternote.presentation.editor.state.EditorFormState
+import com.afternote.feature.afternote.presentation.editorFlowRoute
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.advanceUntilIdle
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import java.io.IOException
+
+/**
+ * 업로드 크기 초과(서버 code 1803)를 일반 저장 실패와 가른다 (#1868).
+ *
+ * 크기 초과는 재시도로 풀리지 않는 유일한 업로드 실패다 — 같은 파일을 다시 보내면 서버가 같은
+ * 코드로 다시 거절한다. 「저장에 실패했습니다」 로 뭉쳐 두면 사용자는 파일을 바꿔야 풀린다는 것도,
+ * 기다렸다 다시 눌러 봐야 소용없다는 것도 알 수 없다.
+ *
+ * 진입은 공개 [AfternoteEditorIntent.Save] 하나이고, 실패는 실제 [ResolveMemorialMediaForSaveUseCase]
+ * 를 통과해 온다 — 매핑만 직접 불러 확인하면 UseCase 가 cause 를 다르게 감싸도 초록으로 남는다.
+ */
+@OptIn(ExperimentalCoroutinesApi::class)
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [35])
+class AfternoteEditorMediaSizeExceededTest {
+    private val dispatcher = StandardTestDispatcher()
+
+    @Before
+    fun setUp() {
+        Dispatchers.setMain(dispatcher)
+    }
+
+    @After
+    fun tearDown() {
+        Dispatchers.resetMain()
+    }
+
+    @Test
+    fun `영상이 한도를 넘으면 저장을 보내지 않고 크기 초과로 알린다`() {
+        assertResolveFailure(
+            failingKind = MediaKind.VIDEO,
+            uploadFailure = fileSizeExceeded(),
+            expected = AfternoteEditorError.MediaSizeExceeded,
+        )
+    }
+
+    @Test
+    fun `사진이 한도를 넘으면 저장을 보내지 않고 크기 초과로 알린다`() {
+        assertResolveFailure(
+            failingKind = MediaKind.PHOTO,
+            uploadFailure = fileSizeExceeded(),
+            expected = AfternoteEditorError.MediaSizeExceeded,
+        )
+    }
+
+    /**
+     * 갈래를 늘리면서 기존 안내를 뭉개지 않았는지 본다 — 사유를 확인하지 못한 업로드 실패는
+     * data 계층이 치환하지 않고 원본 그대로 흘려보내므로, 여기서도 종전 일반 오류로 남아야 한다.
+     */
+    @Test
+    fun `사유를 모르는 업로드 실패는 기존 저장 미디어 오류로 남는다`() {
+        assertResolveFailure(
+            failingKind = MediaKind.VIDEO,
+            uploadFailure = IOException("connection reset"),
+            expected = AfternoteEditorError.Upload(AfternoteEditorError.Upload.Target.SAVE_MEDIA),
+        )
+    }
+
+    @Test
+    fun `크기 초과는 일반 저장 실패와 다른 문구로 나가고 다시 시도를 권하지 않는다`() {
+        assertEquals(
+            R.string.afternote_editor_media_size_exceeded,
+            AfternoteEditorError.MediaSizeExceeded.messageResId(),
+        )
+        assertNotEquals(
+            "크기 초과가 일반 저장 실패와 같은 문구로 나가면 파일을 바꿔야 한다는 사실이 사라진다",
+            AfternoteEditorError.Upload(AfternoteEditorError.Upload.Target.SAVE_MEDIA).messageResId(),
+            AfternoteEditorError.MediaSizeExceeded.messageResId(),
+        )
+        assertFalse(
+            "같은 파일을 다시 보내면 서버가 같은 코드로 거절한다 — 재시도 액션을 붙이면 안 된다",
+            AfternoteEditorError.MediaSizeExceeded.offersMemorialThumbnailRetry(),
+        )
+    }
+
+    /**
+     * @param failingKind 업로드가 거절당하는 매체. 영상이 먼저 해석되므로 사진 갈래는 영상이
+     *   통과한 뒤에야 도달한다 ([ResolveMemorialMediaForSaveUseCase]).
+     */
+    private fun assertResolveFailure(
+        failingKind: MediaKind,
+        uploadFailure: Throwable,
+        expected: AfternoteEditorError,
+    ) = runTest(dispatcher) {
+        // strict fake — 저장 요청이 한 줄이라도 나가면 그 자리에서 터진다.
+        val repository = FakeAfternoteRepository.strict()
+        val viewModel = viewModel(repository, failingKind, uploadFailure)
+        viewModel.onIntent(AfternoteEditorIntent.SetMemorialPhoto(PHOTO_URI))
+        viewModel.onIntent(AfternoteEditorIntent.SetMemorialVideo(VIDEO_URI))
+
+        val pickedMedia =
+            viewModel.uiState.value.form
+                .memorialMediaForSave()
+        viewModel.onIntent(
+            AfternoteEditorIntent.Save(
+                payload = RegisterAfternotePayload(serviceName = "추억 노트", date = "2026.09.20"),
+                selectedReceiverIds = emptyList(),
+                memorialMedia = pickedMedia,
+            ),
+        )
+        advanceUntilIdle()
+
+        val state = viewModel.uiState.value
+        assertEquals(expected, state.error)
+        assertFalse("업로드에서 끊겼는데 저장 중 표시가 남으면 등록 버튼이 잠긴 채로 굳는다", state.isSaving)
+        assertNull(state.savedId)
+        // 업로드에서 끊겼으니 저장 요청 자체가 나가지 않는다 — 나갔다면 payload 가 기록된다.
+        assertTrue("미디어를 못 올렸는데 저장이 나가면 미디어 없는 기록이 확정된다", repository.memorialPayloads.isEmpty())
+        // 고른 파일은 그대로 둔다 — 한도를 넘긴 쪽만 바꿔 다시 저장할 수 있어야 한다.
+        assertEquals(PHOTO_URI, state.form.displayMemorialPhotoUri())
+        assertEquals(VIDEO_URI, state.form.displayedMemorialVideo?.url)
+    }
+
+    private fun viewModel(
+        repository: FakeAfternoteRepository,
+        failingKind: MediaKind,
+        uploadFailure: Throwable,
+    ): AfternoteEditorViewModel {
+        val savedStateHandle = afternoteEditorSavedStateHandle(initialType = AfternoteType.MEMORIAL)
+        return AfternoteEditorViewModel(
+            route = savedStateHandle.editorFlowRoute(),
+            savedStateHandle = savedStateHandle,
+            userReceiverRepository = afternoteAuthorUserReceiverRepository(),
+            afternoteRepository = repository,
+            memorialThumbnailUploadRepository =
+                MemorialThumbnailUploadRepository { error("썸네일 업로드가 호출되면 안 됩니다") },
+            resolveMemorialMediaForSave =
+                ResolveMemorialMediaForSaveUseCase(
+                    MemorialMediaUploadRepository { input, kind ->
+                        when {
+                            kind == failingKind -> Result.failure(uploadFailure)
+                            input is MediaInput.Local -> Result.success("https://cdn.test/${kind.name.lowercase()}")
+                            else -> Result.success(null)
+                        }
+                    },
+                ),
+            saveAfternoteUseCase = SaveAfternoteUseCase(repository),
+            errorReporter = NoopAuthorErrorReporter,
+        )
+    }
+
+    /** 서버 봉투의 code 1803 을 data 계층이 옮겨 놓은 모양 — presentation 은 이 타입만 보고 가른다. */
+    private fun fileSizeExceeded(): FileUploadFailure.FileSizeExceeded =
+        FileUploadFailure.FileSizeExceeded(IllegalStateException("code=1803 FILE_SIZE_EXCEEDED"))
+
+    private fun EditorFormState.memorialMediaForSave(): SaveAfternoteMemorialMedia =
+        SaveAfternoteMemorialMedia(
+            memorialVideo = memorialVideo ?: EditableMemorialVideo.empty(),
+            memorialPhoto = memorialPhoto ?: EditableMemorialPhoto.empty(),
+        )
+
+    private companion object {
+        const val PHOTO_URI = "content://photos/portrait"
+        const val VIDEO_URI = "content://videos/farewell"
+    }
+}
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorMemorialMediaRemoveTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorMemorialMediaRemoveTest.kt
index cb68335e94..6246ad3e42 100644
--- a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorMemorialMediaRemoveTest.kt
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorMemorialMediaRemoveTest.kt
@@ -2,12 +2,14 @@ package com.afternote.feature.afternote.presentation.editor
 
 import androidx.lifecycle.SavedStateHandle
 import com.afternote.core.common.reporting.ErrorReporter
-import com.afternote.core.domain.repository.UserRepository
+import com.afternote.core.domain.repository.UserReceiverRepository
 import com.afternote.feature.afternote.domain.AfternoteType
 import com.afternote.feature.afternote.domain.repository.author.AfternoteRepository
+import com.afternote.feature.afternote.domain.repository.author.MediaInput
 import com.afternote.feature.afternote.domain.repository.author.MemorialMediaUploadRepository
 import com.afternote.feature.afternote.domain.repository.author.MemorialThumbnailUploadRepository
 import com.afternote.feature.afternote.domain.usecase.editor.ResolveMemorialMediaForSaveUseCase
+import com.afternote.feature.afternote.domain.usecase.editor.SaveAfternoteUseCase
 import com.afternote.feature.afternote.presentation.editor.memorial.Song
 import com.afternote.feature.afternote.presentation.editor.model.EditorContentPrefill
 import com.afternote.feature.afternote.presentation.editor.model.EditorFormPrefill
@@ -17,6 +19,10 @@ import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.StandardTestDispatcher
 import kotlinx.coroutines.test.resetMain
 import kotlinx.coroutines.test.setMain
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonNull
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.jsonObject
 import org.junit.After
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
@@ -54,91 +60,173 @@ class AfternoteEditorMemorialMediaRemoveTest {
     @Test
     fun `신규 영상을 삭제하면 파생 썸네일도 함께 비운다`() {
         val viewModel = viewModel(memorialSavedStateHandle())
-        viewModel.setMemorialVideo("content://videos/farewell")
-        viewModel.setMemorialThumbnail("https://cdn.test/thumbnail.jpg")
+        viewModel.onIntent(AfternoteEditorIntent.SetMemorialVideo("content://videos/farewell"))
+        viewModel.onIntent(AfternoteEditorIntent.SetMemorialThumbnail("https://cdn.test/thumbnail.jpg"))
 
-        viewModel.removeMemorialVideo()
+        viewModel.onIntent(AfternoteEditorIntent.RemoveMemorialVideo)
 
-        assertNull(viewModel.currentForm().displayedMemorialVideo)
+        assertNull(viewModel.uiState.value.form.displayedMemorialVideo)
     }
 
     @Test
     fun `사진 삭제는 로컬 픽과 서버 원본을 함께 비운다`() {
         val viewModel = viewModel(memorialSavedStateHandle())
-        viewModel.applyPrefill(memorialPrefill(photoUrl = "https://cdn.test/portrait.jpg"))
-        viewModel.setMemorialPhoto("content://photos/replacement")
-        assertEquals("content://photos/replacement", viewModel.currentForm().displayMemorialPhotoUri())
+        viewModel.onIntent(AfternoteEditorIntent.ApplyPrefill(memorialPrefill(photoUrl = "https://cdn.test/portrait.jpg")))
+        viewModel.onIntent(AfternoteEditorIntent.SetMemorialPhoto("content://photos/replacement"))
+        assertEquals(
+            "content://photos/replacement",
+            viewModel.uiState.value.form
+                .displayMemorialPhotoUri(),
+        )
 
-        viewModel.removeMemorialPhoto()
+        viewModel.onIntent(AfternoteEditorIntent.RemoveMemorialPhoto)
 
-        assertNull(viewModel.currentForm().pickedMemorialPhotoUri)
-        assertNull(viewModel.currentForm().memorialPhotoUrl)
-        assertNull(viewModel.currentForm().displayMemorialPhotoUri())
+        assertNull(
+            viewModel.uiState.value.form.memorialPhoto
+                ?.toSnapshot()
+                ?.selection,
+        )
+        assertNull(
+            viewModel.uiState.value.form.memorialPhoto
+                ?.toSnapshot()
+                ?.persisted,
+        )
+        assertNull(
+            viewModel.uiState.value.form
+                .displayMemorialPhotoUri(),
+        )
     }
 
     @Test
     fun `영상 삭제는 로컬 픽과 서버 원본과 썸네일을 함께 비운다`() {
         val viewModel = viewModel(memorialSavedStateHandle())
-        viewModel.applyPrefill(
-            memorialPrefill(
-                videoUrl = "https://cdn.test/farewell.mp4",
-                thumbnailUrl = "https://cdn.test/server-thumbnail.jpg",
+        viewModel.onIntent(
+            AfternoteEditorIntent.ApplyPrefill(
+                memorialPrefill(
+                    videoUrl = "https://cdn.test/farewell.mp4",
+                    thumbnailUrl = "https://cdn.test/server-thumbnail.jpg",
+                ),
             ),
         )
-        viewModel.setMemorialVideo("content://videos/replacement")
-        viewModel.setMemorialThumbnail("https://cdn.test/local-thumbnail.jpg")
+        viewModel.onIntent(AfternoteEditorIntent.SetMemorialVideo("content://videos/replacement"))
+        viewModel.onIntent(AfternoteEditorIntent.SetMemorialThumbnail("https://cdn.test/local-thumbnail.jpg"))
 
-        viewModel.removeMemorialVideo()
+        viewModel.onIntent(AfternoteEditorIntent.RemoveMemorialVideo)
 
-        assertNull(viewModel.currentForm().displayedMemorialVideo)
-        assertFalse(viewModel.currentForm().canRemoveMemorialVideo)
+        assertNull(viewModel.uiState.value.form.displayedMemorialVideo)
+        assertFalse(viewModel.uiState.value.form.canRemoveMemorialVideo)
     }
 
     @Test
     fun `서버 미디어만 있어도 사진과 영상을 삭제할 수 있다`() {
         val viewModel = viewModel(memorialSavedStateHandle())
-        viewModel.applyPrefill(
-            memorialPrefill(
-                photoUrl = "https://cdn.test/portrait.jpg",
-                videoUrl = "https://cdn.test/farewell.mp4",
-                thumbnailUrl = "https://cdn.test/thumbnail.jpg",
+        viewModel.onIntent(
+            AfternoteEditorIntent.ApplyPrefill(
+                memorialPrefill(
+                    photoUrl = "https://cdn.test/portrait.jpg",
+                    videoUrl = "https://cdn.test/farewell.mp4",
+                    thumbnailUrl = "https://cdn.test/thumbnail.jpg",
+                ),
             ),
         )
 
-        viewModel.removeMemorialPhoto()
-        viewModel.removeMemorialVideo()
+        viewModel.onIntent(AfternoteEditorIntent.RemoveMemorialPhoto)
+        viewModel.onIntent(AfternoteEditorIntent.RemoveMemorialVideo)
 
-        assertNull(viewModel.currentForm().pickedMemorialPhotoUri)
-        assertNull(viewModel.currentForm().memorialPhotoUrl)
-        assertNull(viewModel.currentForm().displayMemorialPhotoUri())
-        assertNull(viewModel.currentForm().displayedMemorialVideo?.url)
-        assertNull(viewModel.currentForm().displayedMemorialVideo?.thumbnailUrl)
+        assertNull(
+            viewModel.uiState.value.form.memorialPhoto
+                ?.toSnapshot()
+                ?.selection,
+        )
+        assertNull(
+            viewModel.uiState.value.form.memorialPhoto
+                ?.toSnapshot()
+                ?.persisted,
+        )
+        assertNull(
+            viewModel.uiState.value.form
+                .displayMemorialPhotoUri(),
+        )
+        assertNull(
+            viewModel.uiState.value.form.displayedMemorialVideo
+                ?.url,
+        )
+        assertNull(
+            viewModel.uiState.value.form.displayedMemorialVideo
+                ?.thumbnailUrl,
+        )
     }
 
     @Test
     fun `삭제한 서버 미디어 스냅샷은 상세 재조회 없는 복원에서도 비어 있다`() {
         val handle = memorialSavedStateHandle()
         val first = viewModel(handle)
-        first.applyPrefill(
-            memorialPrefill(
-                photoUrl = "https://cdn.test/portrait.jpg",
-                videoUrl = "https://cdn.test/farewell.mp4",
-                thumbnailUrl = "https://cdn.test/thumbnail.jpg",
-                playlistSongs = listOf(Song("detail:0", "노래", "가수")),
+        first.onIntent(
+            AfternoteEditorIntent.ApplyPrefill(
+                memorialPrefill(
+                    photoUrl = "https://cdn.test/portrait.jpg",
+                    videoUrl = "https://cdn.test/farewell.mp4",
+                    thumbnailUrl = "https://cdn.test/thumbnail.jpg",
+                    playlistSongs = listOf(Song("detail:0", "노래", "가수")),
+                ),
             ),
         )
-        first.removeMemorialVideo()
-        first.removeMemorialPhoto()
+        first.onIntent(AfternoteEditorIntent.RemoveMemorialVideo)
+        first.onIntent(AfternoteEditorIntent.RemoveMemorialPhoto)
 
-        val restored = viewModel(handle).currentForm()
+        val restored = viewModel(handle).uiState.value.form
 
         assertNull(restored.displayedMemorialVideo)
-        assertNull(restored.pickedMemorialPhotoUri)
-        assertNull(restored.memorialPhotoUrl)
+        assertNull(restored.memorialPhoto?.toSnapshot()?.selection)
+        assertNull(restored.memorialPhoto?.toSnapshot()?.persisted)
         assertNull(restored.displayMemorialPhotoUri())
         assertEquals(listOf("노래"), restored.memorialPlaylistSongs.map { it.title })
     }
 
+    @Test
+    fun `빈 사진 상태를 기존 JSON 키로 저장하고 복원한다`() {
+        assertPhotoSnapshotRoundTrip(null, null, MediaInput.None)
+    }
+
+    @Test
+    fun `서버 사진 상태를 기존 JSON 키로 저장하고 복원한다`() {
+        assertPhotoSnapshotRoundTrip("https://cdn.test/portrait.jpg", null, MediaInput.Remote("https://cdn.test/portrait.jpg"))
+    }
+
+    @Test
+    fun `로컬 사진 상태를 기존 JSON 키로 저장하고 복원한다`() {
+        assertPhotoSnapshotRoundTrip(null, "content://photo", MediaInput.Local("content://photo"))
+    }
+
+    @Test
+    fun `교체 중 사진의 서버 기준값과 로컬 선택을 함께 복원한다`() {
+        assertPhotoSnapshotRoundTrip("https://cdn.test/portrait.jpg", "content://photo", MediaInput.Local("content://photo"))
+    }
+
+    private fun assertPhotoSnapshotRoundTrip(
+        persisted: String?,
+        selection: String?,
+        expectedInput: MediaInput,
+    ) {
+        val handle = memorialSavedStateHandle()
+        val original = viewModel(handle)
+        original.onIntent(AfternoteEditorIntent.ApplyPrefill(memorialPrefill(photoUrl = persisted)))
+        if (selection != null) original.onIntent(AfternoteEditorIntent.SetMemorialPhoto(selection))
+        val encoded = requireNotNull(handle.get<String>("editor_form_snapshot_v6"))
+        val fields = Json.parseToJsonElement(encoded).jsonObject
+        assertEquals(persisted?.let(::JsonPrimitive) ?: JsonNull, fields["memorialPhotoUrl"])
+        assertEquals(selection?.let(::JsonPrimitive) ?: JsonNull, fields["pickedMemorialPhotoUri"])
+
+        // 같은 진입 경로의 새 SavedStateHandle로 실제 직렬화된 스냅샷만 복사한다.
+        val restored = viewModel(memorialSavedStateHandle().apply { set("editor_form_snapshot_v6", encoded) })
+        val photo = requireNotNull(restored.uiState.value.form.memorialPhoto)
+        assertEquals(original.uiState.value.form, restored.uiState.value.form)
+        assertEquals(selection ?: persisted, photo.displayed)
+        assertEquals(expectedInput, photo.toMediaInput())
+        restored.onIntent(AfternoteEditorIntent.RemoveMemorialPhoto)
+        assertEquals(MediaInput.None, requireNotNull(restored.uiState.value.form.memorialPhoto).toMediaInput())
+    }
+
     private fun memorialSavedStateHandle(): SavedStateHandle = SavedStateHandle(mapOf("initialType" to AfternoteType.MEMORIAL))
 
     private fun memorialPrefill(
@@ -163,7 +251,7 @@ class AfternoteEditorMemorialMediaRemoveTest {
         AfternoteEditorViewModel(
             route = savedStateHandle.editorFlowRoute(),
             savedStateHandle = savedStateHandle,
-            userRepository = repositoryProxy<UserRepository>(),
+            userReceiverRepository = repositoryProxy<UserReceiverRepository>(),
             afternoteRepository = repositoryProxy<AfternoteRepository>(),
             memorialThumbnailUploadRepository =
                 MemorialThumbnailUploadRepository { error("썸네일 업로드가 호출되면 안 됩니다") },
@@ -171,6 +259,7 @@ class AfternoteEditorMemorialMediaRemoveTest {
                 ResolveMemorialMediaForSaveUseCase(
                     MemorialMediaUploadRepository { _, _ -> error("미디어 업로드가 호출되면 안 됩니다") },
                 ),
+            saveAfternoteUseCase = SaveAfternoteUseCase(repositoryProxy<AfternoteRepository>()),
             errorReporter = repositoryProxy<ErrorReporter>(),
         )
 
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorMissingBaselineTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorMissingBaselineTest.kt
index 3603e8e72c..c50d06f37f 100644
--- a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorMissingBaselineTest.kt
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorMissingBaselineTest.kt
@@ -2,7 +2,7 @@ package com.afternote.feature.afternote.presentation.editor
 
 import androidx.lifecycle.SavedStateHandle
 import com.afternote.core.common.reporting.ErrorReporter
-import com.afternote.core.domain.testing.FakeUserRepository
+import com.afternote.core.domain.testing.FakeUserReceiverRepository
 import com.afternote.feature.afternote.domain.AfternoteType
 import com.afternote.feature.afternote.domain.model.author.Detail
 import com.afternote.feature.afternote.domain.model.author.DetailContent
@@ -11,6 +11,7 @@ import com.afternote.feature.afternote.domain.repository.author.MemorialMediaUpl
 import com.afternote.feature.afternote.domain.repository.author.MemorialThumbnailUploadRepository
 import com.afternote.feature.afternote.domain.testing.FakeAfternoteRepository
 import com.afternote.feature.afternote.domain.usecase.editor.ResolveMemorialMediaForSaveUseCase
+import com.afternote.feature.afternote.domain.usecase.editor.SaveAfternoteUseCase
 import com.afternote.feature.afternote.presentation.R
 import com.afternote.feature.afternote.presentation.editor.model.RegisterAfternotePayload
 import com.afternote.feature.afternote.presentation.editor.state.AfternoteEditorError
@@ -69,10 +70,12 @@ class AfternoteEditorMissingBaselineTest {
             backgroundScope.launch { viewModel.uiState.collect {} }
             runCurrent()
 
-            viewModel.saveAfternote(
-                payload = RegisterAfternotePayload(serviceName = "구글 포토", date = "2026-08-30"),
-                selectedReceiverIds = emptyList(),
-                memorialMedia = SaveAfternoteMemorialMedia(),
+            viewModel.onIntent(
+                AfternoteEditorIntent.Save(
+                    payload = RegisterAfternotePayload(serviceName = "구글 포토", date = "2026-08-30"),
+                    selectedReceiverIds = emptyList(),
+                    memorialMedia = SaveAfternoteMemorialMedia(),
+                ),
             )
             runCurrent()
 
@@ -96,13 +99,15 @@ class AfternoteEditorMissingBaselineTest {
             runCurrent()
             // 화면이 prefill 을 폼에 반영했다는 통보. 이걸 빼면 저장이 «아직 읽는 중»
             // ([AfternoteEditorError.PrefillNotReady]) 으로 막혀 기준 판정까지 가지 못한다 (#705).
-            viewModel.onPrefillConsumed()
+            viewModel.onIntent(AfternoteEditorIntent.ConsumePrefill)
             runCurrent()
 
-            viewModel.saveAfternote(
-                payload = RegisterAfternotePayload(serviceName = "새 제목", date = "2026-08-30"),
-                selectedReceiverIds = emptyList(),
-                memorialMedia = SaveAfternoteMemorialMedia(),
+            viewModel.onIntent(
+                AfternoteEditorIntent.Save(
+                    payload = RegisterAfternotePayload(serviceName = "새 제목", date = "2026-08-30"),
+                    selectedReceiverIds = emptyList(),
+                    memorialMedia = SaveAfternoteMemorialMedia(),
+                ),
             )
             runCurrent()
 
@@ -149,8 +154,9 @@ class AfternoteEditorMissingBaselineTest {
                         "itemId" to EDIT_ID,
                     ),
                 ),
-            userRepository = FakeUserRepository.strict(),
+            userReceiverRepository = FakeUserReceiverRepository.strict(),
             afternoteRepository = afternoteRepository,
+            saveAfternoteUseCase = SaveAfternoteUseCase(afternoteRepository),
             memorialThumbnailUploadRepository =
                 MemorialThumbnailUploadRepository { error("썸네일 업로드가 호출되면 안 됩니다") },
             resolveMemorialMediaForSave =
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorMultiReceiverSelectionTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorMultiReceiverSelectionTest.kt
index 7604ed116f..c594a19aa0 100644
--- a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorMultiReceiverSelectionTest.kt
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorMultiReceiverSelectionTest.kt
@@ -2,26 +2,31 @@ package com.afternote.feature.afternote.presentation.editor
 
 import androidx.lifecycle.SavedStateHandle
 import com.afternote.core.common.reporting.ErrorReporter
-import com.afternote.core.domain.testing.FakeUserRepository
+import com.afternote.core.domain.testing.FakeUserReceiverRepository
 import com.afternote.core.model.user.Receiver
 import com.afternote.feature.afternote.domain.AfternoteType
 import com.afternote.feature.afternote.domain.repository.author.AfternoteRepository
 import com.afternote.feature.afternote.domain.repository.author.MemorialMediaUploadRepository
 import com.afternote.feature.afternote.domain.repository.author.MemorialThumbnailUploadRepository
 import com.afternote.feature.afternote.domain.usecase.editor.ResolveMemorialMediaForSaveUseCase
+import com.afternote.feature.afternote.domain.usecase.editor.SaveAfternoteUseCase
 import com.afternote.feature.afternote.presentation.editor.state.AfternoteEditorError
 import com.afternote.feature.afternote.presentation.navigation.model.AfternoteRoute
+import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.NonCancellable
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.test.StandardTestDispatcher
 import kotlinx.coroutines.test.resetMain
 import kotlinx.coroutines.test.runCurrent
 import kotlinx.coroutines.test.runTest
 import kotlinx.coroutines.test.setMain
+import kotlinx.coroutines.withContext
 import org.junit.After
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -58,16 +63,19 @@ class AfternoteEditorMultiReceiverSelectionTest {
             val viewModel = viewModel(repositoryWith(DAUGHTER, FRIEND))
             runCurrent()
 
-            viewModel.applySelectedReceivers(listOf(DAUGHTER_ID, FRIEND_ID))
+            viewModel.onIntent(AfternoteEditorIntent.ReceiversSelected(listOf(DAUGHTER_ID, FRIEND_ID)))
+            viewModel.onIntent(AfternoteEditorIntent.ApplyPendingReceiverSelection)
             runCurrent()
 
             assertEquals(
                 listOf(DAUGHTER_ID, FRIEND_ID),
-                viewModel.currentForm().afternoteEditReceivers.map { it.id },
+                viewModel.uiState.value.form.afternoteEditReceivers
+                    .map { it.id },
             )
             assertEquals(
                 listOf("김수신", "박친구"),
-                viewModel.currentForm().afternoteEditReceivers.map { it.name },
+                viewModel.uiState.value.form.afternoteEditReceivers
+                    .map { it.name },
             )
         }
 
@@ -75,15 +83,17 @@ class AfternoteEditorMultiReceiverSelectionTest {
     fun `이미 폼에 있는 수신자를 다시 확정해도 중복으로 쌓이지 않는다`() =
         runTest(dispatcher) {
             val viewModel = viewModel(repositoryWith(DAUGHTER, FRIEND))
-            viewModel.addReceiverIfAbsent(DAUGHTER_ID, "김수신", "딸")
+            viewModel.onIntent(AfternoteEditorIntent.AddReceiverIfAbsent(DAUGHTER_ID, "김수신", "딸"))
             runCurrent()
 
-            viewModel.applySelectedReceivers(listOf(DAUGHTER_ID, FRIEND_ID))
+            viewModel.onIntent(AfternoteEditorIntent.ReceiversSelected(listOf(DAUGHTER_ID, FRIEND_ID)))
+            viewModel.onIntent(AfternoteEditorIntent.ApplyPendingReceiverSelection)
             runCurrent()
 
             assertEquals(
                 listOf(DAUGHTER_ID, FRIEND_ID),
-                viewModel.currentForm().afternoteEditReceivers.map { it.id },
+                viewModel.uiState.value.form.afternoteEditReceivers
+                    .map { it.id },
             )
         }
 
@@ -91,16 +101,18 @@ class AfternoteEditorMultiReceiverSelectionTest {
     fun `선택에서 빠진 기존 수신자는 폼에서도 빠진다`() =
         runTest(dispatcher) {
             val viewModel = viewModel(repositoryWith(DAUGHTER, FRIEND))
-            viewModel.addReceiverIfAbsent(DAUGHTER_ID, "김수신", "딸")
-            viewModel.addReceiverIfAbsent(FRIEND_ID, "박친구", "친구")
+            viewModel.onIntent(AfternoteEditorIntent.AddReceiverIfAbsent(DAUGHTER_ID, "김수신", "딸"))
+            viewModel.onIntent(AfternoteEditorIntent.AddReceiverIfAbsent(FRIEND_ID, "박친구", "친구"))
             runCurrent()
 
-            viewModel.applySelectedReceivers(listOf(FRIEND_ID))
+            viewModel.onIntent(AfternoteEditorIntent.ReceiversSelected(listOf(FRIEND_ID)))
+            viewModel.onIntent(AfternoteEditorIntent.ApplyPendingReceiverSelection)
             runCurrent()
 
             assertEquals(
                 listOf(FRIEND_ID),
-                viewModel.currentForm().afternoteEditReceivers.map { it.id },
+                viewModel.uiState.value.form.afternoteEditReceivers
+                    .map { it.id },
             )
         }
 
@@ -109,15 +121,17 @@ class AfternoteEditorMultiReceiverSelectionTest {
         runTest(dispatcher) {
             val repository = repositoryWith(DAUGHTER)
             val viewModel = viewModel(repository)
-            viewModel.addReceiverIfAbsent(DAUGHTER_ID, "김수신", "딸")
+            viewModel.onIntent(AfternoteEditorIntent.AddReceiverIfAbsent(DAUGHTER_ID, "김수신", "딸"))
             runCurrent()
 
-            viewModel.applySelectedReceivers(listOf(DAUGHTER_ID))
+            viewModel.onIntent(AfternoteEditorIntent.ReceiversSelected(listOf(DAUGHTER_ID)))
+            viewModel.onIntent(AfternoteEditorIntent.ApplyPendingReceiverSelection)
             runCurrent()
 
             assertEquals(
                 listOf(DAUGHTER_ID),
-                viewModel.currentForm().afternoteEditReceivers.map { it.id },
+                viewModel.uiState.value.form.afternoteEditReceivers
+                    .map { it.id },
             )
             assertEquals("폼이 이미 들고 있는 표시값을 두고 재조회할 이유가 없다", 0, repository.getReceiversCalls)
         }
@@ -129,12 +143,14 @@ class AfternoteEditorMultiReceiverSelectionTest {
             backgroundScope.launch { viewModel.uiState.collect {} }
             runCurrent()
 
-            viewModel.applySelectedReceivers(listOf(DAUGHTER_ID, UNKNOWN_ID))
+            viewModel.onIntent(AfternoteEditorIntent.ReceiversSelected(listOf(DAUGHTER_ID, UNKNOWN_ID)))
+            viewModel.onIntent(AfternoteEditorIntent.ApplyPendingReceiverSelection)
             runCurrent()
 
             assertEquals(
                 listOf(DAUGHTER_ID),
-                viewModel.currentForm().afternoteEditReceivers.map { it.id },
+                viewModel.uiState.value.form.afternoteEditReceivers
+                    .map { it.id },
             )
             assertEquals(
                 AfternoteEditorError.ReceiverSelectionUnavailable,
@@ -147,28 +163,122 @@ class AfternoteEditorMultiReceiverSelectionTest {
         runTest(dispatcher) {
             val viewModel = viewModel(repositoryWith(DAUGHTER, FRIEND))
             backgroundScope.launch { viewModel.uiState.collect {} }
-            viewModel.addReceiverIfAbsent(DAUGHTER_ID, "김수신", "딸")
-            viewModel.addReceiverIfAbsent(FRIEND_ID, "박친구", "친구")
+            viewModel.onIntent(AfternoteEditorIntent.AddReceiverIfAbsent(DAUGHTER_ID, "김수신", "딸"))
+            viewModel.onIntent(AfternoteEditorIntent.AddReceiverIfAbsent(FRIEND_ID, "박친구", "친구"))
             runCurrent()
 
-            viewModel.applySelectedReceivers(listOf(DAUGHTER_ID, FRIEND_ID))
+            viewModel.onIntent(AfternoteEditorIntent.ReceiversSelected(listOf(DAUGHTER_ID, FRIEND_ID)))
+            viewModel.onIntent(AfternoteEditorIntent.ApplyPendingReceiverSelection)
             runCurrent()
 
             assertEquals(
                 listOf(DAUGHTER_ID, FRIEND_ID),
-                viewModel.currentForm().afternoteEditReceivers.map { it.id },
+                viewModel.uiState.value.form.afternoteEditReceivers
+                    .map { it.id },
             )
             assertNull("정상 반영에는 오류를 세우지 않는다", viewModel.uiState.value.error)
         }
 
-    private fun repositoryWith(vararg receivers: Receiver): FakeUserRepository =
-        FakeUserRepository.strict().apply { onGetReceivers = { receivers.toList() } }
+    @Test
+    fun `선택 결과는 편집기 복귀에서 한 번만 폼에 적용한다`() =
+        runTest(dispatcher) {
+            val viewModel = viewModel(repositoryWith(DAUGHTER))
+            viewModel.onIntent(AfternoteEditorIntent.ReceiversSelected(listOf(DAUGHTER_ID)))
+            runCurrent()
+            assertTrue(
+                viewModel.uiState.value.form.afternoteEditReceivers
+                    .isEmpty(),
+            )
+
+            viewModel.onIntent(AfternoteEditorIntent.ApplyPendingReceiverSelection)
+            runCurrent()
+            assertEquals(
+                listOf(DAUGHTER_ID),
+                viewModel.uiState.value.form.afternoteEditReceivers
+                    .map { it.id },
+            )
+
+            viewModel.onIntent(AfternoteEditorIntent.DeleteReceiver(DAUGHTER_ID))
+            viewModel.onIntent(AfternoteEditorIntent.ApplyPendingReceiverSelection)
+            runCurrent()
+            assertTrue(
+                viewModel.uiState.value.form.afternoteEditReceivers
+                    .isEmpty(),
+            )
+        }
+
+    @Test
+    fun `확정된 수신자 선택은 흐름 복원 뒤에도 한 번 적용한다`() =
+        runTest(dispatcher) {
+            val handle = SavedStateHandle()
+            val first = viewModel(repositoryWith(DAUGHTER), handle)
+            first.onIntent(AfternoteEditorIntent.ReceiversSelected(listOf(DAUGHTER_ID)))
+
+            val restored = viewModel(repositoryWith(DAUGHTER), handle)
+            restored.onIntent(AfternoteEditorIntent.ApplyPendingReceiverSelection)
+            runCurrent()
+            assertEquals(
+                listOf(DAUGHTER_ID),
+                restored.uiState.value.form.afternoteEditReceivers
+                    .map { it.id },
+            )
+        }
+
+    @Test
+    fun `취소 뒤 늦게 도착한 이전 조회는 최신 선택과 수신자 목록을 덮지 않는다`() =
+        runTest(dispatcher) {
+            val previousLookup = CompletableDeferred<List<Receiver>>()
+            var calls = 0
+            val repository =
+                FakeUserReceiverRepository.strict().apply {
+                    onGetReceivers = {
+                        if (calls++ == 0) {
+                            withContext(NonCancellable) { previousLookup.await() }
+                        } else {
+                            listOf(FRIEND)
+                        }
+                    }
+                }
+            val viewModel = viewModel(repository)
+            viewModel.onIntent(AfternoteEditorIntent.ReceiversSelected(listOf(DAUGHTER_ID)))
+            viewModel.onIntent(AfternoteEditorIntent.ApplyPendingReceiverSelection)
+            runCurrent()
+
+            viewModel.onIntent(AfternoteEditorIntent.ReceiversSelected(listOf(FRIEND_ID)))
+            viewModel.onIntent(AfternoteEditorIntent.ApplyPendingReceiverSelection)
+            runCurrent()
+            assertEquals(
+                listOf(FRIEND_ID),
+                viewModel.uiState.value.form.afternoteEditReceivers
+                    .map { it.id },
+            )
+
+            previousLookup.complete(listOf(DAUGHTER))
+            runCurrent()
+            assertEquals(
+                listOf(FRIEND_ID),
+                viewModel.uiState.value.form.afternoteEditReceivers
+                    .map { it.id },
+            )
+            assertEquals(
+                listOf(FRIEND_ID),
+                viewModel.uiState.value.authorReceivers
+                    .map { it.id },
+            )
+            assertNull(viewModel.uiState.value.error)
+        }
+
+    private fun repositoryWith(vararg receivers: Receiver): FakeUserReceiverRepository =
+        FakeUserReceiverRepository.strict().apply { onGetReceivers = { receivers.toList() } }
 
-    private fun viewModel(userRepository: FakeUserRepository): AfternoteEditorViewModel =
+    private fun viewModel(
+        userRepository: FakeUserReceiverRepository,
+        savedStateHandle: SavedStateHandle = SavedStateHandle(),
+    ): AfternoteEditorViewModel =
         AfternoteEditorViewModel(
             route = AfternoteRoute.EditorFlowRoute(initialType = AfternoteType.SOCIAL_NETWORK),
-            savedStateHandle = SavedStateHandle(mapOf("initialType" to AfternoteType.SOCIAL_NETWORK)),
-            userRepository = userRepository,
+            savedStateHandle = savedStateHandle,
+            userReceiverRepository = userRepository,
             afternoteRepository = unusedProxy<AfternoteRepository>(),
             memorialThumbnailUploadRepository =
                 MemorialThumbnailUploadRepository { error("썸네일 업로드가 호출되면 안 됩니다") },
@@ -176,6 +286,7 @@ class AfternoteEditorMultiReceiverSelectionTest {
                 ResolveMemorialMediaForSaveUseCase(
                     MemorialMediaUploadRepository { _, _ -> error("미디어 저장이 호출되면 안 됩니다") },
                 ),
+            saveAfternoteUseCase = SaveAfternoteUseCase(unusedProxy<AfternoteRepository>()),
             errorReporter = NoopErrorReporter,
         )
 
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorPrefillFailureTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorPrefillFailureTest.kt
index f72b85f393..e7de690dfd 100644
--- a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorPrefillFailureTest.kt
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorPrefillFailureTest.kt
@@ -2,7 +2,7 @@ package com.afternote.feature.afternote.presentation.editor
 
 import androidx.lifecycle.SavedStateHandle
 import com.afternote.core.common.reporting.ErrorReporter
-import com.afternote.core.domain.repository.UserRepository
+import com.afternote.core.domain.repository.UserReceiverRepository
 import com.afternote.feature.afternote.domain.AfternoteType
 import com.afternote.feature.afternote.domain.model.LeaveMessageBlock
 import com.afternote.feature.afternote.domain.model.author.Detail
@@ -14,6 +14,7 @@ import com.afternote.feature.afternote.domain.repository.author.MemorialMediaUpl
 import com.afternote.feature.afternote.domain.repository.author.MemorialThumbnailUploadRepository
 import com.afternote.feature.afternote.domain.testing.FakeAfternoteRepository
 import com.afternote.feature.afternote.domain.usecase.editor.ResolveMemorialMediaForSaveUseCase
+import com.afternote.feature.afternote.domain.usecase.editor.SaveAfternoteUseCase
 import com.afternote.feature.afternote.presentation.R
 import com.afternote.feature.afternote.presentation.afternoteEditorSavedStateHandle
 import com.afternote.feature.afternote.presentation.editor.model.RegisterAfternotePayload
@@ -90,10 +91,12 @@ class AfternoteEditorPrefillFailureTest {
             backgroundScope.launch { viewModel.uiState.collect {} }
             runCurrent()
 
-            viewModel.saveAfternote(
-                payload = SAVE_PAYLOAD,
-                selectedReceiverIds = listOf(7L),
-                memorialMedia = SaveAfternoteMemorialMedia(),
+            viewModel.onIntent(
+                AfternoteEditorIntent.Save(
+                    payload = SAVE_PAYLOAD,
+                    selectedReceiverIds = listOf(7L),
+                    memorialMedia = SaveAfternoteMemorialMedia(),
+                ),
             )
             runCurrent()
 
@@ -117,7 +120,7 @@ class AfternoteEditorPrefillFailureTest {
             assertTrue(viewModel.uiState.value.isPrefillFailed)
 
             shouldFail = false
-            viewModel.retryPrefill()
+            viewModel.onIntent(AfternoteEditorIntent.RetryPrefill)
             runCurrent()
 
             val state = viewModel.uiState.value
@@ -142,17 +145,19 @@ class AfternoteEditorPrefillFailureTest {
             runCurrent()
 
             shouldFail = false
-            viewModel.retryPrefill()
+            viewModel.onIntent(AfternoteEditorIntent.RetryPrefill)
             runCurrent()
             // 화면이 pendingPrefill 을 폼·TextFieldState 에 실은 뒤 통보하는 단계. 이걸 거쳐야
             // isPrefillLoading 이 내려간다 — 저장 가드가 «읽는 중» 도 막으므로 (#705) 여기서
             // 생략하면 폼이 아직 비어 있는 상태의 저장이 되어 정상 경로가 아니다.
-            viewModel.onPrefillConsumed()
+            viewModel.onIntent(AfternoteEditorIntent.ConsumePrefill)
             runCurrent()
-            viewModel.saveAfternote(
-                payload = SAVE_PAYLOAD,
-                selectedReceiverIds = listOf(7L),
-                memorialMedia = SaveAfternoteMemorialMedia(),
+            viewModel.onIntent(
+                AfternoteEditorIntent.Save(
+                    payload = SAVE_PAYLOAD,
+                    selectedReceiverIds = listOf(7L),
+                    memorialMedia = SaveAfternoteMemorialMedia(),
+                ),
             )
             runCurrent()
 
@@ -194,10 +199,12 @@ class AfternoteEditorPrefillFailureTest {
             assertTrue("전제: 아직 prefill 을 읽는 중이어야 한다", viewModel.uiState.value.isPrefillLoading)
             assertFalse("이 경로는 실패가 아니다", viewModel.uiState.value.isPrefillFailed)
 
-            viewModel.saveAfternote(
-                payload = SAVE_PAYLOAD,
-                selectedReceiverIds = listOf(7L),
-                memorialMedia = SaveAfternoteMemorialMedia(),
+            viewModel.onIntent(
+                AfternoteEditorIntent.Save(
+                    payload = SAVE_PAYLOAD,
+                    selectedReceiverIds = listOf(7L),
+                    memorialMedia = SaveAfternoteMemorialMedia(),
+                ),
             )
             runCurrent()
 
@@ -244,7 +251,7 @@ class AfternoteEditorPrefillFailureTest {
                     route = AfternoteRoute.EditorFlowRoute(initialType = AfternoteType.SOCIAL_NETWORK),
                     savedStateHandle =
                         afternoteEditorSavedStateHandle(initialType = AfternoteType.SOCIAL_NETWORK, itemId = null),
-                    userRepository = unusedProxy<UserRepository>(),
+                    userReceiverRepository = unusedProxy<UserReceiverRepository>(),
                     afternoteRepository = repository,
                     memorialThumbnailUploadRepository =
                         MemorialThumbnailUploadRepository { error("썸네일 업로드가 호출되면 안 됩니다") },
@@ -254,13 +261,14 @@ class AfternoteEditorPrefillFailureTest {
                                 if (input == MediaInput.None) Result.success(null) else error("미디어 업로드가 호출되면 안 됩니다")
                             },
                         ),
+                    saveAfternoteUseCase = SaveAfternoteUseCase(repository),
                     errorReporter = RecordingErrorReporter(),
                 )
             backgroundScope.launch { viewModel.uiState.collect {} }
             runCurrent()
             assertFalse("전제: 신규 작성은 prefill 을 돌리지 않는다", viewModel.uiState.value.isPrefillLoading)
 
-            viewModel.retryPrefill()
+            viewModel.onIntent(AfternoteEditorIntent.RetryPrefill)
             runCurrent()
 
             assertFalse("재시도가 신규 작성에서 skeleton 을 세우면 안 된다", viewModel.uiState.value.isPrefillLoading)
@@ -293,7 +301,7 @@ class AfternoteEditorPrefillFailureTest {
         return AfternoteEditorViewModel(
             route = editorHandle.editorFlowRoute(),
             savedStateHandle = editorHandle,
-            userRepository = unusedProxy<UserRepository>(),
+            userReceiverRepository = unusedProxy<UserReceiverRepository>(),
             afternoteRepository = repository,
             memorialThumbnailUploadRepository =
                 MemorialThumbnailUploadRepository { error("썸네일 업로드가 호출되면 안 됩니다") },
@@ -308,6 +316,7 @@ class AfternoteEditorPrefillFailureTest {
                         }
                     },
                 ),
+            saveAfternoteUseCase = SaveAfternoteUseCase(repository),
             errorReporter = errorReporter,
         )
     }
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorProcessDeathPrefillTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorProcessDeathPrefillTest.kt
index 8b7a0e896d..10ccd28724 100644
--- a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorProcessDeathPrefillTest.kt
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorProcessDeathPrefillTest.kt
@@ -2,7 +2,7 @@ package com.afternote.feature.afternote.presentation.editor
 
 import androidx.lifecycle.SavedStateHandle
 import com.afternote.core.common.reporting.ErrorReporter
-import com.afternote.core.domain.testing.FakeUserRepository
+import com.afternote.core.domain.testing.FakeUserReceiverRepository
 import com.afternote.feature.afternote.domain.AfternoteType
 import com.afternote.feature.afternote.domain.model.author.Detail
 import com.afternote.feature.afternote.domain.model.author.DetailContent
@@ -11,7 +11,9 @@ import com.afternote.feature.afternote.domain.repository.author.MemorialMediaUpl
 import com.afternote.feature.afternote.domain.repository.author.MemorialThumbnailUploadRepository
 import com.afternote.feature.afternote.domain.testing.FakeAfternoteRepository
 import com.afternote.feature.afternote.domain.usecase.editor.ResolveMemorialMediaForSaveUseCase
+import com.afternote.feature.afternote.domain.usecase.editor.SaveAfternoteUseCase
 import com.afternote.feature.afternote.presentation.editor.model.EditorContentPrefill
+import com.afternote.feature.afternote.presentation.editor.model.RegisterAfternotePayload
 import com.afternote.feature.afternote.presentation.navigation.model.AfternoteRoute
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
@@ -23,29 +25,16 @@ import kotlinx.coroutines.test.runTest
 import kotlinx.coroutines.test.setMain
 import org.junit.After
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
 import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
 import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.robolectric.RobolectricTestRunner
 import org.robolectric.annotation.Config
 
-/**
- * **알려진 한계를 드러내는 가드** — 프로세스 사망 복원이 사용자의 미저장 편집을 서버 값으로 덮는다.
- *
- * 복원 경로는 두 갈래가 겹친다: `SavedStateHandle` 의 폼 스냅샷이 편집분을 되살리고, 곧이어
- * `init` 의 상세 재조회가 `pendingPrefill` 을 다시 발행해 UI 가 폼을 서버 값으로 덮어쓴다.
- * 이 테스트는 그 두 번째 발행이 **폼이 더러운지 묻지 않고** 일어난다는 사실을 고정한다.
- *
- * 이 축은 #1617 의 부분 PATCH 가 만든 것이 아니고 고치지도 않는다 — 스냅샷 복원과 프리필 재적용이
- * 함께 있던 종전부터의 동작이다. 부분 PATCH 는 오히려 이 경로를 **덜 위험하게** 만든다: 덮인 폼은
- * 서버 값과 같아져 「바뀐 것 없음」으로 아무 슬롯도 실리지 않고, 프리필이 도착하기 전 저장을
- * 시도하면 기준이 없다는 이유로 [AfternoteEditorMissingBaselineTest] 의 가드가 막는다.
- *
- * 제대로 고치려면 「복원된 편집이 있으면 프리필을 덮어쓰지 않거나 사용자에게 고를 기회를 준다」는
- * 화면 흐름 결정이 필요하다 — 편집 유실 안내·충돌 해소 UI 는 #1617 의 해야 할 일 2번(서버 거절 시
- * 화면 동작)과 같은 결의 별도 축이라 그쪽에서 다룬다.
- */
+/** 발행 수정 화면 복원 뒤 재조회가 미저장 입력을 보존하고 저장 기준은 갱신하는지 검증한다. */
 @OptIn(ExperimentalCoroutinesApi::class)
 @RunWith(RobolectricTestRunner::class)
 @Config(sdk = [35])
@@ -63,7 +52,7 @@ class AfternoteEditorProcessDeathPrefillTest {
     }
 
     @Test
-    fun `복원된 편집이 있어도 상세 재조회 프리필이 다시 발행된다`() =
+    fun `복원된 편집이 있으면 상세 재조회가 프리필을 발행하지 않는다`() =
         runTest(dispatcher) {
             val repository =
                 FakeAfternoteRepository.strict().apply {
@@ -73,18 +62,111 @@ class AfternoteEditorProcessDeathPrefillTest {
             backgroundScope.launch { viewModel.uiState.collect {} }
             runCurrent()
 
-            // 복원 직후의 폼은 사용자가 고친 제목을 들고 있다.
-            assertEquals(EDITED_SERVICE, viewModel.currentForm().selectedService)
+            assertEquals(
+                "복원된 폼은 사용자가 고친 제목을 그대로 들고 있다",
+                EDITED_SERVICE,
+                viewModel.uiState.value.form.selectedService,
+            )
+            assertNull(
+                "재조회가 프리필을 발행하면 화면이 그것을 실어 사용자의 편집이 사라진다",
+                viewModel.uiState.value.pendingPrefill,
+            )
+        }
+
+    @Test
+    fun `프리필을 막아도 복원된 편집 그대로 저장이 나간다`() =
+        runTest(dispatcher) {
+            val repository =
+                FakeAfternoteRepository.strict().apply {
+                    onGetDetail = { Result.success(serverDetail()) }
+                    onUpdate = { id, _ -> Result.success(id) }
+                }
+            val viewModel = viewModel(repository)
+            backgroundScope.launch { viewModel.uiState.collect {} }
+            runCurrent()
+
+            assertFalse(
+                "프리필을 싣지 않았으니 skeleton 도 여기서 걷혀야 한다",
+                viewModel.uiState.value.isPrefillLoading,
+            )
+
+            // 화면이 복원된 폼 값을 그대로 담아 보내는 저장이다.
+            viewModel.onIntent(
+                AfternoteEditorIntent.Save(
+                    payload =
+                        RegisterAfternotePayload(
+                            serviceName = EDITED_SERVICE,
+                            date = "2026-08-30",
+                            processingMethods = listOf(SERVER_PROCESSING_METHOD),
+                        ),
+                    selectedReceiverIds = emptyList(),
+                    memorialMedia = SaveAfternoteMemorialMedia(),
+                ),
+            )
+            runCurrent()
+
+            val updated = repository.updateCalls.single().second
+            assertEquals("사용자가 고친 제목이 그대로 나간다", EDITED_SERVICE, updated.title)
+            assertNull(
+                "복원된 폼이 서버 값을 그대로 들고 있으므로 안 건드린 필드는 실리지 않는다 (#1617)",
+                updated.processingMethods,
+            )
+        }
+
+    @Test
+    fun `프리필이 실린 적 없는 복원은 여전히 프리필을 받는다`() =
+        runTest(dispatcher) {
+            val repository =
+                FakeAfternoteRepository.strict().apply {
+                    onGetDetail = { Result.success(serverDetail()) }
+                }
+            val viewModel = viewModel(repository, prefillSeeded = false)
+            backgroundScope.launch { viewModel.uiState.collect {} }
+            runCurrent()
+
+            val prefill = viewModel.uiState.value.pendingPrefill
+            assertNotNull("서버 값을 본 적 없는 폼은 프리필로 채워야 한다", prefill)
+            assertEquals(
+                SERVER_SERVICE,
+                (prefill?.content as EditorContentPrefill.Gallery).serviceName,
+            )
+        }
+
+    @Test
+    fun `스냅샷이 깨져 빈 폼으로 떨어진 복원은 프리필을 받는다`() =
+        runTest(dispatcher) {
+            val repository =
+                FakeAfternoteRepository.strict().apply {
+                    onGetDetail = { Result.success(serverDetail()) }
+                }
+            val viewModel = viewModel(repository, snapshot = "{ 이건 EditorFormSnapshot 이 아니다 }")
+            backgroundScope.launch { viewModel.uiState.collect {} }
+            runCurrent()
 
             val prefill = viewModel.uiState.value.pendingPrefill
-            assertNotNull("상세 재조회는 폼이 더러운지 묻지 않고 프리필을 발행한다", prefill)
+            assertNotNull("빈 폼으로 떨어졌으면 프리필을 막으면 안 된다", prefill)
             assertEquals(
-                "그 프리필은 서버 값이라, UI 가 적용하면 사용자의 편집이 사라진다",
                 SERVER_SERVICE,
                 (prefill?.content as EditorContentPrefill.Gallery).serviceName,
             )
         }
 
+    @Test
+    fun `표식만 남고 폼 스냅샷이 없으면 프리필을 받는다`() =
+        runTest(dispatcher) {
+            val repository =
+                FakeAfternoteRepository.strict().apply {
+                    onGetDetail = { Result.success(serverDetail()) }
+                }
+            val viewModel = viewModel(repository, snapshot = null)
+            backgroundScope.launch { viewModel.uiState.collect {} }
+            runCurrent()
+
+            val prefill = viewModel.uiState.value.pendingPrefill
+            assertNotNull("실제 폼 복원이 없으면 서버 값을 받아야 한다", prefill)
+            assertEquals(SERVER_SERVICE, (prefill?.content as EditorContentPrefill.Gallery).serviceName)
+        }
+
     private fun serverDetail() =
         Detail(
             id = EDIT_ID,
@@ -92,29 +174,36 @@ class AfternoteEditorProcessDeathPrefillTest {
             timestamps = DetailTimestamps(updatedAt = "2026-08-30"),
             receivers = emptyList(),
             leaveMessageBlocks = emptyList(),
-            content = DetailContent.Gallery(processingMethods = listOf("파일 전달")),
+            content = DetailContent.Gallery(processingMethods = listOf(SERVER_PROCESSING_METHOD)),
         )
 
-    /** 프로세스 사망 전에 저장돼 있던 폼 스냅샷 — 사용자가 제목을 고쳐 둔 상태다. */
+    /** 서버 prefill 적용 뒤 제목만 고친 폼. */
     private fun restoredSnapshot(): String =
         """
         {"type":"GALLERY_AND_FILES","selectedService":"$EDITED_SERVICE","receivers":[],
-        "processingMethods":[],"memorialPlaylistSongs":[]}
+        "processingMethods":[{"localId":0,"text":"$SERVER_PROCESSING_METHOD"}],"memorialPlaylistSongs":[]}
         """.trimIndent().replace("\n", "")
 
-    private fun viewModel(afternoteRepository: FakeAfternoteRepository): AfternoteEditorViewModel =
+    private fun viewModel(
+        afternoteRepository: FakeAfternoteRepository,
+        prefillSeeded: Boolean = true,
+        snapshot: String? = restoredSnapshot(),
+    ): AfternoteEditorViewModel =
         AfternoteEditorViewModel(
             route = AfternoteRoute.EditorFlowRoute(itemId = EDIT_ID, initialType = AfternoteType.GALLERY_AND_FILES),
             savedStateHandle =
                 SavedStateHandle(
-                    mapOf(
-                        "initialType" to AfternoteType.GALLERY_AND_FILES,
-                        "itemId" to EDIT_ID,
-                        "editor_form_snapshot_v6" to restoredSnapshot(),
-                    ),
+                    buildMap {
+                        put("initialType", AfternoteType.GALLERY_AND_FILES)
+                        put("itemId", EDIT_ID)
+                        if (snapshot != null) put("editor_form_snapshot_v6", snapshot)
+                        // 화면이 프리필을 폼에 실을 때 ViewModel 이 같은 번들에 남기는 표식.
+                        if (prefillSeeded) put("editor_prefill_seeded_item_id", EDIT_ID)
+                    },
                 ),
-            userRepository = FakeUserRepository.strict(),
+            userReceiverRepository = FakeUserReceiverRepository.strict(),
             afternoteRepository = afternoteRepository,
+            saveAfternoteUseCase = SaveAfternoteUseCase(afternoteRepository),
             memorialThumbnailUploadRepository =
                 MemorialThumbnailUploadRepository { error("썸네일 업로드가 호출되면 안 됩니다") },
             resolveMemorialMediaForSave =
@@ -135,5 +224,6 @@ class AfternoteEditorProcessDeathPrefillTest {
         const val EDIT_ID = 73L
         const val EDITED_SERVICE = "사용자가 고친 제목"
         const val SERVER_SERVICE = "구글 포토"
+        const val SERVER_PROCESSING_METHOD = "파일 전달"
     }
 }
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorProcessingMethodDefaultsTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorProcessingMethodDefaultsTest.kt
index bf16a8850b..11d871bc82 100644
--- a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorProcessingMethodDefaultsTest.kt
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorProcessingMethodDefaultsTest.kt
@@ -2,13 +2,14 @@ package com.afternote.feature.afternote.presentation.editor
 
 import androidx.lifecycle.SavedStateHandle
 import com.afternote.core.common.reporting.ErrorReporter
-import com.afternote.core.domain.repository.UserRepository
+import com.afternote.core.domain.repository.UserReceiverRepository
 import com.afternote.feature.afternote.domain.AfternoteType
 import com.afternote.feature.afternote.domain.model.author.CreateAfternoteInput
 import com.afternote.feature.afternote.domain.repository.author.AfternoteRepository
 import com.afternote.feature.afternote.domain.repository.author.MemorialMediaUploadRepository
 import com.afternote.feature.afternote.domain.repository.author.MemorialThumbnailUploadRepository
 import com.afternote.feature.afternote.domain.usecase.editor.ResolveMemorialMediaForSaveUseCase
+import com.afternote.feature.afternote.domain.usecase.editor.SaveAfternoteUseCase
 import com.afternote.feature.afternote.presentation.editor.model.RegisterAfternotePayload
 import com.afternote.feature.afternote.presentation.editorFlowRoute
 import kotlinx.coroutines.Dispatchers
@@ -48,30 +49,55 @@ class AfternoteEditorProcessingMethodDefaultsTest {
         val viewModel = viewModel(savedStateHandle)
         val defaults = listOf("게시물 내리기", "추모 게시물 올리기")
 
-        viewModel.initializeProcessingMethodDefaults(AfternoteType.SOCIAL_NETWORK, defaults)
+        viewModel.onIntent(AfternoteEditorIntent.InitializeProcessingMethodDefaults(AfternoteType.SOCIAL_NETWORK, defaults))
 
-        assertEquals(listOf(1, 2), viewModel.currentForm().processingMethods.map { it.localId })
-        assertEquals(defaults, viewModel.currentForm().processingMethods.map { it.text })
+        assertEquals(
+            listOf(1, 2),
+            viewModel.uiState.value.form.processingMethods
+                .map { it.localId },
+        )
+        assertEquals(
+            defaults,
+            viewModel.uiState.value.form.processingMethods
+                .map { it.text },
+        )
 
-        viewModel.currentForm().processingMethods.forEach { viewModel.deleteProcessingMethod(it.localId) }
-        viewModel.initializeProcessingMethodDefaults(AfternoteType.SOCIAL_NETWORK, defaults)
+        viewModel.uiState.value.form.processingMethods.forEach {
+            viewModel.onIntent(
+                AfternoteEditorIntent.DeleteProcessingMethod(it.localId),
+            )
+        }
+        viewModel.onIntent(AfternoteEditorIntent.InitializeProcessingMethodDefaults(AfternoteType.SOCIAL_NETWORK, defaults))
 
-        assertTrue(viewModel.currentForm().processingMethods.isEmpty())
-        assertTrue(viewModel(savedStateHandle).currentForm().processingMethods.isEmpty())
+        assertTrue(
+            viewModel.uiState.value.form.processingMethods
+                .isEmpty(),
+        )
+        assertTrue(
+            viewModel(savedStateHandle)
+                .uiState.value.form.processingMethods
+                .isEmpty(),
+        )
     }
 
     @Test
     fun `카테고리를 바꾸면 새 카테고리 추천을 채운다`() {
         val viewModel = viewModel(SavedStateHandle(mapOf("initialType" to AfternoteType.SOCIAL_NETWORK)))
-        viewModel.initializeProcessingMethodDefaults(AfternoteType.SOCIAL_NETWORK, listOf("계정 삭제"))
+        viewModel.onIntent(AfternoteEditorIntent.InitializeProcessingMethodDefaults(AfternoteType.SOCIAL_NETWORK, listOf("계정 삭제")))
+
+        viewModel.onIntent(AfternoteEditorIntent.SetType(AfternoteType.GALLERY_AND_FILES))
+        viewModel.onIntent(
+            AfternoteEditorIntent.InitializeProcessingMethodDefaults(
+                AfternoteType.GALLERY_AND_FILES,
+                listOf("폴더 전송", "폴더 삭제"),
+            ),
+        )
 
-        viewModel.setType(AfternoteType.GALLERY_AND_FILES)
-        viewModel.initializeProcessingMethodDefaults(
-            AfternoteType.GALLERY_AND_FILES,
+        assertEquals(
             listOf("폴더 전송", "폴더 삭제"),
+            viewModel.uiState.value.form.processingMethods
+                .map { it.text },
         )
-
-        assertEquals(listOf("폴더 전송", "폴더 삭제"), viewModel.currentForm().processingMethods.map { it.text })
     }
 
     @Test
@@ -94,7 +120,7 @@ class AfternoteEditorProcessingMethodDefaultsTest {
         AfternoteEditorViewModel(
             route = savedStateHandle.editorFlowRoute(),
             savedStateHandle = savedStateHandle,
-            userRepository = repositoryProxy(),
+            userReceiverRepository = repositoryProxy<UserReceiverRepository>(),
             afternoteRepository = repositoryProxy(),
             memorialThumbnailUploadRepository =
                 MemorialThumbnailUploadRepository { error("썸네일 업로드가 호출되면 안 됩니다") },
@@ -102,6 +128,7 @@ class AfternoteEditorProcessingMethodDefaultsTest {
                 ResolveMemorialMediaForSaveUseCase(
                     MemorialMediaUploadRepository { _, _ -> error("미디어 업로드가 호출되면 안 됩니다") },
                 ),
+            saveAfternoteUseCase = SaveAfternoteUseCase(repositoryProxy()),
             errorReporter = repositoryProxy(),
         )
 
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorReceiverSelectionRecoveryTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorReceiverSelectionRecoveryTest.kt
index edaec4efd9..ef8f814300 100644
--- a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorReceiverSelectionRecoveryTest.kt
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorReceiverSelectionRecoveryTest.kt
@@ -2,13 +2,14 @@ package com.afternote.feature.afternote.presentation.editor
 
 import androidx.lifecycle.SavedStateHandle
 import com.afternote.core.common.reporting.ErrorReporter
-import com.afternote.core.domain.testing.FakeUserRepository
+import com.afternote.core.domain.testing.FakeUserReceiverRepository
 import com.afternote.core.model.user.Receiver
 import com.afternote.feature.afternote.domain.AfternoteType
 import com.afternote.feature.afternote.domain.repository.author.AfternoteRepository
 import com.afternote.feature.afternote.domain.repository.author.MemorialMediaUploadRepository
 import com.afternote.feature.afternote.domain.repository.author.MemorialThumbnailUploadRepository
 import com.afternote.feature.afternote.domain.usecase.editor.ResolveMemorialMediaForSaveUseCase
+import com.afternote.feature.afternote.domain.usecase.editor.SaveAfternoteUseCase
 import com.afternote.feature.afternote.presentation.R
 import com.afternote.feature.afternote.presentation.editor.state.AfternoteEditorError
 import com.afternote.feature.afternote.presentation.navigation.model.AfternoteRoute
@@ -61,8 +62,12 @@ class AfternoteEditorReceiverSelectionRecoveryTest {
             backgroundScope.launch { viewModel.uiState.collect {} }
             runCurrent()
 
-            val resolved = viewModel.resolveSelectedReceiver(RECEIVER_ID)
+            viewModel.onIntent(AfternoteEditorIntent.ReceiversSelected(listOf(RECEIVER_ID)))
+            viewModel.onIntent(AfternoteEditorIntent.ApplyPendingReceiverSelection)
             runCurrent()
+            val resolved =
+                viewModel.uiState.value.form.afternoteEditReceivers
+                    .singleOrNull()
 
             assertNull("해석하지 못한 선택은 폼에 넣을 값이 없다", resolved)
             assertEquals(
@@ -79,8 +84,12 @@ class AfternoteEditorReceiverSelectionRecoveryTest {
             backgroundScope.launch { viewModel.uiState.collect {} }
             runCurrent()
 
-            val resolved = viewModel.resolveSelectedReceiver(RECEIVER_ID)
+            viewModel.onIntent(AfternoteEditorIntent.ReceiversSelected(listOf(RECEIVER_ID)))
+            viewModel.onIntent(AfternoteEditorIntent.ApplyPendingReceiverSelection)
             runCurrent()
+            val resolved =
+                viewModel.uiState.value.form.afternoteEditReceivers
+                    .singleOrNull()
 
             assertEquals("김수신", resolved?.name)
             assertEquals("딸", resolved?.label)
@@ -93,11 +102,15 @@ class AfternoteEditorReceiverSelectionRecoveryTest {
             val repository = repositoryWith { listOf(RECEIVER) }
             val viewModel = viewModel(repository)
             backgroundScope.launch { viewModel.uiState.collect {} }
-            viewModel.refreshAuthorReceivers()
+            viewModel.onIntent(AfternoteEditorIntent.RefreshAuthorReceivers)
             runCurrent()
 
-            val resolved = viewModel.resolveSelectedReceiver(RECEIVER_ID)
+            viewModel.onIntent(AfternoteEditorIntent.ReceiversSelected(listOf(RECEIVER_ID)))
+            viewModel.onIntent(AfternoteEditorIntent.ApplyPendingReceiverSelection)
             runCurrent()
+            val resolved =
+                viewModel.uiState.value.form.afternoteEditReceivers
+                    .singleOrNull()
 
             assertEquals(RECEIVER_ID, resolved?.id)
             assertEquals("캐시 적중이면 추가 조회가 없어야 한다", 1, repository.getReceiversCalls)
@@ -111,14 +124,14 @@ class AfternoteEditorReceiverSelectionRecoveryTest {
         )
     }
 
-    private fun repositoryWith(receivers: suspend () -> List<Receiver>): FakeUserRepository =
-        FakeUserRepository.strict().apply { onGetReceivers = receivers }
+    private fun repositoryWith(receivers: suspend () -> List<Receiver>): FakeUserReceiverRepository =
+        FakeUserReceiverRepository.strict().apply { onGetReceivers = receivers }
 
-    private fun viewModel(userRepository: FakeUserRepository): AfternoteEditorViewModel =
+    private fun viewModel(userReceiverRepository: FakeUserReceiverRepository): AfternoteEditorViewModel =
         AfternoteEditorViewModel(
             route = AfternoteRoute.EditorFlowRoute(initialType = AfternoteType.SOCIAL_NETWORK),
             savedStateHandle = SavedStateHandle(mapOf("initialType" to AfternoteType.SOCIAL_NETWORK)),
-            userRepository = userRepository,
+            userReceiverRepository = userReceiverRepository,
             afternoteRepository = unusedProxy<AfternoteRepository>(),
             memorialThumbnailUploadRepository =
                 MemorialThumbnailUploadRepository { error("썸네일 업로드가 호출되면 안 됩니다") },
@@ -126,6 +139,7 @@ class AfternoteEditorReceiverSelectionRecoveryTest {
                 ResolveMemorialMediaForSaveUseCase(
                     MemorialMediaUploadRepository { _, _ -> error("미디어 저장이 호출되면 안 됩니다") },
                 ),
+            saveAfternoteUseCase = SaveAfternoteUseCase(unusedProxy<AfternoteRepository>()),
             errorReporter = NoopErrorReporter,
         )
 
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorReceiverSnapshotTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorReceiverSnapshotTest.kt
index c7a82854b7..6065b4e3c1 100644
--- a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorReceiverSnapshotTest.kt
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorReceiverSnapshotTest.kt
@@ -2,13 +2,14 @@ package com.afternote.feature.afternote.presentation.editor
 
 import androidx.lifecycle.SavedStateHandle
 import com.afternote.core.common.reporting.ErrorReporter
-import com.afternote.core.domain.repository.UserRepository
+import com.afternote.core.domain.repository.UserReceiverRepository
 import com.afternote.feature.afternote.domain.AfternoteType
 import com.afternote.feature.afternote.domain.repository.author.AfternoteRepository
 import com.afternote.feature.afternote.domain.repository.author.MediaInput
 import com.afternote.feature.afternote.domain.repository.author.MemorialMediaUploadRepository
 import com.afternote.feature.afternote.domain.repository.author.MemorialThumbnailUploadRepository
 import com.afternote.feature.afternote.domain.usecase.editor.ResolveMemorialMediaForSaveUseCase
+import com.afternote.feature.afternote.domain.usecase.editor.SaveAfternoteUseCase
 import com.afternote.feature.afternote.presentation.editor.state.MemorialVideoAttachment
 import com.afternote.feature.afternote.presentation.editorFlowRoute
 import org.junit.Assert.assertEquals
@@ -29,13 +30,13 @@ class AfternoteEditorReceiverSnapshotTest {
         val savedStateHandle = SavedStateHandle(mapOf("initialType" to AfternoteType.SOCIAL_NETWORK))
         val viewModel = viewModel(savedStateHandle)
 
-        viewModel.addReceiverIfAbsent(Long.MAX_VALUE, "김수신", "딸")
+        viewModel.onIntent(AfternoteEditorIntent.AddReceiverIfAbsent(Long.MAX_VALUE, "김수신", "딸"))
 
         val raw = requireNotNull(savedStateHandle.get<String>(SNAPSHOT_KEY))
         assertTrue(raw.contains("\"id\":${Long.MAX_VALUE}"))
         val restoredId =
             viewModel(savedStateHandle)
-                .currentForm()
+                .uiState.value.form
                 .afternoteEditReceivers
                 .single()
                 .id
@@ -70,15 +71,15 @@ class AfternoteEditorReceiverSnapshotTest {
             )
         val viewModel = viewModel(savedStateHandle)
 
-        assertEquals(selection, viewModel.currentForm().displayedMemorialVideo)
-        assertTrue(viewModel.currentForm().canRemoveMemorialVideo)
+        assertEquals(selection, viewModel.uiState.value.form.displayedMemorialVideo)
+        assertTrue(viewModel.uiState.value.form.canRemoveMemorialVideo)
 
-        viewModel.setMemorialThumbnail("https://cdn.test/round-trip-thumb.jpg")
+        viewModel.onIntent(AfternoteEditorIntent.SetMemorialThumbnail("https://cdn.test/round-trip-thumb.jpg"))
         val roundTrippedRaw = requireNotNull(savedStateHandle.get<String>(SNAPSHOT_KEY))
         assertTrue(roundTrippedRaw.contains("\"memorialVideo\""))
 
         val restoredViewModel = viewModel(savedStateHandle)
-        val roundTripped = restoredViewModel.currentForm()
+        val roundTripped = restoredViewModel.uiState.value.form
         assertEquals(
             selection.copy(thumbnailUrl = "https://cdn.test/round-trip-thumb.jpg"),
             roundTripped.displayedMemorialVideo,
@@ -86,19 +87,23 @@ class AfternoteEditorReceiverSnapshotTest {
         assertEquals(MediaInput.Local(selection.url), roundTripped.memorialVideo?.toMediaInput())
         assertTrue(roundTripped.canRemoveMemorialVideo)
 
-        restoredViewModel.removeMemorialVideo()
+        restoredViewModel.onIntent(AfternoteEditorIntent.RemoveMemorialVideo)
 
-        // 삭제는 슬롯을 비운다 — 저장 시 명시적 null 로 나간다(#1597).
-        assertNull(restoredViewModel.currentForm().displayedMemorialVideo)
-        assertEquals(MediaInput.None, restoredViewModel.currentForm().memorialVideo?.toMediaInput())
-        assertFalse(restoredViewModel.currentForm().canRemoveMemorialVideo)
+        // 삭제는 교체분과 서버 원본을 함께 비운다 — 저장 시 명시적 null 로 나간다(#1597).
+        assertNull(restoredViewModel.uiState.value.form.displayedMemorialVideo)
+        assertEquals(
+            MediaInput.None,
+            restoredViewModel.uiState.value.form.memorialVideo
+                ?.toMediaInput(),
+        )
+        assertFalse(restoredViewModel.uiState.value.form.canRemoveMemorialVideo)
     }
 
     private fun viewModel(savedStateHandle: SavedStateHandle): AfternoteEditorViewModel =
         AfternoteEditorViewModel(
             route = savedStateHandle.editorFlowRoute(),
             savedStateHandle = savedStateHandle,
-            userRepository = repositoryProxy<UserRepository>(),
+            userReceiverRepository = repositoryProxy<UserReceiverRepository>(),
             afternoteRepository = repositoryProxy<AfternoteRepository>(),
             memorialThumbnailUploadRepository =
                 MemorialThumbnailUploadRepository { error("썸네일 업로드가 호출되면 안 됩니다") },
@@ -106,6 +111,7 @@ class AfternoteEditorReceiverSnapshotTest {
                 ResolveMemorialMediaForSaveUseCase(
                     MemorialMediaUploadRepository { _, _ -> error("미디어 저장이 호출되면 안 됩니다") },
                 ),
+            saveAfternoteUseCase = SaveAfternoteUseCase(repositoryProxy<AfternoteRepository>()),
             errorReporter = repositoryProxy<ErrorReporter>(),
         )
 
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorServerMediaDeleteSaveTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorServerMediaDeleteSaveTest.kt
index a8ba6767a2..d2750916b6 100644
--- a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorServerMediaDeleteSaveTest.kt
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorServerMediaDeleteSaveTest.kt
@@ -12,10 +12,12 @@ import com.afternote.feature.afternote.domain.repository.author.MemorialMediaUpl
 import com.afternote.feature.afternote.domain.repository.author.MemorialThumbnailUploadRepository
 import com.afternote.feature.afternote.domain.testing.FakeAfternoteRepository
 import com.afternote.feature.afternote.domain.usecase.editor.ResolveMemorialMediaForSaveUseCase
+import com.afternote.feature.afternote.domain.usecase.editor.SaveAfternoteUseCase
 import com.afternote.feature.afternote.presentation.NoopAuthorErrorReporter
-import com.afternote.feature.afternote.presentation.afternoteAuthorUserRepository
+import com.afternote.feature.afternote.presentation.afternoteAuthorUserReceiverRepository
 import com.afternote.feature.afternote.presentation.afternoteEditorSavedStateHandle
 import com.afternote.feature.afternote.presentation.editor.model.RegisterAfternotePayload
+import com.afternote.feature.afternote.presentation.editor.state.EditableMemorialPhoto
 import com.afternote.feature.afternote.presentation.editor.state.EditableMemorialVideo
 import com.afternote.feature.afternote.presentation.editor.state.EditorFormState
 import com.afternote.feature.afternote.presentation.editorFlowRoute
@@ -65,17 +67,19 @@ class AfternoteEditorServerMediaDeleteSaveTest {
             val first = viewModel(repository)
             collectState(first)
             applyLoadedPrefill(first)
-            assertServerMediaAndSongs(first.currentForm())
+            assertServerMediaAndSongs(first.uiState.value.form)
 
-            first.removeMemorialPhoto()
-            first.removeMemorialVideo()
-            val deletedForm = first.currentForm()
+            first.onIntent(AfternoteEditorIntent.RemoveMemorialPhoto)
+            first.onIntent(AfternoteEditorIntent.RemoveMemorialVideo)
+            val deletedForm = first.uiState.value.form
 
             assertDeletedMediaAndSongs(deletedForm)
-            first.saveAfternote(
-                payload = validMemorialPayload(),
-                selectedReceiverIds = emptyList(),
-                memorialMedia = deletedForm.fullMemorialMediaForSave(),
+            first.onIntent(
+                AfternoteEditorIntent.Save(
+                    payload = validMemorialPayload(),
+                    selectedReceiverIds = emptyList(),
+                    memorialMedia = deletedForm.fullMemorialMediaForSave(),
+                ),
             )
             advanceUntilIdle()
 
@@ -95,7 +99,7 @@ class AfternoteEditorServerMediaDeleteSaveTest {
             collectState(reentered)
             applyLoadedPrefill(reentered)
 
-            assertDeletedMediaAndSongs(reentered.currentForm())
+            assertDeletedMediaAndSongs(reentered.uiState.value.form)
         }
 
     @Test
@@ -115,15 +119,15 @@ class AfternoteEditorServerMediaDeleteSaveTest {
             val viewModel = viewModel(repository)
             collectState(viewModel)
             applyLoadedPrefill(viewModel)
-            viewModel.removeMemorialPhoto()
-            viewModel.removeMemorialVideo()
+            viewModel.onIntent(AfternoteEditorIntent.RemoveMemorialPhoto)
+            viewModel.onIntent(AfternoteEditorIntent.RemoveMemorialVideo)
 
             viewModel.saveCurrentMemorialForm()
             advanceUntilIdle()
 
             assertNotNull(viewModel.uiState.value.error)
             assertNull(viewModel.uiState.value.savedId)
-            assertDeletedMediaAndSongs(viewModel.currentForm())
+            assertDeletedMediaAndSongs(viewModel.uiState.value.form)
 
             viewModel.saveCurrentMemorialForm()
             advanceUntilIdle()
@@ -147,37 +151,38 @@ class AfternoteEditorServerMediaDeleteSaveTest {
     private fun TestScope.applyLoadedPrefill(viewModel: AfternoteEditorViewModel) {
         advanceUntilIdle()
         val prefill = requireNotNull(viewModel.uiState.value.pendingPrefill)
-        viewModel.applyPrefill(prefill)
-        viewModel.onPrefillConsumed()
+        viewModel.onIntent(AfternoteEditorIntent.ApplyPrefill(prefill))
+        viewModel.onIntent(AfternoteEditorIntent.ConsumePrefill)
         advanceUntilIdle()
     }
 
     private fun AfternoteEditorViewModel.saveCurrentMemorialForm() {
-        val form = currentForm()
-        saveAfternote(
-            payload = validMemorialPayload(),
-            selectedReceiverIds = emptyList(),
-            memorialMedia = form.fullMemorialMediaForSave(),
+        val form = uiState.value.form
+        onIntent(
+            AfternoteEditorIntent.Save(
+                payload = validMemorialPayload(),
+                selectedReceiverIds = emptyList(),
+                memorialMedia = form.fullMemorialMediaForSave(),
+            ),
         )
     }
 
     private fun EditorFormState.fullMemorialMediaForSave(): SaveAfternoteMemorialMedia =
         SaveAfternoteMemorialMedia(
             memorialVideo = memorialVideo ?: EditableMemorialVideo.empty(),
-            memorialPhotoUrl = memorialPhotoUrl,
-            pickedMemorialPhotoUri = pickedMemorialPhotoUri,
+            memorialPhoto = memorialPhoto ?: EditableMemorialPhoto.empty(),
         )
 
     private fun assertServerMediaAndSongs(form: EditorFormState) {
-        assertEquals("https://cdn.test/portrait.jpg", form.memorialPhotoUrl)
+        assertEquals("https://cdn.test/portrait.jpg", form.memorialPhoto?.toSnapshot()?.persisted)
         assertEquals("https://cdn.test/farewell.mp4", form.displayedMemorialVideo?.url)
         assertEquals("https://cdn.test/thumbnail.jpg", form.displayedMemorialVideo?.thumbnailUrl)
         assertEquals(listOf("배경음악"), form.memorialPlaylistSongs.map { it.title })
     }
 
     private fun assertDeletedMediaAndSongs(form: EditorFormState) {
-        assertNull(form.pickedMemorialPhotoUri)
-        assertNull(form.memorialPhotoUrl)
+        assertNull(form.memorialPhoto?.toSnapshot()?.selection)
+        assertNull(form.memorialPhoto?.toSnapshot()?.persisted)
         assertNull(form.displayMemorialPhotoUri())
         assertNull(form.displayedMemorialVideo?.url)
         assertNull(form.displayedMemorialVideo?.thumbnailUrl)
@@ -193,7 +198,7 @@ class AfternoteEditorServerMediaDeleteSaveTest {
         return AfternoteEditorViewModel(
             route = savedStateHandle.editorFlowRoute(),
             savedStateHandle = savedStateHandle,
-            userRepository = afternoteAuthorUserRepository(),
+            userReceiverRepository = afternoteAuthorUserReceiverRepository(),
             afternoteRepository = repository,
             memorialThumbnailUploadRepository =
                 MemorialThumbnailUploadRepository { error("썸네일 업로드가 호출되면 안 됩니다") },
@@ -207,6 +212,7 @@ class AfternoteEditorServerMediaDeleteSaveTest {
                         }
                     },
                 ),
+            saveAfternoteUseCase = SaveAfternoteUseCase(repository),
             errorReporter = NoopAuthorErrorReporter,
         )
     }
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorSnackbarActionTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorSnackbarActionTest.kt
index eda7c4876f..000ac7e485 100644
--- a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorSnackbarActionTest.kt
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorSnackbarActionTest.kt
@@ -24,6 +24,8 @@ class AfternoteEditorSnackbarActionTest {
     fun `저장 실패와 그 밖의 오류에는 썸네일 재시도가 붙지 않는다`() {
         listOf(
             AfternoteEditorError.Upload(Target.SAVE_MEDIA),
+            // 크기 초과는 재시도로 풀리지 않는 유일한 업로드 실패다 — 다시 보내면 서버가 같은 코드로 거절한다 (#1868).
+            AfternoteEditorError.MediaSizeExceeded,
             AfternoteEditorError.Network,
             AfternoteEditorError.Server,
             AfternoteEditorError.ReceiverSelectionUnavailable,
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorThumbnailRetryTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorThumbnailRetryTest.kt
index 20869c74b1..5558f75dcb 100644
--- a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorThumbnailRetryTest.kt
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorThumbnailRetryTest.kt
@@ -2,12 +2,13 @@ package com.afternote.feature.afternote.presentation.editor
 
 import androidx.lifecycle.SavedStateHandle
 import com.afternote.core.common.reporting.ErrorReporter
-import com.afternote.core.domain.repository.UserRepository
+import com.afternote.core.domain.repository.UserReceiverRepository
 import com.afternote.feature.afternote.domain.AfternoteType
 import com.afternote.feature.afternote.domain.repository.author.AfternoteRepository
 import com.afternote.feature.afternote.domain.repository.author.MemorialMediaUploadRepository
 import com.afternote.feature.afternote.domain.repository.author.MemorialThumbnailUploadRepository
 import com.afternote.feature.afternote.domain.usecase.editor.ResolveMemorialMediaForSaveUseCase
+import com.afternote.feature.afternote.domain.usecase.editor.SaveAfternoteUseCase
 import com.afternote.feature.afternote.presentation.editor.state.AfternoteEditorError
 import com.afternote.feature.afternote.presentation.navigation.model.AfternoteRoute
 import kotlinx.coroutines.Dispatchers
@@ -58,9 +59,9 @@ class AfternoteEditorThumbnailRetryTest {
         runTest(dispatcher) {
             val viewModel = viewModel(uploads = ThumbnailUploads(failures = 1))
             observeUiState(viewModel)
-            viewModel.setMemorialVideo(LOCAL_VIDEO)
+            viewModel.onIntent(AfternoteEditorIntent.SetMemorialVideo(LOCAL_VIDEO))
 
-            viewModel.uploadMemorialThumbnail(JPEG_BYTES)
+            viewModel.onIntent(AfternoteEditorIntent.UploadMemorialThumbnail(JPEG_BYTES))
             advanceUntilIdle()
 
             assertEquals(
@@ -75,17 +76,21 @@ class AfternoteEditorThumbnailRetryTest {
             val uploads = ThumbnailUploads(failures = 1)
             val viewModel = viewModel(uploads)
             observeUiState(viewModel)
-            viewModel.setMemorialVideo(LOCAL_VIDEO)
-            viewModel.uploadMemorialThumbnail(JPEG_BYTES)
+            viewModel.onIntent(AfternoteEditorIntent.SetMemorialVideo(LOCAL_VIDEO))
+            viewModel.onIntent(AfternoteEditorIntent.UploadMemorialThumbnail(JPEG_BYTES))
             advanceUntilIdle()
 
-            viewModel.retryMemorialThumbnail()
+            viewModel.onIntent(AfternoteEditorIntent.RetryMemorialThumbnail)
             advanceUntilIdle()
 
             assertEquals("두 번째 시도까지 두 번 올린다", 2, uploads.attempts)
             assertEquals(UPLOADED_URL, viewModel.uiState.value.pendingThumbnailUrl)
             // 고른 영상은 그대로다 — 되돌리려고 영상을 다시 고르게 하지 않는다.
-            assertEquals(LOCAL_VIDEO, viewModel.currentForm().displayedMemorialVideo?.url)
+            assertEquals(
+                LOCAL_VIDEO,
+                viewModel.uiState.value.form.displayedMemorialVideo
+                    ?.url,
+            )
         }
 
     @Test
@@ -93,9 +98,9 @@ class AfternoteEditorThumbnailRetryTest {
         runTest(dispatcher) {
             val viewModel = viewModel()
             observeUiState(viewModel)
-            viewModel.setMemorialVideo(LOCAL_VIDEO)
+            viewModel.onIntent(AfternoteEditorIntent.SetMemorialVideo(LOCAL_VIDEO))
 
-            viewModel.onMemorialThumbnailExtractionFailed(IllegalStateException("no frame"))
+            viewModel.onIntent(AfternoteEditorIntent.MemorialThumbnailExtractionFailed(IllegalStateException("no frame")))
             advanceUntilIdle()
 
             assertEquals(
@@ -110,11 +115,11 @@ class AfternoteEditorThumbnailRetryTest {
             val uploads = ThumbnailUploads()
             val viewModel = viewModel(uploads)
             observeUiState(viewModel)
-            viewModel.setMemorialVideo(LOCAL_VIDEO)
-            viewModel.onMemorialThumbnailExtractionFailed(IllegalStateException("no frame"))
+            viewModel.onIntent(AfternoteEditorIntent.SetMemorialVideo(LOCAL_VIDEO))
+            viewModel.onIntent(AfternoteEditorIntent.MemorialThumbnailExtractionFailed(IllegalStateException("no frame")))
             val before = viewModel.uiState.value.memorialThumbnailRetryToken
 
-            viewModel.retryMemorialThumbnail()
+            viewModel.onIntent(AfternoteEditorIntent.RetryMemorialThumbnail)
             advanceUntilIdle()
 
             // 토큰이 바뀌면 화면이 같은 영상에서 프레임 추출을 다시 발화한다.
@@ -128,12 +133,12 @@ class AfternoteEditorThumbnailRetryTest {
             val uploads = ThumbnailUploads(failures = 1)
             val viewModel = viewModel(uploads)
             observeUiState(viewModel)
-            viewModel.setMemorialVideo(LOCAL_VIDEO)
-            viewModel.uploadMemorialThumbnail(JPEG_BYTES)
+            viewModel.onIntent(AfternoteEditorIntent.SetMemorialVideo(LOCAL_VIDEO))
+            viewModel.onIntent(AfternoteEditorIntent.UploadMemorialThumbnail(JPEG_BYTES))
             advanceUntilIdle()
 
-            viewModel.setMemorialVideo("content://videos/another")
-            viewModel.retryMemorialThumbnail()
+            viewModel.onIntent(AfternoteEditorIntent.SetMemorialVideo("content://videos/another"))
+            viewModel.onIntent(AfternoteEditorIntent.RetryMemorialThumbnail)
             advanceUntilIdle()
 
             // 남은 바이트로 다시 올리면 다른 영상의 그림이 붙는다.
@@ -153,13 +158,14 @@ class AfternoteEditorThumbnailRetryTest {
         AfternoteEditorViewModel(
             route = AfternoteRoute.EditorFlowRoute(initialType = AfternoteType.MEMORIAL),
             savedStateHandle = SavedStateHandle(mapOf("initialType" to AfternoteType.MEMORIAL)),
-            userRepository = repositoryProxy<UserRepository>(),
+            userReceiverRepository = repositoryProxy<UserReceiverRepository>(),
             afternoteRepository = repositoryProxy<AfternoteRepository>(),
             memorialThumbnailUploadRepository = uploads,
             resolveMemorialMediaForSave =
                 ResolveMemorialMediaForSaveUseCase(
                     MemorialMediaUploadRepository { _, _ -> error("미디어 업로드가 호출되면 안 됩니다") },
                 ),
+            saveAfternoteUseCase = SaveAfternoteUseCase(repositoryProxy<AfternoteRepository>()),
             errorReporter = RecordingErrorReporter(),
         )
 
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorValidationEventTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorValidationEventTest.kt
index d1cdf84eac..059a12a3f3 100644
--- a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorValidationEventTest.kt
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorValidationEventTest.kt
@@ -2,12 +2,13 @@ package com.afternote.feature.afternote.presentation.editor
 
 import androidx.lifecycle.SavedStateHandle
 import com.afternote.core.common.reporting.ErrorReporter
-import com.afternote.core.domain.repository.UserRepository
+import com.afternote.core.domain.repository.UserReceiverRepository
 import com.afternote.feature.afternote.domain.AfternoteType
 import com.afternote.feature.afternote.domain.repository.author.AfternoteRepository
 import com.afternote.feature.afternote.domain.repository.author.MemorialMediaUploadRepository
 import com.afternote.feature.afternote.domain.repository.author.MemorialThumbnailUploadRepository
 import com.afternote.feature.afternote.domain.usecase.editor.ResolveMemorialMediaForSaveUseCase
+import com.afternote.feature.afternote.domain.usecase.editor.SaveAfternoteUseCase
 import com.afternote.feature.afternote.presentation.editor.model.RegisterAfternotePayload
 import com.afternote.feature.afternote.presentation.editor.state.AfternoteEditorError
 import com.afternote.feature.afternote.presentation.editor.state.AfternoteValidationError
@@ -59,7 +60,7 @@ class AfternoteEditorValidationEventTest {
             val first = requireNotNull(viewModel.uiState.value.errorEvent)
 
             // 소비(null)와 다음 동일 오류를 UI 수집기가 각각 관찰하지 못하고 합쳐도, 새 occurrence로 구분돼야 한다.
-            viewModel.onErrorConsumed(first)
+            viewModel.onIntent(AfternoteEditorIntent.ConsumeError(first))
             viewModel.saveInvalidSocialAfternote()
             runCurrent()
             val second = requireNotNull(viewModel.uiState.value.errorEvent)
@@ -77,27 +78,29 @@ class AfternoteEditorValidationEventTest {
             assertEquals(second.error, third.error)
             assertNotEquals("소비 전 같은 오류도 저장 시도마다 별도 UI 이벤트여야 한다", second, third)
 
-            viewModel.onErrorConsumed(second)
+            viewModel.onIntent(AfternoteEditorIntent.ConsumeError(second))
             runCurrent()
             assertEquals("이전 Snackbar의 종료가 최신 이벤트를 지우면 안 된다", third, viewModel.uiState.value.errorEvent)
 
-            viewModel.onErrorConsumed(third)
+            viewModel.onIntent(AfternoteEditorIntent.ConsumeError(third))
             runCurrent()
             assertNull(viewModel.uiState.value.errorEvent)
         }
 
     private fun AfternoteEditorViewModel.saveInvalidSocialAfternote() {
-        saveAfternote(
-            payload =
-                RegisterAfternotePayload(
-                    serviceName = "",
-                    date = "2026.08.27",
-                    accountId = "account",
-                    password = "password",
-                    processingMethods = listOf("계정 삭제"),
-                ),
-            selectedReceiverIds = listOf(1L),
-            memorialMedia = SaveAfternoteMemorialMedia(),
+        onIntent(
+            AfternoteEditorIntent.Save(
+                payload =
+                    RegisterAfternotePayload(
+                        serviceName = "",
+                        date = "2026.08.27",
+                        accountId = "account",
+                        password = "password",
+                        processingMethods = listOf("계정 삭제"),
+                    ),
+                selectedReceiverIds = listOf(1L),
+                memorialMedia = SaveAfternoteMemorialMedia(),
+            ),
         )
     }
 
@@ -105,7 +108,7 @@ class AfternoteEditorValidationEventTest {
         AfternoteEditorViewModel(
             route = AfternoteRoute.EditorFlowRoute(initialType = AfternoteType.SOCIAL_NETWORK),
             savedStateHandle = SavedStateHandle(mapOf("initialType" to AfternoteType.SOCIAL_NETWORK)),
-            userRepository = repositoryProxy<UserRepository>(),
+            userReceiverRepository = repositoryProxy<UserReceiverRepository>(),
             afternoteRepository = repositoryProxy<AfternoteRepository>(),
             memorialThumbnailUploadRepository =
                 MemorialThumbnailUploadRepository { error("썸네일 업로드가 호출되면 안 됩니다") },
@@ -113,6 +116,7 @@ class AfternoteEditorValidationEventTest {
                 ResolveMemorialMediaForSaveUseCase(
                     MemorialMediaUploadRepository { _, _ -> error("미디어 저장이 호출되면 안 됩니다") },
                 ),
+            saveAfternoteUseCase = SaveAfternoteUseCase(repositoryProxy<AfternoteRepository>()),
             errorReporter = repositoryProxy<ErrorReporter>(),
         )
 
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/EditorContentSignatureCompletenessTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/EditorContentSignatureCompletenessTest.kt
index 10bd398cdd..2f1ed08bf5 100644
--- a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/EditorContentSignatureCompletenessTest.kt
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/EditorContentSignatureCompletenessTest.kt
@@ -1,31 +1,90 @@
 package com.afternote.feature.afternote.presentation.editor
 
+import androidx.activity.ComponentActivity
 import androidx.compose.foundation.text.input.TextFieldState
+import androidx.compose.runtime.key
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.ui.test.junit4.v2.createAndroidComposeRule
+import androidx.compose.ui.test.onNodeWithContentDescription
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import com.afternote.core.ui.theme.AfternoteTheme
 import com.afternote.feature.afternote.domain.AfternoteType
 import com.afternote.feature.afternote.presentation.editor.receiver.AfternoteEditorReceiver
 import com.afternote.feature.afternote.presentation.editor.state.AfternoteEditorState
 import com.afternote.feature.afternote.presentation.editor.state.AfternoteTypeForm
+import com.afternote.feature.afternote.presentation.editor.state.EditableMemorialPhoto
 import com.afternote.feature.afternote.presentation.editor.state.EditableMemorialVideo
 import com.afternote.feature.afternote.presentation.editor.state.EditorFormState
 import com.afternote.feature.afternote.presentation.editor.state.MemorialVideoAttachment
 import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNotEquals
 import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
 import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
 
-/**
- * 이탈 가드 상태 지문([editorContentSignature])의 완전성 계약 테스트.
- *
- * [AfternoteEditorState]의 [TextFieldState]를 리플렉션으로 전수 열거한 뒤 하나씩 실제로
- * 입력해 보고 지문이 반응하는지 검사한다. 상태 홀더에 입력 상태가 새로 생기면 이 테스트가 자동으로
- * 그 필드를 집어 들므로, 지문에 반영하거나 [dialogTransientStates] 에 사유와 함께 올리는 결정이
- * 강제된다. 폼 쪽은 공용 필드가 통째 직렬화라 필드 추가가 자동 포함이고, 카테고리 축은
- * [AfternoteTypeForm.pristineFor] 의 exhaustive `when` 이 컴파일 단계에서 누락을 잡는다 — 양쪽에 카나리만 둔다.
- */
+/** 내부 지문 대신 실제 화면의 뒤로가기·이탈 경고 계약으로 입력 누락과 오탐을 검증한다. */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [35])
 class EditorContentSignatureCompletenessTest {
-    /** 서비스 시트를 닫거나 선택하면 비우는 검색 query라 이탈 지문에서 제외한다. */
-    private val transientUiStates =
-        setOf("serviceSearchQueryState")
+    @get:Rule val composeRule = createAndroidComposeRule<ComponentActivity>()
+    private val activeCase = mutableStateOf<ExitCase?>(null)
+    private val transientUiStates = setOf("serviceSearchQueryState")
+
+    @Before
+    fun setUp() {
+        composeRule.setContent {
+            activeCase.value?.let { case ->
+                key(case) {
+                    AfternoteTheme {
+                        AfternoteEditorScreen(
+                            form = case.form.value,
+                            state = case.state,
+                            onBackClick = { case.backCalls++ },
+                            onRegisterClick = {},
+                            snackbarMessage = null,
+                            onSnackbarMessageConsumed = {},
+                            validationMessage = null,
+                            onValidationMessageConsumed = {},
+                            content = {},
+                        )
+                    }
+                }
+            }
+        }
+    }
+
+    private class ExitCase(
+        initialForm: EditorFormState,
+        val state: AfternoteEditorState,
+    ) {
+        val form = mutableStateOf(initialForm)
+        var backCalls = 0
+    }
+
+    private fun assertExitGuard(
+        before: EditorFormState = EditorFormState(),
+        after: EditorFormState = before,
+        changed: Boolean = true,
+        prepare: (AfternoteEditorState) -> Unit = {},
+        edit: (AfternoteEditorState) -> Unit = {},
+    ) {
+        val state = newState().also(prepare)
+        val case = ExitCase(before, state)
+        composeRule.runOnIdle { activeCase.value = case }
+        composeRule.waitForIdle()
+        composeRule.runOnIdle {
+            case.form.value = after
+            edit(state)
+        }
+        composeRule.onNodeWithContentDescription("뒤로가기").performClick()
+        val warning = composeRule.onNodeWithText("작성 중인 내용이 사라집니다.", substring = true)
+        if (changed) warning.assertExists() else warning.assertDoesNotExist()
+        assertEquals(if (changed) 0 else 1, case.backCalls)
+    }
 
     private fun newState(): AfternoteEditorState =
         AfternoteEditorState(
@@ -49,191 +108,84 @@ class EditorContentSignatureCompletenessTest {
             editProcessingMethod = { _, _ -> },
         )
 
-    private fun textFieldStateGetters() =
-        AfternoteEditorState::class.java.methods
-            .filter { it.parameterCount == 0 && it.returnType == TextFieldState::class.java }
-
     @Test
-    fun `에디터 상태의 모든 TextFieldState 는 지문에 반영되거나 제외 사유가 명시돼야 한다`() {
-        val getters = textFieldStateGetters()
-        assertTrue("TextFieldState 게터 열거 실패 — 리플렉션 전제 붕괴", getters.size >= 3)
-
+    fun `모든 TextFieldState 편집은 이탈 경고에 반영되거나 제외 사유가 있어야 한다`() {
+        val getters =
+            AfternoteEditorState::class.java.methods
+                .filter { it.parameterCount == 0 && it.returnType == TextFieldState::class.java }
+        assertTrue(getters.size >= 3)
         getters.forEach { getter ->
             val name = getter.name.removePrefix("get").replaceFirstChar { it.lowercase() }
-            val state = newState()
-            val form = EditorFormState()
-            val before = editorContentSignature(form, state)
-            (getter.invoke(state) as TextFieldState).edit { replace(0, length, "완전성테스트입력") }
-            val after = editorContentSignature(form, state)
-            if (name in transientUiStates) {
-                assertEquals("휘발 UI 입력 '$name' 은 지문에서 제외돼야 한다", before, after)
-            } else {
-                assertNotEquals(
-                    "'$name' 입력이 지문에 반영되지 않는다 — editorContentSignature 에 추가하거나 " +
-                        "transientUiStates 에 사유와 함께 올릴 것",
-                    before,
-                    after,
-                )
+            assertExitGuard(changed = name !in transientUiStates) { state ->
+                (getter.invoke(state) as TextFieldState).edit { replace(0, length, "완전성테스트입력") }
             }
         }
     }
 
     @Test
-    fun `메시지 블록 타이핑이 지문에 반영된다`() {
-        val state = newState()
-        val form = EditorFormState()
-        state.addEditorMessage()
-        val before = editorContentSignature(form, state)
-        state.editorMessages
-            .first()
-            .titleState
-            .edit { replace(0, length, "제목") }
-        assertNotEquals(before, editorContentSignature(form, state))
-    }
-
-    @Test
-    fun `공용 폼 필드 변경이 지문에 반영된다 - 통째 직렬화 카나리`() {
-        val state = newState()
-        val before = editorContentSignature(EditorFormState(), state)
-        val after =
-            editorContentSignature(
-                EditorFormState(
-                    afternoteEditReceivers = listOf(AfternoteEditorReceiver(id = 1L, name = "김수신", label = "딸")),
-                ),
-                state,
-            )
-        assertNotEquals(before, after)
+    fun `메시지 블록 입력 후 이탈을 경고한다`() {
+        assertExitGuard(prepare = { it.addEditorMessage() }) { state ->
+            state.editorMessages
+                .first()
+                .titleState
+                .edit { replace(0, length, "제목") }
+        }
     }
 
     @Test
-    fun `카테고리 전용 입력 변경이 지문에 반영된다 - 같은 카테고리끼리 비교`() {
-        val state = newState()
-        val before = editorContentSignature(EditorFormState(typeForm = AfternoteTypeForm.Memorial()), state)
-        val after =
-            editorContentSignature(
-                EditorFormState(typeForm = AfternoteTypeForm.Memorial(pickedPhotoUri = "content://photo")),
-                state,
-            )
-        assertNotEquals(before, after)
+    fun `수신자와 카테고리 전용 입력 변경 후 이탈을 경고한다`() {
+        assertExitGuard(after = EditorFormState(afternoteEditReceivers = listOf(AfternoteEditorReceiver(1L, "수신자", "딸"))))
+        assertExitGuard(before = memorial(), after = memorial(photo = "content://photo"))
+        assertExitGuard(after = EditorFormState(typeForm = AfternoteTypeForm.Social(selectedService = "인스타그램")))
     }
 
     @Test
-    fun `서비스 선택이 지문에 반영된다 - 미선택(null)과 구분`() {
-        val state = newState()
-        val before = editorContentSignature(EditorFormState(typeForm = AfternoteTypeForm.Social()), state)
-        val after =
-            editorContentSignature(
-                EditorFormState(typeForm = AfternoteTypeForm.Social(selectedService = "인스타그램")),
-                state,
-            )
-        assertNotEquals(before, after)
+    fun `입력 없는 카테고리 구경은 경고하지 않는다`() {
+        AfternoteType.entries.forEach { type ->
+            assertExitGuard(after = EditorFormState(typeForm = AfternoteTypeForm.pristineFor(type)), changed = false)
+        }
     }
 
     @Test
-    fun `어느 카테고리를 골라도 입력이 없으면 지문이 같다`() {
-        val state = newState()
-        val signatures =
-            AfternoteType.entries.map { type ->
-                editorContentSignature(
-                    EditorFormState(typeForm = AfternoteTypeForm.pristineFor(type)),
-                    state,
-                )
-            }
-        assertEquals(
-            "카테고리 구경은 변경이 아니다 — 입력이 빈 카테고리는 전부 같은 지문이어야 한다",
-            1,
-            signatures.distinct().size,
+    fun `카테고리 전환으로 입력을 버리면 경고한다`() {
+        assertExitGuard(
+            before = EditorFormState(typeForm = AfternoteTypeForm.Social(selectedService = "인스타그램")),
+            after = EditorFormState(typeForm = AfternoteTypeForm.Gallery()),
         )
     }
 
     @Test
-    fun `카테고리 전환으로 입력값이 버려지면 지문이 달라진다`() {
-        val state = newState()
-        val filled =
-            editorContentSignature(
-                EditorFormState(typeForm = AfternoteTypeForm.Social(selectedService = "인스타그램")),
-                state,
-            )
-        val switched = editorContentSignature(EditorFormState(typeForm = AfternoteTypeForm.Gallery()), state)
-        assertNotEquals(filled, switched)
+    fun `선택 영상은 경고하고 자동 파생 썸네일만 바뀌면 경고하지 않는다`() {
+        val video = EditableMemorialVideo.empty().withSelection("content://video")
+        assertExitGuard(before = memorial(), after = memorial(video))
+        assertExitGuard(
+            before = memorial(video),
+            after = memorial(video.withSelectionThumbnail("https://cdn.test/thumb.jpg")),
+            changed = false,
+        )
     }
 
     @Test
-    fun `자동 파생 썸네일은 지문에서 제외되고 영상 자체는 반영된다`() {
-        val state = newState()
-        val picked = MemorialVideoAttachment(url = "content://video")
-        val pristine = editorContentSignature(EditorFormState(typeForm = AfternoteTypeForm.Memorial()), state)
-        val withVideo =
-            editorContentSignature(
-                EditorFormState(
-                    typeForm =
-                        AfternoteTypeForm.Memorial(
-                            video = EditableMemorialVideo.empty().withSelection(picked.url),
-                        ),
-                ),
-                state,
-            )
-
-        assertNotEquals("고른 영상 자체는 사용자 입력이다", pristine, withVideo)
-        assertEquals(
-            "썸네일은 영상에서 파생된 값이라 사용자 입력이 아니다 — 복원 뒤 재추출로 URL 이 바뀌어도 지문은 그대로여야 한다",
-            withVideo,
-            editorContentSignature(
-                EditorFormState(
-                    typeForm =
-                        AfternoteTypeForm.Memorial(
-                            video =
-                                EditableMemorialVideo
-                                    .empty()
-                                    .withSelection(picked.url)
-                                    .withSelectionThumbnail("https://cdn.test/thumb.jpg"),
-                        ),
-                ),
-                state,
-            ),
+    fun `서버 영상 삭제는 경고하고 서버 썸네일만 바뀌면 경고하지 않는다`() {
+        val attachment = MemorialVideoAttachment("https://cdn.test/video.mp4", "https://cdn.test/thumb.jpg")
+        val video = EditableMemorialVideo.fromServer(attachment)
+        assertExitGuard(before = memorial(video), after = memorial())
+        assertExitGuard(
+            before = memorial(video),
+            after = memorial(EditableMemorialVideo.fromServer(attachment.copy(thumbnailUrl = "https://cdn.test/other.jpg"))),
+            changed = false,
         )
     }
 
-    /**
-     * #1561 은 「prefill 이 채운 서버 원본은 지문에서 제외된다」 는 카나리로 «사용자 입력만 센다» 를 잠갔다.
-     * #1597 이 서버 원본 삭제를 열면서 그 존재 자체가 사용자가 바꿀 수 있는 사실이 됐으므로 지문은 수정
-     * 진입 기준선과 비교해 서버 원본을 포함한다. 저장 성공 후 서버 값만 새로고침하는 경로가 생기면 그때
-     * 기준선을 다시 잡아야 한다 — 제외로 되돌리면 서버 삭제가 이탈 경고 없이 사라진다.
-     */
-    @Test
-    fun `서버 영상 삭제는 지문에 반영되고 서버 썸네일만 달라지면 제외된다`() {
-        val state = newState()
-        val serverVideo =
-            MemorialVideoAttachment(
-                url = "https://cdn.test/farewell.mp4",
-                thumbnailUrl = "https://cdn.test/farewell-thumb.jpg",
-            )
-        val withServerVideo =
-            editorContentSignature(
-                EditorFormState(typeForm = AfternoteTypeForm.Memorial(video = EditableMemorialVideo.fromServer(serverVideo))),
-                state,
-            )
-
-        assertNotEquals(
-            "서버 원본 삭제는 저장하지 않고 이탈할 때 경고해야 한다",
-            withServerVideo,
-            editorContentSignature(EditorFormState(typeForm = AfternoteTypeForm.Memorial()), state),
-        )
-        assertEquals(
-            "서버 썸네일은 영상에서 파생된 값이라 지문에서 제외한다",
-            withServerVideo,
-            editorContentSignature(
-                EditorFormState(
-                    typeForm =
-                        AfternoteTypeForm.Memorial(
-                            video =
-                                EditableMemorialVideo.fromServer(
-                                    serverVideo.copy(thumbnailUrl = "https://cdn.test/another-thumb.jpg"),
-                                ),
-                        ),
-                ),
-                state,
+    private fun memorial(
+        video: EditableMemorialVideo = EditableMemorialVideo.empty(),
+        photo: String? = null,
+    ) = EditorFormState(
+        typeForm =
+            AfternoteTypeForm.Memorial(
+                video = video,
+                photo =
+                    photo?.let { EditableMemorialPhoto.empty().withSelection(it) } ?: EditableMemorialPhoto.empty(),
             ),
-        )
-    }
+    )
 }
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongSearchProgressTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongSearchProgressTest.kt
index 02474ebfd4..78b32fcb82 100644
--- a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongSearchProgressTest.kt
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongSearchProgressTest.kt
@@ -54,8 +54,7 @@ class AddSongSearchProgressTest {
             AfternoteTheme {
                 AddSongScreen(
                     uiState = uiState,
-                    onSearchQueryChange = {},
-                    onErrorConsumed = {},
+                    onIntent = {},
                     onBackClick = {},
                     onSongsAdded = {},
                 )
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongViewModelTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongViewModelTest.kt
new file mode 100644
index 0000000000..524938f605
--- /dev/null
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/AddSongViewModelTest.kt
@@ -0,0 +1,64 @@
+package com.afternote.feature.afternote.presentation.editor.memorial
+
+import com.afternote.feature.afternote.domain.repository.author.MusicSearchRepository
+import com.afternote.feature.afternote.presentation.NoopAuthorErrorReporter
+import com.afternote.feature.afternote.presentation.R
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.advanceTimeBy
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runCurrent
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+import java.io.IOException
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class AddSongViewModelTest {
+    @After
+    fun resetDispatcher() = Dispatchers.resetMain()
+
+    @Test
+    fun `검색 Intent는 debounce한 최신 검색어만 조회하고 실패를 소비한 뒤 다시 표시한다`() =
+        runTest {
+            Dispatchers.setMain(StandardTestDispatcher(testScheduler))
+            val queries = mutableListOf<String>()
+            val repository =
+                MusicSearchRepository { query ->
+                    queries += query
+                    Result.failure(IOException("offline"))
+                }
+            val viewModel = AddSongViewModel(repository, NoopAuthorErrorReporter)
+            viewModel.onIntent(AddSongIntent.Search("old"))
+            runCurrent()
+            advanceTimeBy(299)
+            viewModel.onIntent(AddSongIntent.Search("  latest  "))
+            runCurrent()
+            advanceTimeBy(300)
+            runCurrent()
+            assertEquals(listOf("latest"), queries)
+            assertEquals("  latest  ", viewModel.uiState.value.searchQuery)
+            assertEquals(R.string.afternote_editor_search_failed_generic, viewModel.uiState.value.errorRes)
+
+            viewModel.onIntent(AddSongIntent.ConsumeError)
+            assertNull(viewModel.uiState.value.errorRes)
+            viewModel.onIntent(AddSongIntent.Search("latest"))
+            runCurrent()
+            advanceTimeBy(300)
+            runCurrent()
+            assertEquals(2, queries.size)
+            assertEquals(R.string.afternote_editor_search_failed_generic, viewModel.uiState.value.errorRes)
+
+            viewModel.onIntent(AddSongIntent.Search("   "))
+            runCurrent()
+            advanceTimeBy(300)
+            runCurrent()
+            assertEquals(2, queries.size)
+            assertEquals(false, viewModel.uiState.value.isLoading)
+            assertNull(viewModel.uiState.value.errorRes)
+        }
+}
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/MemorialMediaRemovableTargetsTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/MemorialMediaRemovableTargetsTest.kt
index 93e8ae2451..352eeb33a2 100644
--- a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/MemorialMediaRemovableTargetsTest.kt
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/memorial/MemorialMediaRemovableTargetsTest.kt
@@ -1,6 +1,7 @@
 package com.afternote.feature.afternote.presentation.editor.memorial
 
 import com.afternote.feature.afternote.presentation.editor.state.AfternoteTypeForm
+import com.afternote.feature.afternote.presentation.editor.state.EditableMemorialPhoto
 import com.afternote.feature.afternote.presentation.editor.state.EditableMemorialVideo
 import com.afternote.feature.afternote.presentation.editor.state.EditorFormState
 import com.afternote.feature.afternote.presentation.editor.state.MemorialVideoAttachment
@@ -23,8 +24,7 @@ class MemorialMediaRemovableTargetsTest {
         EditorFormState(
             typeForm =
                 AfternoteTypeForm.Memorial(
-                    pickedPhotoUri = pickedPhotoUri,
-                    photoUrl = photoUrl,
+                    photo = EditableMemorialPhoto.fromSnapshot(photoUrl, pickedPhotoUri),
                     video =
                         EditableMemorialVideo
                             .fromServer(MemorialVideoAttachment.ofOrNull(persistedVideoUrl))
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/receiver/SelectReceiverViewModelTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/receiver/SelectReceiverViewModelTest.kt
index f835d72307..7f854c61aa 100644
--- a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/receiver/SelectReceiverViewModelTest.kt
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/receiver/SelectReceiverViewModelTest.kt
@@ -2,7 +2,7 @@ package com.afternote.feature.afternote.presentation.editor.receiver
 
 import androidx.lifecycle.SavedStateHandle
 import com.afternote.core.common.reporting.ErrorReporter
-import com.afternote.core.domain.testing.FakeUserRepository
+import com.afternote.core.domain.testing.FakeUserReceiverRepository
 import com.afternote.core.model.user.Receiver
 import com.afternote.feature.afternote.presentation.NoopAuthorErrorReporter
 import kotlinx.coroutines.CompletableDeferred
@@ -47,7 +47,7 @@ class SelectReceiverViewModelTest {
     fun `진입 시 수신자 목록을 불러와 에디터 표시 모델로 채운다`() =
         runTest {
             val repository =
-                FakeUserRepository(
+                FakeUserReceiverRepository(
                     receivers =
                         listOf(
                             Receiver(1L, "김혜성", "아들"),
@@ -70,7 +70,7 @@ class SelectReceiverViewModelTest {
     fun `로드가 끝나기 전에는 로딩 상태다`() =
         runTest {
             val gate = CompletableDeferred<List<Receiver>>()
-            val repository = FakeUserRepository(onGetReceivers = { gate.await() })
+            val repository = FakeUserReceiverRepository(onGetReceivers = { gate.await() })
 
             val viewModel = SelectReceiverViewModel(repository, NoopAuthorErrorReporter, SavedStateHandle())
             runCurrent()
@@ -92,7 +92,7 @@ class SelectReceiverViewModelTest {
     fun `로드 실패 시 실패 상태를 남기고 텔레메트리에 기록한다`() =
         runTest {
             val reporter = RecordingErrorReporter()
-            val repository = FakeUserRepository(onGetReceivers = { error("server down") })
+            val repository = FakeUserReceiverRepository(onGetReceivers = { error("server down") })
 
             val viewModel = SelectReceiverViewModel(repository, reporter, SavedStateHandle())
             runCurrent()
@@ -108,7 +108,7 @@ class SelectReceiverViewModelTest {
     fun `실패 후 다시 시도가 성공하면 실패 상태를 걷어낸다`() =
         runTest {
             val repository =
-                FakeUserRepository(
+                FakeUserReceiverRepository(
                     receivers = listOf(Receiver(1L, "김혜성", "아들")),
                     onGetReceivers = { error("server down") },
                 )
@@ -118,7 +118,7 @@ class SelectReceiverViewModelTest {
             assertTrue(viewModel.uiState.value.loadFailed)
 
             repository.onGetReceivers = null
-            viewModel.refresh()
+            viewModel.onIntent(SelectReceiverIntent.Refresh)
             runCurrent()
 
             val state = viewModel.uiState.value
@@ -131,10 +131,10 @@ class SelectReceiverViewModelTest {
         runTest {
             val viewModel = viewModelWithReceivers()
 
-            viewModel.toggleReceiverSelection(1L)
+            viewModel.onIntent(SelectReceiverIntent.ToggleReceiver(1L))
             assertEquals(listOf(1L), viewModel.uiState.value.selectedReceiverIds)
 
-            viewModel.toggleReceiverSelection(1L)
+            viewModel.onIntent(SelectReceiverIntent.ToggleReceiver(1L))
             assertEquals(emptyList<Long>(), viewModel.uiState.value.selectedReceiverIds)
         }
 
@@ -143,8 +143,8 @@ class SelectReceiverViewModelTest {
         runTest {
             val viewModel = viewModelWithReceivers()
 
-            viewModel.toggleReceiverSelection(2L)
-            viewModel.toggleReceiverSelection(1L)
+            viewModel.onIntent(SelectReceiverIntent.ToggleReceiver(2L))
+            viewModel.onIntent(SelectReceiverIntent.ToggleReceiver(1L))
 
             assertEquals(listOf(2L, 1L), viewModel.uiState.value.selectedReceiverIds)
         }
@@ -154,9 +154,9 @@ class SelectReceiverViewModelTest {
         runTest {
             val viewModel = viewModelWithReceivers()
 
-            viewModel.toggleReceiverSelection(1L)
-            viewModel.toggleReceiverSelection(2L)
-            viewModel.toggleReceiverSelection(1L)
+            viewModel.onIntent(SelectReceiverIntent.ToggleReceiver(1L))
+            viewModel.onIntent(SelectReceiverIntent.ToggleReceiver(2L))
+            viewModel.onIntent(SelectReceiverIntent.ToggleReceiver(1L))
 
             assertEquals(listOf(2L), viewModel.uiState.value.selectedReceiverIds)
         }
@@ -174,8 +174,8 @@ class SelectReceiverViewModelTest {
         runTest {
             val viewModel = viewModelWithReceivers(formReceiverIds = listOf(1L))
 
-            viewModel.toggleReceiverSelection(1L)
-            viewModel.applyPreselection(listOf(1L))
+            viewModel.onIntent(SelectReceiverIntent.ToggleReceiver(1L))
+            viewModel.onIntent(SelectReceiverIntent.ApplyPreselection(listOf(1L)))
 
             assertEquals(emptyList<Long>(), viewModel.uiState.value.selectedReceiverIds)
         }
@@ -185,8 +185,8 @@ class SelectReceiverViewModelTest {
         runTest {
             val viewModel = viewModelWithReceivers(formReceiverIds = listOf(1L))
 
-            viewModel.toggleReceiverSelection(1L)
-            viewModel.toggleReceiverSelection(1L)
+            viewModel.onIntent(SelectReceiverIntent.ToggleReceiver(1L))
+            viewModel.onIntent(SelectReceiverIntent.ToggleReceiver(1L))
 
             assertEquals(listOf(1L), viewModel.uiState.value.selectedReceiverIds)
         }
@@ -196,11 +196,11 @@ class SelectReceiverViewModelTest {
         runTest {
             // 미저장 폼을 둔 채 설정에서 수신자를 지우고 돌아온 경우 — 폼엔 남았지만 목록엔 없다.
             val gate = CompletableDeferred<List<Receiver>>()
-            val repository = FakeUserRepository(onGetReceivers = { gate.await() })
+            val repository = FakeUserReceiverRepository(onGetReceivers = { gate.await() })
             val viewModel = SelectReceiverViewModel(repository, NoopAuthorErrorReporter, SavedStateHandle())
             runCurrent()
 
-            viewModel.applyPreselection(listOf(1L, 99L))
+            viewModel.onIntent(SelectReceiverIntent.ApplyPreselection(listOf(1L, 99L)))
 
             gate.complete(
                 listOf(
@@ -217,7 +217,7 @@ class SelectReceiverViewModelTest {
     fun `재조회로 목록에서 사라진 수신자 선택만 해제되고 나머지는 남는다`() =
         runTest {
             val repository =
-                FakeUserRepository(
+                FakeUserReceiverRepository(
                     receivers =
                         listOf(
                             Receiver(1L, "김혜성", "아들"),
@@ -227,10 +227,10 @@ class SelectReceiverViewModelTest {
             val viewModel = SelectReceiverViewModel(repository, NoopAuthorErrorReporter, SavedStateHandle())
             runCurrent()
 
-            viewModel.toggleReceiverSelection(1L)
-            viewModel.toggleReceiverSelection(2L)
+            viewModel.onIntent(SelectReceiverIntent.ToggleReceiver(1L))
+            viewModel.onIntent(SelectReceiverIntent.ToggleReceiver(2L))
             repository.receiverState.value = listOf(Receiver(1L, "김혜성", "아들"))
-            viewModel.refresh()
+            viewModel.onIntent(SelectReceiverIntent.Refresh)
             runCurrent()
 
             assertEquals(listOf(1L), viewModel.uiState.value.selectedReceiverIds)
@@ -240,12 +240,12 @@ class SelectReceiverViewModelTest {
     fun `재조회 후에도 목록에 남아 있는 수신자 선택은 유지된다`() =
         runTest {
             val repository =
-                FakeUserRepository(receivers = listOf(Receiver(1L, "김혜성", "아들")))
+                FakeUserReceiverRepository(receivers = listOf(Receiver(1L, "김혜성", "아들")))
             val viewModel = SelectReceiverViewModel(repository, NoopAuthorErrorReporter, SavedStateHandle())
             runCurrent()
 
-            viewModel.toggleReceiverSelection(1L)
-            viewModel.refresh()
+            viewModel.onIntent(SelectReceiverIntent.ToggleReceiver(1L))
+            viewModel.onIntent(SelectReceiverIntent.Refresh)
             runCurrent()
 
             assertEquals(listOf(1L), viewModel.uiState.value.selectedReceiverIds)
@@ -258,7 +258,7 @@ class SelectReceiverViewModelTest {
         runTest {
             val savedStateHandle = SavedStateHandle()
             val repository =
-                FakeUserRepository(
+                FakeUserReceiverRepository(
                     receivers =
                         listOf(
                             Receiver(1L, "김혜성", "아들"),
@@ -267,7 +267,7 @@ class SelectReceiverViewModelTest {
                 )
             val beforeDeath = SelectReceiverViewModel(repository, NoopAuthorErrorReporter, savedStateHandle)
             runCurrent()
-            beforeDeath.toggleReceiverSelection(2L)
+            beforeDeath.onIntent(SelectReceiverIntent.ToggleReceiver(2L))
 
             val restored = SelectReceiverViewModel(repository, NoopAuthorErrorReporter, savedStateHandle)
             runCurrent()
@@ -280,7 +280,7 @@ class SelectReceiverViewModelTest {
         runTest {
             val savedStateHandle = SavedStateHandle()
             val repository =
-                FakeUserRepository(
+                FakeUserReceiverRepository(
                     receivers =
                         listOf(
                             Receiver(1L, "김혜성", "아들"),
@@ -288,13 +288,13 @@ class SelectReceiverViewModelTest {
                         ),
                 )
             val beforeDeath = SelectReceiverViewModel(repository, NoopAuthorErrorReporter, savedStateHandle)
-            beforeDeath.applyPreselection(listOf(1L))
+            beforeDeath.onIntent(SelectReceiverIntent.ApplyPreselection(listOf(1L)))
             runCurrent()
-            beforeDeath.toggleReceiverSelection(1L)
+            beforeDeath.onIntent(SelectReceiverIntent.ToggleReceiver(1L))
 
             // 재생성 뒤 Route 의 LaunchedEffect 가 같은 폼 수신자로 다시 부른다.
             val restored = SelectReceiverViewModel(repository, NoopAuthorErrorReporter, savedStateHandle)
-            restored.applyPreselection(listOf(1L))
+            restored.onIntent(SelectReceiverIntent.ApplyPreselection(listOf(1L)))
             runCurrent()
 
             assertEquals(emptyList<Long>(), restored.uiState.value.selectedReceiverIds)
@@ -306,7 +306,7 @@ class SelectReceiverViewModelTest {
      */
     private fun viewModelWithReceivers(formReceiverIds: List<Long> = emptyList()): SelectReceiverViewModel {
         val repository =
-            FakeUserRepository(
+            FakeUserReceiverRepository(
                 receivers =
                     listOf(
                         Receiver(1L, "김혜성", "아들"),
@@ -314,7 +314,7 @@ class SelectReceiverViewModelTest {
                     ),
             )
         val viewModel = SelectReceiverViewModel(repository, NoopAuthorErrorReporter, SavedStateHandle())
-        if (formReceiverIds.isNotEmpty()) viewModel.applyPreselection(formReceiverIds)
+        if (formReceiverIds.isNotEmpty()) viewModel.onIntent(SelectReceiverIntent.ApplyPreselection(formReceiverIds))
         dispatcher.scheduler.runCurrent()
         return viewModel
     }
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/selection/EditorServiceSelectionSheetTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/selection/EditorServiceSelectionSheetTest.kt
index 719daf2fd1..5f16011a75 100644
--- a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/selection/EditorServiceSelectionSheetTest.kt
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/selection/EditorServiceSelectionSheetTest.kt
@@ -41,8 +41,9 @@ class EditorServiceSelectionSheetTest {
         val queryState = TextFieldState()
         composeRule.setContent {
             AfternoteTheme {
-                EditorServiceSelectionSheetContent(
-                    title = "소셜 네트워크 서비스 선택",
+                EditorServiceSelectionSheet(
+                    visible = true,
+                    onDismissRequest = {},
                     type = AfternoteType.SOCIAL_NETWORK,
                     services = services,
                     searchQueryState = queryState,
@@ -97,8 +98,9 @@ class EditorServiceSelectionSheetTest {
         val queryState = TextFieldState()
         composeRule.setContent {
             AfternoteTheme {
-                EditorServiceSelectionSheetContent(
-                    title = "비즈니스 서비스 선택",
+                EditorServiceSelectionSheet(
+                    visible = true,
+                    onDismissRequest = {},
                     type = AfternoteType.BUSINESS,
                     services = AfternoteServiceCatalog.businessServices,
                     searchQueryState = queryState,
@@ -122,8 +124,9 @@ class EditorServiceSelectionSheetTest {
         val queryState = TextFieldState()
         composeRule.setContent {
             AfternoteTheme {
-                EditorServiceSelectionSheetContent(
-                    title = "소셜 네트워크 서비스 선택",
+                EditorServiceSelectionSheet(
+                    visible = true,
+                    onDismissRequest = {},
                     type = AfternoteType.SOCIAL_NETWORK,
                     services = listOf("인스타그램", "페이스북"),
                     searchQueryState = queryState,
@@ -132,7 +135,11 @@ class EditorServiceSelectionSheetTest {
             }
         }
 
-        composeRule.assertAccessibleClickTargets()
+        // 시트째 띄우면 Material3 스크림(이름만 있고 Role 없음)이 스윕에 들어온다. 우리 화면
+        // 노드가 아니므로 그것만 빼고 검색 입력·빈 결과 안내·행 전체의 48dp·이름·role·중첩
+        // 클릭 계약(#1167·#1179·#1669)은 그대로 본다.
+        val closeSheet = composeRule.activity.getString(androidx.compose.ui.R.string.close_sheet)
+        composeRule.assertAccessibleClickTargets(exclude = { it.name == closeSheet })
         val rows =
             composeRule
                 .scanEnabledClickTargets()
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/state/EditableMemorialVideoTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/state/EditableMemorialVideoTest.kt
index 25387a4038..df8af4a72b 100644
--- a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/state/EditableMemorialVideoTest.kt
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/editor/state/EditableMemorialVideoTest.kt
@@ -125,6 +125,17 @@ class EditableMemorialVideoTest {
         assertEquals(serverVideo, afterLateThumbnail.displayed)
     }
 
+    @Test
+    fun `빈 썸네일 결과는 썸네일 없음이다`() {
+        val video =
+            EditableMemorialVideo
+                .empty()
+                .withSelection(pickedVideo.url)
+                .withSelectionThumbnail("")
+
+        assertEquals(MemorialVideoAttachment(url = pickedVideo.url, thumbnailUrl = null), video.displayed)
+    }
+
     @Test
     fun `썸네일을 떼도 출처는 남는다`() {
         assertEquals(
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/home/AfternoteHomeListFailureReportingTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/home/AfternoteHomeListFailureReportingTest.kt
index ebe8668066..55424216af 100644
--- a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/home/AfternoteHomeListFailureReportingTest.kt
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/home/AfternoteHomeListFailureReportingTest.kt
@@ -41,7 +41,7 @@ class AfternoteHomeListFailureReportingTest {
         val reporter = RecordingErrorReporter()
         val viewModel = viewModel(reporter)
 
-        viewModel.onListLoadFailed(IOException("목록 조회 실패"))
+        viewModel.onIntent(AfternoteHomeIntent.ListLoadFailed(IOException("목록 조회 실패")))
 
         assertEquals(listOf("list_load"), reporter.recordedStages)
         assertEquals(listOf(IOException::class.java.name), reporter.recordedErrorTypes)
@@ -52,7 +52,7 @@ class AfternoteHomeListFailureReportingTest {
         val reporter = RecordingErrorReporter()
         val viewModel = viewModel(reporter)
 
-        repeat(5) { viewModel.onListLoadFailed(IOException("목록 조회 실패")) }
+        repeat(5) { viewModel.onIntent(AfternoteHomeIntent.ListLoadFailed(IOException("목록 조회 실패"))) }
 
         assertEquals(1, reporter.recordedStages.size)
     }
@@ -62,8 +62,8 @@ class AfternoteHomeListFailureReportingTest {
         val reporter = RecordingErrorReporter()
         val viewModel = viewModel(reporter)
 
-        viewModel.onListLoadFailed(IOException("연결 실패"))
-        viewModel.onListLoadFailed(SocketTimeoutException("응답 없음"))
+        viewModel.onIntent(AfternoteHomeIntent.ListLoadFailed(IOException("연결 실패")))
+        viewModel.onIntent(AfternoteHomeIntent.ListLoadFailed(SocketTimeoutException("응답 없음")))
 
         assertEquals(
             listOf(IOException::class.java.name, SocketTimeoutException::class.java.name),
@@ -76,9 +76,9 @@ class AfternoteHomeListFailureReportingTest {
         val reporter = RecordingErrorReporter()
         val viewModel = viewModel(reporter)
 
-        viewModel.onListLoadFailed(IOException("목록 조회 실패"))
-        viewModel.onListLoadSucceeded()
-        viewModel.onListLoadFailed(IOException("목록 조회 실패"))
+        viewModel.onIntent(AfternoteHomeIntent.ListLoadFailed(IOException("목록 조회 실패")))
+        viewModel.onIntent(AfternoteHomeIntent.ListLoadSucceeded)
+        viewModel.onIntent(AfternoteHomeIntent.ListLoadFailed(IOException("목록 조회 실패")))
 
         assertEquals(listOf("list_load", "list_load"), reporter.recordedStages)
     }
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/receiver/detail/ReceivedAfternoteDetailViewModelTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/receiver/detail/ReceivedAfternoteDetailViewModelTest.kt
index cd0766bfdb..ad98f7a14a 100644
--- a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/receiver/detail/ReceivedAfternoteDetailViewModelTest.kt
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/receiver/detail/ReceivedAfternoteDetailViewModelTest.kt
@@ -63,12 +63,12 @@ class ReceivedAfternoteDetailViewModelTest {
             val states = recordStates(viewModel)
 
             // 첫 진입 화면의 ON_RESUME (init 로드는 이미 실패로 종료됨) — 재조회가 걸리면 안 된다.
-            viewModel.refreshOnReturn()
+            viewModel.onIntent(ReceivedAfternoteDetailIntent.RefreshOnReturn)
             assertEquals(listOf(42L), repository.requestedDetailIds)
             assertTrue(states.last() is ReceivedAfternoteDetailUiState.Error)
 
             // 복구는 사용자의 수동 재시도로만 일어난다.
-            viewModel.retry()
+            viewModel.onIntent(ReceivedAfternoteDetailIntent.Retry)
             assertEquals(listOf(42L, 42L), repository.requestedDetailIds)
             assertEquals("Instagram", states.last().serviceNameOrNull())
         }
@@ -88,8 +88,8 @@ class ReceivedAfternoteDetailViewModelTest {
             val states = recordStates(viewModel)
 
             // init 로드가 아직 도는 중 — 첫 resume(스킵) 뒤 또 한 번 resume 이 와도 중복이 없어야 한다.
-            viewModel.refreshOnReturn()
-            viewModel.refreshOnReturn()
+            viewModel.onIntent(ReceivedAfternoteDetailIntent.RefreshOnReturn)
+            viewModel.onIntent(ReceivedAfternoteDetailIntent.RefreshOnReturn)
             gate.complete(Unit)
 
             assertEquals(listOf(42L), repository.requestedDetailIds)
@@ -113,8 +113,8 @@ class ReceivedAfternoteDetailViewModelTest {
             val viewModel = viewModel(repository)
             val states = recordStates(viewModel)
 
-            viewModel.refreshOnReturn() // 첫 진입의 ON_RESUME — 스킵
-            viewModel.refreshOnReturn() // 백스택 복귀의 ON_RESUME
+            viewModel.onIntent(ReceivedAfternoteDetailIntent.RefreshOnReturn) // 첫 진입의 ON_RESUME — 스킵
+            viewModel.onIntent(ReceivedAfternoteDetailIntent.RefreshOnReturn) // 백스택 복귀의 ON_RESUME
 
             assertEquals(listOf(42L, 42L), repository.requestedDetailIds)
             assertEquals("Facebook", states.last().serviceNameOrNull())
@@ -141,8 +141,8 @@ class ReceivedAfternoteDetailViewModelTest {
             val viewModel = viewModel(repository, errorReporter = reporter)
             val states = recordStates(viewModel)
 
-            viewModel.refreshOnReturn() // 첫 진입의 ON_RESUME — 스킵
-            viewModel.refreshOnReturn() // 백스택 복귀의 ON_RESUME
+            viewModel.onIntent(ReceivedAfternoteDetailIntent.RefreshOnReturn) // 첫 진입의 ON_RESUME — 스킵
+            viewModel.onIntent(ReceivedAfternoteDetailIntent.RefreshOnReturn) // 백스택 복귀의 ON_RESUME
 
             // 잘 보고 있던 상세가 에러 화면으로 대체되지 않는다.
             assertEquals("Instagram", states.last().serviceNameOrNull())
@@ -175,7 +175,7 @@ class ReceivedAfternoteDetailViewModelTest {
             val states = recordStates(viewModel)
 
             // 첫 로드가 매달린 사이 사용자가 «다시 시도하기» — 옛 Job 은 잘리고 새 로드가 화면을 채운다.
-            viewModel.retry()
+            viewModel.onIntent(ReceivedAfternoteDetailIntent.Retry)
             assertEquals("Fresh", states.last().serviceNameOrNull())
 
             // 잘린 옛 로드가 이제야 값을 들고 돌아온다.
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/receiver/playlist/ReceiverMemorialPlaylistViewModelTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/receiver/playlist/ReceiverMemorialPlaylistViewModelTest.kt
index e508ac4f14..514ad56f7f 100644
--- a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/receiver/playlist/ReceiverMemorialPlaylistViewModelTest.kt
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/receiver/playlist/ReceiverMemorialPlaylistViewModelTest.kt
@@ -74,7 +74,7 @@ class ReceiverMemorialPlaylistViewModelTest {
         assertEquals(IOException::class.java.name, errorReporter.reportedErrors.single().message)
         assertTrue(errorReporter.reportedErrors.none { it.message?.contains("sensitive") == true })
 
-        viewModel.retry()
+        viewModel.onIntent(ReceiverMemorialPlaylistIntent.Retry)
 
         assertEquals(listOf(42L, 42L), repository.requestedDetailIds)
         assertEquals(2, errorReporter.reportedErrors.size)
@@ -98,7 +98,7 @@ class ReceiverMemorialPlaylistViewModelTest {
         val viewModel = viewModel(afternoteId = 42L, repository = repository)
 
         // 첫 진입 화면의 ON_RESUME (init 로드는 이미 실패로 종료됨).
-        viewModel.refreshOnReturn()
+        viewModel.onIntent(ReceiverMemorialPlaylistIntent.RefreshOnReturn)
 
         assertEquals(listOf(42L), repository.requestedDetailIds)
         assertTrue(viewModel.uiState.value is ReceiverMemorialPlaylistUiState.Error)
@@ -118,8 +118,8 @@ class ReceiverMemorialPlaylistViewModelTest {
             val viewModel = viewModel(afternoteId = 42L, repository = repository)
 
             // init 로드가 아직 도는 중 — 첫 resume(스킵) 뒤 또 한 번 resume 이 와도 중복이 없어야 한다.
-            viewModel.refreshOnReturn()
-            viewModel.refreshOnReturn()
+            viewModel.onIntent(ReceiverMemorialPlaylistIntent.RefreshOnReturn)
+            viewModel.onIntent(ReceiverMemorialPlaylistIntent.RefreshOnReturn)
             gate.complete(Unit)
 
             assertEquals(listOf(42L), repository.requestedDetailIds)
@@ -147,8 +147,8 @@ class ReceiverMemorialPlaylistViewModelTest {
                 viewModel.uiState.collect { states += it }
             }
 
-            viewModel.refreshOnReturn() // 첫 진입의 ON_RESUME — 스킵
-            viewModel.refreshOnReturn() // 백스택 복귀의 ON_RESUME
+            viewModel.onIntent(ReceiverMemorialPlaylistIntent.RefreshOnReturn) // 첫 진입의 ON_RESUME — 스킵
+            viewModel.onIntent(ReceiverMemorialPlaylistIntent.RefreshOnReturn) // 백스택 복귀의 ON_RESUME
 
             assertEquals(listOf(42L, 42L), repository.requestedDetailIds)
             val refreshed = states.last() as ReceiverMemorialPlaylistUiState.Success
@@ -178,8 +178,8 @@ class ReceiverMemorialPlaylistViewModelTest {
                 errorReporter = errorReporter,
             )
 
-        viewModel.refreshOnReturn() // 첫 진입의 ON_RESUME — 스킵
-        viewModel.refreshOnReturn() // 백스택 복귀의 ON_RESUME
+        viewModel.onIntent(ReceiverMemorialPlaylistIntent.RefreshOnReturn) // 첫 진입의 ON_RESUME — 스킵
+        viewModel.onIntent(ReceiverMemorialPlaylistIntent.RefreshOnReturn) // 백스택 복귀의 ON_RESUME
 
         // 잘 보고 있던 목록이 에러 화면으로 대체되지 않는다.
         val state = viewModel.uiState.value as ReceiverMemorialPlaylistUiState.Success
diff --git a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/receiver/playlist/ReceiverPlaylistHeaderTest.kt b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/receiver/playlist/ReceiverPlaylistHeaderTest.kt
index 7f5a70b33f..6baf1ae5ef 100644
--- a/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/receiver/playlist/ReceiverPlaylistHeaderTest.kt
+++ b/feature/afternote/presentation/src/test/kotlin/com/afternote/feature/afternote/presentation/receiver/playlist/ReceiverPlaylistHeaderTest.kt
@@ -57,7 +57,7 @@ class ReceiverPlaylistHeaderTest {
     fun `수신자 플레이리스트 헤더는 곡 수를 보여준다`() {
         renderScreen()
 
-        val songCount = composeRule.activity.getString(R.string.afternote_receiver_playlist_song_count_format, songs.size)
+        val songCount = composeRule.activity.getString(R.string.afternote_playlist_song_count_format, songs.size)
         composeRule.onNodeWithText(songCount).assertIsDisplayed()
     }
 }
diff --git a/feature/afternote/presentation/src/testFixtures/kotlin/com/afternote/feature/afternote/presentation/testing/AfternoteScreenFixtures.kt b/feature/afternote/presentation/src/testFixtures/kotlin/com/afternote/feature/afternote/presentation/testing/AfternoteScreenFixtures.kt
new file mode 100644
index 0000000000..469e214f50
--- /dev/null
+++ b/feature/afternote/presentation/src/testFixtures/kotlin/com/afternote/feature/afternote/presentation/testing/AfternoteScreenFixtures.kt
@@ -0,0 +1,52 @@
+package com.afternote.feature.afternote.presentation.testing
+
+import androidx.compose.runtime.Composable
+import com.afternote.core.common.reporting.ErrorReporter
+import com.afternote.feature.afternote.domain.AfternoteType
+import com.afternote.feature.afternote.domain.repository.author.AfternoteRepository
+import com.afternote.feature.afternote.presentation.home.AfternoteHomeEntry
+import com.afternote.feature.afternote.presentation.home.AfternoteHomeViewModel
+import com.afternote.feature.afternote.presentation.receiver.detail.ReceivedAfternoteDetailRoute
+import com.afternote.feature.afternote.presentation.receiver.detail.ReceivedAfternoteDetailViewModel
+import com.afternote.feature.afternote.presentation.receiver.navigation.ReceivedAfternoteRoute
+import com.afternote.feature.receiver.domain.repository.ReceiverRepository
+
+/** 실제 목록 VM과 화면을 연결한다. 테스트는 저장소 응답과 화면의 사용자 액션으로 동작을 검증한다. */
+public class AfternoteHomeScreenFixture(
+    repository: AfternoteRepository,
+    errorReporter: ErrorReporter,
+) {
+    private val viewModel = AfternoteHomeViewModel(repository, errorReporter)
+
+    @Composable
+    public fun Content(
+        navigateToDetail: (Long) -> Unit,
+        navigateToAdd: (AfternoteType) -> Unit,
+        onSettingClick: () -> Unit,
+    ) {
+        AfternoteHomeEntry(navigateToDetail, navigateToAdd, onSettingClick, viewModel)
+    }
+}
+
+/** 수신 상세의 실제 조회·재시도·Lifecycle·렌더 경계를 앱 기기 테스트에서도 그대로 사용한다. */
+public class ReceivedAfternoteDetailScreenFixture(
+    afternoteId: Long,
+    receiverRepository: ReceiverRepository,
+    errorReporter: ErrorReporter,
+) {
+    private val viewModel =
+        ReceivedAfternoteDetailViewModel(
+            route = ReceivedAfternoteRoute.DetailRoute(afternoteId),
+            receiverRepository = receiverRepository,
+            errorReporter = errorReporter,
+        )
+
+    @Composable
+    public fun Content(
+        onNavigateBack: () -> Unit,
+        onNavigateToFullList: () -> Unit,
+        onNavigateToPlaylist: (Long) -> Unit,
+    ) {
+        ReceivedAfternoteDetailRoute(onNavigateBack, onNavigateToFullList, onNavigateToPlaylist, viewModel)
+    }
+}
diff --git a/feature/receiver/data/src/main/kotlin/com/afternote/feature/receiver/data/paging/ReceiverAfternotePagingSource.kt b/feature/receiver/data/src/main/kotlin/com/afternote/feature/receiver/data/paging/ReceiverAfternotePagingSource.kt
index 9a387391bb..118686ba77 100644
--- a/feature/receiver/data/src/main/kotlin/com/afternote/feature/receiver/data/paging/ReceiverAfternotePagingSource.kt
+++ b/feature/receiver/data/src/main/kotlin/com/afternote/feature/receiver/data/paging/ReceiverAfternotePagingSource.kt
@@ -3,7 +3,7 @@ package com.afternote.feature.receiver.data.paging
 import androidx.paging.PagingSource
 import androidx.paging.PagingState
 import com.afternote.core.common.reporting.ErrorReporter
-import com.afternote.core.common.result.runCatchingCancellable
+import com.afternote.core.domain.result.runCatchingCancellable
 import com.afternote.core.network.model.requireData
 import com.afternote.feature.receiver.data.error.toReceiverFailure
 import com.afternote.feature.receiver.data.mapper.toReceiverDomainList
diff --git a/feature/receiver/data/src/main/kotlin/com/afternote/feature/receiver/data/repositoryimpl/ReceiverAuthRepositoryImpl.kt b/feature/receiver/data/src/main/kotlin/com/afternote/feature/receiver/data/repositoryimpl/ReceiverAuthRepositoryImpl.kt
index b7ba0241fa..6a71e456f4 100644
--- a/feature/receiver/data/src/main/kotlin/com/afternote/feature/receiver/data/repositoryimpl/ReceiverAuthRepositoryImpl.kt
+++ b/feature/receiver/data/src/main/kotlin/com/afternote/feature/receiver/data/repositoryimpl/ReceiverAuthRepositoryImpl.kt
@@ -1,7 +1,7 @@
 package com.afternote.feature.receiver.data.repositoryimpl
 
 import com.afternote.core.common.reporting.ErrorReporter
-import com.afternote.core.common.result.runCatchingCancellable
+import com.afternote.core.domain.result.runCatchingCancellable
 import com.afternote.core.network.model.requireData
 import com.afternote.core.network.model.requireStatus
 import com.afternote.feature.receiver.data.dto.DeliveryVerificationRequestDto
diff --git a/feature/receiver/data/src/main/kotlin/com/afternote/feature/receiver/data/repositoryimpl/ReceiverDeliveryDocumentUploadRepositoryImpl.kt b/feature/receiver/data/src/main/kotlin/com/afternote/feature/receiver/data/repositoryimpl/ReceiverDeliveryDocumentUploadRepositoryImpl.kt
index 513ee94c7c..20bcce9f57 100644
--- a/feature/receiver/data/src/main/kotlin/com/afternote/feature/receiver/data/repositoryimpl/ReceiverDeliveryDocumentUploadRepositoryImpl.kt
+++ b/feature/receiver/data/src/main/kotlin/com/afternote/feature/receiver/data/repositoryimpl/ReceiverDeliveryDocumentUploadRepositoryImpl.kt
@@ -1,7 +1,7 @@
 package com.afternote.feature.receiver.data.repositoryimpl
 
 import com.afternote.core.common.di.IoDispatcher
-import com.afternote.core.common.result.runCatchingCancellable
+import com.afternote.core.domain.result.runCatchingCancellable
 import com.afternote.feature.receiver.data.error.mapReceiverFailure
 import com.afternote.feature.receiver.domain.repository.ReceiverAuthRepository
 import com.afternote.feature.receiver.domain.repository.ReceiverDeliveryDocumentUploadRepository
diff --git a/feature/receiver/data/src/main/kotlin/com/afternote/feature/receiver/data/repositoryimpl/ReceiverRepositoryImpl.kt b/feature/receiver/data/src/main/kotlin/com/afternote/feature/receiver/data/repositoryimpl/ReceiverRepositoryImpl.kt
index dc7ff95df6..e3ff45f4c2 100644
--- a/feature/receiver/data/src/main/kotlin/com/afternote/feature/receiver/data/repositoryimpl/ReceiverRepositoryImpl.kt
+++ b/feature/receiver/data/src/main/kotlin/com/afternote/feature/receiver/data/repositoryimpl/ReceiverRepositoryImpl.kt
@@ -4,7 +4,7 @@ import androidx.paging.Pager
 import androidx.paging.PagingConfig
 import androidx.paging.PagingData
 import com.afternote.core.common.reporting.ErrorReporter
-import com.afternote.core.common.result.runCatchingCancellable
+import com.afternote.core.domain.result.runCatchingCancellable
 import com.afternote.core.network.model.requireData
 import com.afternote.feature.receiver.data.error.mapReceiverFailure
 import com.afternote.feature.receiver.data.local.ReceiverMasterKeyDataSource
diff --git a/feature/receiver/presentation/build.gradle.kts b/feature/receiver/presentation/build.gradle.kts
index 1e571a5ee8..8853032a97 100644
--- a/feature/receiver/presentation/build.gradle.kts
+++ b/feature/receiver/presentation/build.gradle.kts
@@ -16,17 +16,16 @@ android {
 
 dependencies {
     implementation(projects.feature.receiver.domain)
-    // 수신자 홈이 각 기능의 수신 Repository·모델을 조합한다. afternote 의존(도메인 모델·서비스명
-    // 아이콘 매핑)은 수신자 흐름 잔여분이 afternote 에서 이 모듈로 합류(#615)하면 재검토.
-    implementation(projects.feature.afternote.domain)
+    // 수신자 흐름의 실패를 애프터노트 리포팅 키(AfternoteFailureStage·recordAfternoteFailure)로 기록한다.
     implementation(projects.feature.afternote.presentation)
     implementation(projects.feature.mindrecord.domain)
     implementation(projects.feature.timeletter.domain)
     implementation(projects.core.domain)
+    // 초대 조회·수락 결과 모델 (#944).
+    implementation(projects.core.model)
     implementation(projects.core.common)
     implementation(projects.core.ui)
     implementation(libs.androidx.activity.compose)
-    implementation(libs.androidx.hilt.navigation.compose)
     implementation(libs.hilt.navigation)
     implementation(libs.androidx.lifecycle.viewmodel.ktx)
     implementation(libs.androidx.lifecycle.runtime.compose)
@@ -35,6 +34,7 @@ dependencies {
     implementation(libs.androidx.paging.compose)
 
     testImplementation(libs.coroutines.test)
+    testImplementation(testFixtures(projects.core.domain))
     testImplementation(testFixtures(projects.feature.mindrecord.domain))
     testImplementation(testFixtures(projects.feature.receiver.domain))
     testImplementation(testFixtures(projects.feature.timeletter.domain))
diff --git a/feature/receiver/presentation/src/main/kotlin/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationCompleteScreen.kt b/feature/receiver/presentation/src/main/kotlin/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationCompleteScreen.kt
new file mode 100644
index 0000000000..9c039580d3
--- /dev/null
+++ b/feature/receiver/presentation/src/main/kotlin/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationCompleteScreen.kt
@@ -0,0 +1,120 @@
+package com.afternote.feature.receiver.presentation.invitation
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Icon
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import com.afternote.core.ui.button.AfternoteButton
+import com.afternote.core.ui.theme.AfternoteDesign
+import com.afternote.core.ui.topbar.DetailTopBar
+import com.afternote.feature.receiver.presentation.R
+import com.afternote.core.ui.R as CoreR
+
+/**
+ * 초대 수락 완료 (시안 4996:39921, #944). «확인하기» 와 back 모두 받은 기록함으로 간다 —
+ * 수락은 서버에 이미 반영됐으므로 되돌아갈 랜딩이 없다.
+ */
+@Composable
+fun ReceiverInvitationCompleteScreen(
+    inviterName: String,
+    onConfirm: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Scaffold(
+        modifier = modifier.fillMaxSize(),
+        containerColor = AfternoteDesign.colors.gray1,
+        topBar = {
+            DetailTopBar(
+                title = stringResource(R.string.receiver_invitation_complete_top_bar_title),
+                onBackClick = onConfirm,
+            )
+        },
+    ) { innerPadding ->
+        Column(
+            modifier =
+                Modifier
+                    .padding(innerPadding)
+                    .fillMaxSize()
+                    .padding(horizontal = 20.dp)
+                    .padding(bottom = 32.dp),
+            horizontalAlignment = Alignment.CenterHorizontally,
+        ) {
+            Spacer(modifier = Modifier.height(96.dp))
+            SuccessCheck()
+            Spacer(modifier = Modifier.height(32.dp))
+            Text(
+                text = stringResource(R.string.receiver_invitation_complete_title),
+                style = AfternoteDesign.typography.h1,
+                color = AfternoteDesign.colors.gray9,
+                textAlign = TextAlign.Center,
+            )
+            Spacer(modifier = Modifier.height(16.dp))
+            Text(
+                text = stringResource(R.string.receiver_invitation_complete_description, inviterName),
+                style = AfternoteDesign.typography.bodySmallR,
+                color = AfternoteDesign.colors.gray7,
+                textAlign = TextAlign.Center,
+            )
+            Spacer(modifier = Modifier.weight(1f))
+            Text(
+                text = stringResource(R.string.receiver_invitation_complete_info),
+                style = AfternoteDesign.typography.captionLargeR,
+                color = AfternoteDesign.colors.gray6,
+                modifier =
+                    Modifier
+                        .fillMaxWidth()
+                        .clip(RoundedCornerShape(12.dp))
+                        .background(AfternoteDesign.colors.gray2)
+                        .padding(16.dp),
+            )
+            Spacer(modifier = Modifier.height(16.dp))
+            AfternoteButton(
+                text = stringResource(R.string.receiver_invitation_complete_confirm),
+                onClick = onConfirm,
+                modifier = Modifier.fillMaxWidth(),
+            )
+        }
+    }
+}
+
+/** 시안의 초록 체크 — 테마에 초록 토큰이 없어 시안 실측값을 이 화면 안에만 둔다. */
+@Composable
+private fun SuccessCheck() {
+    Box(
+        modifier =
+            Modifier
+                .size(96.dp)
+                .clip(CircleShape)
+                .background(SuccessCircleColor),
+        contentAlignment = Alignment.Center,
+    ) {
+        Icon(
+            painter = painterResource(CoreR.drawable.core_ui_ic_check),
+            contentDescription = stringResource(R.string.receiver_invitation_complete_check_description),
+            tint = SuccessCheckColor,
+            modifier = Modifier.size(width = 36.dp, height = 27.dp),
+        )
+    }
+}
+
+private val SuccessCircleColor = Color(0xFFD5EBDB)
+private val SuccessCheckColor = Color(0xFF2E9E4F)
diff --git a/feature/receiver/presentation/src/main/kotlin/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationContract.kt b/feature/receiver/presentation/src/main/kotlin/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationContract.kt
new file mode 100644
index 0000000000..cbbf62aeba
--- /dev/null
+++ b/feature/receiver/presentation/src/main/kotlin/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationContract.kt
@@ -0,0 +1,111 @@
+package com.afternote.feature.receiver.presentation.invitation
+
+import androidx.compose.runtime.Immutable
+import com.afternote.core.ui.UiText
+import com.afternote.core.ui.mvi.MviIntent
+import com.afternote.core.ui.mvi.ReducerEvent
+import com.afternote.core.ui.mvi.UiState
+import com.afternote.feature.receiver.presentation.error.ReceiverErrorPopup
+
+/** 초대 랜딩(4996:40023)의 사용자 의도 (#944). */
+sealed interface ReceiverInvitationIntent : MviIntent {
+    /** «카카오로 시작하고 수락하기» — 로그인 여부 판정은 화면 밖(앱 셸)이 하고, 로그인 상태에서만 온다. */
+    data object Accept : ReceiverInvitationIntent
+
+    /** «나중에 결정하기» — 토큰은 남기고 화면만 닫는다. */
+    data object Defer : ReceiverInvitationIntent
+
+    /** 안내로 끝난 초대의 «확인» — 토큰은 이미 지워져 있고 화면만 닫는다. */
+    data object AcknowledgeNotice : ReceiverInvitationIntent
+
+    /** 오류 팝업의 «다시 시도» — 조회 실패면 조회를, 수락 실패면 수락을 다시 한다. */
+    data object Retry : ReceiverInvitationIntent
+
+    data object DismissErrorPopup : ReceiverInvitationIntent
+
+    data object ConsumeAccepted : ReceiverInvitationIntent
+
+    data object ConsumeOpenReceivedRecords : ReceiverInvitationIntent
+
+    data object ConsumeLoginRequired : ReceiverInvitationIntent
+
+    data object ConsumeClose : ReceiverInvitationIntent
+}
+
+/** 랜딩이 그리는 본문의 갈래. */
+sealed interface ReceiverInvitationPhase {
+    /** 조회 중 — 초대자 이름을 아직 모른다. */
+    data object Loading : ReceiverInvitationPhase
+
+    /** 초대자를 확인했다 — 수락 버튼을 보인다. */
+    data class Ready(
+        val inviterName: String,
+    ) : ReceiverInvitationPhase
+
+    /**
+     * 더 진행할 수 없는 초대(없음·만료·다른 사용자가 수락·본인 초대) — 안내 한 줄과 «확인» 만 보인다.
+     * 이 갈래에 들어올 때 토큰은 이미 지워졌다.
+     */
+    data class Notice(
+        val message: UiText,
+    ) : ReceiverInvitationPhase
+}
+
+/**
+ * 초대 랜딩 상태 (#944). 일회성 신호는 nullable 필드로 담고 `Consume*` Intent 로 비운다(#228).
+ *
+ * @property acceptedInviterName 수락 성공 — 완료 화면(4996:39921)으로 이 이름을 들고 간다.
+ * @property openReceivedRecords 이미 등록된 수신자였다 — 안내 없이 받은 기록함으로 보낸다.
+ * @property loginRequired 서버가 인증을 거절했다 — 토큰은 남기고 로그인으로 보낸다.
+ * @property close «나중에 결정하기»·안내 확인 — 화면을 닫는다.
+ */
+@Immutable
+data class ReceiverInvitationUiState(
+    val phase: ReceiverInvitationPhase = ReceiverInvitationPhase.Loading,
+    val isAccepting: Boolean = false,
+    val errorPopup: ReceiverErrorPopup? = null,
+    val acceptedInviterName: String? = null,
+    val openReceivedRecords: Boolean = false,
+    val loginRequired: Boolean = false,
+    val close: Boolean = false,
+) : UiState
+
+sealed interface ReceiverInvitationReducerEvent : ReducerEvent {
+    data object LookupStarted : ReceiverInvitationReducerEvent
+
+    data class LookupSucceeded(
+        val inviterName: String,
+    ) : ReceiverInvitationReducerEvent
+
+    data class NoticeShown(
+        val message: UiText,
+    ) : ReceiverInvitationReducerEvent
+
+    data class ErrorPopupShown(
+        val popup: ReceiverErrorPopup,
+    ) : ReceiverInvitationReducerEvent
+
+    data object ErrorPopupDismissed : ReceiverInvitationReducerEvent
+
+    data object AcceptStarted : ReceiverInvitationReducerEvent
+
+    data class AcceptSucceeded(
+        val inviterName: String,
+    ) : ReceiverInvitationReducerEvent
+
+    data object AcceptFinished : ReceiverInvitationReducerEvent
+
+    data object AlreadyRegistered : ReceiverInvitationReducerEvent
+
+    data object LoginRequired : ReceiverInvitationReducerEvent
+
+    data object CloseRequested : ReceiverInvitationReducerEvent
+
+    data object AcceptedConsumed : ReceiverInvitationReducerEvent
+
+    data object OpenReceivedRecordsConsumed : ReceiverInvitationReducerEvent
+
+    data object LoginRequiredConsumed : ReceiverInvitationReducerEvent
+
+    data object CloseConsumed : ReceiverInvitationReducerEvent
+}
diff --git a/feature/receiver/presentation/src/main/kotlin/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationLandingContent.kt b/feature/receiver/presentation/src/main/kotlin/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationLandingContent.kt
new file mode 100644
index 0000000000..1df22d761a
--- /dev/null
+++ b/feature/receiver/presentation/src/main/kotlin/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationLandingContent.kt
@@ -0,0 +1,200 @@
+package com.afternote.feature.receiver.presentation.invitation
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.afternote.core.ui.asString
+import com.afternote.core.ui.button.AfternoteButton
+import com.afternote.core.ui.button.AfternoteButtonType
+import com.afternote.core.ui.mvi.ObserveSignal
+import com.afternote.core.ui.theme.AfternoteDesign
+import com.afternote.core.ui.topbar.DetailTopBar
+import com.afternote.feature.receiver.presentation.R
+import com.afternote.feature.receiver.presentation.error.ReceiverErrorPopupHost
+
+/** [ReceiverInvitationLandingScreen] 의 상태 없는 본문 — 프리뷰·스크린샷·Robolectric 진입점. */
+@Composable
+internal fun ReceiverInvitationLandingContent(
+    state: ReceiverInvitationUiState,
+    onIntent: (ReceiverInvitationIntent) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    ReceiverErrorPopupHost(
+        popup = state.errorPopup,
+        onRetry = { onIntent(ReceiverInvitationIntent.Retry) },
+        onDismiss = { onIntent(ReceiverInvitationIntent.DismissErrorPopup) },
+    )
+
+    Scaffold(
+        modifier = modifier.fillMaxSize(),
+        containerColor = AfternoteDesign.colors.gray1,
+        topBar = {
+            DetailTopBar(
+                title = stringResource(R.string.receiver_invitation_top_bar_title),
+                onBackClick = { onIntent(ReceiverInvitationIntent.Defer) },
+            )
+        },
+    ) { innerPadding ->
+        Column(
+            modifier =
+                Modifier
+                    .padding(innerPadding)
+                    .fillMaxSize()
+                    .padding(horizontal = 20.dp)
+                    .padding(bottom = 32.dp),
+        ) {
+            when (val phase = state.phase) {
+                ReceiverInvitationPhase.Loading -> {
+                    LoadingBody(modifier = Modifier.weight(1f))
+                }
+
+                is ReceiverInvitationPhase.Ready -> {
+                    ReadyBody(
+                        inviterName = phase.inviterName,
+                        modifier =
+                            Modifier
+                                .weight(1f)
+                                .verticalScroll(rememberScrollState()),
+                    )
+                    AfternoteButton(
+                        text = stringResource(R.string.receiver_invitation_accept),
+                        onClick = { onIntent(ReceiverInvitationIntent.Accept) },
+                        containerColor = KakaoContainerColor,
+                        contentColor = KakaoContentColor,
+                        isLoading = state.isAccepting,
+                        modifier = Modifier.fillMaxWidth(),
+                    )
+                    Spacer(modifier = Modifier.height(12.dp))
+                    AfternoteButton(
+                        text = stringResource(R.string.receiver_invitation_defer),
+                        onClick = { onIntent(ReceiverInvitationIntent.Defer) },
+                        type = AfternoteButtonType.Plain,
+                        modifier = Modifier.fillMaxWidth(),
+                    )
+                    Spacer(modifier = Modifier.height(16.dp))
+                    Text(
+                        text = stringResource(R.string.receiver_invitation_privacy_caption, phase.inviterName),
+                        style = AfternoteDesign.typography.captionLargeR,
+                        color = AfternoteDesign.colors.gray6,
+                        textAlign = TextAlign.Center,
+                        modifier = Modifier.fillMaxWidth(),
+                    )
+                }
+
+                is ReceiverInvitationPhase.Notice -> {
+                    Box(
+                        modifier = Modifier.weight(1f),
+                        contentAlignment = Alignment.Center,
+                    ) {
+                        Text(
+                            text = phase.message.asString(),
+                            style = AfternoteDesign.typography.bodyBase,
+                            color = AfternoteDesign.colors.gray9,
+                            textAlign = TextAlign.Center,
+                        )
+                    }
+                    AfternoteButton(
+                        text = stringResource(R.string.receiver_invitation_notice_confirm),
+                        onClick = { onIntent(ReceiverInvitationIntent.AcknowledgeNotice) },
+                        modifier = Modifier.fillMaxWidth(),
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun LoadingBody(modifier: Modifier = Modifier) {
+    Column(
+        modifier = modifier.fillMaxWidth(),
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.Center,
+    ) {
+        CircularProgressIndicator(color = AfternoteDesign.colors.gray6)
+        Spacer(modifier = Modifier.height(16.dp))
+        Text(
+            text = stringResource(R.string.receiver_invitation_loading),
+            style = AfternoteDesign.typography.bodySmallR,
+            color = AfternoteDesign.colors.gray6,
+        )
+    }
+}
+
+@Composable
+private fun ReadyBody(
+    inviterName: String,
+    modifier: Modifier = Modifier,
+) {
+    Column(modifier = modifier) {
+        Spacer(modifier = Modifier.height(24.dp))
+        Text(
+            text = stringResource(R.string.receiver_invitation_title, inviterName),
+            style = AfternoteDesign.typography.h1,
+            color = AfternoteDesign.colors.gray9,
+        )
+        Spacer(modifier = Modifier.height(16.dp))
+        Text(
+            text = stringResource(R.string.receiver_invitation_description, inviterName),
+            style = AfternoteDesign.typography.bodySmallR,
+            color = AfternoteDesign.colors.gray7,
+        )
+        Spacer(modifier = Modifier.height(48.dp))
+        InviterRow(inviterName = inviterName)
+    }
+}
+
+/** 시안의 정보 카드 한 줄 — 조회 응답에 있는 «나를 등록한 분» 만 그린다. */
+@Composable
+private fun InviterRow(inviterName: String) {
+    Row(
+        modifier =
+            Modifier
+                .fillMaxWidth()
+                .clip(RoundedCornerShape(12.dp))
+                .background(AfternoteDesign.colors.white)
+                .padding(horizontal = 16.dp, vertical = 20.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Text(
+            text = stringResource(R.string.receiver_invitation_row_inviter),
+            style = AfternoteDesign.typography.bodyBase,
+            color = AfternoteDesign.colors.gray9,
+            modifier = Modifier.weight(1f),
+        )
+        Text(
+            text = inviterName,
+            style = AfternoteDesign.typography.bodyBase,
+            color = AfternoteDesign.colors.gray9,
+        )
+    }
+}
+
+/** 카카오 브랜드 노랑 — 온보딩 로그인 버튼(`LoginScreen.KakaoContainerColor`)과 같은 값. */
+internal val KakaoContainerColor = Color(0xFFFEE500)
+
+/** 카카오 버튼 라벨 색 — 심볼과 같은 #212121·알파 90.2%. */
+internal val KakaoContentColor = Color(0xE6212121)
diff --git a/feature/receiver/presentation/src/main/kotlin/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationLandingScreen.kt b/feature/receiver/presentation/src/main/kotlin/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationLandingScreen.kt
new file mode 100644
index 0000000000..d3027e7ead
--- /dev/null
+++ b/feature/receiver/presentation/src/main/kotlin/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationLandingScreen.kt
@@ -0,0 +1,89 @@
+package com.afternote.feature.receiver.presentation.invitation
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.afternote.core.ui.asString
+import com.afternote.core.ui.button.AfternoteButton
+import com.afternote.core.ui.button.AfternoteButtonType
+import com.afternote.core.ui.mvi.ObserveSignal
+import com.afternote.core.ui.theme.AfternoteDesign
+import com.afternote.core.ui.topbar.DetailTopBar
+import com.afternote.feature.receiver.presentation.R
+import com.afternote.feature.receiver.presentation.error.ReceiverErrorPopupHost
+
+/**
+ * 카카오톡 초대 랜딩 (시안 4996:40023, #944).
+ *
+ * @param isLoggedIn 앱 셸이 판정한 인증 상태. 로그인 전이면 «수락» 은 ViewModel 로 가지 않고
+ *   [onLoginRequired] 로 나간다 — 토큰은 남아 있고, 로그인이 끝나면 셸이 이 화면을 다시 띄운다.
+ */
+@Composable
+fun ReceiverInvitationLandingScreen(
+    isLoggedIn: Boolean,
+    viewModel: ReceiverInvitationViewModel,
+    onAccepted: (inviterName: String) -> Unit,
+    onOpenReceivedRecords: () -> Unit,
+    onLoginRequired: () -> Unit,
+    onClose: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val state by viewModel.uiState.collectAsStateWithLifecycle()
+
+    ObserveSignal(
+        signal = state.acceptedInviterName,
+        consumed = ReceiverInvitationIntent.ConsumeAccepted,
+        onIntent = viewModel::onIntent,
+        onSignal = onAccepted,
+    )
+    ObserveSignal(
+        signal = state.openReceivedRecords.takeIf { it },
+        consumed = ReceiverInvitationIntent.ConsumeOpenReceivedRecords,
+        onIntent = viewModel::onIntent,
+    ) { onOpenReceivedRecords() }
+    ObserveSignal(
+        signal = state.loginRequired.takeIf { it },
+        consumed = ReceiverInvitationIntent.ConsumeLoginRequired,
+        onIntent = viewModel::onIntent,
+    ) { onLoginRequired() }
+    ObserveSignal(
+        signal = state.close.takeIf { it },
+        consumed = ReceiverInvitationIntent.ConsumeClose,
+        onIntent = viewModel::onIntent,
+    ) { onClose() }
+
+    ReceiverInvitationLandingContent(
+        state = state,
+        onIntent = { intent ->
+            if (intent == ReceiverInvitationIntent.Accept && !isLoggedIn) {
+                onLoginRequired()
+            } else {
+                viewModel.onIntent(intent)
+            }
+        },
+        modifier = modifier,
+    )
+}
diff --git a/feature/receiver/presentation/src/main/kotlin/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationViewModel.kt b/feature/receiver/presentation/src/main/kotlin/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationViewModel.kt
new file mode 100644
index 0000000000..fb47edb296
--- /dev/null
+++ b/feature/receiver/presentation/src/main/kotlin/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationViewModel.kt
@@ -0,0 +1,258 @@
+package com.afternote.feature.receiver.presentation.invitation
+
+import androidx.lifecycle.viewModelScope
+import com.afternote.core.common.reporting.ErrorReporter
+import com.afternote.core.domain.error.ReceiverInvitationFailure
+import com.afternote.core.domain.repository.PendingReceiverInvitationStore
+import com.afternote.core.domain.repository.ReceiverInvitationRepository
+import com.afternote.core.ui.UiText
+import com.afternote.core.ui.mvi.MviViewModel
+import com.afternote.feature.receiver.presentation.R
+import com.afternote.feature.receiver.presentation.error.ReceiverErrorPopup
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
+import java.io.IOException
+import javax.inject.Inject
+
+/**
+ * 초대 랜딩·수락 ViewModel (#944).
+ *
+ * 토큰은 [PendingReceiverInvitationStore] 에서 읽는다 — 화면 인자로 나르지 않는다. 처분 규칙:
+ *
+ * | 결과 | 토큰 | 화면 |
+ * |---|---|---|
+ * | 수락 성공 | 지움 | 완료 화면 |
+ * | 없음·만료·다른 사용자 수락·본인 초대 | 지움 | 안내 뒤 닫기 |
+ * | 이미 등록됨 | 지움 | 받은 기록함 |
+ * | 미인증 | 유지 | 로그인 |
+ * | 네트워크·5xx | 유지 | 재시도 팝업 |
+ * | 나중에 결정하기 | 유지 | 닫기 |
+ */
+@HiltViewModel
+class ReceiverInvitationViewModel
+    @Inject
+    constructor(
+        private val invitationRepository: ReceiverInvitationRepository,
+        private val pendingInvitationStore: PendingReceiverInvitationStore,
+        private val errorReporter: ErrorReporter,
+    ) : MviViewModel<ReceiverInvitationIntent, ReceiverInvitationUiState, ReceiverInvitationReducerEvent>(
+            ReceiverInvitationUiState(),
+        ) {
+        /** 마지막으로 실패한 작업 — «다시 시도» 가 무엇을 다시 할지 정한다. */
+        private var retryAction: (() -> Unit)? = null
+
+        init {
+            lookup()
+        }
+
+        override fun onIntent(intent: ReceiverInvitationIntent) {
+            when (intent) {
+                ReceiverInvitationIntent.Accept -> accept()
+                ReceiverInvitationIntent.Defer -> dispatch(ReceiverInvitationReducerEvent.CloseRequested)
+                ReceiverInvitationIntent.AcknowledgeNotice -> dispatch(ReceiverInvitationReducerEvent.CloseRequested)
+                ReceiverInvitationIntent.Retry -> retry()
+                ReceiverInvitationIntent.DismissErrorPopup -> dispatch(ReceiverInvitationReducerEvent.ErrorPopupDismissed)
+                ReceiverInvitationIntent.ConsumeAccepted -> dispatch(ReceiverInvitationReducerEvent.AcceptedConsumed)
+                ReceiverInvitationIntent.ConsumeOpenReceivedRecords -> dispatch(ReceiverInvitationReducerEvent.OpenReceivedRecordsConsumed)
+                ReceiverInvitationIntent.ConsumeLoginRequired -> dispatch(ReceiverInvitationReducerEvent.LoginRequiredConsumed)
+                ReceiverInvitationIntent.ConsumeClose -> dispatch(ReceiverInvitationReducerEvent.CloseConsumed)
+            }
+        }
+
+        override fun reduce(
+            state: ReceiverInvitationUiState,
+            event: ReceiverInvitationReducerEvent,
+        ): ReceiverInvitationUiState =
+            when (event) {
+                ReceiverInvitationReducerEvent.LookupStarted -> {
+                    state.copy(phase = ReceiverInvitationPhase.Loading)
+                }
+
+                is ReceiverInvitationReducerEvent.LookupSucceeded -> {
+                    state.copy(phase = ReceiverInvitationPhase.Ready(event.inviterName))
+                }
+
+                is ReceiverInvitationReducerEvent.NoticeShown -> {
+                    state.copy(
+                        phase = ReceiverInvitationPhase.Notice(event.message),
+                        isAccepting = false,
+                    )
+                }
+
+                is ReceiverInvitationReducerEvent.ErrorPopupShown -> {
+                    state.copy(errorPopup = event.popup, isAccepting = false)
+                }
+
+                ReceiverInvitationReducerEvent.ErrorPopupDismissed -> {
+                    state.copy(errorPopup = null)
+                }
+
+                ReceiverInvitationReducerEvent.AcceptStarted -> {
+                    state.copy(isAccepting = true)
+                }
+
+                is ReceiverInvitationReducerEvent.AcceptSucceeded -> {
+                    state.copy(
+                        isAccepting = false,
+                        acceptedInviterName = event.inviterName,
+                    )
+                }
+
+                ReceiverInvitationReducerEvent.AcceptFinished -> {
+                    state.copy(isAccepting = false)
+                }
+
+                ReceiverInvitationReducerEvent.AlreadyRegistered -> {
+                    state.copy(isAccepting = false, openReceivedRecords = true)
+                }
+
+                ReceiverInvitationReducerEvent.LoginRequired -> {
+                    state.copy(isAccepting = false, loginRequired = true)
+                }
+
+                ReceiverInvitationReducerEvent.CloseRequested -> {
+                    state.copy(close = true)
+                }
+
+                ReceiverInvitationReducerEvent.AcceptedConsumed -> {
+                    state.copy(acceptedInviterName = null)
+                }
+
+                ReceiverInvitationReducerEvent.OpenReceivedRecordsConsumed -> {
+                    state.copy(openReceivedRecords = false)
+                }
+
+                ReceiverInvitationReducerEvent.LoginRequiredConsumed -> {
+                    state.copy(loginRequired = false)
+                }
+
+                ReceiverInvitationReducerEvent.CloseConsumed -> {
+                    state.copy(close = false)
+                }
+            }
+
+        private fun lookup() {
+            retryAction = ::lookup
+            viewModelScope.launch {
+                dispatch(ReceiverInvitationReducerEvent.LookupStarted)
+                val token = pendingInvitationStore.pendingToken.first()
+                if (token == null) {
+                    // 랜딩이 떠 있는 동안 다른 경로가 토큰을 지웠다 — 보여 줄 초대가 없다.
+                    dispatch(ReceiverInvitationReducerEvent.NoticeShown(UiText.Resource(R.string.receiver_invitation_notice_not_found)))
+                    return@launch
+                }
+                invitationRepository
+                    .lookup(token)
+                    .onSuccess { lookup ->
+                        if (lookup.isExpired) {
+                            pendingInvitationStore.clear()
+                            dispatch(
+                                ReceiverInvitationReducerEvent.NoticeShown(UiText.Resource(R.string.receiver_invitation_notice_expired)),
+                            )
+                        } else {
+                            dispatch(ReceiverInvitationReducerEvent.LookupSucceeded(lookup.inviterName))
+                        }
+                    }.onFailure { failure -> handleFailure(failure, stage = STAGE_LOOKUP) }
+            }
+        }
+
+        private fun accept() {
+            if (currentState.isAccepting) return
+            retryAction = ::accept
+            viewModelScope.launch {
+                dispatch(ReceiverInvitationReducerEvent.AcceptStarted)
+                val token = pendingInvitationStore.pendingToken.first()
+                if (token == null) {
+                    dispatch(ReceiverInvitationReducerEvent.NoticeShown(UiText.Resource(R.string.receiver_invitation_notice_not_found)))
+                    return@launch
+                }
+                invitationRepository
+                    .accept(token)
+                    .onSuccess { accepted ->
+                        pendingInvitationStore.clear()
+                        dispatch(ReceiverInvitationReducerEvent.AcceptSucceeded(accepted.inviterName))
+                    }.onFailure { failure -> handleFailure(failure, stage = STAGE_ACCEPT) }
+            }
+        }
+
+        private fun retry() {
+            dispatch(ReceiverInvitationReducerEvent.ErrorPopupDismissed)
+            retryAction?.invoke()
+        }
+
+        /**
+         * 실패 처분. [ReceiverInvitationFailure] 가 아닌 것은 Data 계층이 번역하지 못한 로컬 실패라
+         * 서버 오류 팝업으로 보낸다 — 토큰은 남긴다.
+         */
+        private suspend fun handleFailure(
+            failure: Throwable,
+            stage: String,
+        ) {
+            when (failure) {
+                is ReceiverInvitationFailure.NotFound -> {
+                    notice(R.string.receiver_invitation_notice_not_found)
+                }
+
+                is ReceiverInvitationFailure.Expired -> {
+                    notice(R.string.receiver_invitation_notice_expired)
+                }
+
+                is ReceiverInvitationFailure.AcceptedByOther -> {
+                    notice(R.string.receiver_invitation_notice_accepted_by_other)
+                }
+
+                is ReceiverInvitationFailure.SelfAccept -> {
+                    notice(R.string.receiver_invitation_notice_self_accept)
+                }
+
+                is ReceiverInvitationFailure.AlreadyRegistered -> {
+                    pendingInvitationStore.clear()
+                    dispatch(ReceiverInvitationReducerEvent.AlreadyRegistered)
+                }
+
+                is ReceiverInvitationFailure.Unauthenticated -> {
+                    dispatch(ReceiverInvitationReducerEvent.LoginRequired)
+                }
+
+                is ReceiverInvitationFailure.Other -> {
+                    errorReporter.recordFailure(failure, mapOf(KEY_STAGE to stage))
+                    when {
+                        // 미등재 4xx — 다시 보내도 같은 거절이라 재시도 팝업이 아니라 안내로 끝낸다.
+                        // 사유를 모르므로 토큰은 지우지 않는다(다음 진입에서 다시 판정한다).
+                        !failure.isRetryable -> {
+                            dispatch(
+                                ReceiverInvitationReducerEvent.NoticeShown(
+                                    UiText.Resource(R.string.receiver_invitation_notice_unavailable),
+                                ),
+                            )
+                        }
+
+                        failure.cause is IOException -> {
+                            dispatch(ReceiverInvitationReducerEvent.ErrorPopupShown(ReceiverErrorPopup.NETWORK))
+                        }
+
+                        else -> {
+                            dispatch(ReceiverInvitationReducerEvent.ErrorPopupShown(ReceiverErrorPopup.SERVER))
+                        }
+                    }
+                }
+
+                else -> {
+                    errorReporter.recordFailure(failure, mapOf(KEY_STAGE to stage))
+                    dispatch(ReceiverInvitationReducerEvent.ErrorPopupShown(ReceiverErrorPopup.SERVER))
+                }
+            }
+        }
+
+        private suspend fun notice(messageRes: Int) {
+            pendingInvitationStore.clear()
+            dispatch(ReceiverInvitationReducerEvent.NoticeShown(UiText.Resource(messageRes)))
+        }
+
+        private companion object {
+            const val KEY_STAGE = "receiver_stage"
+            const val STAGE_LOOKUP = "receiver_invitation_lookup"
+            const val STAGE_ACCEPT = "receiver_invitation_accept"
+        }
+    }
diff --git a/feature/receiver/presentation/src/main/kotlin/com/afternote/feature/receiver/presentation/navigation/ReceiverInvitationLocalNavActions.kt b/feature/receiver/presentation/src/main/kotlin/com/afternote/feature/receiver/presentation/navigation/ReceiverInvitationLocalNavActions.kt
new file mode 100644
index 0000000000..00b18773ce
--- /dev/null
+++ b/feature/receiver/presentation/src/main/kotlin/com/afternote/feature/receiver/presentation/navigation/ReceiverInvitationLocalNavActions.kt
@@ -0,0 +1,13 @@
+package com.afternote.feature.receiver.presentation.navigation
+
+import androidx.navigation3.runtime.NavBackStack
+import androidx.navigation3.runtime.NavKey
+import com.afternote.core.ui.navigation.replaceAllWith
+import com.afternote.feature.receiver.presentation.navigation.model.ReceiverInvitationRoute
+
+/** 랜딩 → 완료는 대체다 — 수락이 서버에 반영된 뒤라 back 으로 랜딩에 되돌아가지 않는다. */
+internal class ReceiverInvitationLocalNavActions(
+    private val backStack: NavBackStack<NavKey>,
+) {
+    fun replaceLandingWithComplete(inviterName: String): Unit = backStack.replaceAllWith(ReceiverInvitationRoute.CompleteRoute(inviterName))
+}
diff --git a/feature/receiver/presentation/src/main/kotlin/com/afternote/feature/receiver/presentation/navigation/ReceiverInvitationNavHost.kt b/feature/receiver/presentation/src/main/kotlin/com/afternote/feature/receiver/presentation/navigation/ReceiverInvitationNavHost.kt
new file mode 100644
index 0000000000..4949c4207f
--- /dev/null
+++ b/feature/receiver/presentation/src/main/kotlin/com/afternote/feature/receiver/presentation/navigation/ReceiverInvitationNavHost.kt
@@ -0,0 +1,78 @@
+package com.afternote.feature.receiver.presentation.navigation
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
+import androidx.navigation3.runtime.NavBackStack
+import androidx.navigation3.runtime.NavKey
+import androidx.navigation3.runtime.entryProvider
+import androidx.navigation3.runtime.rememberNavBackStack
+import com.afternote.core.ui.navigation.FeatureNavDisplay
+import com.afternote.core.ui.navigation.FeatureNavigationCallbacks
+import com.afternote.core.ui.navigation.replaceAllWith
+import com.afternote.feature.receiver.presentation.invitation.ReceiverInvitationCompleteScreen
+import com.afternote.feature.receiver.presentation.invitation.ReceiverInvitationLandingScreen
+import com.afternote.feature.receiver.presentation.navigation.model.ReceiverInvitationRoute
+
+/**
+ * 초대 랜딩 로컬 스택이 셸에 남긴 이동 (#944).
+ *
+ * 스택 안의 랜딩 → 완료는 host 가 직접 처리하고, 셸이 답해야 하는 셋만 남는다.
+ */
+public interface ReceiverInvitationExternalActions {
+    /** 로그인 전에 «수락» 을 눌렀다. 셸은 이 화면을 내리고 온보딩을 보이며, 로그인이 끝나면 다시 띄운다. */
+    public fun requestLogin()
+
+    /** 수락이 끝났거나 이미 등록된 수신자였다 — 받은 기록함으로. */
+    public fun openReceivedRecords()
+
+    /** «나중에 결정하기»·안내 확인 — 이 화면을 내린다. 토큰 처분은 ViewModel 이 이미 끝냈다. */
+    public fun close()
+}
+
+/**
+ * 카카오톡 초대 랜딩·완료의 로컬 Navigation 3 스택 (#944).
+ *
+ * @param isLoggedIn 셸이 판정한 인증 상태 — 랜딩의 «수락» 이 서버로 갈지 로그인으로 갈지 가른다.
+ */
+@Composable
+public fun ReceiverInvitationNavHost(
+    isLoggedIn: Boolean,
+    boundary: FeatureNavigationCallbacks,
+    externalActions: ReceiverInvitationExternalActions,
+    modifier: Modifier = Modifier,
+) {
+    val backStack = rememberNavBackStack(ReceiverInvitationRoute.LandingRoute)
+    val actions = remember(backStack) { ReceiverInvitationLocalNavActions(backStack) }
+
+    FeatureNavDisplay(
+        backStack = backStack,
+        boundary = boundary,
+        modifier = modifier,
+        entryProvider =
+            entryProvider {
+                entry<ReceiverInvitationRoute.LandingRoute> {
+                    ReceiverTheme {
+                        ReceiverInvitationLandingScreen(
+                            isLoggedIn = isLoggedIn,
+                            viewModel = hiltViewModel(),
+                            onAccepted = actions::replaceLandingWithComplete,
+                            onOpenReceivedRecords = externalActions::openReceivedRecords,
+                            onLoginRequired = externalActions::requestLogin,
+                            onClose = externalActions::close,
+                        )
+                    }
+                }
+
+                entry<ReceiverInvitationRoute.CompleteRoute> { key ->
+                    ReceiverTheme {
+                        ReceiverInvitationCompleteScreen(
+                            inviterName = key.inviterName,
+                            onConfirm = externalActions::openReceivedRecords,
+                        )
+                    }
+                }
+            },
+    )
+}
diff --git a/feature/receiver/presentation/src/main/kotlin/com/afternote/feature/receiver/presentation/navigation/model/ReceiverInvitationRoute.kt b/feature/receiver/presentation/src/main/kotlin/com/afternote/feature/receiver/presentation/navigation/model/ReceiverInvitationRoute.kt
new file mode 100644
index 0000000000..a4b587f678
--- /dev/null
+++ b/feature/receiver/presentation/src/main/kotlin/com/afternote/feature/receiver/presentation/navigation/model/ReceiverInvitationRoute.kt
@@ -0,0 +1,21 @@
+package com.afternote.feature.receiver.presentation.navigation.model
+
+import androidx.navigation3.runtime.NavKey
+import kotlinx.serialization.Serializable
+
+/**
+ * 카카오톡 초대 랜딩 [com.afternote.core.ui.Route.ReceiverInvitation] 그래프 내부 라우트 (#944).
+ *
+ * 토큰은 라우트에 싣지 않는다 — 비밀값이고, 기기 저장소가 정본이라 ViewModel 이 거기서 읽는다.
+ */
+sealed interface ReceiverInvitationRoute : NavKey {
+    /** 랜딩(4996:40023) — 초대자 확인과 수락·보류. */
+    @Serializable
+    data object LandingRoute : ReceiverInvitationRoute
+
+    /** 수락 완료(4996:39921). 랜딩을 대체하므로 back 으로 되돌아가지 않는다. */
+    @Serializable
+    data class CompleteRoute(
+        val inviterName: String,
+    ) : ReceiverInvitationRoute
+}
diff --git a/feature/receiver/presentation/src/main/res/values/strings.xml b/feature/receiver/presentation/src/main/res/values/strings.xml
index d8eb2cb24e..af1b1190f9 100644
--- a/feature/receiver/presentation/src/main/res/values/strings.xml
+++ b/feature/receiver/presentation/src/main/res/values/strings.xml
@@ -107,4 +107,31 @@
     <string name="receiver_verify_step_description">수신자 인증 진행도 4단계 중 %1$d단계</string>
     <!-- 홈 섹션 건수 문장. rememberCountLine 이 숫자 앞부분과 뒷문장을 나눠 받아 서로 다른 스타일로
          그리므로 리소스도 그 경계대로 둘로 둔다. 끝 공백이 유효하므로 따옴표로 감싼다. -->
+
+    <!--
+      카카오톡 초대 랜딩(4996:40023)·수락 완료(4996:39921) — 시안 문구 그대로 (#944).
+      카드의 «관계»·«지금 볼 수 있는 기록» 줄은 조회 응답에 없어 그리지 않는다.
+    -->
+    <string name="receiver_invitation_top_bar_title">받은 기록함</string>
+    <string name="receiver_invitation_title">%1$s님이\n당신을 수신자로 설정했어요.</string>
+    <string name="receiver_invitation_description">%1$s 님이 남긴 기록을 정해진 때에\n받아보실 분으로 지정되었어요.</string>
+    <string name="receiver_invitation_row_inviter">나를 등록한 분</string>
+    <string name="receiver_invitation_accept">카카오로 시작하고 수락하기</string>
+    <string name="receiver_invitation_defer">나중에 결정하기</string>
+    <string name="receiver_invitation_privacy_caption">지금 수락해도 %1$s 님은 당신의 연락처를 볼 수 없어요.</string>
+    <string name="receiver_invitation_loading">초대를 확인하고 있어요.</string>
+    <string name="receiver_invitation_notice_confirm">확인</string>
+    <!-- 진행할 수 없는 초대의 안내. 시안에 없는 상태라 FE 잠정 문구다 — PM 확정 시 교체. -->
+    <string name="receiver_invitation_notice_not_found">초대를 찾을 수 없어요.\n초대한 분에게 새 링크를 받아주세요.</string>
+    <string name="receiver_invitation_notice_expired">초대 링크가 만료됐어요.\n초대한 분에게 새 링크를 받아주세요.</string>
+    <string name="receiver_invitation_notice_accepted_by_other">이미 다른 분이 수락한 초대예요.\n초대한 분에게 새 링크를 받아주세요.</string>
+    <string name="receiver_invitation_notice_self_accept">내가 보낸 초대는 내가 수락할 수 없어요.</string>
+    <string name="receiver_invitation_notice_unavailable">지금은 초대를 처리할 수 없어요.\n잠시 후 링크를 다시 열어주세요.</string>
+
+    <string name="receiver_invitation_complete_top_bar_title">수신자 등록</string>
+    <string name="receiver_invitation_complete_title">등록이 완료됐어요.</string>
+    <string name="receiver_invitation_complete_description">%1$s 님에게 수신자 등록 완료\n알림을 보냈어요.</string>
+    <string name="receiver_invitation_complete_info">아직 확인할 수 있는 기록이 없어요.\n기록을 확인할 수 있게 되면 카카오톡과 이메일로 안내해 드릴게요.\n그전까지는 연결 상태가 안전하게 유지됩니다.</string>
+    <string name="receiver_invitation_complete_confirm">확인하기</string>
+    <string name="receiver_invitation_complete_check_description">등록 완료</string>
 </resources>
diff --git a/feature/receiver/presentation/src/screenshotTest/kotlin/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationCompleteScreenScreenshotTest.kt b/feature/receiver/presentation/src/screenshotTest/kotlin/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationCompleteScreenScreenshotTest.kt
new file mode 100644
index 0000000000..2f11fc29b8
--- /dev/null
+++ b/feature/receiver/presentation/src/screenshotTest/kotlin/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationCompleteScreenScreenshotTest.kt
@@ -0,0 +1,25 @@
+package com.afternote.feature.receiver.presentation.invitation
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.tooling.preview.Preview
+import com.afternote.core.ui.theme.AfternoteTheme
+import com.afternote.feature.receiver.presentation.COMPACT_DEVICE_SPEC
+import com.android.tools.screenshot.PreviewTest
+
+@PreviewTest
+@Preview(showBackground = true)
+@Composable
+internal fun receiverInvitationCompleteScreenshot() {
+    AfternoteTheme {
+        ReceiverInvitationCompleteScreen(inviterName = "김혜성", onConfirm = {})
+    }
+}
+
+@PreviewTest
+@Preview(showBackground = true, device = COMPACT_DEVICE_SPEC)
+@Composable
+internal fun receiverInvitationCompleteCompactScreenshot() {
+    AfternoteTheme {
+        ReceiverInvitationCompleteScreen(inviterName = "김혜성", onConfirm = {})
+    }
+}
diff --git a/feature/receiver/presentation/src/screenshotTest/kotlin/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationLandingScreenScreenshotTest.kt b/feature/receiver/presentation/src/screenshotTest/kotlin/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationLandingScreenScreenshotTest.kt
new file mode 100644
index 0000000000..768b0ab193
--- /dev/null
+++ b/feature/receiver/presentation/src/screenshotTest/kotlin/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationLandingScreenScreenshotTest.kt
@@ -0,0 +1,49 @@
+package com.afternote.feature.receiver.presentation.invitation
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.tooling.preview.Preview
+import com.afternote.core.ui.UiText
+import com.afternote.core.ui.theme.AfternoteTheme
+import com.afternote.feature.receiver.presentation.COMPACT_DEVICE_SPEC
+import com.afternote.feature.receiver.presentation.LARGE_FONT_SCALE
+import com.afternote.feature.receiver.presentation.R
+import com.android.tools.screenshot.PreviewTest
+
+@PreviewTest
+@Preview(showBackground = true)
+@Composable
+internal fun receiverInvitationLandingReadyScreenshot() {
+    LandingScreenshot(ReceiverInvitationUiState(phase = ReceiverInvitationPhase.Ready("김혜성")))
+}
+
+@PreviewTest
+@Preview(showBackground = true, device = COMPACT_DEVICE_SPEC)
+@Composable
+internal fun receiverInvitationLandingReadyCompactScreenshot() {
+    LandingScreenshot(ReceiverInvitationUiState(phase = ReceiverInvitationPhase.Ready("김혜성")))
+}
+
+@PreviewTest
+@Preview(showBackground = true, fontScale = LARGE_FONT_SCALE)
+@Composable
+internal fun receiverInvitationLandingReadyLargeFontScreenshot() {
+    LandingScreenshot(ReceiverInvitationUiState(phase = ReceiverInvitationPhase.Ready("김혜성")))
+}
+
+@PreviewTest
+@Preview(showBackground = true)
+@Composable
+internal fun receiverInvitationLandingNoticeScreenshot() {
+    LandingScreenshot(
+        ReceiverInvitationUiState(
+            phase = ReceiverInvitationPhase.Notice(UiText.Resource(R.string.receiver_invitation_notice_expired)),
+        ),
+    )
+}
+
+@Composable
+private fun LandingScreenshot(state: ReceiverInvitationUiState) {
+    AfternoteTheme {
+        ReceiverInvitationLandingContent(state = state, onIntent = {})
+    }
+}
diff --git a/feature/receiver/presentation/src/screenshotTestDebug/reference/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationCompleteScreenScreenshotTestKt/receiverInvitationCompleteCompactScreenshot_c2abd7e6_0.png b/feature/receiver/presentation/src/screenshotTestDebug/reference/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationCompleteScreenScreenshotTestKt/receiverInvitationCompleteCompactScreenshot_c2abd7e6_0.png
new file mode 100644
index 0000000000..8107e6330e
Binary files /dev/null and b/feature/receiver/presentation/src/screenshotTestDebug/reference/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationCompleteScreenScreenshotTestKt/receiverInvitationCompleteCompactScreenshot_c2abd7e6_0.png differ
diff --git a/feature/receiver/presentation/src/screenshotTestDebug/reference/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationCompleteScreenScreenshotTestKt/receiverInvitationCompleteScreenshot_748aa731_0.png b/feature/receiver/presentation/src/screenshotTestDebug/reference/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationCompleteScreenScreenshotTestKt/receiverInvitationCompleteScreenshot_748aa731_0.png
new file mode 100644
index 0000000000..415057f064
Binary files /dev/null and b/feature/receiver/presentation/src/screenshotTestDebug/reference/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationCompleteScreenScreenshotTestKt/receiverInvitationCompleteScreenshot_748aa731_0.png differ
diff --git a/feature/receiver/presentation/src/screenshotTestDebug/reference/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationLandingScreenScreenshotTestKt/receiverInvitationLandingNoticeScreenshot_748aa731_0.png b/feature/receiver/presentation/src/screenshotTestDebug/reference/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationLandingScreenScreenshotTestKt/receiverInvitationLandingNoticeScreenshot_748aa731_0.png
new file mode 100644
index 0000000000..7d543af65c
Binary files /dev/null and b/feature/receiver/presentation/src/screenshotTestDebug/reference/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationLandingScreenScreenshotTestKt/receiverInvitationLandingNoticeScreenshot_748aa731_0.png differ
diff --git a/feature/receiver/presentation/src/screenshotTestDebug/reference/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationLandingScreenScreenshotTestKt/receiverInvitationLandingReadyCompactScreenshot_c2abd7e6_0.png b/feature/receiver/presentation/src/screenshotTestDebug/reference/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationLandingScreenScreenshotTestKt/receiverInvitationLandingReadyCompactScreenshot_c2abd7e6_0.png
new file mode 100644
index 0000000000..a216879ee5
Binary files /dev/null and b/feature/receiver/presentation/src/screenshotTestDebug/reference/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationLandingScreenScreenshotTestKt/receiverInvitationLandingReadyCompactScreenshot_c2abd7e6_0.png differ
diff --git a/feature/receiver/presentation/src/screenshotTestDebug/reference/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationLandingScreenScreenshotTestKt/receiverInvitationLandingReadyLargeFontScreenshot_39fcf3fa_0.png b/feature/receiver/presentation/src/screenshotTestDebug/reference/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationLandingScreenScreenshotTestKt/receiverInvitationLandingReadyLargeFontScreenshot_39fcf3fa_0.png
new file mode 100644
index 0000000000..49db6c99fa
Binary files /dev/null and b/feature/receiver/presentation/src/screenshotTestDebug/reference/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationLandingScreenScreenshotTestKt/receiverInvitationLandingReadyLargeFontScreenshot_39fcf3fa_0.png differ
diff --git a/feature/receiver/presentation/src/screenshotTestDebug/reference/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationLandingScreenScreenshotTestKt/receiverInvitationLandingReadyScreenshot_748aa731_0.png b/feature/receiver/presentation/src/screenshotTestDebug/reference/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationLandingScreenScreenshotTestKt/receiverInvitationLandingReadyScreenshot_748aa731_0.png
new file mode 100644
index 0000000000..c624c72d68
Binary files /dev/null and b/feature/receiver/presentation/src/screenshotTestDebug/reference/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationLandingScreenScreenshotTestKt/receiverInvitationLandingReadyScreenshot_748aa731_0.png differ
diff --git a/feature/receiver/presentation/src/test/kotlin/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationViewModelTest.kt b/feature/receiver/presentation/src/test/kotlin/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationViewModelTest.kt
new file mode 100644
index 0000000000..1b450e82e0
--- /dev/null
+++ b/feature/receiver/presentation/src/test/kotlin/com/afternote/feature/receiver/presentation/invitation/ReceiverInvitationViewModelTest.kt
@@ -0,0 +1,217 @@
+package com.afternote.feature.receiver.presentation.invitation
+
+import com.afternote.core.common.reporting.ErrorReporter
+import com.afternote.core.domain.error.ReceiverInvitationFailure
+import com.afternote.core.domain.testing.FakePendingReceiverInvitationStore
+import com.afternote.core.domain.testing.FakeReceiverInvitationRepository
+import com.afternote.core.model.user.ReceiverInvitationLookup
+import com.afternote.core.ui.UiText
+import com.afternote.feature.receiver.presentation.R
+import com.afternote.feature.receiver.presentation.error.ReceiverErrorPopup
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.advanceUntilIdle
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import java.io.IOException
+
+/** 초대 랜딩·수락의 토큰 처분 규칙 (#944) — ViewModel KDoc 의 표를 그대로 잠근다. */
+@OptIn(ExperimentalCoroutinesApi::class)
+class ReceiverInvitationViewModelTest {
+    private val dispatcher = StandardTestDispatcher()
+
+    @Before
+    fun setUp() {
+        Dispatchers.setMain(dispatcher)
+    }
+
+    @After
+    fun tearDown() {
+        Dispatchers.resetMain()
+    }
+
+    @Test
+    fun `진입하면 보관 토큰으로 조회해 초대자 이름을 그린다`() =
+        runTest(dispatcher) {
+            val fixture = Fixture()
+            val viewModel = fixture.viewModel()
+            advanceUntilIdle()
+
+            assertEquals(ReceiverInvitationPhase.Ready("김혜성"), viewModel.uiState.value.phase)
+            assertEquals(listOf(TOKEN), fixture.repository.lookupTokens)
+        }
+
+    @Test
+    fun `만료된 초대는 토큰을 지우고 안내로 끝난다`() =
+        runTest(dispatcher) {
+            val fixture = Fixture()
+            fixture.repository.lookup = ReceiverInvitationLookup(inviterName = "김혜성", isExpired = true)
+            val viewModel = fixture.viewModel()
+            advanceUntilIdle()
+
+            assertEquals(
+                ReceiverInvitationPhase.Notice(UiText.Resource(R.string.receiver_invitation_notice_expired)),
+                viewModel.uiState.value.phase,
+            )
+            assertNull(fixture.store.tokenState.value)
+        }
+
+    @Test
+    fun `수락 성공은 토큰을 지우고 완료 신호를 낸다`() =
+        runTest(dispatcher) {
+            val fixture = Fixture()
+            val viewModel = fixture.viewModel()
+            advanceUntilIdle()
+
+            viewModel.onIntent(ReceiverInvitationIntent.Accept)
+            advanceUntilIdle()
+
+            assertEquals("김혜성", viewModel.uiState.value.acceptedInviterName)
+            assertEquals(listOf(TOKEN), fixture.repository.acceptTokens)
+            assertNull(fixture.store.tokenState.value)
+            assertFalse(viewModel.uiState.value.isAccepting)
+        }
+
+    @Test
+    fun `다른 사용자가 수락한 초대는 토큰을 지우고 안내로 끝난다`() =
+        runTest(dispatcher) {
+            val fixture = Fixture()
+            fixture.repository.onAccept = { Result.failure(ReceiverInvitationFailure.AcceptedByOther(IllegalStateException())) }
+            val viewModel = fixture.viewModel()
+            advanceUntilIdle()
+
+            viewModel.onIntent(ReceiverInvitationIntent.Accept)
+            advanceUntilIdle()
+
+            assertEquals(
+                ReceiverInvitationPhase.Notice(UiText.Resource(R.string.receiver_invitation_notice_accepted_by_other)),
+                viewModel.uiState.value.phase,
+            )
+            assertNull(fixture.store.tokenState.value)
+        }
+
+    @Test
+    fun `이미 등록된 수신자면 토큰을 지우고 받은 기록함으로 보낸다`() =
+        runTest(dispatcher) {
+            val fixture = Fixture()
+            fixture.repository.onAccept = { Result.failure(ReceiverInvitationFailure.AlreadyRegistered(IllegalStateException())) }
+            val viewModel = fixture.viewModel()
+            advanceUntilIdle()
+
+            viewModel.onIntent(ReceiverInvitationIntent.Accept)
+            advanceUntilIdle()
+
+            assertTrue(viewModel.uiState.value.openReceivedRecords)
+            assertNull(fixture.store.tokenState.value)
+        }
+
+    @Test
+    fun `미인증 거절은 토큰을 남기고 로그인 신호를 낸다`() =
+        runTest(dispatcher) {
+            val fixture = Fixture()
+            fixture.repository.onAccept = { Result.failure(ReceiverInvitationFailure.Unauthenticated(IllegalStateException())) }
+            val viewModel = fixture.viewModel()
+            advanceUntilIdle()
+
+            viewModel.onIntent(ReceiverInvitationIntent.Accept)
+            advanceUntilIdle()
+
+            assertTrue(viewModel.uiState.value.loginRequired)
+            assertEquals(TOKEN, fixture.store.tokenState.value)
+        }
+
+    @Test
+    fun `전송 실패는 토큰을 남기고 네트워크 팝업을 띄우며 재시도는 수락을 다시 한다`() =
+        runTest(dispatcher) {
+            val fixture = Fixture()
+            var failOnce = true
+            fixture.repository.onAccept = {
+                if (failOnce) {
+                    failOnce = false
+                    Result.failure(ReceiverInvitationFailure.Other(IOException("offline"), isRetryable = true))
+                } else {
+                    Result.success(fixture.repository.accepted)
+                }
+            }
+            val viewModel = fixture.viewModel()
+            advanceUntilIdle()
+
+            viewModel.onIntent(ReceiverInvitationIntent.Accept)
+            advanceUntilIdle()
+            assertEquals(ReceiverErrorPopup.NETWORK, viewModel.uiState.value.errorPopup)
+            assertEquals(TOKEN, fixture.store.tokenState.value)
+
+            viewModel.onIntent(ReceiverInvitationIntent.Retry)
+            advanceUntilIdle()
+            assertNull(viewModel.uiState.value.errorPopup)
+            assertEquals("김혜성", viewModel.uiState.value.acceptedInviterName)
+            assertEquals(2, fixture.repository.acceptTokens.size)
+        }
+
+    @Test
+    fun `5xx 는 서버 팝업이고 미등재 4xx 는 토큰을 남긴 채 안내로 끝난다`() =
+        runTest(dispatcher) {
+            val server = Fixture()
+            server.repository.onLookup = { Result.failure(ReceiverInvitationFailure.Other(IllegalStateException(), isRetryable = true)) }
+            val serverViewModel = server.viewModel()
+            advanceUntilIdle()
+            assertEquals(ReceiverErrorPopup.SERVER, serverViewModel.uiState.value.errorPopup)
+            assertEquals(TOKEN, server.store.tokenState.value)
+
+            val client = Fixture()
+            client.repository.onLookup = { Result.failure(ReceiverInvitationFailure.Other(IllegalStateException(), isRetryable = false)) }
+            val clientViewModel = client.viewModel()
+            advanceUntilIdle()
+            assertEquals(
+                ReceiverInvitationPhase.Notice(UiText.Resource(R.string.receiver_invitation_notice_unavailable)),
+                clientViewModel.uiState.value.phase,
+            )
+            assertEquals(TOKEN, client.store.tokenState.value)
+        }
+
+    @Test
+    fun `나중에 결정하기는 토큰을 남기고 닫기 신호만 낸다`() =
+        runTest(dispatcher) {
+            val fixture = Fixture()
+            val viewModel = fixture.viewModel()
+            advanceUntilIdle()
+
+            viewModel.onIntent(ReceiverInvitationIntent.Defer)
+
+            assertTrue(viewModel.uiState.value.close)
+            assertEquals(TOKEN, fixture.store.tokenState.value)
+            assertEquals(0, fixture.store.clearCalls)
+        }
+
+    private class Fixture {
+        val repository = FakeReceiverInvitationRepository()
+        val store = FakePendingReceiverInvitationStore(token = TOKEN)
+
+        fun viewModel() =
+            ReceiverInvitationViewModel(
+                invitationRepository = repository,
+                pendingInvitationStore = store,
+                errorReporter = NoopErrorReporter,
+            )
+    }
+
+    private object NoopErrorReporter : ErrorReporter {
+        override fun writeFailure(
+            throwable: Throwable,
+            attributes: Map<String, String>,
+        ) = Unit
+    }
+
+    private companion object {
+        const val TOKEN = "abcDEF123_-token"
+    }
+}
diff --git a/feature/receiver/presentation/src/test/kotlin/com/afternote/feature/receiver/presentation/navigation/ReceiverInvitationLocalNavActionsTest.kt b/feature/receiver/presentation/src/test/kotlin/com/afternote/feature/receiver/presentation/navigation/ReceiverInvitationLocalNavActionsTest.kt
new file mode 100644
index 0000000000..99bbde3014
--- /dev/null
+++ b/feature/receiver/presentation/src/test/kotlin/com/afternote/feature/receiver/presentation/navigation/ReceiverInvitationLocalNavActionsTest.kt
@@ -0,0 +1,20 @@
+package com.afternote.feature.receiver.presentation.navigation
+
+import androidx.navigation3.runtime.NavBackStack
+import androidx.navigation3.runtime.NavKey
+import com.afternote.feature.receiver.presentation.navigation.model.ReceiverInvitationRoute
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+/** 초대 랜딩 로컬 스택 — 완료는 랜딩을 대체한다 (#944). */
+class ReceiverInvitationLocalNavActionsTest {
+    private val backStack = NavBackStack<NavKey>(ReceiverInvitationRoute.LandingRoute)
+    private val actions = ReceiverInvitationLocalNavActions(backStack)
+
+    @Test
+    fun `수락 완료는 랜딩을 남기지 않고 완료 화면 하나만 둔다`() {
+        actions.replaceLandingWithComplete("김혜성")
+
+        assertEquals(listOf(ReceiverInvitationRoute.CompleteRoute("김혜성")), backStack.toList())
+    }
+}
diff --git a/feature/setting/data/build.gradle.kts b/feature/setting/data/build.gradle.kts
index 584c87c69b..60748588ea 100644
--- a/feature/setting/data/build.gradle.kts
+++ b/feature/setting/data/build.gradle.kts
@@ -5,6 +5,9 @@ plugins {
 
 android {
     namespace = "com.afternote.feature.setting.data"
+    testFixtures {
+        enable = true
+    }
 }
 
 dependencies {
@@ -12,6 +15,10 @@ dependencies {
     // 탈퇴 실패 진단(ErrorReporter). core:domain·model·network 는 data 규약이 이미 붙인다.
     implementation(projects.core.common)
 
+    testFixturesImplementation(projects.feature.setting.domain)
+    testFixturesImplementation(libs.hilt.android.testing)
+    add("kspTestFixtures", libs.hilt.compiler)
+
     testImplementation(testFixtures(projects.core.domain))
     testImplementation(libs.coroutines.test)
 }
diff --git a/feature/setting/data/src/main/kotlin/com/afternote/feature/setting/data/PasskeyApiService.kt b/feature/setting/data/src/main/kotlin/com/afternote/feature/setting/data/PasskeyApiService.kt
new file mode 100644
index 0000000000..7d7c2dcf0f
--- /dev/null
+++ b/feature/setting/data/src/main/kotlin/com/afternote/feature/setting/data/PasskeyApiService.kt
@@ -0,0 +1,29 @@
+package com.afternote.feature.setting.data
+
+import com.afternote.core.network.model.BaseResponse
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.JsonElement
+import retrofit2.http.Body
+import retrofit2.http.GET
+import retrofit2.http.POST
+
+internal interface PasskeyApiService {
+    @GET("users/passkeys")
+    suspend fun getPasskeys(): BaseResponse<List<PasskeyDto>>
+
+    @POST("auth/passkey/register/options")
+    suspend fun getRegistrationOptions(): BaseResponse<JsonElement>
+
+    @POST("auth/passkey/register")
+    suspend fun registerPasskey(
+        @Body credential: JsonElement,
+    ): BaseResponse<PasskeyDto>
+}
+
+@Serializable
+internal data class PasskeyDto(
+    @SerialName("id") val id: Long,
+    @SerialName("displayName") val displayName: String,
+    @SerialName("createdAt") val createdAt: String,
+)
diff --git a/feature/setting/data/src/main/kotlin/com/afternote/feature/setting/data/PasskeyModule.kt b/feature/setting/data/src/main/kotlin/com/afternote/feature/setting/data/PasskeyModule.kt
new file mode 100644
index 0000000000..423d2b258b
--- /dev/null
+++ b/feature/setting/data/src/main/kotlin/com/afternote/feature/setting/data/PasskeyModule.kt
@@ -0,0 +1,16 @@
+package com.afternote.feature.setting.data
+
+import com.afternote.feature.setting.domain.PasskeyRepository
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import retrofit2.Retrofit
+import retrofit2.create
+
+@Module
+@InstallIn(SingletonComponent::class)
+internal object PasskeyModule {
+    @Provides
+    fun providePasskeyRepository(retrofit: Retrofit): PasskeyRepository = PasskeyRepositoryImpl(retrofit.create<PasskeyApiService>())
+}
diff --git a/feature/setting/data/src/main/kotlin/com/afternote/feature/setting/data/PasskeyRepositoryImpl.kt b/feature/setting/data/src/main/kotlin/com/afternote/feature/setting/data/PasskeyRepositoryImpl.kt
new file mode 100644
index 0000000000..8b571d7376
--- /dev/null
+++ b/feature/setting/data/src/main/kotlin/com/afternote/feature/setting/data/PasskeyRepositoryImpl.kt
@@ -0,0 +1,19 @@
+package com.afternote.feature.setting.data
+
+import com.afternote.core.network.model.requireData
+import com.afternote.feature.setting.domain.Passkey
+import com.afternote.feature.setting.domain.PasskeyRepository
+import kotlinx.serialization.json.Json
+
+internal class PasskeyRepositoryImpl(
+    private val apiService: PasskeyApiService,
+) : PasskeyRepository {
+    override suspend fun getPasskeys(): List<Passkey> = apiService.getPasskeys().requireData().map { it.toDomain() }
+
+    override suspend fun getRegistrationOptions(): String = apiService.getRegistrationOptions().requireData().toString()
+
+    override suspend fun registerPasskey(credentialJson: String): Passkey =
+        apiService.registerPasskey(Json.parseToJsonElement(credentialJson)).requireData().toDomain()
+}
+
+private fun PasskeyDto.toDomain(): Passkey = Passkey(id = id, displayName = displayName, createdAt = createdAt)
diff --git a/feature/setting/data/src/test/kotlin/com/afternote/feature/setting/data/PasskeyRepositoryTest.kt b/feature/setting/data/src/test/kotlin/com/afternote/feature/setting/data/PasskeyRepositoryTest.kt
new file mode 100644
index 0000000000..4c7cd34428
--- /dev/null
+++ b/feature/setting/data/src/test/kotlin/com/afternote/feature/setting/data/PasskeyRepositoryTest.kt
@@ -0,0 +1,75 @@
+package com.afternote.feature.setting.data
+
+import com.afternote.core.network.model.BaseResponse
+import com.afternote.feature.setting.domain.Passkey
+import kotlinx.coroutines.runBlocking
+import kotlinx.serialization.SerializationException
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonElement
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class PasskeyRepositoryTest {
+    @Test
+    fun registration_roundTripsCompleteServerOptionsAndPlatformCredential() =
+        runBlocking {
+            val options = Json.parseToJsonElement("""{"challenge":"challenge","rp":{"id":"example.test"},"extension":{"future":true}}""")
+            val credential = Json.parseToJsonElement("""{"id":"credential-id","response":{"attestationObject":"attestation"}}""")
+            var submitted: JsonElement? = null
+            val service =
+                object : PasskeyApiService {
+                    override suspend fun getPasskeys(): BaseResponse<List<PasskeyDto>> = error("Not used")
+
+                    override suspend fun getRegistrationOptions(): BaseResponse<JsonElement> =
+                        BaseResponse(status = 200, code = 200, data = options)
+
+                    override suspend fun registerPasskey(credential: JsonElement): BaseResponse<PasskeyDto> {
+                        submitted = credential
+                        return BaseResponse(status = 200, code = 200, data = DTO)
+                    }
+                }
+            val repository = PasskeyRepositoryImpl(service)
+            assertEquals(options, Json.parseToJsonElement(repository.getRegistrationOptions()))
+            assertEquals(Passkey(DTO.id, DTO.displayName, DTO.createdAt), repository.registerPasskey(credential.toString()))
+            assertEquals(credential, submitted)
+        }
+
+    @Test
+    fun list_preservesEveryRegisteredPasskeyAndAnActualEmptyList() =
+        runBlocking {
+            val service = ListPasskeyService()
+            val repository = PasskeyRepositoryImpl(service)
+            assertTrue(repository.getPasskeys().isEmpty())
+            service.response = BaseResponse(status = 200, code = 200, data = listOf(DTO, DTO.copy(id = 8L)))
+            assertEquals(listOf(7L, 8L), repository.getPasskeys().map { it.id })
+        }
+
+    @Test
+    fun list_failedOrMissingResponseDoesNotBecomeAnEmptyList() =
+        runBlocking {
+            val service = ListPasskeyService()
+            val repository = PasskeyRepositoryImpl(service)
+            service.response = BaseResponse(status = 500, code = 500, data = emptyList())
+            assertTrue(runCatching { repository.getPasskeys() }.isFailure)
+            service.response = BaseResponse(status = 200, code = 200, data = null)
+            assertTrue(runCatching { repository.getPasskeys() }.isFailure)
+        }
+
+    @Test(expected = SerializationException::class)
+    fun list_missingRequiredIdentityIsNotDefaulted() {
+        Json.decodeFromString<PasskeyDto>("""{"displayName":"Passkey","createdAt":"2026-09-06T10:00:00"}""")
+    }
+}
+
+private class ListPasskeyService : PasskeyApiService {
+    var response = BaseResponse(status = 200, code = 200, data = emptyList<PasskeyDto>())
+
+    override suspend fun getPasskeys(): BaseResponse<List<PasskeyDto>> = response
+
+    override suspend fun getRegistrationOptions(): BaseResponse<JsonElement> = error("Not used")
+
+    override suspend fun registerPasskey(credential: JsonElement): BaseResponse<PasskeyDto> = error("Not used")
+}
+
+private val DTO = PasskeyDto(id = 7L, displayName = "Passkey", createdAt = "2026-09-06T10:00:00")
diff --git a/feature/setting/data/src/testFixtures/kotlin/com/afternote/feature/setting/data/PasskeyTestModule.kt b/feature/setting/data/src/testFixtures/kotlin/com/afternote/feature/setting/data/PasskeyTestModule.kt
new file mode 100644
index 0000000000..bc91723a54
--- /dev/null
+++ b/feature/setting/data/src/testFixtures/kotlin/com/afternote/feature/setting/data/PasskeyTestModule.kt
@@ -0,0 +1,61 @@
+package com.afternote.feature.setting.data
+
+import com.afternote.feature.setting.domain.Passkey
+import com.afternote.feature.setting.domain.PasskeyRepository
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.components.SingletonComponent
+import dagger.hilt.testing.TestInstallIn
+import jakarta.inject.Singleton
+import java.io.IOException
+import java.util.concurrent.CopyOnWriteArrayList
+import java.util.concurrent.atomic.AtomicInteger
+
+/** app 계측은 이 fixture를 통해 internal 프로덕션 모듈을 대체한다. */
+@Module
+@TestInstallIn(components = [SingletonComponent::class], replaces = [PasskeyModule::class])
+public object PasskeyTestModule {
+    @Provides
+    @Singleton
+    public fun provideScenario(): PasskeyTestScenario = PasskeyTestScenario()
+
+    @Provides
+    public fun providePasskeyRepository(scenario: PasskeyTestScenario): PasskeyRepository = scenario
+}
+
+public class PasskeyTestScenario : PasskeyRepository {
+    @Volatile
+    public var passkeys: List<Passkey> = emptyList()
+
+    @Volatile
+    public var listFails: Boolean = false
+
+    public val listCalls: AtomicInteger = AtomicInteger()
+    public val optionsCalls: AtomicInteger = AtomicInteger()
+    public val registeredCredentials: CopyOnWriteArrayList<String> = CopyOnWriteArrayList<String>()
+
+    override suspend fun getPasskeys(): List<Passkey> {
+        listCalls.incrementAndGet()
+        if (listFails) throw IOException("Controlled passkey list failure")
+        return passkeys
+    }
+
+    override suspend fun getRegistrationOptions(): String {
+        optionsCalls.incrementAndGet()
+        return """
+            {
+              "challenge": "YWZ0ZXJub3RlLXRlc3QtY2hhbGxlbmdl",
+              "rp": {"name": "Afternote test", "id": "example.test"},
+              "user": {"id": "dGVzdA", "name": "test@example.test", "displayName": "Test"},
+              "pubKeyCredParams": [{"type": "public-key", "alg": -7}],
+              "timeout": 1000,
+              "attestation": "none"
+            }
+            """.trimIndent()
+    }
+
+    override suspend fun registerPasskey(credentialJson: String): Passkey {
+        registeredCredentials += credentialJson
+        error("Real credentials must not be registered by this fixture")
+    }
+}
diff --git a/feature/setting/domain/build.gradle.kts b/feature/setting/domain/build.gradle.kts
index 39b64eebda..9b6f1c8941 100644
--- a/feature/setting/domain/build.gradle.kts
+++ b/feature/setting/domain/build.gradle.kts
@@ -6,6 +6,12 @@ plugins {
 dependencies {
     // 계정·알림 계약이 노출하는 도메인 모델(UserConnectedAccount·UserPushSetting·UserMarketingConsent).
     implementation(projects.core.model)
+    // 수신자 저장 UseCase 가 core 계약 UserReceiverRepository 를 쓴다 (#1691).
+    implementation(projects.core.domain)
+    implementation(libs.coroutines.core)
 
     testFixturesImplementation(projects.core.model)
+
+    testImplementation(libs.coroutines.test)
+    testImplementation(testFixtures(projects.core.domain))
 }
diff --git a/feature/setting/domain/src/main/java/com/afternote/feature/setting/domain/PasskeyRepository.kt b/feature/setting/domain/src/main/java/com/afternote/feature/setting/domain/PasskeyRepository.kt
new file mode 100644
index 0000000000..8e96dd6ca9
--- /dev/null
+++ b/feature/setting/domain/src/main/java/com/afternote/feature/setting/domain/PasskeyRepository.kt
@@ -0,0 +1,18 @@
+package com.afternote.feature.setting.domain
+
+public data class Passkey(
+    val id: Long,
+    val displayName: String,
+    val createdAt: String,
+)
+
+/** 설정의 패스키 목록·등록 계약. 서버가 자격 증명 등록 여부의 정본이다. */
+public interface PasskeyRepository {
+    public suspend fun getPasskeys(): List<Passkey>
+
+    /** Credential Manager에 전달할 PublicKeyCredentialCreationOptions JSON. */
+    public suspend fun getRegistrationOptions(): String
+
+    /** Credential Manager가 생성한 PublicKeyCredential JSON을 서버에서 검증·등록한다. */
+    public suspend fun registerPasskey(credentialJson: String): Passkey
+}
diff --git a/feature/setting/domain/src/main/java/com/afternote/feature/setting/domain/UpdateReceiverInfoUseCase.kt b/feature/setting/domain/src/main/java/com/afternote/feature/setting/domain/UpdateReceiverInfoUseCase.kt
new file mode 100644
index 0000000000..66584b725c
--- /dev/null
+++ b/feature/setting/domain/src/main/java/com/afternote/feature/setting/domain/UpdateReceiverInfoUseCase.kt
@@ -0,0 +1,60 @@
+package com.afternote.feature.setting.domain
+
+import com.afternote.core.domain.repository.UserReceiverRepository
+import com.afternote.core.domain.result.runCatchingCancellable
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.ensureActive
+import javax.inject.Inject
+
+/**
+ * 수신자 저장 결과 (#1691).
+ *
+ * 기본정보와 인사말은 서로 다른 쓰기라 실패한 요청 단계에 따라 사용자에게 알릴 내용을 구분한다.
+ * 인사말 요청 단계에서 실패하면 기본정보 요청은 이미 성공한 상태다.
+ */
+public sealed interface UpdateReceiverInfoResult {
+    public data object Success : UpdateReceiverInfoResult
+
+    /**
+     * 기본정보 쓰기가 실패해 인사말 쓰기를 시도하지 않았다.
+     *
+     * [cause] 는 저장소가 던진 원인 그대로다. 소비자가 거절 예외를 가려 문구를 고르므로 감싸지 않는다.
+     * `Exception` 이 아니라 `Throwable` 인 것은 이 정책을 옮겨 오기 전 ViewModel 이 쓰던
+     * `runCatchingCancellable` 의 포착 범위(취소를 뺀 모든 `Throwable`)를 그대로 보존한 결과다.
+     */
+    public data class BasicInfoFailed(
+        public val cause: Throwable,
+    ) : UpdateReceiverInfoResult
+
+    public data object MessageFailedAfterBasicInfoUpdated : UpdateReceiverInfoResult
+}
+
+/**
+ * 수신자 기본정보를 저장한 뒤 인사말을 저장한다 (#1691).
+ *
+ * 순서를 고정한다. 기본정보가 실패하면 인사말은 시도하지 않는다. 두 쓰기 사이에서 취소되면
+ * 인사말 쓰기를 시작하지 않고 취소를 그대로 전파한다.
+ */
+public class UpdateReceiverInfoUseCase
+    @Inject
+    constructor(
+        private val repository: UserReceiverRepository,
+    ) {
+        public suspend operator fun invoke(
+            receiverId: Long,
+            name: String,
+            phone: String,
+            relation: String,
+            email: String,
+            message: String,
+        ): UpdateReceiverInfoResult {
+            runCatchingCancellable { repository.updateReceiver(receiverId, name, phone, relation, email) }
+                .onFailure { return UpdateReceiverInfoResult.BasicInfoFailed(it) }
+            currentCoroutineContext().ensureActive()
+            return runCatchingCancellable { repository.updateReceiverMessage(receiverId, message) }
+                .fold(
+                    onSuccess = { UpdateReceiverInfoResult.Success },
+                    onFailure = { UpdateReceiverInfoResult.MessageFailedAfterBasicInfoUpdated },
+                )
+        }
+    }
diff --git a/feature/setting/domain/src/main/java/com/afternote/feature/setting/domain/UpdateTimeLetterDeliveryConditionUseCase.kt b/feature/setting/domain/src/main/java/com/afternote/feature/setting/domain/UpdateTimeLetterDeliveryConditionUseCase.kt
new file mode 100644
index 0000000000..83c12da89d
--- /dev/null
+++ b/feature/setting/domain/src/main/java/com/afternote/feature/setting/domain/UpdateTimeLetterDeliveryConditionUseCase.kt
@@ -0,0 +1,58 @@
+package com.afternote.feature.setting.domain
+
+import com.afternote.core.domain.repository.UserReceiverRepository
+import com.afternote.core.model.delivery.ConditionState
+import com.afternote.core.model.delivery.DeliveryConditionItem
+import com.afternote.core.model.delivery.DeliveryConditionType
+import com.afternote.core.model.delivery.DeliveryContentType
+import com.afternote.core.model.delivery.InactivityPeriod
+import com.afternote.core.model.delivery.ReceiverDeliveryConditions
+import javax.inject.Inject
+
+/**
+ * 타임레터 전달조건만 바꿔 수신자의 전달조건 전량을 저장한다 (#1691).
+ *
+ * 저장 API 가 조건 목록을 통째로 받으므로 다른 콘텐츠의 조건은 손대지 않고 그대로 실어 보낸다.
+ * 타임레터 조건이 아직 없으면 ACTIVE 로 합성하고, 수신자 요청 방식에는 무활동 기간을 비운다.
+ *
+ * 실패는 호출부가 판정한다. 이 UseCase 는 예외를 삼키지 않고 저장소 응답을 그대로 돌려준다.
+ */
+public class UpdateTimeLetterDeliveryConditionUseCase
+    @Inject
+    constructor(
+        private val repository: UserReceiverRepository,
+    ) {
+        public suspend operator fun invoke(
+            receiverId: Long,
+            conditions: List<DeliveryConditionItem>,
+            conditionType: DeliveryConditionType,
+            inactivityPeriod: InactivityPeriod,
+        ): ReceiverDeliveryConditions {
+            val period = inactivityPeriod.takeIf { conditionType == DeliveryConditionType.INACTIVITY }
+            val updated =
+                conditions
+                    .map { condition ->
+                        if (condition.contentType == DeliveryContentType.TIME_LETTER) {
+                            condition.copy(conditionType = conditionType, inactivityPeriod = period)
+                        } else {
+                            condition
+                        }
+                    }.let { items ->
+                        if (items.any { it.contentType == DeliveryContentType.TIME_LETTER }) {
+                            items
+                        } else {
+                            items +
+                                DeliveryConditionItem(
+                                    contentType = DeliveryContentType.TIME_LETTER,
+                                    conditionType = conditionType,
+                                    inactivityPeriod = period,
+                                    state = ConditionState.ACTIVE,
+                                    fulfilled = false,
+                                    gracePeriodStartedAt = null,
+                                    fulfilledAt = null,
+                                )
+                        }
+                    }
+            return repository.updateReceiverDeliveryConditions(receiverId, updated)
+        }
+    }
diff --git a/feature/setting/domain/src/test/kotlin/com/afternote/feature/setting/domain/ReceiverSavePolicyTest.kt b/feature/setting/domain/src/test/kotlin/com/afternote/feature/setting/domain/ReceiverSavePolicyTest.kt
new file mode 100644
index 0000000000..860f6cd60e
--- /dev/null
+++ b/feature/setting/domain/src/test/kotlin/com/afternote/feature/setting/domain/ReceiverSavePolicyTest.kt
@@ -0,0 +1,181 @@
+package com.afternote.feature.setting.domain
+
+import com.afternote.core.domain.testing.FakeUserReceiverRepository
+import com.afternote.core.model.delivery.ConditionState
+import com.afternote.core.model.delivery.DeliveryConditionItem
+import com.afternote.core.model.delivery.DeliveryConditionType
+import com.afternote.core.model.delivery.DeliveryContentType
+import com.afternote.core.model.delivery.InactivityPeriod
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertSame
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class ReceiverSavePolicyTest {
+    @Test
+    fun `basic info failure skips message and preserves cause`() =
+        runTest {
+            val error = IllegalStateException("save failed")
+            val repository = FakeUserReceiverRepository(onUpdateReceiver = { _, _, _, _, _ -> throw error })
+            val result = save(repository)
+            assertSame(error, (result as UpdateReceiverInfoResult.BasicInfoFailed).cause)
+            assertTrue(repository.receiverMessageCalls.isEmpty())
+        }
+
+    /**
+     * 옮겨 오기 전 ViewModel 은 `runCatchingCancellable` 로 감싸 `Exception` 이 아닌 `Throwable` 도
+     * 화면 오류로 바꿨다. UseCase 가 `Exception` 만 잡으면 그 경로가 코루틴 밖으로 튀어 화면이 저장 중에
+     * 머문다 — 포착 범위를 좁히는 회귀를 여기서 막는다.
+     */
+    @Test
+    fun `basic info failure keeps non exception throwable as cause`() =
+        runTest {
+            val error = AssertionError("save failed")
+            val repository = FakeUserReceiverRepository(onUpdateReceiver = { _, _, _, _, _ -> throw error })
+            val result = save(repository)
+            assertSame(error, (result as UpdateReceiverInfoResult.BasicInfoFailed).cause)
+            assertTrue(repository.receiverMessageCalls.isEmpty())
+        }
+
+    @Test
+    fun `message failure reports already saved basic info`() =
+        runTest {
+            val repository = FakeUserReceiverRepository(onUpdateReceiverMessage = { _, _ -> error("message failed") })
+            assertEquals(UpdateReceiverInfoResult.MessageFailedAfterBasicInfoUpdated, save(repository))
+            assertEquals(
+                "updated",
+                repository.receiverState.value
+                    .single()
+                    .name,
+            )
+            assertEquals(1, repository.receiverMessageCalls.size)
+        }
+
+    /** 인사말 쪽도 같은 이유로 `Throwable` 까지 부분 저장 결과로 접는다. */
+    @Test
+    fun `message failure reports partial save for non exception throwable`() =
+        runTest {
+            val repository =
+                FakeUserReceiverRepository(
+                    onUpdateReceiverMessage = { _, _ -> throw AssertionError("message failed") },
+                )
+            assertEquals(UpdateReceiverInfoResult.MessageFailedAfterBasicInfoUpdated, save(repository))
+            assertEquals(1, repository.receiverMessageCalls.size)
+        }
+
+    @Test
+    fun `success saves basic info before message`() =
+        runTest {
+            val repository = FakeUserReceiverRepository()
+            repository.onUpdateReceiverMessage = { _, _ ->
+                assertEquals(
+                    "updated",
+                    repository.receiverState.value
+                        .single()
+                        .name,
+                )
+            }
+            assertEquals(UpdateReceiverInfoResult.Success, save(repository))
+        }
+
+    @Test
+    fun `cancellation between writes does not save message`() =
+        runTest {
+            val repository = FakeUserReceiverRepository()
+            repository.onUpdateReceiver = { _, _, _, _, _ ->
+                currentCoroutineContext().cancel()
+                repository.receiverState.value.single()
+            }
+            var completed = false
+            val job =
+                launch {
+                    save(repository)
+                    completed = true
+                }
+            job.join()
+            assertTrue(job.isCancelled)
+            assertTrue(repository.receiverMessageCalls.isEmpty())
+            assertEquals(false, completed)
+        }
+
+    @Test
+    fun `basic info cancellation propagates`() =
+        runTest {
+            val cancelled = CancellationException("cancelled")
+            val repository = FakeUserReceiverRepository(onUpdateReceiver = { _, _, _, _, _ -> throw cancelled })
+            try {
+                save(repository)
+                error("Expected cancellation")
+            } catch (actual: CancellationException) {
+                assertSame(cancelled, actual)
+            }
+            assertTrue(repository.receiverMessageCalls.isEmpty())
+        }
+
+    @Test
+    fun `message cancellation propagates`() =
+        runTest {
+            val cancelled = CancellationException("cancelled")
+            val repository = FakeUserReceiverRepository(onUpdateReceiverMessage = { _, _ -> throw cancelled })
+            try {
+                save(repository)
+                error("Expected cancellation")
+            } catch (actual: CancellationException) {
+                assertSame(cancelled, actual)
+            }
+        }
+
+    @Test
+    fun `time letter patch preserves other conditions and removes request period`() =
+        runTest {
+            val otherType = DeliveryContentType.entries.first { it != DeliveryContentType.TIME_LETTER }
+            val other = condition(otherType)
+            val timeLetter = condition(DeliveryContentType.TIME_LETTER)
+            val repository = FakeUserReceiverRepository()
+            val result =
+                UpdateTimeLetterDeliveryConditionUseCase(repository)(
+                    7L,
+                    listOf(other, timeLetter),
+                    DeliveryConditionType.RECEIVER_REQUEST,
+                    InactivityPeriod.ONE_YEAR,
+                )
+            assertEquals(
+                listOf(other, timeLetter.copy(conditionType = DeliveryConditionType.RECEIVER_REQUEST, inactivityPeriod = null)),
+                result.conditions,
+            )
+            assertEquals(result.conditions, repository.deliveryUpdateCalls.single().conditions)
+        }
+
+    @Test
+    fun `missing time letter is synthesized with selected inactivity period`() =
+        runTest {
+            val repository = FakeUserReceiverRepository()
+            val result =
+                UpdateTimeLetterDeliveryConditionUseCase(repository)(
+                    7L,
+                    emptyList(),
+                    DeliveryConditionType.INACTIVITY,
+                    InactivityPeriod.ONE_YEAR,
+                )
+            assertEquals(listOf(condition(DeliveryContentType.TIME_LETTER)), result.conditions)
+        }
+
+    private suspend fun save(repository: FakeUserReceiverRepository): UpdateReceiverInfoResult =
+        UpdateReceiverInfoUseCase(repository)(7L, "updated", "01012345678", "가족", "receiver@test.com", "hello")
+
+    private fun condition(type: DeliveryContentType) =
+        DeliveryConditionItem(
+            contentType = type,
+            conditionType = DeliveryConditionType.INACTIVITY,
+            inactivityPeriod = InactivityPeriod.ONE_YEAR,
+            state = ConditionState.ACTIVE,
+            fulfilled = false,
+            gracePeriodStartedAt = null,
+            fulfilledAt = null,
+        )
+}
diff --git a/feature/setting/presentation/build.gradle.kts b/feature/setting/presentation/build.gradle.kts
index 4eb2c8004c..e29d8541bf 100644
--- a/feature/setting/presentation/build.gradle.kts
+++ b/feature/setting/presentation/build.gradle.kts
@@ -31,10 +31,9 @@ dependencies {
     implementation(projects.core.domain)
     implementation(projects.core.model)
     implementation(projects.core.ui)
-    implementation(libs.androidx.hilt.navigation.compose)
     implementation(libs.androidx.compose.runtime)
-    implementation(libs.kakao.sdk.auth)
-    implementation(libs.kakao.sdk.user)
+    implementation(libs.coil.compose)
+    implementation(libs.kakao.sdk.share)
     implementation(libs.androidx.biometric)
     implementation(libs.androidx.credentials)
     implementation(libs.androidx.credentials.play.services.auth)
@@ -48,6 +47,8 @@ dependencies {
     testImplementation(libs.androidx.compose.ui.test.junit4)
     testImplementation(libs.androidx.test.core.ktx)
     testImplementation(libs.robolectric)
+    testImplementation(libs.hilt.android.testing)
+    kspTest(libs.hilt.compiler)
     debugImplementation(libs.androidx.compose.ui.test.manifest)
 
     screenshotTestImplementation(libs.screenshot.validation.api)
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsContent.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsContent.kt
index 1a51323a4d..5ae70a7d4b 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsContent.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsContent.kt
@@ -1,5 +1,6 @@
 package com.afternote.feature.setting.presentation.account
 
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
@@ -14,10 +15,12 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
+import com.afternote.core.ui.loading.LoadingBody
 import com.afternote.core.ui.theme.AfternoteDesign
 import com.afternote.core.ui.topbar.DetailTopBar
 import com.afternote.feature.setting.presentation.R
 import com.afternote.feature.setting.presentation.account.component.SocialAccountRow
+import com.afternote.feature.setting.presentation.shared.component.SettingLoadErrorContent
 
 /**
  * 연결된 계정 화면의 상태 없는 본문.
@@ -30,6 +33,7 @@ internal fun ConnectedAccountsContent(
     snackbarHostState: SnackbarHostState,
     onBack: () -> Unit,
     onToggle: (provider: String, enabled: Boolean) -> Unit,
+    onRetry: () -> Unit,
     modifier: Modifier = Modifier,
 ) {
     Scaffold(
@@ -43,30 +47,46 @@ internal fun ConnectedAccountsContent(
             )
         },
     ) { paddingValues ->
-        Column(
-            modifier =
-                Modifier
-                    .fillMaxSize()
-                    .padding(paddingValues)
-                    .padding(horizontal = 20.dp, vertical = 16.dp),
-        ) {
-            Text(
-                text = stringResource(R.string.setting_sns_login_section_title),
-                style = AfternoteDesign.typography.bodyLargeR,
-            )
-            Spacer(modifier = Modifier.height(4.dp))
-            Text(
-                text = stringResource(R.string.setting_sns_login_section_desc),
-                style = AfternoteDesign.typography.bodySmallR,
-            )
-            Spacer(modifier = Modifier.height(24.dp))
+        when {
+            uiState.isLoading -> {
+                LoadingBody(modifier = Modifier.padding(paddingValues))
+            }
 
-            uiState.accounts.forEach { account ->
-                SocialAccountRow(
-                    account = account,
-                    onToggle = { enabled -> onToggle(account.provider, enabled) },
+            uiState.errorMessage != null -> {
+                SettingLoadErrorContent(
+                    message = uiState.errorMessage,
+                    onRetry = onRetry,
+                    modifier = Modifier.padding(paddingValues),
                 )
-                Spacer(modifier = Modifier.height(8.dp))
+            }
+
+            else -> {
+                Column(
+                    modifier =
+                        Modifier
+                            .fillMaxSize()
+                            .padding(paddingValues)
+                            .padding(horizontal = 20.dp, vertical = 16.dp),
+                ) {
+                    Text(
+                        text = stringResource(R.string.setting_sns_login_section_title),
+                        style = AfternoteDesign.typography.bodyLargeR,
+                    )
+                    Spacer(modifier = Modifier.height(4.dp))
+                    Text(
+                        text = stringResource(R.string.setting_sns_login_section_desc),
+                        style = AfternoteDesign.typography.bodySmallR,
+                    )
+                    Spacer(modifier = Modifier.height(24.dp))
+
+                    uiState.accounts.forEach { account ->
+                        SocialAccountRow(
+                            account = account,
+                            onToggle = { enabled -> if (!uiState.isUpdating) onToggle(account.provider, enabled) },
+                        )
+                        Spacer(modifier = Modifier.height(8.dp))
+                    }
+                }
             }
         }
     }
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsContract.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsContract.kt
new file mode 100644
index 0000000000..53c4241d99
--- /dev/null
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsContract.kt
@@ -0,0 +1,64 @@
+package com.afternote.feature.setting.presentation.account
+
+import com.afternote.core.ui.mvi.MviIntent
+import com.afternote.core.ui.mvi.ReducerEvent
+
+internal sealed interface ConnectedAccountsIntent : MviIntent {
+    data object RefreshOnReturn : ConnectedAccountsIntent
+
+    data object RetryLoad : ConnectedAccountsIntent
+
+    data class ConsumeError(
+        val message: String,
+    ) : ConnectedAccountsIntent
+
+    data class Toggle(
+        val provider: String,
+        val enabled: Boolean,
+    ) : ConnectedAccountsIntent
+
+    /** 화면이 플랫폼 인증으로 받아낸 [accessToken] 으로 [provider] 를 연결한다. */
+    data class Link(
+        val provider: String,
+        val accessToken: String,
+    ) : ConnectedAccountsIntent
+
+    /** 화면이 처리한 연결 요청 [provider] 를 되돌려준다. 그사이 다른 제공자 요청이 올라왔으면 그 요청은 남는다. */
+    data class ConsumeLinkRequest(
+        val provider: String,
+    ) : ConnectedAccountsIntent
+}
+
+internal sealed interface ConnectedAccountsReducerEvent : ReducerEvent {
+    data object Loading : ConnectedAccountsReducerEvent
+
+    data object Changing : ConnectedAccountsReducerEvent
+
+    data class ErrorConsumed(
+        val message: String,
+    ) : ConnectedAccountsReducerEvent
+
+    data class Loaded(
+        val accounts: List<SocialAccountState>,
+    ) : ConnectedAccountsReducerEvent
+
+    data class LoadFailed(
+        val message: String,
+    ) : ConnectedAccountsReducerEvent
+
+    data class AccountsChanged(
+        val accounts: List<SocialAccountState>,
+    ) : ConnectedAccountsReducerEvent
+
+    data class ChangeFailed(
+        val message: String,
+    ) : ConnectedAccountsReducerEvent
+
+    data class LinkRequested(
+        val provider: String,
+    ) : ConnectedAccountsReducerEvent
+
+    data class LinkRequestConsumed(
+        val provider: String,
+    ) : ConnectedAccountsReducerEvent
+}
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsScreen.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsScreen.kt
index 6e6d6295f4..8d3e675540 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsScreen.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsScreen.kt
@@ -3,46 +3,57 @@ package com.afternote.feature.setting.presentation.account
 import android.app.Activity
 import androidx.compose.material3.SnackbarHostState
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.credentials.CredentialManager
 import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.compose.LifecycleEventEffect
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.afternote.core.common.auth.requestKakaoAccessToken
 import com.afternote.core.domain.error.CoreAuthFailure
 import com.afternote.core.ui.findActivity
+import com.afternote.core.ui.mvi.ObserveSignal
 import com.afternote.feature.setting.presentation.BuildConfig
 import com.afternote.feature.setting.presentation.R
 import com.afternote.feature.setting.presentation.account.social.KakaoAuthResult
 import com.afternote.feature.setting.presentation.account.social.requestGoogleIdToken
-import com.afternote.feature.setting.presentation.account.social.requestKakaoAccessToken
 import com.afternote.feature.setting.presentation.account.social.toKakaoAuthResult
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 
 @Composable
-fun ConnectedAccountsScreen(
+internal fun ConnectedAccountsScreen(
     onBack: () -> Unit,
     modifier: Modifier = Modifier,
     viewModel: ConnectedAccountsViewModel = hiltViewModel(),
 ) {
     val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+    LifecycleEventEffect(Lifecycle.Event.ON_RESUME) { viewModel.onIntent(ConnectedAccountsIntent.RefreshOnReturn) }
     val context = LocalContext.current
     val credentialManager = remember(context) { CredentialManager.create(context) }
     val snackbarHostState = remember { SnackbarHostState() }
     val kakaoAccountLinkFailedMessage = stringResource(R.string.setting_kakao_account_link_failed)
     val googleAccountLinkFailedMessage = stringResource(R.string.setting_google_account_link_failed)
+    // 소비가 ObserveSignal 의 effect 를 다시 시작시켜도 인증·스낵바는 끝까지 간다. 예전 이벤트 수집처럼
+    // 요청을 하나씩 처리하도록 화면 코루틴에서 잠금으로 줄을 세운다.
+    val linkScope = rememberCoroutineScope()
+    val linkMutex = remember { Mutex() }
 
-    LaunchedEffect(Unit) {
-        viewModel.events.collect { event ->
-            when (event) {
-                is ConnectedAccountsEvent.ShowError -> {
-                    snackbarHostState.showSnackbar(event.message)
-                }
-
-                is ConnectedAccountsEvent.RequestLink -> {
-                    when (event.provider) {
+    uiState.pendingLinkProvider?.let { pendingProvider ->
+        ObserveSignal(
+            signal = pendingProvider,
+            consumed = ConnectedAccountsIntent.ConsumeLinkRequest(pendingProvider),
+            onIntent = viewModel::onIntent,
+        ) { provider ->
+            linkScope.launch {
+                linkMutex.withLock {
+                    when (provider) {
                         "kakao" -> {
                             val activity = context.findActivity<Activity>()
                             val authResult =
@@ -51,15 +62,13 @@ fun ConnectedAccountsScreen(
                                     ?: KakaoAuthResult.Failure
                             when (authResult) {
                                 is KakaoAuthResult.Success -> {
-                                    viewModel.link("kakao", authResult.accessToken)
+                                    viewModel.onIntent(ConnectedAccountsIntent.Link("kakao", authResult.accessToken))
                                 }
 
                                 KakaoAuthResult.Cancelled -> {}
 
                                 KakaoAuthResult.Failure -> {
-                                    snackbarHostState.showSnackbar(
-                                        kakaoAccountLinkFailedMessage,
-                                    )
+                                    snackbarHostState.showSnackbar(kakaoAccountLinkFailedMessage)
                                 }
                             }
                         }
@@ -69,14 +78,13 @@ fun ConnectedAccountsScreen(
                                 context = context,
                                 credentialManager = credentialManager,
                                 serverClientId = BuildConfig.GOOGLE_WEB_CLIENT_ID,
-                            ).onSuccess { token -> viewModel.link("google", token) }
-                                .onFailure { e ->
-                                    if (e !is CoreAuthFailure.UserCancelledAuth) {
-                                        viewModel.notifyLinkError(
-                                            googleAccountLinkFailedMessage,
-                                        )
-                                    }
+                            ).onSuccess { token ->
+                                viewModel.onIntent(ConnectedAccountsIntent.Link("google", token))
+                            }.onFailure { e ->
+                                if (e !is CoreAuthFailure.UserCancelledAuth) {
+                                    snackbarHostState.showSnackbar(googleAccountLinkFailedMessage)
                                 }
+                            }
                         }
                     }
                 }
@@ -84,11 +92,18 @@ fun ConnectedAccountsScreen(
         }
     }
 
+    uiState.pendingError?.let { message ->
+        ObserveSignal(message, ConnectedAccountsIntent.ConsumeError(message), viewModel::onIntent) {
+            linkScope.launch { snackbarHostState.showSnackbar(it) }
+        }
+    }
+
     ConnectedAccountsContent(
         uiState = uiState,
         snackbarHostState = snackbarHostState,
         onBack = onBack,
-        onToggle = viewModel::onToggle,
+        onRetry = { viewModel.onIntent(ConnectedAccountsIntent.RetryLoad) },
+        onToggle = { provider, enabled -> viewModel.onIntent(ConnectedAccountsIntent.Toggle(provider, enabled)) },
         modifier = modifier,
     )
 }
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsUiState.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsUiState.kt
index 7fb4ecbf53..56754d98a2 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsUiState.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsUiState.kt
@@ -1,17 +1,19 @@
 package com.afternote.feature.setting.presentation.account
 
+import com.afternote.core.ui.mvi.UiState
+
 data class ConnectedAccountsUiState(
     val isLoading: Boolean = false,
     val accounts: List<SocialAccountState> = emptyList(),
     val errorMessage: String? = null,
-)
-
-sealed interface ConnectedAccountsEvent {
-    data class RequestLink(
-        val provider: String,
-    ) : ConnectedAccountsEvent
-
-    data class ShowError(
-        val message: String,
-    ) : ConnectedAccountsEvent
-}
+    val isUpdating: Boolean = false,
+    val pendingError: String? = null,
+    /**
+     * 화면이 플랫폼 인증(카카오 SDK·Credential Manager)을 시작해야 하는 제공자 신호다 (#1502).
+     *
+     * ViewModel 은 Activity·Context 에 닿지 않으므로 토큰을 직접 받지 못한다. 화면이 이 신호를 받아
+     * 인증을 돌린 뒤 토큰만 [ConnectedAccountsIntent.Link] 로 돌려보내고, 받은 즉시
+     * [ConnectedAccountsIntent.ConsumeLinkRequest] 로 되돌린다.
+     */
+    val pendingLinkProvider: String? = null,
+) : UiState
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsViewModel.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsViewModel.kt
index 9bb3992114..80d657aac8 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsViewModel.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsViewModel.kt
@@ -1,77 +1,167 @@
 package com.afternote.feature.setting.presentation.account
 
-import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
+import com.afternote.core.domain.result.runCatchingCancellable
 import com.afternote.core.model.user.UserConnectedAccount
+import com.afternote.core.ui.mvi.MviViewModel
 import com.afternote.feature.setting.domain.SettingAccountRepository
 import com.afternote.feature.setting.presentation.R
 import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.receiveAsFlow
-import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.launch
 import javax.inject.Inject
 
 @HiltViewModel
-class ConnectedAccountsViewModel
+internal class ConnectedAccountsViewModel
     @Inject
     constructor(
         private val accountRepository: SettingAccountRepository,
-    ) : ViewModel() {
-        private val _uiState = MutableStateFlow(ConnectedAccountsUiState(isLoading = true))
-        val uiState = _uiState.asStateFlow()
-
-        private val _events = Channel<ConnectedAccountsEvent>(Channel.BUFFERED)
-        val events = _events.receiveAsFlow()
+    ) : MviViewModel<ConnectedAccountsIntent, ConnectedAccountsUiState, ConnectedAccountsReducerEvent>(
+            ConnectedAccountsUiState(isLoading = true),
+        ) {
+        private var loadJob: Job? = null
+        private var isFirstResume = true
 
         init {
             loadConnectedAccounts()
         }
 
-        private fun loadConnectedAccounts() {
-            viewModelScope.launch {
-                runCatching { accountRepository.getConnectedAccounts() }
-                    .onSuccess { accounts ->
-                        _uiState.update { it.copy(isLoading = false, accounts = accounts.toStateList()) }
-                    }.onFailure {
-                        _uiState.update { it.copy(isLoading = false, errorMessage = "계정 정보를 불러올 수 없습니다.") }
+        override fun onIntent(intent: ConnectedAccountsIntent) {
+            when (intent) {
+                ConnectedAccountsIntent.RefreshOnReturn -> {
+                    refreshOnReturn()
+                }
+
+                ConnectedAccountsIntent.RetryLoad -> {
+                    if (currentState.errorMessage != null) loadConnectedAccounts()
+                }
+
+                is ConnectedAccountsIntent.ConsumeError -> {
+                    dispatch(ConnectedAccountsReducerEvent.ErrorConsumed(intent.message))
+                }
+
+                is ConnectedAccountsIntent.Toggle -> {
+                    toggle(intent.provider, intent.enabled)
+                }
+
+                is ConnectedAccountsIntent.Link -> {
+                    link(intent.provider, intent.accessToken)
+                }
+
+                is ConnectedAccountsIntent.ConsumeLinkRequest -> {
+                    dispatch(
+                        ConnectedAccountsReducerEvent.LinkRequestConsumed(intent.provider),
+                    )
+                }
+            }
+        }
+
+        override fun reduce(
+            state: ConnectedAccountsUiState,
+            event: ConnectedAccountsReducerEvent,
+        ): ConnectedAccountsUiState =
+            when (event) {
+                ConnectedAccountsReducerEvent.Loading -> {
+                    state.copy(isLoading = true, errorMessage = null)
+                }
+
+                ConnectedAccountsReducerEvent.Changing -> {
+                    state.copy(isUpdating = true, pendingError = null)
+                }
+
+                is ConnectedAccountsReducerEvent.ErrorConsumed -> {
+                    if (state.pendingError ==
+                        event.message
+                    ) {
+                        state.copy(pendingError = null)
+                    } else {
+                        state
                     }
+                }
+
+                is ConnectedAccountsReducerEvent.Loaded -> {
+                    state.copy(isLoading = false, errorMessage = null, accounts = event.accounts)
+                }
+
+                is ConnectedAccountsReducerEvent.LoadFailed -> {
+                    state.copy(isLoading = false, errorMessage = event.message)
+                }
+
+                is ConnectedAccountsReducerEvent.AccountsChanged -> {
+                    state.copy(accounts = event.accounts, isUpdating = false)
+                }
+
+                is ConnectedAccountsReducerEvent.ChangeFailed -> {
+                    state.copy(pendingError = event.message, isUpdating = false)
+                }
+
+                is ConnectedAccountsReducerEvent.LinkRequested -> {
+                    state.copy(pendingLinkProvider = event.provider)
+                }
+
+                // 늦게 도착한 소비가 그사이 올라온 다른 제공자 요청을 지우지 않게 한다.
+                is ConnectedAccountsReducerEvent.LinkRequestConsumed -> {
+                    if (state.pendingLinkProvider == event.provider) state.copy(pendingLinkProvider = null) else state
+                }
             }
+
+        private fun refreshOnReturn() {
+            if (isFirstResume) {
+                isFirstResume = false
+                return
+            }
+            loadConnectedAccounts(isAutomatic = true)
+        }
+
+        private fun loadConnectedAccounts(isAutomatic: Boolean = false) {
+            if (loadJob?.isActive == true || currentState.isUpdating || currentState.pendingLinkProvider != null) return
+            if (!isAutomatic) dispatch(ConnectedAccountsReducerEvent.Loading)
+            loadJob =
+                viewModelScope.launch {
+                    runCatchingCancellable { accountRepository.getConnectedAccounts() }
+                        .onSuccess { accounts ->
+                            dispatch(ConnectedAccountsReducerEvent.Loaded(accounts.toStateList()))
+                        }.onFailure {
+                            if (!isAutomatic || currentState.accounts.isEmpty()) {
+                                dispatch(ConnectedAccountsReducerEvent.LoadFailed("계정 정보를 불러올 수 없습니다."))
+                            }
+                        }
+                }
         }
 
-        fun onToggle(
+        private fun toggle(
             provider: String,
             enabled: Boolean,
         ) {
+            if (currentState.isLoading || currentState.errorMessage != null || currentState.isUpdating) return
             if (enabled) {
-                viewModelScope.launch { _events.send(ConnectedAccountsEvent.RequestLink(provider)) }
+                dispatch(ConnectedAccountsReducerEvent.LinkRequested(provider))
             } else {
                 unlink(provider)
             }
         }
 
-        fun notifyLinkError(message: String) {
-            viewModelScope.launch { _events.send(ConnectedAccountsEvent.ShowError(message)) }
-        }
-
-        fun link(
+        private fun link(
             provider: String,
             accessToken: String,
         ) {
+            if (currentState.isLoading || currentState.errorMessage != null || currentState.isUpdating) return
+            loadJob?.cancel()
+            dispatch(ConnectedAccountsReducerEvent.Changing)
             viewModelScope.launch {
-                runCatching { accountRepository.linkConnectedAccount(provider, accessToken) }
-                    .onSuccess { accounts -> _uiState.update { it.copy(accounts = accounts.toStateList()) } }
-                    .onFailure { _uiState.update { it.copy(errorMessage = "계정 연결에 실패했습니다.") } }
+                runCatchingCancellable { accountRepository.linkConnectedAccount(provider, accessToken) }
+                    .onSuccess { accounts -> dispatch(ConnectedAccountsReducerEvent.AccountsChanged(accounts.toStateList())) }
+                    .onFailure { dispatch(ConnectedAccountsReducerEvent.ChangeFailed("계정 연결에 실패했습니다.")) }
             }
         }
 
         private fun unlink(provider: String) {
+            loadJob?.cancel()
+            dispatch(ConnectedAccountsReducerEvent.Changing)
             viewModelScope.launch {
-                runCatching { accountRepository.unlinkConnectedAccount(provider) }
-                    .onSuccess { accounts -> _uiState.update { it.copy(accounts = accounts.toStateList()) } }
-                    .onFailure { _uiState.update { it.copy(errorMessage = "계정 연결 해제에 실패했습니다.") } }
+                runCatchingCancellable { accountRepository.unlinkConnectedAccount(provider) }
+                    .onSuccess { accounts -> dispatch(ConnectedAccountsReducerEvent.AccountsChanged(accounts.toStateList())) }
+                    .onFailure { dispatch(ConnectedAccountsReducerEvent.ChangeFailed("계정 연결 해제에 실패했습니다.")) }
             }
         }
 
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/applock/AppLockSetupContract.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/applock/AppLockSetupContract.kt
new file mode 100644
index 0000000000..c5e2e67d62
--- /dev/null
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/applock/AppLockSetupContract.kt
@@ -0,0 +1,24 @@
+package com.afternote.feature.setting.presentation.applock
+
+import com.afternote.core.ui.mvi.MviIntent
+import com.afternote.core.ui.mvi.ReducerEvent
+
+internal sealed interface AppLockSetupIntent : MviIntent {
+    data class DigitInput(
+        val digit: String,
+    ) : AppLockSetupIntent
+
+    data object Delete : AppLockSetupIntent
+
+    data object ResetPin : AppLockSetupIntent
+}
+
+internal sealed interface AppLockSetupReducerEvent : ReducerEvent {
+    data class DigitEntered(
+        val digit: String,
+    ) : AppLockSetupReducerEvent
+
+    data object Deleted : AppLockSetupReducerEvent
+
+    data object PinReset : AppLockSetupReducerEvent
+}
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/applock/AppLockSetupScreen.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/applock/AppLockSetupScreen.kt
index 0dc39dabf1..7a704844e0 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/applock/AppLockSetupScreen.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/applock/AppLockSetupScreen.kt
@@ -9,7 +9,7 @@ import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 
 @Composable
-fun AppLockSetupScreen(
+internal fun AppLockSetupScreen(
     step: PinSetupStep,
     onPinComplete: (pin: String) -> Unit,
     onBack: () -> Unit,
@@ -22,15 +22,15 @@ fun AppLockSetupScreen(
     LaunchedEffect(uiState.isComplete) {
         if (uiState.isComplete) {
             currentOnPinComplete(uiState.pin)
-            viewModel.resetPin()
+            viewModel.onIntent(AppLockSetupIntent.ResetPin)
         }
     }
 
     AppLockSetupContent(
         step = step,
         passwordLength = uiState.pin.length,
-        onDigitClick = viewModel::onDigitInput,
-        onDeleteClick = viewModel::onDelete,
+        onDigitClick = { viewModel.onIntent(AppLockSetupIntent.DigitInput(it)) },
+        onDeleteClick = { viewModel.onIntent(AppLockSetupIntent.Delete) },
         onConfirmClick = { currentOnPinComplete(uiState.pin) },
         onBack = onBack,
         modifier = modifier,
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/applock/AppLockSetupUiState.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/applock/AppLockSetupUiState.kt
index 99c2815557..12c99a65c8 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/applock/AppLockSetupUiState.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/applock/AppLockSetupUiState.kt
@@ -1,6 +1,8 @@
 package com.afternote.feature.setting.presentation.applock
 
-data class AppLockSetupUiState(
+import com.afternote.core.ui.mvi.UiState
+
+internal data class AppLockSetupUiState(
     val pin: String = "",
     val isComplete: Boolean = false,
-)
+) : UiState
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/applock/AppLockSetupViewModel.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/applock/AppLockSetupViewModel.kt
index c7866b7f13..2a87350a33 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/applock/AppLockSetupViewModel.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/applock/AppLockSetupViewModel.kt
@@ -1,38 +1,42 @@
 package com.afternote.feature.setting.presentation.applock
 
-import androidx.lifecycle.ViewModel
+import com.afternote.core.ui.mvi.MviViewModel
 import dagger.hilt.android.lifecycle.HiltViewModel
 import jakarta.inject.Inject
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.update
 
 @HiltViewModel
-class AppLockSetupViewModel
+internal class AppLockSetupViewModel
     @Inject
-    constructor() : ViewModel() {
-        private val _uiState = MutableStateFlow(AppLockSetupUiState())
-        val uiState: StateFlow<AppLockSetupUiState> = _uiState.asStateFlow()
-
-        fun onDigitInput(digit: String) {
-            _uiState.update { state ->
-                if (state.pin.length < 4) {
-                    val newPin = state.pin + digit
-                    state.copy(pin = newPin, isComplete = newPin.length == 4)
-                } else {
-                    state
-                }
+    constructor() :
+    MviViewModel<AppLockSetupIntent, AppLockSetupUiState, AppLockSetupReducerEvent>(AppLockSetupUiState()) {
+        override fun onIntent(intent: AppLockSetupIntent) {
+            when (intent) {
+                is AppLockSetupIntent.DigitInput -> dispatch(AppLockSetupReducerEvent.DigitEntered(intent.digit))
+                AppLockSetupIntent.Delete -> dispatch(AppLockSetupReducerEvent.Deleted)
+                AppLockSetupIntent.ResetPin -> dispatch(AppLockSetupReducerEvent.PinReset)
             }
         }
 
-        fun onDelete() {
-            _uiState.update { state ->
-                state.copy(pin = state.pin.dropLast(1), isComplete = false)
-            }
-        }
+        override fun reduce(
+            state: AppLockSetupUiState,
+            event: AppLockSetupReducerEvent,
+        ): AppLockSetupUiState =
+            when (event) {
+                is AppLockSetupReducerEvent.DigitEntered -> {
+                    if (state.pin.length < 4) {
+                        val newPin = state.pin + event.digit
+                        state.copy(pin = newPin, isComplete = newPin.length == 4)
+                    } else {
+                        state
+                    }
+                }
 
-        fun resetPin() {
-            _uiState.update { AppLockSetupUiState() }
-        }
+                AppLockSetupReducerEvent.Deleted -> {
+                    state.copy(pin = state.pin.dropLast(1), isComplete = false)
+                }
+
+                AppLockSetupReducerEvent.PinReset -> {
+                    AppLockSetupUiState()
+                }
+            }
     }
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/delivery/DeliveryConditionContract.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/delivery/DeliveryConditionContract.kt
new file mode 100644
index 0000000000..44207cf6c5
--- /dev/null
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/delivery/DeliveryConditionContract.kt
@@ -0,0 +1,43 @@
+package com.afternote.feature.setting.presentation.delivery
+
+import com.afternote.core.model.delivery.DeliveryConditionItem
+import com.afternote.core.model.delivery.DeliveryConditionType
+import com.afternote.core.ui.mvi.MviIntent
+import com.afternote.core.ui.mvi.ReducerEvent
+
+internal sealed interface DeliveryConditionIntent : MviIntent {
+    data object RefreshOnReturn : DeliveryConditionIntent
+
+    data class SelectConditionType(
+        val type: DeliveryConditionType,
+    ) : DeliveryConditionIntent
+
+    data object Save : DeliveryConditionIntent
+
+    data object ConsumeSuccess : DeliveryConditionIntent
+}
+
+internal sealed interface DeliveryConditionReducerEvent : ReducerEvent {
+    data object Loading : DeliveryConditionReducerEvent
+
+    data class Loaded(
+        val conditions: List<DeliveryConditionItem>,
+    ) : DeliveryConditionReducerEvent
+
+    data object LoadFailed : DeliveryConditionReducerEvent
+
+    data class ConditionSelected(
+        val type: DeliveryConditionType,
+    ) : DeliveryConditionReducerEvent
+
+    data object Saving : DeliveryConditionReducerEvent
+
+    data class Saved(
+        val revision: Int,
+        val conditions: List<DeliveryConditionItem>,
+    ) : DeliveryConditionReducerEvent
+
+    data object SaveFailed : DeliveryConditionReducerEvent
+
+    data object SuccessConsumed : DeliveryConditionReducerEvent
+}
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/delivery/DeliveryConditionScreen.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/delivery/DeliveryConditionScreen.kt
index 50dc3c6696..17a5104cfe 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/delivery/DeliveryConditionScreen.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/delivery/DeliveryConditionScreen.kt
@@ -17,17 +17,18 @@ import androidx.compose.material3.Scaffold
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
-import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.compose.LifecycleEventEffect
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.afternote.core.model.delivery.DeliveryConditionType
+import com.afternote.core.ui.mvi.ObserveFlag
 import com.afternote.core.ui.theme.AfternoteDesign
 import com.afternote.core.ui.topbar.DetailTopBar
 import com.afternote.feature.setting.presentation.R
@@ -42,18 +43,20 @@ internal fun DeliveryConditionScreen(
     viewModel: DeliveryConditionViewModel,
 ) {
     val uiState by viewModel.uiState.collectAsStateWithLifecycle()
-    val currentOnSaveSuccess by rememberUpdatedState(onSaveSuccess)
-
-    LaunchedEffect(Unit) {
-        viewModel.saveSuccess.collect { currentOnSaveSuccess() }
-    }
+    LifecycleEventEffect(Lifecycle.Event.ON_RESUME) { viewModel.onIntent(DeliveryConditionIntent.RefreshOnReturn) }
+    ObserveFlag(
+        raised = uiState.isSaveSuccessPending,
+        consumed = DeliveryConditionIntent.ConsumeSuccess,
+        onIntent = viewModel::onIntent,
+        onRaised = onSaveSuccess,
+    )
 
     DeliveryConditionContent(
         uiState = uiState,
         onBack = onBack,
-        onConditionTypeSelect = viewModel::onConditionTypeSelected,
+        onConditionTypeSelect = { viewModel.onIntent(DeliveryConditionIntent.SelectConditionType(it)) },
         onLastGreetingEditClick = onLastGreetingEditClick,
-        onSave = viewModel::onSave,
+        onSave = { viewModel.onIntent(DeliveryConditionIntent.Save) },
     )
 }
 
@@ -61,10 +64,12 @@ internal fun DeliveryConditionScreen(
 private fun DeliveryConditionContent(
     uiState: DeliveryConditionUiState,
     onBack: () -> Unit,
-    onConditionTypeSelect: (Int) -> Unit,
+    onConditionTypeSelect: (DeliveryConditionType) -> Unit,
     onLastGreetingEditClick: () -> Unit,
     onSave: () -> Unit,
 ) {
+    // 라디오 순서의 단일 출처. processingMethodItems 와 같은 순서로 둔다.
+    val conditionTypes = listOf(DeliveryConditionType.INACTIVITY, DeliveryConditionType.RECEIVER_REQUEST)
     val processingMethodItems =
         listOf(
             RadioGroupItem(
@@ -83,7 +88,7 @@ private fun DeliveryConditionContent(
                 title = stringResource(R.string.setting_recipient_after_delivery),
                 onBackClick = onBack,
                 actions = {
-                    val isSaveEnabled = uiState.isInitialized && !uiState.isLoading && !uiState.isSaving
+                    val isSaveEnabled = uiState.isInitialized && !uiState.isLoading && !uiState.isSaveLocked
                     TextButton(onClick = onSave, enabled = isSaveEnabled) {
                         Text(
                             text = stringResource(R.string.setting_delivery_condition_save),
@@ -127,8 +132,8 @@ private fun DeliveryConditionContent(
             Spacer(Modifier.height(28.dp))
             RadioGroup(
                 items = processingMethodItems,
-                selectedIndex = if (uiState.conditionType == DeliveryConditionType.INACTIVITY) 0 else 1,
-                onSelectIndex = onConditionTypeSelect,
+                selectedIndex = conditionTypes.indexOf(uiState.conditionType),
+                onSelectIndex = { onConditionTypeSelect(conditionTypes[it]) },
             )
 
             Spacer(Modifier.height(32.dp))
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/delivery/DeliveryConditionUiState.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/delivery/DeliveryConditionUiState.kt
index 723942ec0e..1d493c8b76 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/delivery/DeliveryConditionUiState.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/delivery/DeliveryConditionUiState.kt
@@ -4,8 +4,11 @@ import com.afternote.core.model.delivery.DeliveryConditionItem
 import com.afternote.core.model.delivery.DeliveryConditionType
 import com.afternote.core.model.delivery.DeliveryContentType
 import com.afternote.core.model.delivery.InactivityPeriod
+import com.afternote.core.ui.mvi.UiState
 
-data class DeliveryConditionUiState(
+internal data class DeliveryConditionUiState(
+    val conditionEditRevision: Int = 0,
+    val savedConditionRevision: Int = 0,
     val isLoading: Boolean = false,
     val isInitialized: Boolean = false,
     val conditionType: DeliveryConditionType = DeliveryConditionType.INACTIVITY,
@@ -13,7 +16,13 @@ data class DeliveryConditionUiState(
     val conditions: List<DeliveryConditionItem> = emptyList(),
     val error: DeliveryConditionError? = null,
     val isSaving: Boolean = false,
-)
+    /** 저장을 마쳤다는 사실. 소비되는 [isSaveSuccessPending] 과 달리 되돌리지 않아, 화면이 닫히는 동안에도 재제출을 막는다. */
+    val isSaved: Boolean = false,
+    /** 화면에 알릴 저장 성공 신호. 어디로 이동할지는 이 신호를 콜백으로 받은 호스트가 정한다. */
+    val isSaveSuccessPending: Boolean = false,
+) : UiState {
+    val isSaveLocked: Boolean get() = isSaving || isSaved
+}
 
 enum class DeliveryConditionError {
     LOAD_FAILED,
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/delivery/DeliveryConditionViewModel.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/delivery/DeliveryConditionViewModel.kt
index 2be5e9e7c7..59e2240c2f 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/delivery/DeliveryConditionViewModel.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/delivery/DeliveryConditionViewModel.kt
@@ -1,25 +1,19 @@
 package com.afternote.feature.setting.presentation.delivery
 
-import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
-import com.afternote.core.common.result.runCatchingCancellable
 import com.afternote.core.domain.repository.UserReceiverRepository
-import com.afternote.core.model.delivery.ConditionState
-import com.afternote.core.model.delivery.DeliveryConditionItem
+import com.afternote.core.domain.result.runCatchingCancellable
 import com.afternote.core.model.delivery.DeliveryConditionType
 import com.afternote.core.model.delivery.DeliveryContentType
 import com.afternote.core.model.delivery.InactivityPeriod
+import com.afternote.core.ui.mvi.MviViewModel
+import com.afternote.feature.setting.domain.UpdateTimeLetterDeliveryConditionUseCase
 import com.afternote.feature.setting.presentation.navigation.SettingRoute
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
 import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.receiveAsFlow
-import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.launch
 
 /**
@@ -32,108 +26,136 @@ internal class DeliveryConditionViewModel
     constructor(
         @Assisted route: SettingRoute.AfterDeliveryRoute,
         private val receiverRepository: UserReceiverRepository,
-    ) : ViewModel() {
+        private val updateTimeLetterDeliveryCondition: UpdateTimeLetterDeliveryConditionUseCase,
+    ) : MviViewModel<DeliveryConditionIntent, DeliveryConditionUiState, DeliveryConditionReducerEvent>(DeliveryConditionUiState()) {
         private val receiverId = route.receiverId
+        private var loadJob: Job? = null
+        private var isFirstResume = true
 
-        private val _uiState = MutableStateFlow(DeliveryConditionUiState())
-        val uiState: StateFlow<DeliveryConditionUiState> = _uiState.asStateFlow()
+        override fun onIntent(intent: DeliveryConditionIntent) {
+            when (intent) {
+                DeliveryConditionIntent.RefreshOnReturn -> refreshOnReturn()
+                is DeliveryConditionIntent.SelectConditionType -> dispatch(DeliveryConditionReducerEvent.ConditionSelected(intent.type))
+                DeliveryConditionIntent.Save -> onSave()
+                DeliveryConditionIntent.ConsumeSuccess -> dispatch(DeliveryConditionReducerEvent.SuccessConsumed)
+            }
+        }
+
+        override fun reduce(
+            state: DeliveryConditionUiState,
+            event: DeliveryConditionReducerEvent,
+        ): DeliveryConditionUiState =
+            when (event) {
+                DeliveryConditionReducerEvent.Loading -> {
+                    state.copy(isLoading = true)
+                }
 
-        private val _saveSuccess = Channel<Unit>(Channel.BUFFERED)
-        val saveSuccess = _saveSuccess.receiveAsFlow()
+                is DeliveryConditionReducerEvent.Loaded -> {
+                    val representative = event.conditions.firstOrNull { it.contentType == DeliveryContentType.TIME_LETTER }
+                    val hasEdits = state.conditionEditRevision != state.savedConditionRevision
+                    state.copy(
+                        isLoading = false,
+                        isInitialized = true,
+                        conditionType =
+                            if (hasEdits) {
+                                state.conditionType
+                            } else {
+                                representative?.conditionType
+                                    ?: DeliveryConditionType.INACTIVITY
+                            },
+                        inactivityPeriod =
+                            if (hasEdits) {
+                                state.inactivityPeriod
+                            } else {
+                                representative?.inactivityPeriod
+                                    ?: InactivityPeriod.ONE_YEAR
+                            },
+                        conditions = event.conditions,
+                        error = state.error.takeUnless { it == DeliveryConditionError.LOAD_FAILED },
+                    )
+                }
+
+                DeliveryConditionReducerEvent.LoadFailed -> {
+                    state.copy(isLoading = false, error = DeliveryConditionError.LOAD_FAILED)
+                }
+
+                is DeliveryConditionReducerEvent.ConditionSelected -> {
+                    state.copy(conditionType = event.type, conditionEditRevision = state.conditionEditRevision + 1)
+                }
+
+                DeliveryConditionReducerEvent.Saving -> {
+                    state.copy(isSaving = true)
+                }
+
+                is DeliveryConditionReducerEvent.Saved -> {
+                    state.copy(
+                        isSaving = false,
+                        conditions = event.conditions,
+                        isSaved = true,
+                        isSaveSuccessPending = true,
+                        savedConditionRevision = event.revision,
+                        error = null,
+                    )
+                }
+
+                DeliveryConditionReducerEvent.SaveFailed -> {
+                    state.copy(isSaving = false, error = DeliveryConditionError.SAVE_FAILED)
+                }
+
+                DeliveryConditionReducerEvent.SuccessConsumed -> {
+                    state.copy(isSaveSuccessPending = false)
+                }
+            }
 
         init {
             loadDeliveryConditions()
         }
 
-        private fun loadDeliveryConditions() {
-            viewModelScope.launch {
-                _uiState.update { it.copy(isLoading = true) }
-                runCatchingCancellable { receiverRepository.getReceiverDeliveryConditions(receiverId) }
-                    .onSuccess { response ->
-                        val representative =
-                            response.conditions.firstOrNull {
-                                it.contentType == DeliveryContentType.TIME_LETTER
-                            }
-                        _uiState.update {
-                            it.copy(
-                                isLoading = false,
-                                isInitialized = true,
-                                conditionType = representative?.conditionType ?: DeliveryConditionType.INACTIVITY,
-                                inactivityPeriod = representative?.inactivityPeriod ?: InactivityPeriod.ONE_YEAR,
-                                conditions = response.conditions,
-                            )
-                        }
-                    }.onFailure {
-                        _uiState.update { it.copy(isLoading = false, error = DeliveryConditionError.LOAD_FAILED) }
-                    }
+        private fun refreshOnReturn() {
+            if (isFirstResume) {
+                isFirstResume = false
+                return
             }
+            loadDeliveryConditions(isAutomatic = true)
         }
 
-        fun onConditionTypeSelected(index: Int) {
-            val conditionType =
-                if (index == 1) DeliveryConditionType.RECEIVER_REQUEST else DeliveryConditionType.INACTIVITY
-            _uiState.update { it.copy(conditionType = conditionType) }
+        private fun loadDeliveryConditions(isAutomatic: Boolean = false) {
+            if (loadJob?.isActive == true || currentState.isSaving) return
+            loadJob =
+                viewModelScope.launch {
+                    if (!isAutomatic) dispatch(DeliveryConditionReducerEvent.Loading)
+                    runCatchingCancellable { receiverRepository.getReceiverDeliveryConditions(receiverId) }
+                        .onSuccess { response ->
+                            dispatch(DeliveryConditionReducerEvent.Loaded(response.conditions))
+                        }.onFailure {
+                            if (!isAutomatic || !currentState.isInitialized) dispatch(DeliveryConditionReducerEvent.LoadFailed)
+                        }
+                }
         }
 
-        fun onSave() {
-            val state = _uiState.value
-            if (!state.isInitialized || state.isSaving) return
-
-            val hasTimeLetterCondition =
-                state.conditions.any { it.contentType == DeliveryContentType.TIME_LETTER }
-            val updatedConditions =
-                state.conditions
-                    .map { condition ->
-                        if (condition.contentType == DeliveryContentType.TIME_LETTER) {
-                            condition.copy(
-                                conditionType = state.conditionType,
-                                inactivityPeriod =
-                                    state.inactivityPeriod.takeIf {
-                                        state.conditionType == DeliveryConditionType.INACTIVITY
-                                    },
-                            )
-                        } else {
-                            condition
-                        }
-                    }.let { conditions ->
-                        if (hasTimeLetterCondition) {
-                            conditions
-                        } else {
-                            conditions +
-                                defaultCondition(DeliveryContentType.TIME_LETTER).copy(
-                                    conditionType = state.conditionType,
-                                    inactivityPeriod =
-                                        state.inactivityPeriod.takeIf {
-                                            state.conditionType == DeliveryConditionType.INACTIVITY
-                                        },
-                                )
-                        }
-                    }
+        private fun onSave() {
+            val state = currentState
+            if (!state.isInitialized || state.isSaveLocked) return
 
+            loadJob?.cancel()
+            val savingRevision = state.conditionEditRevision
+            dispatch(DeliveryConditionReducerEvent.Saving)
             viewModelScope.launch {
-                _uiState.update { it.copy(isSaving = true) }
                 runCatchingCancellable {
-                    receiverRepository.updateReceiverDeliveryConditions(receiverId, updatedConditions)
+                    updateTimeLetterDeliveryCondition(
+                        receiverId = receiverId,
+                        conditions = state.conditions,
+                        conditionType = state.conditionType,
+                        inactivityPeriod = state.inactivityPeriod,
+                    )
                 }.onSuccess { response ->
-                    _uiState.update { it.copy(isSaving = false, conditions = response.conditions) }
-                    _saveSuccess.send(Unit)
+                    dispatch(DeliveryConditionReducerEvent.Saved(savingRevision, response.conditions))
                 }.onFailure {
-                    _uiState.update { it.copy(isSaving = false, error = DeliveryConditionError.SAVE_FAILED) }
+                    dispatch(DeliveryConditionReducerEvent.SaveFailed)
                 }
             }
         }
 
-        private fun defaultCondition(contentType: DeliveryContentType) =
-            DeliveryConditionItem(
-                contentType = contentType,
-                conditionType = DeliveryConditionType.INACTIVITY,
-                inactivityPeriod = InactivityPeriod.ONE_YEAR,
-                state = ConditionState.ACTIVE,
-                fulfilled = false,
-                gracePeriodStartedAt = null,
-                fulfilledAt = null,
-            )
-
         @AssistedFactory
         interface Factory {
             fun create(route: SettingRoute.AfterDeliveryRoute): DeliveryConditionViewModel
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/home/SettingContract.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/home/SettingContract.kt
new file mode 100644
index 0000000000..013ea36728
--- /dev/null
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/home/SettingContract.kt
@@ -0,0 +1,70 @@
+package com.afternote.feature.setting.presentation.home
+
+import com.afternote.core.ui.mvi.MviIntent
+import com.afternote.core.ui.mvi.ReducerEvent
+import com.afternote.core.ui.mvi.UiState
+
+internal data class SettingUiState(
+    val profile: SettingProfileState = SettingProfileState.Loading,
+    val logoutCompleted: Unit? = null,
+    val withdraw: WithdrawUiState = WithdrawUiState.Idle,
+) : UiState
+
+internal sealed interface SettingProfileState {
+    data object Loading : SettingProfileState
+
+    data class Success(
+        val name: String,
+        val email: String,
+        val profileImageUrl: String? = null,
+    ) : SettingProfileState
+
+    /** 문구는 화면이 `setting_profile_load_error` 리소스로 그린다. 프로필 수정 화면과 같은 문장이다. */
+    data object Error : SettingProfileState
+}
+
+internal sealed interface WithdrawUiState {
+    data object Idle : WithdrawUiState
+
+    data object Loading : WithdrawUiState
+
+    data object Success : WithdrawUiState
+
+    data object Error : WithdrawUiState
+}
+
+internal sealed interface SettingIntent : MviIntent {
+    data object Refresh : SettingIntent
+
+    data object Logout : SettingIntent
+
+    data object ConsumeLogoutSuccess : SettingIntent
+
+    data object DeleteAccount : SettingIntent
+
+    data object DismissWithdrawError : SettingIntent
+}
+
+internal sealed interface SettingReducerEvent : ReducerEvent {
+    data object ProfileLoading : SettingReducerEvent
+
+    data class ProfileLoaded(
+        val name: String,
+        val email: String,
+        val profileImageUrl: String?,
+    ) : SettingReducerEvent
+
+    data object ProfileFailed : SettingReducerEvent
+
+    data object LoggedOut : SettingReducerEvent
+
+    data object LogoutConsumed : SettingReducerEvent
+
+    data object Withdrawing : SettingReducerEvent
+
+    data object Withdrawn : SettingReducerEvent
+
+    data object WithdrawFailed : SettingReducerEvent
+
+    data object WithdrawErrorDismissed : SettingReducerEvent
+}
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/home/SettingScreen.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/home/SettingScreen.kt
index 0474ef8b65..aece551f96 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/home/SettingScreen.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/home/SettingScreen.kt
@@ -1,7 +1,10 @@
 package com.afternote.feature.setting.presentation.home
 
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.verticalScroll
@@ -26,12 +29,14 @@ import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.compose.LocalLifecycleOwner
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.afternote.core.ui.mvi.ObserveSignal
 import com.afternote.core.ui.popup.Popup
 import com.afternote.core.ui.popup.PopupType
 import com.afternote.core.ui.topbar.DetailTopBar
 import com.afternote.feature.setting.presentation.R
 import com.afternote.feature.setting.presentation.home.component.SettingProfile
 import com.afternote.feature.setting.presentation.home.component.SettingSection
+import com.afternote.feature.setting.presentation.shared.component.SettingLoadErrorContent
 import com.afternote.feature.setting.presentation.shared.component.SettingMenuItem
 import kotlinx.coroutines.launch
 
@@ -59,19 +64,18 @@ internal fun SettingScreen(
     val unavailableMessage = stringResource(R.string.setting_menu_unavailable)
     val acknowledgeLabel = stringResource(R.string.setting_menu_acknowledge)
     val uiState by viewModel.uiState.collectAsStateWithLifecycle()
-    val logoutCompleted by viewModel.logoutCompleted.collectAsStateWithLifecycle()
     val currentOnLogoutSuccess by rememberUpdatedState(onLogoutSuccess)
 
     val lifecycle = LocalLifecycleOwner.current.lifecycle
     val lifecycleState by lifecycle.currentStateFlow.collectAsStateWithLifecycle()
     LaunchedEffect(lifecycleState) {
         if (lifecycleState == Lifecycle.State.RESUMED) {
-            viewModel.refresh()
+            viewModel.onIntent(SettingIntent.Refresh)
         }
     }
 
-    LaunchedEffect(logoutCompleted) {
-        if (logoutCompleted) {
+    uiState.logoutCompleted?.let { signal ->
+        ObserveSignal(signal, SettingIntent.ConsumeLogoutSuccess, viewModel::onIntent) {
             currentOnLogoutSuccess()
         }
     }
@@ -88,8 +92,9 @@ internal fun SettingScreen(
         containerColor = Color.Transparent,
     ) { innerPadding ->
         SettingScreenContent(
-            uiState = uiState,
-            onLogoutClick = viewModel::logout,
+            uiState = uiState.profile,
+            onRetry = { viewModel.onIntent(SettingIntent.Refresh) },
+            onLogoutClick = { viewModel.onIntent(SettingIntent.Logout) },
             onUnavailableClick = {
                 scope.launch {
                     snackbarHostState.currentSnackbarData?.dismiss()
@@ -114,7 +119,8 @@ internal fun SettingScreen(
 
 @Composable
 private fun SettingScreenContent(
-    uiState: SettingUiState,
+    uiState: SettingProfileState,
+    onRetry: () -> Unit,
     onLogoutClick: () -> Unit,
     onUnavailableClick: () -> Unit,
     onProfileEditClick: () -> Unit,
@@ -146,125 +152,115 @@ private fun SettingScreenContent(
         )
     }
 
-    when (val state = uiState) {
-        is SettingUiState.Loading -> {
-            Column(
-                modifier = modifier.fillMaxSize(),
-                horizontalAlignment = Alignment.CenterHorizontally,
-            ) {
-                CircularProgressIndicator()
+    Column(
+        modifier = modifier.fillMaxSize().verticalScroll(rememberScrollState()),
+    ) {
+        when (val state = uiState) {
+            SettingProfileState.Loading -> {
+                Box(Modifier.fillMaxWidth().height(160.dp), contentAlignment = Alignment.Center) {
+                    CircularProgressIndicator()
+                }
             }
-        }
 
-        is SettingUiState.Success -> {
-            Column(
-                modifier =
-                    modifier
-                        .fillMaxSize()
-                        .verticalScroll(rememberScrollState()),
-            ) {
+            is SettingProfileState.Success -> {
                 SettingProfile(
                     name = state.name,
                     email = state.email,
+                    profileImageUrl = state.profileImageUrl,
                     onInquiryClick = onUnavailableClick,
                     onNoticeClick = onNoticeClick,
                     onRecipientListClick = onRecipientListClick,
                 )
+            }
 
-                SettingSection(title = stringResource(R.string.setting_section_account)) {
-                    SettingMenuItem(
-                        label = stringResource(R.string.setting_account_profile_edit),
-                        onClick = onProfileEditClick,
-                    )
-                    SettingMenuItem(
-                        label = stringResource(R.string.setting_account_password_change),
-                        onClick = onPasswordChangeClick,
-                    )
-                    SettingMenuItem(
-                        label = stringResource(R.string.setting_account_linked_account),
-                        onClick = onLinkedAccountClick,
-                    )
-                    SettingMenuItem(
-                        label = stringResource(R.string.setting_account_notification),
-                        onClick = onNotificationClick,
-                    )
-                }
-
-                SettingSection(title = stringResource(R.string.setting_section_recipient)) {
-                    SettingMenuItem(
-                        label = stringResource(R.string.setting_recipient_list),
-                        onClick = onRecipientListClick,
-                    )
-                    SettingMenuItem(
-                        label = stringResource(R.string.setting_recipient_register),
-                        onClick = onRecipientRegisterClick,
-                    )
-                    SettingMenuItem(
-                        label = stringResource(R.string.setting_recipient_after_delivery),
-                        onClick = onDeliveryConditionsClick,
-                    )
-                }
-
-                SettingSection(title = stringResource(R.string.setting_section_security)) {
-                    SettingMenuItem(
-                        label = stringResource(R.string.setting_security_passkey),
-                        onClick = onPasskeyClick,
-                    )
-                    SettingMenuItem(
-                        label = stringResource(R.string.setting_security_app_lock),
-                        onClick = onAppLockClick,
-                    )
-                }
-
-                SettingSection(title = stringResource(R.string.setting_section_support)) {
-                    SettingMenuItem(
-                        label = stringResource(R.string.setting_support_faq),
-                        onClick = onUnavailableClick,
-                    )
-                    SettingMenuItem(
-                        label = stringResource(R.string.setting_support_inquiry),
-                        onClick = onUnavailableClick,
-                    )
-                    SettingMenuItem(
-                        label = stringResource(R.string.setting_support_notice),
-                        onClick = onNoticeClick,
-                    )
-                    SettingMenuItem(
-                        label = stringResource(R.string.setting_support_terms),
-                        onClick = onUnavailableClick,
-                    )
-                    SettingMenuItem(
-                        label = stringResource(R.string.setting_support_privacy),
-                        onClick = onUnavailableClick,
-                    )
-                    SettingMenuItem(
-                        label = stringResource(R.string.setting_support_service_info),
-                        onClick = onUnavailableClick,
-                    )
-                }
-
-                SettingMenuItem(
-                    label = stringResource(R.string.setting_logout),
-                    onClick = { showLogoutDialog = true },
-                    modifier = Modifier.padding(top = 8.dp),
-                )
-                SettingMenuItem(
-                    label = stringResource(R.string.setting_account_withdraw),
-                    onClick = onWithdrawGuideClick,
+            SettingProfileState.Error -> {
+                SettingLoadErrorContent(
+                    message = stringResource(R.string.setting_profile_load_error),
+                    onRetry = onRetry,
+                    modifier = Modifier.height(160.dp),
                 )
             }
         }
+        SettingSection(title = stringResource(R.string.setting_section_account)) {
+            SettingMenuItem(
+                label = stringResource(R.string.setting_account_profile_edit),
+                onClick = onProfileEditClick,
+            )
+            SettingMenuItem(
+                label = stringResource(R.string.setting_account_password_change),
+                onClick = onPasswordChangeClick,
+            )
+            SettingMenuItem(
+                label = stringResource(R.string.setting_account_linked_account),
+                onClick = onLinkedAccountClick,
+            )
+            SettingMenuItem(
+                label = stringResource(R.string.setting_account_notification),
+                onClick = onNotificationClick,
+            )
+        }
 
-        is SettingUiState.Error -> {
-            Column(
-                modifier = modifier.fillMaxSize(),
-                horizontalAlignment = Alignment.CenterHorizontally,
-            ) {
-                SettingMenuItem(
-                    label = stringResource(R.string.setting_logout),
-                    onClick = { showLogoutDialog = true },
-                )
-            }
+        SettingSection(title = stringResource(R.string.setting_section_recipient)) {
+            SettingMenuItem(
+                label = stringResource(R.string.setting_recipient_list),
+                onClick = onRecipientListClick,
+            )
+            SettingMenuItem(
+                label = stringResource(R.string.setting_recipient_register),
+                onClick = onRecipientRegisterClick,
+            )
+            SettingMenuItem(
+                label = stringResource(R.string.setting_recipient_after_delivery),
+                onClick = onDeliveryConditionsClick,
+            )
+        }
+
+        SettingSection(title = stringResource(R.string.setting_section_security)) {
+            SettingMenuItem(
+                label = stringResource(R.string.setting_security_passkey),
+                onClick = onPasskeyClick,
+            )
+            SettingMenuItem(
+                label = stringResource(R.string.setting_security_app_lock),
+                onClick = onAppLockClick,
+            )
+        }
+
+        SettingSection(title = stringResource(R.string.setting_section_support)) {
+            SettingMenuItem(
+                label = stringResource(R.string.setting_support_faq),
+                onClick = onUnavailableClick,
+            )
+            SettingMenuItem(
+                label = stringResource(R.string.setting_support_inquiry),
+                onClick = onUnavailableClick,
+            )
+            SettingMenuItem(
+                label = stringResource(R.string.setting_support_notice),
+                onClick = onNoticeClick,
+            )
+            SettingMenuItem(
+                label = stringResource(R.string.setting_support_terms),
+                onClick = onUnavailableClick,
+            )
+            SettingMenuItem(
+                label = stringResource(R.string.setting_support_privacy),
+                onClick = onUnavailableClick,
+            )
+            SettingMenuItem(
+                label = stringResource(R.string.setting_support_service_info),
+                onClick = onUnavailableClick,
+            )
         }
+
+        SettingMenuItem(
+            label = stringResource(R.string.setting_logout),
+            onClick = { showLogoutDialog = true },
+            modifier = Modifier.padding(top = 8.dp),
+        )
+        SettingMenuItem(
+            label = stringResource(R.string.setting_account_withdraw),
+            onClick = onWithdrawGuideClick,
+        )
     }
 }
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/home/SettingViewModel.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/home/SettingViewModel.kt
index d051696f53..4b795f2a22 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/home/SettingViewModel.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/home/SettingViewModel.kt
@@ -1,111 +1,116 @@
 package com.afternote.feature.setting.presentation.home
 
-import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.afternote.core.domain.repository.MyProfileRepository
 import com.afternote.core.domain.repository.auth.AuthRepository
+import com.afternote.core.domain.result.runCatchingCancellable
+import com.afternote.core.ui.mvi.MviViewModel
 import com.afternote.feature.setting.domain.SettingAccountRepository
 import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.CancellationException
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.launch
 import javax.inject.Inject
 
-sealed interface SettingUiState {
-    data object Loading : SettingUiState
-
-    data class Success(
-        val name: String,
-        val email: String,
-    ) : SettingUiState
-
-    data class Error(
-        val message: String,
-    ) : SettingUiState
-}
-
-sealed interface WithdrawUiState {
-    data object Idle : WithdrawUiState
-
-    data object Loading : WithdrawUiState
-
-    data object Success : WithdrawUiState
-
-    data object Error : WithdrawUiState
-}
-
-/**
- * 설정 화면용 ViewModel.
- *
- * 로그아웃 시 [AuthRepository.logout] 한 번 호출로 끝낸다. 내부적으로 서버 호출은 best-effort,
- * 로컬 토큰은 결과 무관하게 정리하도록 위임돼 있다. 호출처는 토큰 정리 여부를 신경 쓸 필요 없음.
- */
 @HiltViewModel
-class SettingViewModel
+internal class SettingViewModel
     @Inject
     constructor(
         private val authRepository: AuthRepository,
         private val myProfileRepository: MyProfileRepository,
         private val accountRepository: SettingAccountRepository,
-    ) : ViewModel() {
-        private val _uiState = MutableStateFlow<SettingUiState>(SettingUiState.Loading)
-        val uiState = _uiState.asStateFlow()
-
-        private val _logoutCompleted = MutableStateFlow(false)
-        val logoutCompleted = _logoutCompleted.asStateFlow()
+    ) : MviViewModel<SettingIntent, SettingUiState, SettingReducerEvent>(SettingUiState()) {
+        private var loadJob: Job? = null
+        private var logoutJob: Job? = null
 
         init {
             loadProfile()
         }
 
-        fun refresh() = loadProfile()
-
-        private fun loadProfile() {
-            viewModelScope.launch {
-                runCatching { myProfileRepository.getMyProfile() }
-                    .onSuccess { profile ->
-                        _uiState.value =
-                            SettingUiState.Success(
-                                name = profile.name,
-                                email = profile.email,
-                            )
-                    }.onFailure {
-                        _uiState.value = SettingUiState.Error("프로필을 불러올 수 없습니다.")
-                    }
+        override fun onIntent(intent: SettingIntent) {
+            when (intent) {
+                SettingIntent.Refresh -> loadProfile()
+                SettingIntent.Logout -> logout()
+                SettingIntent.ConsumeLogoutSuccess -> dispatch(SettingReducerEvent.LogoutConsumed)
+                SettingIntent.DeleteAccount -> deleteAccount()
+                SettingIntent.DismissWithdrawError -> dispatch(SettingReducerEvent.WithdrawErrorDismissed)
             }
         }
 
-        fun logout() {
-            viewModelScope.launch {
-                // logout() 내부에서 서버 호출(best-effort) + 로컬 토큰 정리까지 처리한다.
-                authRepository.logout()
-                _logoutCompleted.value = true
-            }
-        }
+        override fun reduce(
+            state: SettingUiState,
+            event: SettingReducerEvent,
+        ): SettingUiState =
+            when (event) {
+                SettingReducerEvent.ProfileLoading -> {
+                    if (state.profile is SettingProfileState.Success) state else state.copy(profile = SettingProfileState.Loading)
+                }
 
-        private val _withdrawUiState = MutableStateFlow<WithdrawUiState>(WithdrawUiState.Idle)
-        val withdrawUiState = _withdrawUiState.asStateFlow()
+                is SettingReducerEvent.ProfileLoaded -> {
+                    state.copy(profile = SettingProfileState.Success(event.name, event.email, event.profileImageUrl))
+                }
 
-        fun deleteAccount() {
-            if (_withdrawUiState.value == WithdrawUiState.Loading) return
-            _withdrawUiState.value = WithdrawUiState.Loading
+                SettingReducerEvent.ProfileFailed -> {
+                    state.copy(profile = SettingProfileState.Error)
+                }
 
-            viewModelScope.launch {
-                try {
-                    accountRepository.deleteAccount()
-                    _withdrawUiState.value = WithdrawUiState.Success
-                } catch (exception: CancellationException) {
-                    throw exception
-                } catch (_: Exception) {
-                    _withdrawUiState.value = WithdrawUiState.Error
+                SettingReducerEvent.LoggedOut -> {
+                    state.copy(logoutCompleted = Unit)
+                }
+
+                SettingReducerEvent.LogoutConsumed -> {
+                    state.copy(logoutCompleted = null)
+                }
+
+                SettingReducerEvent.Withdrawing -> {
+                    state.copy(withdraw = WithdrawUiState.Loading)
+                }
+
+                SettingReducerEvent.Withdrawn -> {
+                    state.copy(withdraw = WithdrawUiState.Success)
+                }
+
+                SettingReducerEvent.WithdrawFailed -> {
+                    state.copy(withdraw = WithdrawUiState.Error)
+                }
+
+                SettingReducerEvent.WithdrawErrorDismissed -> {
+                    if (state.withdraw ==
+                        WithdrawUiState.Error
+                    ) {
+                        state.copy(withdraw = WithdrawUiState.Idle)
+                    } else {
+                        state
+                    }
                 }
             }
+
+        private fun loadProfile() {
+            if (loadJob?.isActive == true) return
+            loadJob =
+                viewModelScope.launch {
+                    dispatch(SettingReducerEvent.ProfileLoading)
+                    runCatchingCancellable { myProfileRepository.getMyProfile() }
+                        .onSuccess { dispatch(SettingReducerEvent.ProfileLoaded(it.name, it.email, it.profileImageUrl)) }
+                        .onFailure { dispatch(SettingReducerEvent.ProfileFailed) }
+                }
         }
 
-        fun dismissWithdrawError() {
-            if (_withdrawUiState.value == WithdrawUiState.Error) {
-                _withdrawUiState.value = WithdrawUiState.Idle
+        private fun logout() {
+            if (logoutJob?.isActive == true || currentState.logoutCompleted != null) return
+            logoutJob =
+                viewModelScope.launch {
+                    authRepository.logout()
+                    dispatch(SettingReducerEvent.LoggedOut)
+                }
+        }
+
+        private fun deleteAccount() {
+            if (currentState.withdraw == WithdrawUiState.Loading || currentState.withdraw == WithdrawUiState.Success) return
+            dispatch(SettingReducerEvent.Withdrawing)
+            viewModelScope.launch {
+                runCatchingCancellable { accountRepository.deleteAccount() }
+                    .onSuccess { dispatch(SettingReducerEvent.Withdrawn) }
+                    .onFailure { dispatch(SettingReducerEvent.WithdrawFailed) }
             }
         }
     }
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/home/WithdrawConfirmScreen.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/home/WithdrawConfirmScreen.kt
index 73560e2fb2..67f490d968 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/home/WithdrawConfirmScreen.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/home/WithdrawConfirmScreen.kt
@@ -1,25 +1,23 @@
 package com.afternote.feature.setting.presentation.home
 
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.afternote.core.ui.popup.Popup
 import com.afternote.core.ui.popup.PopupType
 import com.afternote.feature.setting.presentation.R
 
 @Composable
-fun WithdrawConfirmScreen(
+internal fun WithdrawConfirmScreen(
     uiState: SettingUiState,
     onBackClick: () -> Unit,
     onWithdrawSuccess: () -> Unit,
     viewModel: SettingViewModel,
     modifier: Modifier = Modifier,
 ) {
-    val userName = (uiState as? SettingUiState.Success)?.name.orEmpty()
-    val userEmail = (uiState as? SettingUiState.Success)?.email.orEmpty()
-    val withdrawUiState by viewModel.withdrawUiState.collectAsStateWithLifecycle()
+    val userName = (uiState.profile as? SettingProfileState.Success)?.name.orEmpty()
+    val userEmail = (uiState.profile as? SettingProfileState.Success)?.email.orEmpty()
+    val withdrawUiState = uiState.withdraw
 
     when (withdrawUiState) {
         WithdrawUiState.Success -> {
@@ -38,8 +36,8 @@ fun WithdrawConfirmScreen(
                 message = stringResource(R.string.setting_withdraw_failed_message),
                 confirmText = stringResource(R.string.setting_withdraw_retry_button),
                 dismissText = stringResource(R.string.setting_withdraw_close_button),
-                onConfirm = viewModel::deleteAccount,
-                onDismiss = viewModel::dismissWithdrawError,
+                onConfirm = { viewModel.onIntent(SettingIntent.DeleteAccount) },
+                onDismiss = { viewModel.onIntent(SettingIntent.DismissWithdrawError) },
             )
         }
 
@@ -52,7 +50,7 @@ fun WithdrawConfirmScreen(
         userName = userName,
         userEmail = userEmail,
         onBackClick = onBackClick,
-        onWithdrawClick = viewModel::deleteAccount,
+        onWithdrawClick = { viewModel.onIntent(SettingIntent.DeleteAccount) },
         isLoading = withdrawUiState == WithdrawUiState.Loading,
         modifier = modifier,
     )
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/home/WithdrawGuideScreen.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/home/WithdrawGuideScreen.kt
index 3916385035..c5204986d0 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/home/WithdrawGuideScreen.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/home/WithdrawGuideScreen.kt
@@ -35,15 +35,15 @@ import com.afternote.feature.setting.presentation.R
 
 // 설정 - 회원 탈퇴 안내
 @Composable
-fun WithdrawGuideScreen(
+internal fun WithdrawGuideScreen(
     uiState: SettingUiState,
     onBackClick: () -> Unit,
     onCancelClick: () -> Unit,
     onConfirmClick: () -> Unit,
     modifier: Modifier = Modifier,
 ) {
-    val userName = (uiState as? SettingUiState.Success)?.name.orEmpty()
-    val userEmail = (uiState as? SettingUiState.Success)?.email.orEmpty()
+    val userName = (uiState.profile as? SettingProfileState.Success)?.name.orEmpty()
+    val userEmail = (uiState.profile as? SettingProfileState.Success)?.email.orEmpty()
     var agreed by remember { mutableStateOf(false) }
     Scaffold(
         topBar = {
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/home/component/SettingProfile.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/home/component/SettingProfile.kt
index 1dc7c14288..bd17a9293b 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/home/component/SettingProfile.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/home/component/SettingProfile.kt
@@ -10,20 +10,26 @@ import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.layout.ContentScale
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
+import coil3.compose.AsyncImage
 import com.afternote.core.ui.theme.AfternoteDesign
 import com.afternote.feature.setting.presentation.R
+import com.afternote.core.ui.R as CoreUiR
 
 @Composable
 internal fun SettingProfile(
     name: String,
     email: String,
+    profileImageUrl: String?,
     onInquiryClick: () -> Unit,
     onNoticeClick: () -> Unit,
     onRecipientListClick: () -> Unit,
@@ -43,11 +49,24 @@ internal fun SettingProfile(
                     .padding(horizontal = 20.dp),
             verticalAlignment = Alignment.CenterVertically,
         ) {
-            Image(
-                painterResource(R.drawable.setting_ic_default_profile),
-                contentDescription = "기본 이미지",
-                modifier = Modifier.size(60.dp),
-            )
+            val defaultProfile = painterResource(R.drawable.setting_ic_default_profile)
+            val profileDescription = stringResource(CoreUiR.string.core_ui_content_description_profile_image)
+            if (profileImageUrl.isNullOrBlank()) {
+                Image(
+                    painter = defaultProfile,
+                    contentDescription = profileDescription,
+                    modifier = Modifier.size(60.dp).clip(CircleShape),
+                )
+            } else {
+                AsyncImage(
+                    model = profileImageUrl,
+                    contentDescription = profileDescription,
+                    modifier = Modifier.size(60.dp).clip(CircleShape),
+                    placeholder = defaultProfile,
+                    error = defaultProfile,
+                    contentScale = ContentScale.Crop,
+                )
+            }
             Spacer(modifier = Modifier.padding(12.dp))
             Column {
                 Text(
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/navigation/SettingNavHost.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/navigation/SettingNavHost.kt
index f30810c265..63f3717edb 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/navigation/SettingNavHost.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/navigation/SettingNavHost.kt
@@ -5,11 +5,14 @@ import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.compose.LifecycleEventEffect
 import androidx.lifecycle.compose.LifecycleStartEffect
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.lifecycle.viewmodel.compose.LocalViewModelStoreOwner
 import androidx.navigation3.runtime.entryProvider
 import androidx.navigation3.runtime.rememberNavBackStack
+import com.afternote.core.ui.asString
 import com.afternote.core.ui.navigation.FeatureNavDisplay
 import com.afternote.core.ui.navigation.FeatureNavigationCallbacks
 import com.afternote.feature.setting.presentation.account.ConnectedAccountsScreen
@@ -24,11 +27,11 @@ import com.afternote.feature.setting.presentation.home.WithdrawGuideScreen
 import com.afternote.feature.setting.presentation.notice.NoticeListScreen
 import com.afternote.feature.setting.presentation.notification.NotificationSettingScreen
 import com.afternote.feature.setting.presentation.notification.PushNotificationScreen
+import com.afternote.feature.setting.presentation.passkey.PassKeyListIntent
 import com.afternote.feature.setting.presentation.passkey.PassKeyListScreen
+import com.afternote.feature.setting.presentation.passkey.PassKeyListViewModel
 import com.afternote.feature.setting.presentation.passkey.PassKeyMakingScreen
 import com.afternote.feature.setting.presentation.passkey.PassKeyPasswordScreen
-import com.afternote.feature.setting.presentation.passkey.PassKeyScreen
-import com.afternote.feature.setting.presentation.passkey.PassKeyViewModel
 import com.afternote.feature.setting.presentation.password.PasswordChangeScreen
 import com.afternote.feature.setting.presentation.profile.ProfileEditScreen
 import com.afternote.feature.setting.presentation.receiver.ReceiverEditScreen
@@ -214,16 +217,17 @@ public fun SettingNavHost(
                 }
 
                 entry<SettingRoute.PasskeyRoute> {
-                    val viewModel: PassKeyViewModel = hiltViewModel()
-                    val isPasskeyRegistered by viewModel.isPasskeyRegistered.collectAsStateWithLifecycle()
-                    if (isPasskeyRegistered == true) {
-                        PassKeyListScreen(onBackClick = actions::popBack)
-                    } else if (isPasskeyRegistered == false) {
-                        PassKeyScreen(
-                            onBackClick = actions::popBack,
-                            onRegisterClick = actions::onPasskeyRegisterClick,
-                        )
-                    }
+                    val viewModel: PassKeyListViewModel = hiltViewModel()
+                    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+                    LifecycleEventEffect(Lifecycle.Event.ON_RESUME) { viewModel.onIntent(PassKeyListIntent.Refresh) }
+                    PassKeyListScreen(
+                        passkeys = uiState.passkeys,
+                        isLoading = uiState.isLoading,
+                        errorMessage = uiState.errorMessage?.asString(),
+                        onBackClick = actions::popBack,
+                        onRegisterClick = actions::onPasskeyRegisterClick,
+                        onRetryClick = { viewModel.onIntent(PassKeyListIntent.Refresh) },
+                    )
                 }
 
                 entry<SettingRoute.PasskeyMakingRoute> {
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/NotificationSettingScreen.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/NotificationSettingScreen.kt
index b5a271b264..9487ad1c42 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/NotificationSettingScreen.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/NotificationSettingScreen.kt
@@ -22,9 +22,9 @@ import androidx.compose.material3.SnackbarHost
 import androidx.compose.material3.SnackbarHostState
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
@@ -36,18 +36,20 @@ import androidx.core.content.ContextCompat
 import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.compose.LifecycleEventEffect
-import androidx.lifecycle.compose.LocalLifecycleOwner
+import androidx.lifecycle.compose.LifecycleStartEffect
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import androidx.lifecycle.repeatOnLifecycle
 import com.afternote.core.ui.findActivity
+import com.afternote.core.ui.mvi.ObserveFlag
 import com.afternote.core.ui.theme.AfternoteDesign
 import com.afternote.core.ui.topbar.DetailTopBar
 import com.afternote.feature.setting.presentation.R
 import com.afternote.feature.setting.presentation.notification.component.DeviceAlarmOffSection
 import com.afternote.feature.setting.presentation.shared.component.SettingMenuItem
+import kotlinx.coroutines.cancelChildren
+import kotlinx.coroutines.launch
 
 @Composable
-fun NotificationSettingScreen(
+internal fun NotificationSettingScreen(
     onBack: () -> Unit,
     onPushNotificationClick: () -> Unit,
     viewModel: PushNotificationViewModel = hiltViewModel(),
@@ -56,7 +58,6 @@ fun NotificationSettingScreen(
     val context = LocalContext.current
     val activity = remember(context) { context.findActivity<Activity>() }
     val snackbarHostState = remember { SnackbarHostState() }
-    val lifecycleOwner = LocalLifecycleOwner.current
     val marketingConsentSaveFailedMessage = stringResource(R.string.setting_marketing_consent_save_failed)
     val openNotificationSettings = {
         val intent =
@@ -67,7 +68,7 @@ fun NotificationSettingScreen(
     }
     val notificationPermissionLauncher =
         rememberLauncherForActivityResult(ActivityResultContracts.RequestPermission()) { granted ->
-            viewModel.refreshDeviceAlarmStatus()
+            viewModel.onIntent(PushNotificationIntent.RefreshDeviceAlarmStatus)
             if (
                 !granted &&
                 activity != null &&
@@ -81,21 +82,66 @@ fun NotificationSettingScreen(
         }
 
     LifecycleEventEffect(Lifecycle.Event.ON_RESUME) {
-        viewModel.refreshDeviceAlarmStatus()
+        viewModel.onIntent(PushNotificationIntent.RefreshOnReturn)
     }
 
-    LaunchedEffect(viewModel, lifecycleOwner, marketingConsentSaveFailedMessage) {
-        lifecycleOwner.lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) {
-            viewModel.events.collect { event ->
-                when (event) {
-                    PushNotificationEvent.MarketingConsentSaveFailed -> {
-                        snackbarHostState.showSnackbar(marketingConsentSaveFailedMessage)
-                    }
-                }
-            }
+    // 소비가 ObserveFlag 의 effect 를 다시 시작시켜도 스낵바가 끊기지 않게 화면 코루틴에 띄운다.
+    val snackbarScope = rememberCoroutineScope()
+
+    // 화면이 STARTED 인 동안만 마케팅 동의 저장 실패를 안내한다. 화면이 없는 동안의 실패는 다음 진입에 재생하지 않는다 (#558).
+    // 멈출 때는 떠 있던 안내와 줄 선 안내도 거둔다. 화면 코루틴은 STOP 에 취소되지 않으므로 그대로 두면 재진입에 뜬다.
+    LifecycleStartEffect(viewModel) {
+        viewModel.onIntent(PushNotificationIntent.MarketingFeedbackStarted)
+        onStopOrDispose {
+            viewModel.onIntent(PushNotificationIntent.MarketingFeedbackStopped)
+            snackbarScope.coroutineContext.cancelChildren()
         }
     }
 
+    ObserveFlag(
+        raised = uiState.isMarketingConsentSaveFailed,
+        consumed = PushNotificationIntent.ConsumeMarketingConsentSaveFailure,
+        onIntent = viewModel::onIntent,
+    ) {
+        snackbarScope.launch { snackbarHostState.showSnackbar(marketingConsentSaveFailedMessage) }
+    }
+
+    NotificationSettingContent(
+        uiState = uiState,
+        snackbarHostState = snackbarHostState,
+        onBack = onBack,
+        onPushNotificationClick = onPushNotificationClick,
+        onDeviceAlarmClick = {
+            val permissionGranted =
+                ContextCompat.checkSelfPermission(
+                    context,
+                    Manifest.permission.POST_NOTIFICATIONS,
+                ) == PackageManager.PERMISSION_GRANTED
+            when (notificationPermissionAction(Build.VERSION.SDK_INT, permissionGranted)) {
+                NotificationPermissionAction.RequestPermission -> {
+                    notificationPermissionLauncher.launch(Manifest.permission.POST_NOTIFICATIONS)
+                }
+
+                NotificationPermissionAction.OpenSettings -> {
+                    openNotificationSettings()
+                }
+            }
+        },
+        onMarketingConsentChange = { consent, checked ->
+            viewModel.onIntent(PushNotificationIntent.ChangeMarketingConsent(consent, checked))
+        },
+    )
+}
+
+@Composable
+private fun NotificationSettingContent(
+    uiState: PushNotificationUiState,
+    snackbarHostState: SnackbarHostState,
+    onBack: () -> Unit,
+    onPushNotificationClick: () -> Unit,
+    onDeviceAlarmClick: () -> Unit,
+    onMarketingConsentChange: (MarketingConsent, Boolean) -> Unit,
+) {
     Scaffold(
         topBar = {
             DetailTopBar(
@@ -117,22 +163,8 @@ fun NotificationSettingScreen(
                 modifier =
                     Modifier
                         .fillMaxWidth()
-                        .clickable {
-                            val permissionGranted =
-                                ContextCompat.checkSelfPermission(
-                                    context,
-                                    Manifest.permission.POST_NOTIFICATIONS,
-                                ) == PackageManager.PERMISSION_GRANTED
-                            when (notificationPermissionAction(Build.VERSION.SDK_INT, permissionGranted)) {
-                                NotificationPermissionAction.RequestPermission -> {
-                                    notificationPermissionLauncher.launch(Manifest.permission.POST_NOTIFICATIONS)
-                                }
-
-                                NotificationPermissionAction.OpenSettings -> {
-                                    openNotificationSettings()
-                                }
-                            }
-                        }.padding(vertical = 12.dp),
+                        .clickable(onClick = onDeviceAlarmClick)
+                        .padding(vertical = 12.dp),
                 verticalAlignment = Alignment.CenterVertically,
             ) {
                 Text(
@@ -160,9 +192,9 @@ fun NotificationSettingScreen(
             } else {
                 DeviceAlarmOffSection(
                     uiState = uiState,
-                    onSmsCheck = viewModel::onSmsChecked,
-                    onEmailCheck = viewModel::onEmailChecked,
-                    onPushCheck = viewModel::onPushChecked,
+                    onSmsCheck = { onMarketingConsentChange(MarketingConsent.SMS, it) },
+                    onEmailCheck = { onMarketingConsentChange(MarketingConsent.EMAIL, it) },
+                    onPushCheck = { onMarketingConsentChange(MarketingConsent.PUSH, it) },
                 )
             }
         }
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationContent.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationContent.kt
index 231273c3c7..d2fdd7c93e 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationContent.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationContent.kt
@@ -1,8 +1,10 @@
 package com.afternote.feature.setting.presentation.notification
 
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material3.Scaffold
@@ -12,10 +14,13 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
+import com.afternote.core.ui.asString
+import com.afternote.core.ui.loading.LoadingBody
 import com.afternote.core.ui.theme.AfternoteDesign
 import com.afternote.core.ui.topbar.DetailTopBar
 import com.afternote.feature.setting.presentation.R
 import com.afternote.feature.setting.presentation.notification.component.PushToggleSection
+import com.afternote.feature.setting.presentation.shared.component.SettingLoadErrorContent
 
 /**
  * 푸시 알림 설정 화면의 상태 없는 본문.
@@ -31,6 +36,7 @@ internal fun PushNotificationContent(
     onNewsletterToggle: (Boolean) -> Unit,
     onMindRecordToggle: (Boolean) -> Unit,
     onAfternoteToggle: (Boolean) -> Unit,
+    onRetry: () -> Unit,
 ) {
     Scaffold(
         topBar = {
@@ -48,12 +54,28 @@ internal fun PushNotificationContent(
                     .padding(padding)
                     .padding(horizontal = 20.dp, vertical = 16.dp),
         ) {
-            PushToggleSection(
-                uiState = uiState,
-                onNewsletterToggle = onNewsletterToggle,
-                onMindRecordToggle = onMindRecordToggle,
-                onAfternoteToggle = onAfternoteToggle,
-            )
+            when {
+                uiState.isLoading -> {
+                    LoadingBody(modifier = Modifier.weight(1f))
+                }
+
+                uiState.errorMessage != null -> {
+                    SettingLoadErrorContent(
+                        message = uiState.errorMessage.asString(),
+                        onRetry = onRetry,
+                        modifier = Modifier.weight(1f),
+                    )
+                }
+
+                else -> {
+                    PushToggleSection(
+                        uiState = uiState,
+                        onNewsletterToggle = onNewsletterToggle,
+                        onMindRecordToggle = onMindRecordToggle,
+                        onAfternoteToggle = onAfternoteToggle,
+                    )
+                }
+            }
 
             Spacer(Modifier.height(24.dp))
             Text(
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationContract.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationContract.kt
new file mode 100644
index 0000000000..b3b35773fd
--- /dev/null
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationContract.kt
@@ -0,0 +1,99 @@
+package com.afternote.feature.setting.presentation.notification
+
+import com.afternote.core.model.user.UserMarketingConsent
+import com.afternote.core.model.user.UserPushSetting
+import com.afternote.core.ui.mvi.MviIntent
+import com.afternote.core.ui.mvi.ReducerEvent
+
+internal sealed interface PushNotificationIntent : MviIntent {
+    data object RefreshOnReturn : PushNotificationIntent
+
+    data object RetryLoad : PushNotificationIntent
+
+    /** 기기 알림 허용 여부를 다시 읽는다. 화면 재개와 권한 요청 결과 때 보낸다. */
+    data object RefreshDeviceAlarmStatus : PushNotificationIntent
+
+    data class ChangeMarketingConsent(
+        val consent: MarketingConsent,
+        val checked: Boolean,
+    ) : PushNotificationIntent
+
+    data class TogglePushSetting(
+        val setting: PushSetting,
+        val on: Boolean,
+    ) : PushNotificationIntent
+
+    data object RetrySave : PushNotificationIntent
+
+    data object DismissSaveFailure : PushNotificationIntent
+
+    /**
+     * 알림 설정 화면이 STARTED 에 들어섰다. 이때부터 마케팅 동의 저장 실패를 안내 신호로 올린다.
+     *
+     * STARTED 밖에서 난 실패는 신호로 남기지 않고, [MarketingFeedbackStopped] 가 남은 신호도 걷는다.
+     * 화면이 없는 동안의 안내를 다음 진입에 재생하지 않는 #558 계약이다.
+     */
+    data object MarketingFeedbackStarted : PushNotificationIntent
+
+    data object MarketingFeedbackStopped : PushNotificationIntent
+
+    data object ConsumeMarketingConsentSaveFailure : PushNotificationIntent
+}
+
+internal sealed interface PushNotificationReducerEvent : ReducerEvent {
+    data class DeviceAlarmStatusRead(
+        val on: Boolean,
+    ) : PushNotificationReducerEvent
+
+    data object PushSettingsLoading : PushNotificationReducerEvent
+
+    data class PushSettingsLoaded(
+        val setting: UserPushSetting,
+    ) : PushNotificationReducerEvent
+
+    data object PushSettingsLoadFailed : PushNotificationReducerEvent
+
+    data class MarketingConsentsLoaded(
+        val consent: UserMarketingConsent,
+    ) : PushNotificationReducerEvent
+
+    data class MarketingConsentChanged(
+        val consent: MarketingConsent,
+        val checked: Boolean,
+    ) : PushNotificationReducerEvent
+
+    /** [requested] 로 바꾸려던 저장이 실패했다. 값은 그 반대로 되돌린다. */
+    data class MarketingConsentSaveFailed(
+        val consent: MarketingConsent,
+        val requested: Boolean,
+    ) : PushNotificationReducerEvent
+
+    data class PushSettingSaving(
+        val update: PushSettingUpdate,
+    ) : PushNotificationReducerEvent
+
+    data class PushSettingSaved(
+        val setting: PushSetting,
+    ) : PushNotificationReducerEvent
+
+    data class PushSettingSaveFailed(
+        val update: PushSettingUpdate,
+        val previous: Boolean,
+        val failure: PushNotificationSaveFailure,
+    ) : PushNotificationReducerEvent
+
+    data object SaveFailureDismissed : PushNotificationReducerEvent
+
+    data class MarketingFeedbackActiveChanged(
+        val active: Boolean,
+    ) : PushNotificationReducerEvent
+
+    data object MarketingConsentSaveFailureConsumed : PushNotificationReducerEvent
+}
+
+/** 기기 알림이 꺼졌을 때 받는 마케팅 알림 채널. */
+internal enum class MarketingConsent {
+    SMS,
+    EMAIL,
+    PUSH,
+}
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationScreen.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationScreen.kt
index 2dcb24789a..87333a6a64 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationScreen.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationScreen.kt
@@ -3,42 +3,41 @@ package com.afternote.feature.setting.presentation.notification
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.compose.LifecycleEventEffect
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.afternote.core.ui.popup.NetworkErrorPopup
 import com.afternote.core.ui.popup.ServerErrorPopup
-import com.afternote.core.ui.theme.AfternoteDesign
-import com.afternote.core.ui.topbar.DetailTopBar
-import com.afternote.feature.setting.presentation.R
-import com.afternote.feature.setting.presentation.notification.component.DeviceAlarmOffSection
-import com.afternote.feature.setting.presentation.notification.component.PushToggleSection
 
 @Composable
-fun PushNotificationScreen(
+internal fun PushNotificationScreen(
     onBack: () -> Unit,
     viewModel: PushNotificationViewModel = hiltViewModel(),
 ) {
     val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+    LifecycleEventEffect(Lifecycle.Event.ON_RESUME) { viewModel.onIntent(PushNotificationIntent.RefreshOnReturn) }
 
     PushNotificationContent(
         uiState = uiState,
         onBack = onBack,
-        onNewsletterToggle = viewModel::onNewsletterToggle,
-        onMindRecordToggle = viewModel::onMindRecordToggle,
-        onAfternoteToggle = viewModel::onAfternoteToggle,
+        onRetry = { viewModel.onIntent(PushNotificationIntent.RetryLoad) },
+        onNewsletterToggle = { viewModel.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.NEWSLETTER, it)) },
+        onMindRecordToggle = { viewModel.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.MIND_RECORD, it)) },
+        onAfternoteToggle = { viewModel.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.AFTERNOTE, it)) },
     )
 
     when (uiState.saveFailure) {
         PushNotificationSaveFailure.NETWORK -> {
             NetworkErrorPopup(
-                onRetry = viewModel::onSaveFailureRetry,
-                onDismiss = viewModel::onSaveFailureDismiss,
+                onRetry = { viewModel.onIntent(PushNotificationIntent.RetrySave) },
+                onDismiss = { viewModel.onIntent(PushNotificationIntent.DismissSaveFailure) },
             )
         }
 
         PushNotificationSaveFailure.SERVER -> {
             ServerErrorPopup(
-                onRetry = viewModel::onSaveFailureRetry,
-                onDismiss = viewModel::onSaveFailureDismiss,
+                onRetry = { viewModel.onIntent(PushNotificationIntent.RetrySave) },
+                onDismiss = { viewModel.onIntent(PushNotificationIntent.DismissSaveFailure) },
             )
         }
 
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationUiState.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationUiState.kt
index 81ee23a7c7..2f42a72486 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationUiState.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationUiState.kt
@@ -1,7 +1,12 @@
 package com.afternote.feature.setting.presentation.notification
 
-data class PushNotificationUiState(
+import com.afternote.core.ui.UiText
+import com.afternote.core.ui.mvi.UiState
+
+internal data class PushNotificationUiState(
     val isLoading: Boolean = false,
+    val hasLoadedPushSettings: Boolean = false,
+    val errorMessage: UiText? = null,
     val isDeviceAlarmOn: Boolean = false,
     // 마케팅 알림 (기기 알림 꺼졌을 때)
     val isSmsChecked: Boolean = true,
@@ -15,13 +20,34 @@ data class PushNotificationUiState(
     val isMindRecordUpdating: Boolean = false,
     val isAfternoteUpdating: Boolean = false,
     val saveFailure: PushNotificationSaveFailure? = null,
-)
+    /**
+     * [saveFailure] 에서 재시도할 변경. [saveFailure] 와 같은 전이에서 함께 채우고 함께 비운다.
+     *
+     * 슬롯 하나 — 서로 다른 토글이 연달아 실패해도 재시도 대상은 마지막 실패만 남긴다.
+     * 이미 실패한 토글은 이전 값으로 롤백되어 화면에 "안 켜짐"으로 보이므로,
+     * 조용히 사라지는 것은 재시도 "대상"뿐이다. 여러 실패를 동시에 재시도하는 요구가
+     * 없어 의도적으로 단순화했다 (#558 리뷰 합의).
+     */
+    val failedUpdate: PushSettingUpdate? = null,
+    /** 알림 설정 화면이 STARTED 인 동안만 true 다. 이때만 마케팅 동의 저장 실패를 안내 신호로 올린다 (#558). */
+    val isMarketingFeedbackActive: Boolean = false,
+    /** 마케팅 동의 저장 실패 안내 신호. 화면이 스낵바를 띄우고 소비 Intent 로 내린다 (#1502). */
+    val isMarketingConsentSaveFailed: Boolean = false,
+) : UiState
 
 enum class PushNotificationSaveFailure {
     NETWORK,
     SERVER,
 }
 
-sealed interface PushNotificationEvent {
-    data object MarketingConsentSaveFailed : PushNotificationEvent
+/** 기기 알림이 켜졌을 때 받는 서비스 알림 종류. */
+internal enum class PushSetting {
+    NEWSLETTER,
+    MIND_RECORD,
+    AFTERNOTE,
 }
+
+internal data class PushSettingUpdate(
+    val setting: PushSetting,
+    val on: Boolean,
+)
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationViewModel.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationViewModel.kt
index 4e928b830b..9850284321 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationViewModel.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationViewModel.kt
@@ -3,49 +3,34 @@ package com.afternote.feature.setting.presentation.notification
 import android.content.Context
 import android.util.Log
 import androidx.core.app.NotificationManagerCompat
-import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.afternote.core.common.reporting.ErrorReporter
-import com.afternote.core.common.result.runCatchingCancellable
 import com.afternote.core.domain.error.PushSettingFailure
+import com.afternote.core.domain.result.runCatchingCancellable
+import com.afternote.core.ui.UiText
+import com.afternote.core.ui.mvi.MviViewModel
 import com.afternote.feature.setting.domain.SettingNotificationRepository
+import com.afternote.feature.setting.presentation.R
 import dagger.hilt.android.lifecycle.HiltViewModel
 import dagger.hilt.android.qualifiers.ApplicationContext
 import jakarta.inject.Inject
-import kotlinx.coroutines.channels.BufferOverflow
-import kotlinx.coroutines.flow.MutableSharedFlow
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asSharedFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.launch
 
 @HiltViewModel
-class PushNotificationViewModel
+internal class PushNotificationViewModel
     @Inject
     constructor(
         @ApplicationContext private val context: Context,
         private val notificationRepository: SettingNotificationRepository,
         private val errorReporter: ErrorReporter,
-    ) : ViewModel() {
-        private val _uiState = MutableStateFlow(PushNotificationUiState())
-        val uiState: StateFlow<PushNotificationUiState> = _uiState.asStateFlow()
-
-        // 화면이 없는 동안의 안내는 다음 진입에 재생하지 않는다.
-        private val _events =
-            MutableSharedFlow<PushNotificationEvent>(
-                replay = 0,
-                extraBufferCapacity = 1,
-                onBufferOverflow = BufferOverflow.DROP_OLDEST,
-            )
-        val events = _events.asSharedFlow()
-
-        // 슬롯 하나 — 서로 다른 토글이 연달아 실패해도 재시도 대상은 마지막 실패만 남긴다.
-        // 이미 실패한 토글은 위에서 이전 값으로 롤백되어 화면에 "안 켜짐"으로 보이므로,
-        // 조용히 사라지는 것은 재시도 "대상"뿐이다. 여러 실패를 동시에 재시도하는 요구가
-        // 없어 의도적으로 단순화했다 (#558 리뷰 합의).
-        private var failedUpdate: PushSettingUpdate? = null
+    ) : MviViewModel<PushNotificationIntent, PushNotificationUiState, PushNotificationReducerEvent>(
+            PushNotificationUiState(isLoading = true),
+        ) {
+        private var loadJob: Job? = null
+        private var marketingLoadJob: Job? = null
+        private var marketingWritesInFlight = 0
+        private var isFirstResume = true
 
         init {
             refreshDeviceAlarmStatus()
@@ -53,122 +38,224 @@ class PushNotificationViewModel
             loadMarketingConsents()
         }
 
-        fun refreshDeviceAlarmStatus() {
-            val deviceAlarmOn = NotificationManagerCompat.from(context).areNotificationsEnabled()
-            Log.d(TAG, "refreshDeviceAlarmStatus: deviceAlarmOn=$deviceAlarmOn")
-            _uiState.update { it.copy(isDeviceAlarmOn = deviceAlarmOn) }
-        }
+        override fun onIntent(intent: PushNotificationIntent) {
+            when (intent) {
+                PushNotificationIntent.RefreshOnReturn -> {
+                    refreshOnReturn()
+                }
 
-        private fun loadPushSettings() {
-            viewModelScope.launch {
-                Log.d(TAG, "loadPushSettings: start")
-                _uiState.update { it.copy(isLoading = true) }
-                runCatchingCancellable { notificationRepository.getMyPushSettings() }
-                    .onSuccess { setting ->
-                        Log.d(TAG, "loadPushSettings: success=$setting")
-                        _uiState.update {
-                            it.copy(
-                                isLoading = false,
-                                isNewsletterOn = setting.timeLetter,
-                                isMindRecordOn = setting.mindRecord,
-                                isAfternoteOn = setting.afterNote,
-                            )
-                        }
-                    }.onFailure { e ->
-                        Log.e(TAG, "loadPushSettings: failed", e)
-                        _uiState.update { it.copy(isLoading = false) }
-                    }
-            }
-        }
+                PushNotificationIntent.RetryLoad -> {
+                    if (currentState.errorMessage != null) loadPushSettings()
+                }
 
-        private fun loadMarketingConsents() {
-            viewModelScope.launch {
-                Log.d(TAG, "loadMarketingConsents: start")
-                runCatching { notificationRepository.getMyMarketingConsents() }
-                    .onSuccess { consent ->
-                        Log.d(TAG, "loadMarketingConsents: success=$consent")
-                        _uiState.update {
-                            it.copy(
-                                isSmsChecked = consent.sms,
-                                isEmailChecked = consent.email,
-                                isPushChecked = consent.push,
-                            )
-                        }
-                    }.onFailure { e ->
-                        Log.e(TAG, "loadMarketingConsents: failed", e)
-                    }
-            }
-        }
+                PushNotificationIntent.RefreshDeviceAlarmStatus -> {
+                    refreshDeviceAlarmStatus()
+                }
 
-        fun onSmsChecked(checked: Boolean) {
-            _uiState.update { it.copy(isSmsChecked = checked) }
-            viewModelScope.launch {
-                runCatchingCancellable { notificationRepository.updateMyMarketingConsents(sms = checked, email = null, push = null) }
-                    .onSuccess { Log.d(TAG, "onSmsChecked: success, checked=$checked") }
-                    .onFailure { e ->
-                        errorReporter.recordFailure(e, mapOf(KEY_STAGE to STAGE_SMS_CONSENT))
-                        _uiState.update { it.copy(isSmsChecked = !checked) }
-                        _events.tryEmit(PushNotificationEvent.MarketingConsentSaveFailed)
-                    }
-            }
-        }
+                is PushNotificationIntent.ChangeMarketingConsent -> {
+                    updateMarketingConsent(intent.consent, intent.checked)
+                }
 
-        fun onEmailChecked(checked: Boolean) {
-            _uiState.update { it.copy(isEmailChecked = checked) }
-            viewModelScope.launch {
-                runCatchingCancellable { notificationRepository.updateMyMarketingConsents(sms = null, email = checked, push = null) }
-                    .onSuccess { Log.d(TAG, "onEmailChecked: success, checked=$checked") }
-                    .onFailure { e ->
-                        errorReporter.recordFailure(e, mapOf(KEY_STAGE to STAGE_EMAIL_CONSENT))
-                        _uiState.update { it.copy(isEmailChecked = !checked) }
-                        _events.tryEmit(PushNotificationEvent.MarketingConsentSaveFailed)
-                    }
+                is PushNotificationIntent.TogglePushSetting -> {
+                    updatePushSetting(PushSettingUpdate(intent.setting, intent.on))
+                }
+
+                PushNotificationIntent.RetrySave -> {
+                    retrySave()
+                }
+
+                PushNotificationIntent.DismissSaveFailure -> {
+                    dispatch(PushNotificationReducerEvent.SaveFailureDismissed)
+                }
+
+                PushNotificationIntent.MarketingFeedbackStarted -> {
+                    dispatch(PushNotificationReducerEvent.MarketingFeedbackActiveChanged(active = true))
+                }
+
+                PushNotificationIntent.MarketingFeedbackStopped -> {
+                    dispatch(PushNotificationReducerEvent.MarketingFeedbackActiveChanged(active = false))
+                }
+
+                PushNotificationIntent.ConsumeMarketingConsentSaveFailure -> {
+                    dispatch(PushNotificationReducerEvent.MarketingConsentSaveFailureConsumed)
+                }
             }
         }
 
-        fun onPushChecked(checked: Boolean) {
-            _uiState.update { it.copy(isPushChecked = checked) }
-            viewModelScope.launch {
-                runCatchingCancellable { notificationRepository.updateMyMarketingConsents(sms = null, email = null, push = checked) }
-                    .onSuccess { Log.d(TAG, "onPushChecked: success, checked=$checked") }
-                    .onFailure { e ->
-                        errorReporter.recordFailure(e, mapOf(KEY_STAGE to STAGE_PUSH_CONSENT))
-                        _uiState.update { it.copy(isPushChecked = !checked) }
-                        _events.tryEmit(PushNotificationEvent.MarketingConsentSaveFailed)
-                    }
+        override fun reduce(
+            state: PushNotificationUiState,
+            event: PushNotificationReducerEvent,
+        ): PushNotificationUiState =
+            when (event) {
+                is PushNotificationReducerEvent.DeviceAlarmStatusRead -> {
+                    state.copy(isDeviceAlarmOn = event.on)
+                }
+
+                PushNotificationReducerEvent.PushSettingsLoading -> {
+                    state.copy(isLoading = true, errorMessage = null)
+                }
+
+                is PushNotificationReducerEvent.PushSettingsLoaded -> {
+                    state.copy(
+                        isLoading = false,
+                        errorMessage = null,
+                        hasLoadedPushSettings = true,
+                        isNewsletterOn = event.setting.timeLetter,
+                        isMindRecordOn = event.setting.mindRecord,
+                        isAfternoteOn = event.setting.afterNote,
+                    )
+                }
+
+                PushNotificationReducerEvent.PushSettingsLoadFailed -> {
+                    state.copy(isLoading = false, errorMessage = UiText.Resource(R.string.setting_push_load_error))
+                }
+
+                is PushNotificationReducerEvent.MarketingConsentsLoaded -> {
+                    state.copy(
+                        isSmsChecked = event.consent.sms,
+                        isEmailChecked = event.consent.email,
+                        isPushChecked = event.consent.push,
+                    )
+                }
+
+                is PushNotificationReducerEvent.MarketingConsentChanged -> {
+                    state.withMarketingConsent(event.consent, event.checked)
+                }
+
+                // 화면이 STARTED 밖이면 값만 되돌리고 안내 신호는 올리지 않는다 (#558).
+                is PushNotificationReducerEvent.MarketingConsentSaveFailed -> {
+                    state
+                        .withMarketingConsent(event.consent, !event.requested)
+                        .copy(isMarketingConsentSaveFailed = state.isMarketingConsentSaveFailed || state.isMarketingFeedbackActive)
+                }
+
+                is PushNotificationReducerEvent.PushSettingSaving -> {
+                    state.withValue(event.update.setting, event.update.on).withUpdating(event.update.setting, updating = true)
+                }
+
+                is PushNotificationReducerEvent.PushSettingSaved -> {
+                    state.withUpdating(event.setting, updating = false)
+                }
+
+                is PushNotificationReducerEvent.PushSettingSaveFailed -> {
+                    state
+                        .withValue(event.update.setting, event.previous)
+                        .withUpdating(event.update.setting, updating = false)
+                        .copy(saveFailure = event.failure, failedUpdate = event.update)
+                }
+
+                PushNotificationReducerEvent.SaveFailureDismissed -> {
+                    state.copy(saveFailure = null, failedUpdate = null)
+                }
+
+                // 비활성으로 바뀌면 아직 소비되지 않은 안내도 걷는다 — 다음 진입에 재생하지 않는다.
+                is PushNotificationReducerEvent.MarketingFeedbackActiveChanged -> {
+                    state.copy(
+                        isMarketingFeedbackActive = event.active,
+                        isMarketingConsentSaveFailed = state.isMarketingConsentSaveFailed && event.active,
+                    )
+                }
+
+                PushNotificationReducerEvent.MarketingConsentSaveFailureConsumed -> {
+                    state.copy(isMarketingConsentSaveFailed = false)
+                }
             }
+
+        private fun refreshDeviceAlarmStatus() {
+            val deviceAlarmOn = NotificationManagerCompat.from(context).areNotificationsEnabled()
+            Log.d(TAG, "refreshDeviceAlarmStatus: deviceAlarmOn=$deviceAlarmOn")
+            dispatch(PushNotificationReducerEvent.DeviceAlarmStatusRead(deviceAlarmOn))
         }
 
-        fun onNewsletterToggle(on: Boolean) {
-            updatePushSetting(PushSettingUpdate(PushSetting.NEWSLETTER, on))
+        private fun refreshOnReturn() {
+            refreshDeviceAlarmStatus()
+            if (isFirstResume) {
+                isFirstResume = false
+                return
+            }
+            loadPushSettings(isAutomatic = true)
+            loadMarketingConsents()
         }
 
-        fun onMindRecordToggle(on: Boolean) {
-            updatePushSetting(PushSettingUpdate(PushSetting.MIND_RECORD, on))
+        private fun loadPushSettings(isAutomatic: Boolean = false) {
+            if (loadJob?.isActive == true ||
+                currentState.run { isNewsletterUpdating || isMindRecordUpdating || isAfternoteUpdating }
+            ) {
+                return
+            }
+            if (!isAutomatic) dispatch(PushNotificationReducerEvent.PushSettingsLoading)
+            loadJob =
+                viewModelScope.launch {
+                    Log.d(TAG, "loadPushSettings: start")
+                    runCatchingCancellable { notificationRepository.getMyPushSettings() }
+                        .onSuccess { setting ->
+                            Log.d(TAG, "loadPushSettings: success=$setting")
+                            dispatch(PushNotificationReducerEvent.PushSettingsLoaded(setting))
+                        }.onFailure { e ->
+                            // 조회 실패는 Logcat 에만 남긴다. 반복 조회 잡음이 저장 실패 진단의 보관 한도를 밀어내지 않게 한다 (#963).
+                            Log.e(TAG, "loadPushSettings: failed", e)
+                            if (!isAutomatic ||
+                                !currentState.hasLoadedPushSettings
+                            ) {
+                                dispatch(PushNotificationReducerEvent.PushSettingsLoadFailed)
+                            }
+                        }
+                }
         }
 
-        fun onAfternoteToggle(on: Boolean) {
-            updatePushSetting(PushSettingUpdate(PushSetting.AFTERNOTE, on))
+        private fun loadMarketingConsents() {
+            if (marketingLoadJob?.isActive == true || marketingWritesInFlight > 0) return
+            marketingLoadJob =
+                viewModelScope.launch {
+                    Log.d(TAG, "loadMarketingConsents: start")
+                    runCatchingCancellable { notificationRepository.getMyMarketingConsents() }
+                        .onSuccess { consent ->
+                            Log.d(TAG, "loadMarketingConsents: success=$consent")
+                            dispatch(PushNotificationReducerEvent.MarketingConsentsLoaded(consent))
+                        }.onFailure { e ->
+                            Log.e(TAG, "loadMarketingConsents: failed", e)
+                        }
+                }
         }
 
-        fun onSaveFailureDismiss() {
-            failedUpdate = null
-            _uiState.update { it.copy(saveFailure = null) }
+        private fun updateMarketingConsent(
+            consent: MarketingConsent,
+            checked: Boolean,
+        ) {
+            marketingLoadJob?.cancel()
+            marketingWritesInFlight++
+            dispatch(PushNotificationReducerEvent.MarketingConsentChanged(consent, checked))
+            viewModelScope.launch {
+                try {
+                    runCatchingCancellable {
+                        notificationRepository.updateMyMarketingConsents(
+                            sms = checked.takeIf { consent == MarketingConsent.SMS },
+                            email = checked.takeIf { consent == MarketingConsent.EMAIL },
+                            push = checked.takeIf { consent == MarketingConsent.PUSH },
+                        )
+                    }.onSuccess {
+                        Log.d(TAG, "updateMarketingConsent: success, consent=$consent, checked=$checked")
+                    }.onFailure { e ->
+                        errorReporter.recordFailure(e, mapOf(KEY_STAGE to consent.reportingStage()))
+                        dispatch(PushNotificationReducerEvent.MarketingConsentSaveFailed(consent, requested = checked))
+                    }
+                } finally {
+                    marketingWritesInFlight--
+                }
+            }
         }
 
-        fun onSaveFailureRetry() {
-            val update = failedUpdate ?: return
-            failedUpdate = null
-            _uiState.update { it.copy(saveFailure = null) }
+        private fun retrySave() {
+            val update = currentState.failedUpdate ?: return
+            dispatch(PushNotificationReducerEvent.SaveFailureDismissed)
             updatePushSetting(update)
         }
 
         private fun updatePushSetting(update: PushSettingUpdate) {
-            if (_uiState.value.isUpdating(update.setting)) return
-            val previousValue = _uiState.value.valueOf(update.setting)
-            _uiState.update {
-                it.withValue(update.setting, update.on).withUpdating(update.setting, updating = true)
-            }
+            if (currentState.isLoading || currentState.errorMessage != null || currentState.isUpdating(update.setting)) return
+            loadJob?.cancel()
+            val previousValue = currentState.valueOf(update.setting)
+            dispatch(PushNotificationReducerEvent.PushSettingSaving(update))
             viewModelScope.launch {
                 runCatchingCancellable {
                     notificationRepository.updateMyPushSettings(
@@ -177,15 +264,16 @@ class PushNotificationViewModel
                         afterNote = update.on.takeIf { update.setting == PushSetting.AFTERNOTE },
                     )
                 }.onSuccess {
-                    _uiState.update { it.withUpdating(update.setting, updating = false) }
+                    dispatch(PushNotificationReducerEvent.PushSettingSaved(update.setting))
                 }.onFailure { failure ->
-                    failedUpdate = update
-                    _uiState.update {
-                        it
-                            .withValue(update.setting, previousValue)
-                            .withUpdating(update.setting, updating = false)
-                            .copy(saveFailure = failure.toSaveFailure())
-                    }
+                    errorReporter.recordFailure(
+                        failure,
+                        mapOf(
+                            KEY_STAGE to STAGE_PUSH_SETTING_UPDATE,
+                            KEY_PUSH_SETTING to update.setting.reportingName(),
+                        ),
+                    )
+                    dispatch(PushNotificationReducerEvent.PushSettingSaveFailed(update, previousValue, failure.toSaveFailure()))
                 }
             }
         }
@@ -193,22 +281,26 @@ class PushNotificationViewModel
         companion object {
             private const val TAG = "PushNotificationVM"
             private const val KEY_STAGE = "stage"
-            private const val STAGE_SMS_CONSENT = "sms_consent_update"
-            private const val STAGE_EMAIL_CONSENT = "email_consent_update"
-            private const val STAGE_PUSH_CONSENT = "push_consent_update"
+            private const val KEY_PUSH_SETTING = "push_setting"
+            private const val STAGE_PUSH_SETTING_UPDATE = "push_setting_update"
         }
     }
 
-private enum class PushSetting {
-    NEWSLETTER,
-    MIND_RECORD,
-    AFTERNOTE,
-}
+/** 진단 속성 값. 토글 종류만 담는 고정 문자열이라 사용자 정보가 섞이지 않는다. */
+private fun PushSetting.reportingName(): String =
+    when (this) {
+        PushSetting.NEWSLETTER -> "newsletter"
+        PushSetting.MIND_RECORD -> "mind_record"
+        PushSetting.AFTERNOTE -> "afternote"
+    }
 
-private data class PushSettingUpdate(
-    val setting: PushSetting,
-    val on: Boolean,
-)
+/** 마케팅 동의 저장 실패의 진단 단계. 채널 이름만 담는 고정 문자열이다. */
+private fun MarketingConsent.reportingStage(): String =
+    when (this) {
+        MarketingConsent.SMS -> "sms_consent_update"
+        MarketingConsent.EMAIL -> "email_consent_update"
+        MarketingConsent.PUSH -> "push_consent_update"
+    }
 
 private fun PushNotificationUiState.valueOf(setting: PushSetting): Boolean =
     when (setting) {
@@ -244,6 +336,16 @@ private fun PushNotificationUiState.withUpdating(
         PushSetting.AFTERNOTE -> copy(isAfternoteUpdating = updating)
     }
 
+private fun PushNotificationUiState.withMarketingConsent(
+    consent: MarketingConsent,
+    checked: Boolean,
+): PushNotificationUiState =
+    when (consent) {
+        MarketingConsent.SMS -> copy(isSmsChecked = checked)
+        MarketingConsent.EMAIL -> copy(isEmailChecked = checked)
+        MarketingConsent.PUSH -> copy(isPushChecked = checked)
+    }
+
 private fun Throwable.toSaveFailure(): PushNotificationSaveFailure =
     when (this) {
         is PushSettingFailure.NetworkUnavailable -> PushNotificationSaveFailure.NETWORK
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/component/DeviceAlarmOffSection.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/component/DeviceAlarmOffSection.kt
index d908c8d8e0..039935aac9 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/component/DeviceAlarmOffSection.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/component/DeviceAlarmOffSection.kt
@@ -16,7 +16,7 @@ import com.afternote.feature.setting.presentation.R
 import com.afternote.feature.setting.presentation.notification.PushNotificationUiState
 
 @Composable
-fun DeviceAlarmOffSection(
+internal fun DeviceAlarmOffSection(
     uiState: PushNotificationUiState,
     onSmsCheck: (Boolean) -> Unit,
     onEmailCheck: (Boolean) -> Unit,
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/component/PushToggleSection.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/component/PushToggleSection.kt
index aca5f1757f..081e521adb 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/component/PushToggleSection.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/notification/component/PushToggleSection.kt
@@ -6,7 +6,7 @@ import com.afternote.feature.setting.presentation.R
 import com.afternote.feature.setting.presentation.notification.PushNotificationUiState
 
 @Composable
-fun PushToggleSection(
+internal fun PushToggleSection(
     uiState: PushNotificationUiState,
     onNewsletterToggle: (Boolean) -> Unit,
     onMindRecordToggle: (Boolean) -> Unit,
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyContract.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyContract.kt
new file mode 100644
index 0000000000..9126c4f252
--- /dev/null
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyContract.kt
@@ -0,0 +1,45 @@
+package com.afternote.feature.setting.presentation.passkey
+
+import com.afternote.core.ui.mvi.MviIntent
+import com.afternote.core.ui.mvi.ReducerEvent
+import com.afternote.core.ui.mvi.UiState
+
+internal data class PassKeyUiState(
+    val isRegistering: Boolean = false,
+    val registrationId: Long = 0,
+    val result: PasskeyRegistrationResult? = null,
+) : UiState
+
+internal sealed interface PassKeyIntent : MviIntent {
+    // Activity 소유 플랫폼 요청은 화면이 제공하고 등록 중에만 보유한다. 화면 폐기 시 CancelRegistration으로 해제한다.
+    data class Register(
+        val createCredential: suspend (optionsJson: String) -> String,
+    ) : PassKeyIntent
+
+    data object CancelRegistration : PassKeyIntent
+
+    data class ConsumeResult(
+        val registrationId: Long,
+        val result: PasskeyRegistrationResult,
+    ) : PassKeyIntent
+}
+
+internal sealed interface PassKeyReducerEvent : ReducerEvent {
+    data object Started : PassKeyReducerEvent
+
+    data class Finished(
+        val registrationId: Long,
+        val result: PasskeyRegistrationResult,
+    ) : PassKeyReducerEvent
+
+    data class Stopped(
+        val registrationId: Long,
+    ) : PassKeyReducerEvent
+
+    data object Canceled : PassKeyReducerEvent
+
+    data class Consumed(
+        val registrationId: Long,
+        val result: PasskeyRegistrationResult,
+    ) : PassKeyReducerEvent
+}
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyListContract.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyListContract.kt
new file mode 100644
index 0000000000..31ba50180f
--- /dev/null
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyListContract.kt
@@ -0,0 +1,19 @@
+package com.afternote.feature.setting.presentation.passkey
+
+import com.afternote.core.ui.mvi.MviIntent
+import com.afternote.core.ui.mvi.ReducerEvent
+import com.afternote.feature.setting.domain.Passkey
+
+internal sealed interface PassKeyListIntent : MviIntent {
+    data object Refresh : PassKeyListIntent
+}
+
+internal sealed interface PassKeyListReducerEvent : ReducerEvent {
+    data object Loading : PassKeyListReducerEvent
+
+    data class Loaded(
+        val passkeys: List<Passkey>,
+    ) : PassKeyListReducerEvent
+
+    data object Failed : PassKeyListReducerEvent
+}
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyListScreen.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyListScreen.kt
index f7128d8896..0247b1e4a0 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyListScreen.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyListScreen.kt
@@ -1,27 +1,45 @@
 package com.afternote.feature.setting.presentation.passkey
 
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
+import com.afternote.core.ui.button.AfternoteButton
+import com.afternote.core.ui.button.AfternoteButtonType
+import com.afternote.core.ui.loading.LoadingBody
 import com.afternote.core.ui.theme.AfternoteDesign
 import com.afternote.core.ui.topbar.DetailTopBar
+import com.afternote.feature.setting.domain.Passkey
 import com.afternote.feature.setting.presentation.R
 import com.afternote.feature.setting.presentation.passkey.component.PasskeyListItem
 
 @Composable
-fun PassKeyListScreen(
+internal fun PassKeyListScreen(
+    passkeys: List<Passkey>,
+    isLoading: Boolean,
+    errorMessage: String?,
     onBackClick: () -> Unit,
+    onRegisterClick: () -> Unit,
+    onRetryClick: () -> Unit,
     modifier: Modifier = Modifier,
 ) {
+    if (!isLoading && errorMessage == null && passkeys.isEmpty()) {
+        PassKeyScreen(onBackClick = onBackClick, onRegisterClick = onRegisterClick, modifier = modifier)
+        return
+    }
     Scaffold(
         modifier = modifier,
         containerColor = Color.Transparent,
@@ -32,34 +50,76 @@ fun PassKeyListScreen(
             )
         },
     ) { innerPadding ->
-        LazyColumn(
-            modifier =
-                Modifier
-                    .fillMaxWidth()
-                    .padding(innerPadding)
-                    .padding(horizontal = 20.dp),
-        ) {
-            item {
-                Spacer(modifier = Modifier.height(16.dp))
-                Text(
-                    text = stringResource(id = R.string.setting_passkey_section_title),
-                    style = AfternoteDesign.typography.bodyLargeB,
-                )
-                Spacer(modifier = Modifier.height(8.dp))
-                Text(
-                    text = stringResource(id = R.string.setting_passkey_description),
-                    style = AfternoteDesign.typography.bodySmallR,
-                )
-                Spacer(modifier = Modifier.height(24.dp))
-                Text(
-                    text = stringResource(id = R.string.setting_passkey_list_header),
-                    style = AfternoteDesign.typography.bodyLargeB,
+        when {
+            isLoading -> {
+                LoadingBody(modifier = Modifier.padding(innerPadding))
+            }
+
+            errorMessage != null -> {
+                PassKeyListErrorState(
+                    message = errorMessage,
+                    onRetryClick = onRetryClick,
+                    modifier =
+                        Modifier
+                            .fillMaxSize()
+                            .padding(innerPadding)
+                            .padding(horizontal = 20.dp),
                 )
-                Spacer(modifier = Modifier.height(12.dp))
             }
-            item {
-                PasskeyListItem()
+
+            else -> {
+                LazyColumn(
+                    modifier =
+                        Modifier
+                            .fillMaxWidth()
+                            .padding(innerPadding)
+                            .padding(horizontal = 20.dp),
+                ) {
+                    item {
+                        Spacer(modifier = Modifier.height(16.dp))
+                        Text(
+                            text = stringResource(id = R.string.setting_passkey_section_title),
+                            style = AfternoteDesign.typography.bodyLargeB,
+                        )
+                        Spacer(modifier = Modifier.height(8.dp))
+                        Text(
+                            text = stringResource(id = R.string.setting_passkey_description),
+                            style = AfternoteDesign.typography.bodySmallR,
+                        )
+                        Spacer(modifier = Modifier.height(24.dp))
+                        Text(
+                            text = stringResource(id = R.string.setting_passkey_list_header),
+                            style = AfternoteDesign.typography.bodyLargeB,
+                        )
+                        Spacer(modifier = Modifier.height(12.dp))
+                    }
+                    items(passkeys, key = { it.id }) { passkey ->
+                        PasskeyListItem(passkey = passkey)
+                    }
+                }
             }
         }
     }
 }
+
+@Composable
+private fun PassKeyListErrorState(
+    message: String,
+    onRetryClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Box(modifier = modifier, contentAlignment = Alignment.Center) {
+        Column(horizontalAlignment = Alignment.CenterHorizontally) {
+            Text(
+                text = message,
+                style = AfternoteDesign.typography.bodySmallR,
+            )
+            Spacer(modifier = Modifier.height(16.dp))
+            AfternoteButton(
+                text = stringResource(id = R.string.setting_passkey_list_retry),
+                onClick = onRetryClick,
+                type = AfternoteButtonType.Default,
+            )
+        }
+    }
+}
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyListUiState.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyListUiState.kt
new file mode 100644
index 0000000000..5e44749f0a
--- /dev/null
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyListUiState.kt
@@ -0,0 +1,11 @@
+package com.afternote.feature.setting.presentation.passkey
+
+import com.afternote.core.ui.UiText
+import com.afternote.core.ui.mvi.UiState
+import com.afternote.feature.setting.domain.Passkey
+
+internal data class PassKeyListUiState(
+    val isLoading: Boolean = false,
+    val passkeys: List<Passkey> = emptyList(),
+    val errorMessage: UiText? = null,
+) : UiState
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyListViewModel.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyListViewModel.kt
new file mode 100644
index 0000000000..b1cc9f42db
--- /dev/null
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyListViewModel.kt
@@ -0,0 +1,82 @@
+package com.afternote.feature.setting.presentation.passkey
+
+import androidx.lifecycle.viewModelScope
+import com.afternote.core.common.reporting.ErrorReporter
+import com.afternote.core.common.result.runCatchingCancellable
+import com.afternote.core.domain.repository.UserProfileCacheRepository
+import com.afternote.core.ui.UiText
+import com.afternote.core.ui.mvi.MviViewModel
+import com.afternote.feature.setting.domain.PasskeyRepository
+import com.afternote.feature.setting.presentation.R
+import dagger.hilt.android.lifecycle.HiltViewModel
+import jakarta.inject.Inject
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+
+@HiltViewModel
+internal class PassKeyListViewModel
+    @Inject
+    constructor(
+        private val passkeyRepository: PasskeyRepository,
+        private val userProfileCacheRepository: UserProfileCacheRepository,
+        private val errorReporter: ErrorReporter,
+    ) : MviViewModel<PassKeyListIntent, PassKeyListUiState, PassKeyListReducerEvent>(PassKeyListUiState(isLoading = true)) {
+        override fun onIntent(intent: PassKeyListIntent) {
+            when (intent) {
+                PassKeyListIntent.Refresh -> refresh()
+            }
+        }
+
+        override fun reduce(
+            state: PassKeyListUiState,
+            event: PassKeyListReducerEvent,
+        ): PassKeyListUiState =
+            when (event) {
+                PassKeyListReducerEvent.Loading -> {
+                    state.copy(isLoading = true, errorMessage = null)
+                }
+
+                is PassKeyListReducerEvent.Loaded -> {
+                    state.copy(isLoading = false, passkeys = event.passkeys)
+                }
+
+                PassKeyListReducerEvent.Failed -> {
+                    state.copy(
+                        isLoading = false,
+                        errorMessage = UiText.Resource(R.string.setting_passkey_list_error),
+                    )
+                }
+            }
+
+        private var loadJob: Job? = null
+        private var requestId = 0L
+
+        /** 최초 진입·등록 화면에서 복귀·사용자 재시도 모두 서버 목록을 다시 읽는다. */
+        private fun refresh() {
+            val currentRequestId = ++requestId
+            loadJob?.cancel()
+            dispatch(PassKeyListReducerEvent.Loading)
+            loadJob =
+                viewModelScope.launch {
+                    runCatchingCancellable { passkeyRepository.getPasskeys() }
+                        .onSuccess { passkeys ->
+                            if (requestId == currentRequestId) dispatch(PassKeyListReducerEvent.Loaded(passkeys))
+                            if (passkeys.isNotEmpty()) syncRegisteredCache()
+                        }.onFailure { failure ->
+                            if (requestId == currentRequestId) {
+                                errorReporter.recordFailure(failure, mapOf("stage" to "passkey_list"))
+                                dispatch(PassKeyListReducerEvent.Failed)
+                            }
+                        }
+                }
+        }
+
+        /**
+         * 등록 직후 캐시 저장이 빠진 기기를 서버 목록으로 되살린다. 지문 관문을 켜는 방향으로만 맞춘다 —
+         * 빈 목록으로 캐시를 내리면 목록 응답 하나가 관문을 끌 수 있다.
+         */
+        private suspend fun syncRegisteredCache() {
+            runCatchingCancellable { userProfileCacheRepository.savePasskeyRegistered(true) }
+                .onFailure { errorReporter.recordFailure(it, mapOf("stage" to "passkey_list_cache")) }
+        }
+    }
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyMakingScreen.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyMakingScreen.kt
index 89aea0918a..ba24e847d8 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyMakingScreen.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyMakingScreen.kt
@@ -1,9 +1,8 @@
 package com.afternote.feature.setting.presentation.passkey
 
-import android.util.Log
 import androidx.biometric.BiometricManager
-import androidx.biometric.BiometricPrompt
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
@@ -11,33 +10,24 @@ import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
-import androidx.core.content.ContextCompat
+import androidx.compose.ui.res.stringResource
+import androidx.credentials.CredentialManager
 import androidx.fragment.app.FragmentActivity
 import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
-import com.afternote.core.common.biometric.confirmWithCryptoOperation
-import com.afternote.core.common.biometric.createBiometricCryptoObject
-import com.afternote.core.common.biometric.isBiometricCryptoSupported
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.afternote.core.common.biometric.BiometricAuthResult
+import com.afternote.core.common.biometric.BiometricMessages
+import com.afternote.core.common.biometric.authenticateBiometric
+import com.afternote.core.ui.asString
 import com.afternote.core.ui.findActivity
+import com.afternote.core.ui.mvi.ObserveSignal
 import com.afternote.core.ui.popup.Popup
 import com.afternote.core.ui.popup.PopupType
+import com.afternote.feature.setting.presentation.R
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.suspendCancellableCoroutine
-import kotlin.coroutines.resume
-
-private const val LOG_TAG = "PassKeyMaking"
-
-private sealed interface BiometricResult {
-    data object Success : BiometricResult
-
-    data object Canceled : BiometricResult
-
-    data class Error(
-        val message: String,
-    ) : BiometricResult
-}
 
 @Composable
-fun PassKeyMakingScreen(
+internal fun PassKeyMakingScreen(
     onBackClick: () -> Unit,
     onPasswordAuthClick: () -> Unit,
     modifier: Modifier = Modifier,
@@ -52,19 +42,54 @@ fun PassKeyMakingScreen(
                 .from(context)
                 .canAuthenticate(BiometricManager.Authenticators.BIOMETRIC_STRONG) == BiometricManager.BIOMETRIC_SUCCESS
         }
-    var showCompletionDialog by remember { mutableStateOf(false) }
+    val credentialManager = remember(context) { CredentialManager.create(context) }
+    val registrationState by viewModel.uiState.collectAsStateWithLifecycle()
+    DisposableEffect(viewModel) {
+        onDispose { viewModel.onIntent(PassKeyIntent.CancelRegistration) }
+    }
+    ObserveSignal(
+        signal = registrationState.registrationId.takeIf { registrationState.result == PasskeyRegistrationResult.Canceled },
+        consumed = PassKeyIntent.ConsumeResult(registrationState.registrationId, PasskeyRegistrationResult.Canceled),
+        onIntent = viewModel::onIntent,
+    ) { }
+    val consumeResult: () -> Unit = {
+        registrationState.result?.let {
+            viewModel.onIntent(PassKeyIntent.ConsumeResult(registrationState.registrationId, it))
+        }
+    }
     var isAuthenticating by remember { mutableStateOf(false) }
     var errorMessage by remember { mutableStateOf<String?>(null) }
 
-    if (showCompletionDialog) {
+    val messages =
+        BiometricMessages(
+            initFailed = stringResource(R.string.setting_biometric_init_failed),
+            noHardware = stringResource(R.string.setting_biometric_no_hardware),
+            noneEnrolled = stringResource(R.string.setting_biometric_none_enrolled),
+            hwUnavailable = stringResource(R.string.setting_biometric_hw_unavailable),
+            notAvailable = stringResource(R.string.setting_biometric_not_available),
+            verificationFailed = stringResource(R.string.setting_biometric_verification_failed),
+        )
+    val promptTitle = stringResource(R.string.setting_biometric_prompt_title)
+    val promptSubtitle = stringResource(R.string.setting_biometric_prompt_subtitle)
+
+    if (registrationState.result == PasskeyRegistrationResult.Success) {
         Popup(
             type = PopupType.Default,
-            message = "패스키 생성이 완료되었습니다",
+            message = stringResource(R.string.setting_passkey_registration_complete),
             onConfirm = {
-                showCompletionDialog = false
+                consumeResult()
                 onBackClick()
             },
-            onDismiss = { showCompletionDialog = false },
+            onDismiss = { consumeResult() },
+        )
+    }
+
+    (registrationState.result as? PasskeyRegistrationResult.Error)?.let { failure ->
+        Popup(
+            type = PopupType.Default,
+            message = failure.message.asString(),
+            onConfirm = consumeResult,
+            onDismiss = consumeResult,
         )
     }
 
@@ -80,21 +105,24 @@ fun PassKeyMakingScreen(
     PassKeyMakingContent(
         onBackClick = onBackClick,
         onBiometricAuthClick = {
-            if (!isAuthenticating && activity != null) {
+            if (!isAuthenticating && !registrationState.isRegistering && registrationState.result == null && activity != null) {
                 isAuthenticating = true
                 coroutineScope.launch {
                     try {
-                        when (val result = authenticate(activity)) {
-                            BiometricResult.Success -> {
-                                viewModel.savePasskeyRegistered()
-                                showCompletionDialog = true
+                        when (val result = activity.authenticateBiometric(promptTitle, promptSubtitle, messages)) {
+                            BiometricAuthResult.Success -> {
+                                viewModel.onIntent(
+                                    PassKeyIntent.Register { options ->
+                                        createPasskeyCredential(activity, credentialManager, options)
+                                    },
+                                )
                             }
 
-                            BiometricResult.Canceled -> {
+                            BiometricAuthResult.Canceled -> {
                                 Unit
                             }
 
-                            is BiometricResult.Error -> {
+                            is BiometricAuthResult.Error -> {
                                 errorMessage = result.message
                             }
                         }
@@ -104,71 +132,8 @@ fun PassKeyMakingScreen(
                 }
             }
         },
-        onPasswordAuthClick = onPasswordAuthClick,
+        onPasswordAuthClick = { if (!isAuthenticating && !registrationState.isRegistering) onPasswordAuthClick() },
         isBiometricAvailable = isBiometricAvailable,
         modifier = modifier,
     )
 }
-
-private suspend fun authenticate(activity: FragmentActivity): BiometricResult =
-    suspendCancellableCoroutine { continuation ->
-        val authenticators =
-            BiometricManager.Authenticators.BIOMETRIC_STRONG or
-                BiometricManager.Authenticators.DEVICE_CREDENTIAL
-
-        val promptInfo =
-            BiometricPrompt.PromptInfo
-                .Builder()
-                .setTitle("패스키 등록")
-                .setSubtitle("패스키로 사용할 지문을 인식해 주세요.")
-                .setAllowedAuthenticators(authenticators)
-                .build()
-
-        // API 26~29 에서는 DEVICE_CREDENTIAL 허용자와 CryptoObject 를 함께 쓸 수 없다.
-        // 이때는 관문 없이 인증하고, 성공 확정은 cipher 부재로 통과시킨다 (#1166).
-        val cryptoObject = if (isBiometricCryptoSupported) createBiometricCryptoObject() else null
-
-        val biometricPrompt =
-            BiometricPrompt(
-                activity,
-                ContextCompat.getMainExecutor(activity),
-                object : BiometricPrompt.AuthenticationCallback() {
-                    override fun onAuthenticationSucceeded(result: BiometricPrompt.AuthenticationResult) {
-                        if (!continuation.isActive) return
-                        // 성공은 콜백의 도달이 아니라 사용자 인증에 묶인 키로 암호 연산이
-                        // 성사되는가로 확정한다 — 콜백만 가로챈 경우 연산이 실패한다 (#1166).
-                        val confirmation = confirmWithCryptoOperation(result.cryptoObject?.cipher)
-                        if (confirmation.isSuccess) {
-                            continuation.resume(BiometricResult.Success)
-                        } else {
-                            Log.w(LOG_TAG, "인증 후 암호 연산 실패", confirmation.exceptionOrNull())
-                            continuation.resume(BiometricResult.Error("지문 확인에 실패했어요. 다시 시도해 주세요."))
-                        }
-                    }
-
-                    override fun onAuthenticationError(
-                        errorCode: Int,
-                        errString: CharSequence,
-                    ) {
-                        if (!continuation.isActive) return
-                        if (errorCode == BiometricPrompt.ERROR_USER_CANCELED ||
-                            errorCode == BiometricPrompt.ERROR_NEGATIVE_BUTTON ||
-                            errorCode == BiometricPrompt.ERROR_CANCELED
-                        ) {
-                            continuation.resume(BiometricResult.Canceled)
-                        } else {
-                            continuation.resume(BiometricResult.Error(errString.toString()))
-                        }
-                    }
-
-                    override fun onAuthenticationFailed() {}
-                },
-            )
-
-        continuation.invokeOnCancellation { biometricPrompt.cancelAuthentication() }
-        if (cryptoObject != null) {
-            biometricPrompt.authenticate(promptInfo, cryptoObject)
-        } else {
-            biometricPrompt.authenticate(promptInfo)
-        }
-    }
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyPasswordScreen.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyPasswordScreen.kt
index 5993c0ad28..47f84769d1 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyPasswordScreen.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyPasswordScreen.kt
@@ -1,16 +1,25 @@
 package com.afternote.feature.setting.presentation.passkey
 
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.credentials.CredentialManager
 import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.afternote.core.ui.asString
+import com.afternote.core.ui.mvi.ObserveSignal
+import com.afternote.core.ui.popup.Popup
+import com.afternote.core.ui.popup.PopupType
+import com.afternote.feature.setting.presentation.applock.AppLockSetupIntent
 import com.afternote.feature.setting.presentation.applock.AppLockSetupViewModel
 
 @Composable
-fun PassKeyPasswordScreen(
+internal fun PassKeyPasswordScreen(
     onPinComplete: (pin: String) -> Unit,
     onBack: () -> Unit,
     modifier: Modifier = Modifier,
@@ -19,20 +28,56 @@ fun PassKeyPasswordScreen(
 ) {
     val uiState by viewModel.uiState.collectAsStateWithLifecycle()
     val currentOnPinComplete by rememberUpdatedState(onPinComplete)
-
-    LaunchedEffect(uiState.isComplete) {
-        if (uiState.isComplete) {
-            passKeyViewModel.savePasskeyRegistered()
-            currentOnPinComplete(uiState.pin)
-            viewModel.resetPin()
+    val context = LocalContext.current
+    val credentialManager = remember(context) { CredentialManager.create(context) }
+    val registrationState by passKeyViewModel.uiState.collectAsStateWithLifecycle()
+    val isRegistering = registrationState.isRegistering
+    DisposableEffect(passKeyViewModel, viewModel) {
+        onDispose {
+            passKeyViewModel.onIntent(PassKeyIntent.CancelRegistration)
+            viewModel.onIntent(AppLockSetupIntent.ResetPin)
+        }
+    }
+    val result = registrationState.result
+    ObserveSignal(
+        signal = result?.takeUnless { it is PasskeyRegistrationResult.Error }?.let { registrationState.registrationId to it },
+        consumed = PassKeyIntent.ConsumeResult(registrationState.registrationId, result ?: PasskeyRegistrationResult.Canceled),
+        onIntent = passKeyViewModel::onIntent,
+    ) { (_, completed) ->
+        val pin = uiState.pin
+        viewModel.onIntent(AppLockSetupIntent.ResetPin)
+        if (completed == PasskeyRegistrationResult.Success) currentOnPinComplete(pin)
+    }
+    LaunchedEffect(result) {
+        if (result is PasskeyRegistrationResult.Error) viewModel.onIntent(AppLockSetupIntent.ResetPin)
+    }
+    val register: () -> Unit = {
+        if (uiState.isComplete && !isRegistering && result == null) {
+            passKeyViewModel.onIntent(
+                PassKeyIntent.Register { options ->
+                    createPasskeyCredential(context, credentialManager, options)
+                },
+            )
         }
     }
+    LaunchedEffect(uiState.isComplete) {
+        if (uiState.isComplete) register()
+    }
+
+    (result as? PasskeyRegistrationResult.Error)?.let { failure ->
+        Popup(
+            type = PopupType.Default,
+            message = failure.message.asString(),
+            onConfirm = { passKeyViewModel.onIntent(PassKeyIntent.ConsumeResult(registrationState.registrationId, failure)) },
+            onDismiss = { passKeyViewModel.onIntent(PassKeyIntent.ConsumeResult(registrationState.registrationId, failure)) },
+        )
+    }
 
     PassKeyPasswordContent(
         passwordLength = uiState.pin.length,
-        onDigitClick = viewModel::onDigitInput,
-        onDeleteClick = viewModel::onDelete,
-        onConfirmClick = { currentOnPinComplete(uiState.pin) },
+        onDigitClick = { if (!isRegistering) viewModel.onIntent(AppLockSetupIntent.DigitInput(it)) },
+        onDeleteClick = { if (!isRegistering) viewModel.onIntent(AppLockSetupIntent.Delete) },
+        onConfirmClick = register,
         onBack = onBack,
         modifier = modifier,
     )
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyViewModel.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyViewModel.kt
index 345fcb0e5c..b9437ab331 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyViewModel.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyViewModel.kt
@@ -1,29 +1,161 @@
 package com.afternote.feature.setting.presentation.passkey
 
-import androidx.lifecycle.ViewModel
+import androidx.credentials.exceptions.CreateCredentialCancellationException
 import androidx.lifecycle.viewModelScope
-import com.afternote.core.datastore.UserProfileDataSource
+import com.afternote.core.common.reporting.ErrorReporter
+import com.afternote.core.common.result.runCatchingCancellable
+import com.afternote.core.domain.repository.UserProfileCacheRepository
+import com.afternote.core.ui.UiText
+import com.afternote.core.ui.mvi.MviViewModel
+import com.afternote.feature.setting.domain.PasskeyRepository
+import com.afternote.feature.setting.presentation.R
 import dagger.hilt.android.lifecycle.HiltViewModel
 import jakarta.inject.Inject
-import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.NonCancellable
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.ensureActive
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import kotlin.coroutines.cancellation.CancellationException
+
+internal sealed interface PasskeyRegistrationResult {
+    data object Success : PasskeyRegistrationResult
+
+    data object Canceled : PasskeyRegistrationResult
+
+    data class Error(
+        val message: UiText,
+    ) : PasskeyRegistrationResult
+}
 
 @HiltViewModel
-class PassKeyViewModel
+internal class PassKeyViewModel
     @Inject
     constructor(
-        private val dataSource: UserProfileDataSource,
-    ) : ViewModel() {
-        val isPasskeyRegistered: StateFlow<Boolean?> =
-            dataSource
-                .isPasskeyRegisteredFlow()
-                .stateIn(viewModelScope, SharingStarted.Eagerly, null)
-
-        fun savePasskeyRegistered() {
-            viewModelScope.launch {
-                dataSource.savePasskeyRegistered(true)
+        private val userProfileCacheRepository: UserProfileCacheRepository,
+        private val passkeyRepository: PasskeyRepository,
+        private val errorReporter: ErrorReporter,
+    ) : MviViewModel<PassKeyIntent, PassKeyUiState, PassKeyReducerEvent>(PassKeyUiState()) {
+        private var registrationJob: Job? = null
+
+        override fun onIntent(intent: PassKeyIntent) {
+            when (intent) {
+                is PassKeyIntent.Register -> {
+                    register(intent.createCredential)
+                }
+
+                PassKeyIntent.CancelRegistration -> {
+                    val canceledJob = registrationJob
+                    registrationJob = null
+                    dispatch(PassKeyReducerEvent.Canceled)
+                    canceledJob?.cancel()
+                }
+
+                is PassKeyIntent.ConsumeResult -> {
+                    dispatch(PassKeyReducerEvent.Consumed(intent.registrationId, intent.result))
+                }
+            }
+        }
+
+        override fun reduce(
+            state: PassKeyUiState,
+            event: PassKeyReducerEvent,
+        ): PassKeyUiState =
+            when (event) {
+                PassKeyReducerEvent.Started -> {
+                    state.copy(isRegistering = true, result = null, registrationId = state.registrationId + 1)
+                }
+
+                is PassKeyReducerEvent.Finished -> {
+                    if (state.registrationId == event.registrationId && state.isRegistering) {
+                        state.copy(isRegistering = false, result = event.result)
+                    } else {
+                        state
+                    }
+                }
+
+                is PassKeyReducerEvent.Stopped -> {
+                    if (state.registrationId == event.registrationId) state.copy(isRegistering = false) else state
+                }
+
+                PassKeyReducerEvent.Canceled -> {
+                    state.copy(isRegistering = false, result = null, registrationId = state.registrationId + 1)
+                }
+
+                is PassKeyReducerEvent.Consumed -> {
+                    if (state.registrationId == event.registrationId && state.result == event.result) state.copy(result = null) else state
+                }
+            }
+
+        private fun register(createCredential: suspend (String) -> String) {
+            if (currentState.isRegistering || currentState.result != null) return
+            dispatch(PassKeyReducerEvent.Started)
+            val registrationId = currentState.registrationId
+            registrationJob =
+                viewModelScope.launch {
+                    try {
+                        registerPasskey(registrationId, createCredential)
+                    } finally {
+                        dispatch(PassKeyReducerEvent.Stopped(registrationId))
+                    }
+                }
+        }
+
+        /** Activity를 가진 화면이 플랫폼 요청을 실행한다. 서버 등록이 성공한 뒤에만 완료 상태를 확정한다. */
+        private suspend fun registerPasskey(
+            registrationId: Long,
+            createCredential: suspend (optionsJson: String) -> String,
+        ) {
+            var stage = STAGE_OPTIONS
+            try {
+                val options = passkeyRepository.getRegistrationOptions()
+                currentCoroutineContext().ensureActive()
+                stage = STAGE_CREDENTIAL
+                val credential = createCredential(options)
+                currentCoroutineContext().ensureActive()
+                stage = STAGE_REGISTER
+                passkeyRepository.registerPasskey(credential)
+                // 서버 성공을 먼저 확정한다. 캐시의 실패나 취소는 재등록을 유도하지 않는다.
+                dispatch(PassKeyReducerEvent.Finished(registrationId, PasskeyRegistrationResult.Success))
+                // 지문 관문이 이 캐시를 본다. 서버에 등록된 뒤에는 화면 이탈·구성 변경으로 job 이 취소돼도
+                // 저장을 끝낸다.
+                withContext(NonCancellable) {
+                    runCatchingCancellable { userProfileCacheRepository.savePasskeyRegistered(true) }
+                        .onFailure { reportFailure(it, STAGE_LOCAL_CACHE) }
+                }
+            } catch (_: CreateCredentialCancellationException) {
+                dispatch(PassKeyReducerEvent.Finished(registrationId, PasskeyRegistrationResult.Canceled))
+            } catch (canceled: CancellationException) {
+                throw canceled
+            } catch (failure: Exception) {
+                reportFailure(failure, stage)
+                dispatch(
+                    PassKeyReducerEvent.Finished(
+                        registrationId,
+                        PasskeyRegistrationResult.Error(
+                            UiText.Resource(
+                                if (stage == STAGE_OPTIONS) {
+                                    R.string.setting_passkey_options_error
+                                } else {
+                                    R.string.setting_passkey_registration_error
+                                },
+                            ),
+                        ),
+                    ),
+                )
             }
         }
+
+        private fun reportFailure(
+            failure: Throwable,
+            stage: String,
+        ) {
+            errorReporter.recordFailure(failure, mapOf("stage" to stage))
+        }
     }
+
+private const val STAGE_OPTIONS = "passkey_registration_options"
+private const val STAGE_CREDENTIAL = "passkey_create_credential"
+private const val STAGE_REGISTER = "passkey_register"
+private const val STAGE_LOCAL_CACHE = "passkey_registration_cache"
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PasskeyRegistrationResult.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PasskeyRegistrationResult.kt
new file mode 100644
index 0000000000..833db41832
--- /dev/null
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/PasskeyRegistrationResult.kt
@@ -0,0 +1,20 @@
+package com.afternote.feature.setting.presentation.passkey
+
+import android.content.Context
+import androidx.credentials.CreatePublicKeyCredentialRequest
+import androidx.credentials.CreatePublicKeyCredentialResponse
+import androidx.credentials.CredentialManager
+
+/** 모든 실패와 취소는 ViewModel의 등록 경계에서 처리한다. */
+internal suspend fun createPasskeyCredential(
+    context: Context,
+    credentialManager: CredentialManager,
+    optionsJson: String,
+): String {
+    val request = CreatePublicKeyCredentialRequest(requestJson = optionsJson)
+    val response = credentialManager.createCredential(context, request)
+    val publicKeyResponse =
+        response as? CreatePublicKeyCredentialResponse
+            ?: error("Credential Manager returned an unexpected credential response type")
+    return publicKeyResponse.registrationResponseJson
+}
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/component/PasskeyListItem.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/component/PasskeyListItem.kt
index c8fbde5ded..6e2a1120fe 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/component/PasskeyListItem.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/passkey/component/PasskeyListItem.kt
@@ -7,18 +7,32 @@ import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
-import androidx.compose.material3.Icon
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.unit.dp
-import com.afternote.core.ui.theme.AfternoteDesign
+import com.afternote.feature.setting.domain.Passkey
 import com.afternote.feature.setting.presentation.R
+import java.time.LocalDateTime
+import java.time.OffsetDateTime
+import java.time.format.DateTimeFormatter
+
+private val passkeyCreatedAtFormatter = DateTimeFormatter.ofPattern("yyyy.MM.dd HH:mm")
+
+private fun formatCreatedAt(raw: String): String =
+    runCatching { OffsetDateTime.parse(raw).format(passkeyCreatedAtFormatter) }
+        .recoverCatching { LocalDateTime.parse(raw).format(passkeyCreatedAtFormatter) }
+        .getOrDefault(raw)
 
 @Composable
-fun PasskeyListItem(modifier: Modifier = Modifier) {
+internal fun PasskeyListItem(
+    passkey: Passkey,
+    modifier: Modifier = Modifier,
+) {
     Row(
         modifier =
             modifier
@@ -26,24 +40,20 @@ fun PasskeyListItem(modifier: Modifier = Modifier) {
                 .padding(horizontal = 20.dp),
         verticalAlignment = Alignment.CenterVertically,
     ) {
-        Image(painterResource(R.drawable.setting_ic_apple_login), contentDescription = "패스키기본")
-        Spacer(modifier = Modifier.weight(1f))
-        Column {
-            Text("이름")
-            Text("생성일시")
+        Image(
+            painter = painterResource(R.drawable.setting_ic_fingerprint),
+            contentDescription = null,
+            modifier = Modifier.size(40.dp),
+        )
+        Spacer(modifier = Modifier.width(16.dp))
+        Column(modifier = Modifier.weight(1f)) {
+            Text(passkey.displayName)
+            Text(formatCreatedAt(passkey.createdAt))
         }
-        Spacer(modifier = Modifier.weight(1f))
+        Spacer(modifier = Modifier.width(12.dp))
         Box {
-            Icon(
-                painter = painterResource(R.drawable.setting_ic_vector1),
-                contentDescription = "왼쪽 막대기",
-                tint = AfternoteDesign.colors.gray5,
-            )
-            Icon(
-                painter = painterResource(R.drawable.setting_ic_vector2),
-                contentDescription = "오른쪽 막대기",
-                tint = AfternoteDesign.colors.gray5,
-            )
+            Image(painterResource(R.drawable.setting_ic_vector1), contentDescription = "왼쪽 막대기")
+            Image(painterResource(R.drawable.setting_ic_vector2), contentDescription = "오른쪽 막대기")
         }
     }
 }
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/password/PasswordChangeContent.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/password/PasswordChangeContent.kt
index 24b699a0ec..d43e9cf127 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/password/PasswordChangeContent.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/password/PasswordChangeContent.kt
@@ -21,10 +21,12 @@ import androidx.compose.ui.text.input.KeyboardType
 import androidx.compose.ui.unit.dp
 import com.afternote.core.ui.AfternoteTextField
 import com.afternote.core.ui.asString
+import com.afternote.core.ui.auth.PasswordRuleItem
 import com.afternote.core.ui.mvi.ObserveSignal
 import com.afternote.core.ui.scaffold.FlowStepScaffold
 import com.afternote.core.ui.theme.AfternoteDesign
 import com.afternote.feature.setting.presentation.R
+import com.afternote.core.ui.R as CoreUiR
 
 /**
  * 비밀번호 변경 화면의 상태 없는 본문.
@@ -101,16 +103,9 @@ internal fun PasswordChangeContent(
                 onImeAction = { onIntent(PasswordChangeIntent.Submit) },
             )
 
-            Text(
-                text = stringResource(R.string.setting_password_change_rule),
-                modifier = Modifier.fillMaxWidth(),
-                style = AfternoteDesign.typography.captionLargeB,
-                color =
-                    if (uiState.isNewPasswordRuleSatisfied) {
-                        AfternoteDesign.colors.b1
-                    } else {
-                        AfternoteDesign.colors.gray5
-                    },
+            PasswordRuleItem(
+                text = stringResource(CoreUiR.string.core_ui_password_rule_combination),
+                isSatisfied = uiState.isNewPasswordRuleSatisfied,
             )
 
             uiState.errorMessage?.let { message ->
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/password/PasswordChangeUiState.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/password/PasswordChangeUiState.kt
index 5810bed96c..c0ee79e6d4 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/password/PasswordChangeUiState.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/password/PasswordChangeUiState.kt
@@ -1,5 +1,6 @@
 package com.afternote.feature.setting.presentation.password
 
+import com.afternote.core.domain.auth.NewPasswordRule
 import com.afternote.core.ui.UiText
 import com.afternote.core.ui.mvi.MviIntent
 import com.afternote.core.ui.mvi.ReducerEvent
@@ -25,13 +26,13 @@ internal data class PasswordChangeUiState(
     /** 변경 완료 신호. 화면이 한 번 소비하고 [PasswordChangeIntent.ConsumeChanged] 로 되돌린다(#228). */
     val changed: PasswordChanged? = null,
 ) : UiState {
-    val isNewPasswordRuleSatisfied: Boolean get() = SettingPasswordRule.isSatisfied(newPassword)
+    val isNewPasswordRuleSatisfied: Boolean get() = NewPasswordRule.isSatisfied(newPassword)
 
     /**
      * 제출 가능 여부.
      *
      * 현재 비밀번호는 비어 있지만 않으면 된다 — 규칙 검사를 걸면 옛 규칙으로 만든 비밀번호를 쓰는
-     * 계정이 변경 자체를 못 한다([SettingPasswordRule]). 새 비밀번호가 현재와 같은지는 서버만
+     * 계정이 변경 자체를 못 한다([NewPasswordRule]). 새 비밀번호가 현재와 같은지는 서버만
      * 판정할 수 있다(BE `NEWPASSWORD_MATCH`) — 클라는 현재 비밀번호의 평문을 비교 근거로 삼지 않는다.
      */
     val isSubmitEnabled: Boolean
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/password/SettingPasswordRule.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/password/SettingPasswordRule.kt
deleted file mode 100644
index 9603577ca6..0000000000
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/password/SettingPasswordRule.kt
+++ /dev/null
@@ -1,30 +0,0 @@
-package com.afternote.feature.setting.presentation.password
-
-/**
- * 설정의 비밀번호 변경이 **새 비밀번호** 에 요구하는 조합 규칙.
- *
- * **서버 규칙과 같다.** BE `domain/auth/dto/PasswordValidation.REGEX` 를 그대로 옮겼다(2026-09-13
- * Afternote-BE main 실코드 확인) — 영문·숫자·허용 특수문자(`@ $ ! % * # ? &`)를 각각 하나 이상
- * 포함하고, 전체 문자는 그 ASCII 허용 목록 안에서만 8~15자여야 한다. 서버는 이 상수 하나를
- * `SignupRequest`·`PasswordChangeRequest`·`PasswordFindRequest` 세 곳에 `@Pattern` 으로 걸고
- * 컨트롤러 진입 전에 거절하므로, 클라가 더 넓으면 사용자는 조건 충족 표시를 다 받고 제출에서 400 을 맞는다.
- *
- * Android 정규식의 `\d` 는 Unicode 숫자까지 포함해 전각 `１`·아라비아-인도 `١` 을 통과시킨다.
- * 서버 JVM 의 기본 판정과 갈리지 않도록 숫자를 `[0-9]` 로 명시한다(#1628).
- *
- * ### 온보딩의 `OnboardingPasswordRule` 과 사본이 둘이다
- * #1644 는 「규칙 사본은 한 곳」을 목표로 두었고 그때 설정의 비밀번호 변경은 화면·호출부가 없어
- * 대상이 아니었다. 지금 그 소비처가 생겼지만 온보딩 쪽 객체는 `feature:onboarding:presentation`
- * 의 `internal` 이라 모듈 밖에서 쓸 수 없고, 공용 자리로 옮기는 일은 남의 모듈 프로덕션을 고치는
- * 일이라 이 변경의 범위 밖이다. 값을 고칠 땐 **BE 실코드를 정본으로** 두 사본을 함께 고친다.
- *
- * 현재 비밀번호에는 이 규칙을 걸지 않는다 — 옛 규칙으로 만든 비밀번호가 그대로 살아 있을 수 있어
- * 클라가 막으면 변경 자체가 불가능해진다(로그인에 규칙을 걸지 않는 것과 같은 판단).
- */
-internal object SettingPasswordRule {
-    /** 8~15자, 영문·숫자·허용 특수문자 8종 각 1개 이상, 그 밖의 문자는 금지. */
-    private val REGEX =
-        Regex("^(?=.*[A-Za-z])(?=.*[0-9])(?=.*[@$!%*#?&])[A-Za-z0-9@$!%*#?&]{8,15}$")
-
-    fun isSatisfied(password: String): Boolean = REGEX.matches(password)
-}
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditContract.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditContract.kt
new file mode 100644
index 0000000000..597b2b1813
--- /dev/null
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditContract.kt
@@ -0,0 +1,51 @@
+package com.afternote.feature.setting.presentation.profile
+
+import com.afternote.core.ui.mvi.MviIntent
+import com.afternote.core.ui.mvi.ReducerEvent
+
+internal sealed interface ProfileEditIntent : MviIntent {
+    data object RefreshOnReturn : ProfileEditIntent
+
+    data object RetryLoad : ProfileEditIntent
+
+    data class SelectPhoto(
+        val uri: String,
+    ) : ProfileEditIntent
+
+    data class UpdateProfile(
+        val name: String,
+        val phone: String,
+    ) : ProfileEditIntent
+
+    /** 화면이 처리한 [event] 를 되돌려준다. 그사이 다른 신호가 올라왔으면 그 신호는 남는다. */
+    data class ConsumeEvent(
+        val event: ProfileEditEvent,
+    ) : ProfileEditIntent
+}
+
+internal sealed interface ProfileEditReducerEvent : ReducerEvent {
+    data object Loading : ProfileEditReducerEvent
+
+    data class Loaded(
+        val name: String,
+        val phone: String,
+        val email: String,
+        val profileImageUrl: String?,
+    ) : ProfileEditReducerEvent
+
+    data class PhotoSelected(
+        val uri: String,
+    ) : ProfileEditReducerEvent
+
+    data object LoadFailed : ProfileEditReducerEvent
+
+    data object Updating : ProfileEditReducerEvent
+
+    data object UpdateSucceeded : ProfileEditReducerEvent
+
+    data object UpdateFailed : ProfileEditReducerEvent
+
+    data class EventConsumed(
+        val event: ProfileEditEvent,
+    ) : ProfileEditReducerEvent
+}
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditScreen.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditScreen.kt
index 5bb9aff051..7d0ef15cf3 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditScreen.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditScreen.kt
@@ -1,5 +1,9 @@
 package com.afternote.feature.setting.presentation.profile
 
+import android.net.Uri
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.PickVisualMediaRequest
+import androidx.activity.result.contract.ActivityResultContracts.PickVisualMedia
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
@@ -12,48 +16,103 @@ import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.text.input.InputTransformation
 import androidx.compose.foundation.text.input.rememberTextFieldState
+import androidx.compose.foundation.text.input.setTextAndPlaceCursorAtEnd
 import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.HorizontalDivider
 import androidx.compose.material3.Scaffold
+import androidx.compose.material3.SnackbarHost
+import androidx.compose.material3.SnackbarHostState
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.input.KeyboardType
 import androidx.compose.ui.unit.dp
 import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.compose.LifecycleEventEffect
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.afternote.core.ui.AfternoteTextField
+import com.afternote.core.ui.ProfileImagePicker
 import com.afternote.core.ui.button.AfternoteButton
 import com.afternote.core.ui.button.AfternoteButtonType
+import com.afternote.core.ui.mvi.ObserveSignal
 import com.afternote.core.ui.theme.AfternoteDesign
 import com.afternote.core.ui.topbar.DetailTopBar
 import com.afternote.feature.setting.presentation.R
-import com.afternote.feature.setting.presentation.shared.component.ProfilePhotoWithAddBadge
+import com.afternote.feature.setting.presentation.receiver.ReceiverPhoneValidation
+import com.afternote.feature.setting.presentation.receiver.validateReceiverPhone
+import com.afternote.feature.setting.presentation.shared.component.SettingLoadErrorContent
+import kotlinx.coroutines.launch
 
 @Composable
-fun ProfileEditScreen(
+internal fun ProfileEditScreen(
     onBackClick: () -> Unit,
     onWithdrawGuideClick: () -> Unit,
     modifier: Modifier = Modifier,
     viewModel: ProfileEditViewModel = hiltViewModel(),
 ) {
     val uiState by viewModel.uiState.collectAsStateWithLifecycle()
-    val currentOnBackClick by rememberUpdatedState(onBackClick)
+    LifecycleEventEffect(Lifecycle.Event.ON_RESUME) { viewModel.onIntent(ProfileEditIntent.RefreshOnReturn) }
+    val snackbarHostState = remember { SnackbarHostState() }
+    val feedbackScope = rememberCoroutineScope()
+    val updateFailedMessage = stringResource(R.string.setting_profile_update_error)
+    val onPickProfileImage =
+        rememberProfileImagePicker(
+            canAcceptPhoto = (uiState as? ProfileEditUiState.Success)?.isUpdating == false,
+            onPhotoPicked = { viewModel.onIntent(ProfileEditIntent.SelectPhoto(it)) },
+        )
 
-    LaunchedEffect(Unit) {
-        viewModel.events.collect { event ->
+    (uiState as? ProfileEditUiState.Success)?.pendingEvent?.let { pendingEvent ->
+        ObserveSignal(
+            signal = pendingEvent,
+            // 소비 Intent 에 처리한 신호를 실어, 늦게 도착한 소비가 새로 올라온 다른 신호를 지우지 않게 한다.
+            consumed = ProfileEditIntent.ConsumeEvent(pendingEvent),
+            onIntent = viewModel::onIntent,
+        ) { event ->
             when (event) {
-                ProfileEditEvent.UpdateSuccess -> currentOnBackClick()
-                ProfileEditEvent.UpdateFailure -> Unit
+                ProfileEditEvent.UpdateSuccess -> {
+                    onBackClick()
+                }
+
+                ProfileEditEvent.UpdateFailure -> {
+                    feedbackScope.launch { snackbarHostState.showSnackbar(updateFailedMessage) }
+                }
             }
         }
     }
 
+    ProfileEditContent(
+        snackbarHostState = snackbarHostState,
+        uiState = uiState,
+        onPickImageClick = onPickProfileImage,
+        onIntent = viewModel::onIntent,
+        onBackClick = onBackClick,
+        onWithdrawGuideClick = onWithdrawGuideClick,
+        modifier = modifier,
+    )
+}
+
+@Composable
+private fun ProfileEditContent(
+    snackbarHostState: SnackbarHostState,
+    uiState: ProfileEditUiState,
+    onPickImageClick: () -> Unit,
+    onIntent: (ProfileEditIntent) -> Unit,
+    onBackClick: () -> Unit,
+    onWithdrawGuideClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
     Scaffold(
         topBar = {
             DetailTopBar(
@@ -63,6 +122,7 @@ fun ProfileEditScreen(
         },
         modifier = modifier,
         containerColor = Color.Transparent,
+        snackbarHost = { SnackbarHost(snackbarHostState) },
     ) { innerPadding ->
         when (val state = uiState) {
             is ProfileEditUiState.Loading -> {
@@ -80,22 +140,19 @@ fun ProfileEditScreen(
             is ProfileEditUiState.Success -> {
                 ProfileEditForm(
                     state = state,
-                    onUpdateClick = viewModel::updateProfile,
+                    onPickImageClick = onPickImageClick,
+                    onUpdateClick = { name, phone -> onIntent(ProfileEditIntent.UpdateProfile(name, phone)) },
                     onWithdrawGuideClick = onWithdrawGuideClick,
                     modifier = Modifier.padding(innerPadding),
                 )
             }
 
             is ProfileEditUiState.Error -> {
-                Box(
-                    modifier =
-                        Modifier
-                            .fillMaxSize()
-                            .padding(innerPadding),
-                    contentAlignment = Alignment.Center,
-                ) {
-                    Text(text = "프로필을 불러올 수 없습니다.")
-                }
+                SettingLoadErrorContent(
+                    message = stringResource(R.string.setting_profile_load_error),
+                    onRetry = { onIntent(ProfileEditIntent.RetryLoad) },
+                    modifier = Modifier.padding(innerPadding),
+                )
             }
         }
     }
@@ -104,6 +161,7 @@ fun ProfileEditScreen(
 @Composable
 private fun ProfileEditForm(
     state: ProfileEditUiState.Success,
+    onPickImageClick: () -> Unit,
     onUpdateClick: (name: String, phone: String) -> Unit,
     onWithdrawGuideClick: () -> Unit,
     modifier: Modifier = Modifier,
@@ -111,6 +169,21 @@ private fun ProfileEditForm(
     val nameState = rememberTextFieldState(initialText = state.name)
     val phoneState = rememberTextFieldState(initialText = state.phone)
     val emailState = rememberTextFieldState(initialText = state.email)
+    var previousName by rememberSaveable { mutableStateOf(state.name) }
+    var previousPhone by rememberSaveable { mutableStateOf(state.phone) }
+    LaunchedEffect(state.name, state.phone, state.email) {
+        // 편집하지 않은 필드만 새 서버 값으로 바꾸고 입력 중인 값과 커서를 보존한다.
+        if (nameState.text.toString() == previousName && previousName != state.name) {
+            nameState.setTextAndPlaceCursorAtEnd(state.name)
+        }
+        if (phoneState.text.toString() == previousPhone && previousPhone != state.phone) {
+            phoneState.setTextAndPlaceCursorAtEnd(state.phone)
+        }
+        if (emailState.text.toString() != state.email) emailState.setTextAndPlaceCursorAtEnd(state.email)
+        previousName = state.name
+        previousPhone = state.phone
+    }
+    val isPhoneInvalid = phoneState.text.toString().validateReceiverPhone(isRequired = false) != ReceiverPhoneValidation.VALID
 
     LazyColumn(
         modifier = modifier.fillMaxSize(),
@@ -123,7 +196,10 @@ private fun ProfileEditForm(
                         .padding(top = 50.dp),
                 contentAlignment = Alignment.Center,
             ) {
-                ProfilePhotoWithAddBadge()
+                ProfileImagePicker(
+                    onPickClick = onPickImageClick,
+                    displayImageUri = state.displayImageUri,
+                )
             }
         }
         item {
@@ -160,8 +236,18 @@ private fun ProfileEditForm(
                 AfternoteTextField(
                     state = phoneState,
                     placeholder = "연락처를 지정해주세요",
+                    keyboardType = KeyboardType.Phone,
+                    isError = isPhoneInvalid,
                     modifier = Modifier.fillMaxWidth(),
                 )
+                if (isPhoneInvalid) {
+                    Spacer(modifier = Modifier.height(6.dp))
+                    Text(
+                        text = stringResource(R.string.setting_receiver_phone_invalid),
+                        style = AfternoteDesign.typography.captionLargeR,
+                        color = AfternoteDesign.colors.error,
+                    )
+                }
             }
         }
         item {
@@ -186,7 +272,7 @@ private fun ProfileEditForm(
             AfternoteButton(
                 text = "수정하기",
                 onClick = { onUpdateClick(nameState.text.toString(), phoneState.text.toString()) },
-                type = if (state.isUpdating) AfternoteButtonType.Un else AfternoteButtonType.Default,
+                type = if (state.isUpdateLocked || isPhoneInvalid) AfternoteButtonType.Un else AfternoteButtonType.Default,
                 modifier =
                     Modifier
                         .padding(horizontal = 20.dp)
@@ -214,3 +300,38 @@ private fun ProfileEditForm(
         }
     }
 }
+
+/**
+ * 갤러리 사진 선택기를 등록하고, 누르면 띄우는 함수를 돌려준다.
+ *
+ * 온보딩 프로필 화면과 같이 갤러리 전용이다(`PickVisualMedia.ImageOnly`). 취소 결과(`null`)는 선택
+ * 변경이 아니라서 기존 사진을 그대로 둔다(온보딩 #1113·#1115 와 같은 처리).
+ *
+ * 돌아온 사진은 [canAcceptPhoto] 가 참일 때까지 [rememberSaveable] 에 보관했다가 넘긴다. 갤러리에
+ * 다녀오는 사이 프로세스가 회수되면 결과가 새 ViewModel 의 프로필 조회보다 먼저 도착하고, 저장 중에
+ * 돌아온 결과는 ViewModel 이 받지 않기 때문이다. 바로 넘기면 두 경우 모두 고른 사진이 사라진다.
+ */
+@Composable
+private fun rememberProfileImagePicker(
+    canAcceptPhoto: Boolean,
+    onPhotoPicked: (String) -> Unit,
+): () -> Unit {
+    val queuedPhoto = rememberSaveable { mutableStateOf<String?>(null) }
+    val currentOnPhotoPicked by rememberUpdatedState(onPhotoPicked)
+
+    LaunchedEffect(queuedPhoto.value, canAcceptPhoto) {
+        val uri = queuedPhoto.value
+        if (uri != null && canAcceptPhoto) {
+            queuedPhoto.value = null
+            currentOnPhotoPicked(uri)
+        }
+    }
+
+    val launcher =
+        rememberLauncherForActivityResult(PickVisualMedia()) { uri: Uri? ->
+            uri?.let { queuedPhoto.value = it.toString() }
+        }
+    return remember(launcher) {
+        { launcher.launch(PickVisualMediaRequest(PickVisualMedia.ImageOnly)) }
+    }
+}
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditUiState.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditUiState.kt
index bc4fbf71d1..06a7a6efda 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditUiState.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditUiState.kt
@@ -1,19 +1,36 @@
 package com.afternote.feature.setting.presentation.profile
 
-sealed interface ProfileEditUiState {
+import com.afternote.core.ui.mvi.UiState
+
+internal sealed interface ProfileEditUiState : UiState {
     data object Loading : ProfileEditUiState
 
+    /**
+     * @param profileImageUrl 서버가 내려준 표시용 프로필 사진 주소. 아직 사진이 없으면 널이다.
+     * @param selectedImageUri 이 화면에서 고르기만 하고 아직 저장하지 않은 사진의 content URI.
+     *   저장이 성공하기 전까지 서버 사진은 건드리지 않는다. 선택 취소나 저장 실패가 기존 사진을
+     *   지우지 않는 자리다(#1438).
+     */
     data class Success(
         val name: String,
         val phone: String,
         val email: String,
+        val profileImageUrl: String? = null,
+        val selectedImageUri: String? = null,
         val isUpdating: Boolean = false,
-    ) : ProfileEditUiState
+        /** 수정을 마쳤다는 사실. 소비되는 [pendingEvent] 와 달리 되돌리지 않아, 화면이 닫히는 동안에도 재제출을 막는다. */
+        val isUpdated: Boolean = false,
+        val pendingEvent: ProfileEditEvent? = null,
+    ) : ProfileEditUiState {
+        /** 아바타에 그릴 사진. 저장 전 선택이 서버 사진보다 앞선다. */
+        val displayImageUri: String? get() = selectedImageUri ?: profileImageUrl
+        val isUpdateLocked: Boolean get() = isUpdating || isUpdated
+    }
 
     data object Error : ProfileEditUiState
 }
 
-sealed interface ProfileEditEvent {
+internal sealed interface ProfileEditEvent {
     data object UpdateSuccess : ProfileEditEvent
 
     data object UpdateFailure : ProfileEditEvent
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditViewModel.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditViewModel.kt
index 6fabdd2988..0e2b19fdf9 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditViewModel.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditViewModel.kt
@@ -1,68 +1,149 @@
 package com.afternote.feature.setting.presentation.profile
 
-import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.afternote.core.domain.repository.MyProfileRepository
+import com.afternote.core.domain.repository.PhotoUploadRepository
+import com.afternote.core.domain.result.runCatchingCancellable
+import com.afternote.core.ui.mvi.MviViewModel
+import com.afternote.feature.setting.presentation.receiver.ReceiverPhoneValidation
+import com.afternote.feature.setting.presentation.receiver.validateReceiverPhone
 import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.receiveAsFlow
-import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.launch
 import javax.inject.Inject
 
+private const val PROFILE_UPLOAD_DIRECTORY = "profiles"
+
 @HiltViewModel
-class ProfileEditViewModel
+internal class ProfileEditViewModel
     @Inject
     constructor(
         private val myProfileRepository: MyProfileRepository,
-    ) : ViewModel() {
-        private val _uiState = MutableStateFlow<ProfileEditUiState>(ProfileEditUiState.Loading)
-        val uiState = _uiState.asStateFlow()
-
-        private val _events = Channel<ProfileEditEvent>(Channel.BUFFERED)
-        val events = _events.receiveAsFlow()
+        private val photoUploadRepository: PhotoUploadRepository,
+    ) : MviViewModel<ProfileEditIntent, ProfileEditUiState, ProfileEditReducerEvent>(ProfileEditUiState.Loading) {
+        private var loadJob: Job? = null
+        private var isFirstResume = true
 
         init {
             loadProfile()
         }
 
-        private fun loadProfile() {
-            viewModelScope.launch {
-                runCatching { myProfileRepository.getMyProfile() }
-                    .onSuccess { user ->
-                        _uiState.value =
-                            ProfileEditUiState.Success(
-                                name = user.name,
-                                phone = user.phone.orEmpty(),
-                                email = user.email,
-                            )
-                    }.onFailure {
-                        _uiState.value = ProfileEditUiState.Error
+        override fun onIntent(intent: ProfileEditIntent) {
+            when (intent) {
+                ProfileEditIntent.RefreshOnReturn -> refreshOnReturn()
+                ProfileEditIntent.RetryLoad -> if (currentState == ProfileEditUiState.Error) loadProfile()
+                is ProfileEditIntent.SelectPhoto -> dispatch(ProfileEditReducerEvent.PhotoSelected(intent.uri))
+                is ProfileEditIntent.UpdateProfile -> updateProfile(intent.name, intent.phone)
+                is ProfileEditIntent.ConsumeEvent -> dispatch(ProfileEditReducerEvent.EventConsumed(intent.event))
+            }
+        }
+
+        override fun reduce(
+            state: ProfileEditUiState,
+            event: ProfileEditReducerEvent,
+        ): ProfileEditUiState =
+            when (event) {
+                ProfileEditReducerEvent.Loading -> {
+                    ProfileEditUiState.Loading
+                }
+
+                is ProfileEditReducerEvent.Loaded -> {
+                    ProfileEditUiState.Success(
+                        name = event.name,
+                        phone = event.phone,
+                        email = event.email,
+                        profileImageUrl = event.profileImageUrl,
+                        selectedImageUri = (state as? ProfileEditUiState.Success)?.selectedImageUri,
+                        pendingEvent = (state as? ProfileEditUiState.Success)?.pendingEvent,
+                    )
+                }
+
+                is ProfileEditReducerEvent.PhotoSelected -> {
+                    state.updateSuccess { if (it.isUpdating) it else it.copy(selectedImageUri = event.uri) }
+                }
+
+                ProfileEditReducerEvent.LoadFailed -> {
+                    ProfileEditUiState.Error
+                }
+
+                ProfileEditReducerEvent.Updating -> {
+                    state.updateSuccess { it.copy(isUpdating = true, pendingEvent = null) }
+                }
+
+                ProfileEditReducerEvent.UpdateSucceeded -> {
+                    state.updateSuccess {
+                        it.copy(isUpdating = false, isUpdated = true, pendingEvent = ProfileEditEvent.UpdateSuccess)
                     }
+                }
+
+                ProfileEditReducerEvent.UpdateFailed -> {
+                    state.updateSuccess { it.copy(isUpdating = false, pendingEvent = ProfileEditEvent.UpdateFailure) }
+                }
+
+                is ProfileEditReducerEvent.EventConsumed -> {
+                    state.updateSuccess { if (it.pendingEvent == event.event) it.copy(pendingEvent = null) else it }
+                }
             }
+
+        private fun refreshOnReturn() {
+            if (isFirstResume) {
+                isFirstResume = false
+                return
+            }
+            loadProfile(isAutomatic = true)
         }
 
-        fun updateProfile(
+        private fun loadProfile(isAutomatic: Boolean = false) {
+            if (loadJob?.isActive == true || (currentState as? ProfileEditUiState.Success)?.isUpdating == true) return
+            if (!isAutomatic) dispatch(ProfileEditReducerEvent.Loading)
+            loadJob =
+                viewModelScope.launch {
+                    runCatchingCancellable { myProfileRepository.getMyProfile() }
+                        .onSuccess { user ->
+                            dispatch(
+                                ProfileEditReducerEvent.Loaded(
+                                    name = user.name,
+                                    phone = user.phone.orEmpty(),
+                                    email = user.email,
+                                    profileImageUrl = user.profileImageUrl,
+                                ),
+                            )
+                        }.onFailure {
+                            if (!isAutomatic || currentState !is ProfileEditUiState.Success) dispatch(ProfileEditReducerEvent.LoadFailed)
+                        }
+                }
+        }
+
+        private fun updateProfile(
             name: String,
             phone: String,
         ) {
-            val current = _uiState.value as? ProfileEditUiState.Success ?: return
-            _uiState.update { current.copy(isUpdating = true) }
+            val current = currentState as? ProfileEditUiState.Success ?: return
+            if (current.isUpdateLocked) return
+            if (phone.validateReceiverPhone(isRequired = false) != ReceiverPhoneValidation.VALID) return
+            loadJob?.cancel()
+            dispatch(ProfileEditReducerEvent.Updating)
             viewModelScope.launch {
-                runCatching {
+                runCatchingCancellable {
+                    val uploadedKey =
+                        current.selectedImageUri?.let { uri ->
+                            photoUploadRepository.upload(uri, PROFILE_UPLOAD_DIRECTORY).getOrThrow().fileKey
+                        }
                     myProfileRepository.updateMyProfile(
                         name = name.takeIf { it.isNotBlank() },
                         phone = phone.takeIf { it.isNotBlank() },
-                        profileImageUrl = null,
+                        // 서버는 표시용 URL 대신 업로드 키를 받아 승격한다. 널이면 기존 사진을 유지한다.
+                        profileImageUrl = uploadedKey,
                     )
                 }.onSuccess {
-                    _events.send(ProfileEditEvent.UpdateSuccess)
+                    dispatch(ProfileEditReducerEvent.UpdateSucceeded)
                 }.onFailure {
-                    _uiState.update { current.copy(isUpdating = false) }
-                    _events.send(ProfileEditEvent.UpdateFailure)
+                    dispatch(ProfileEditReducerEvent.UpdateFailed)
                 }
             }
         }
     }
+
+private inline fun ProfileEditUiState.updateSuccess(
+    transform: (ProfileEditUiState.Success) -> ProfileEditUiState.Success,
+): ProfileEditUiState = if (this is ProfileEditUiState.Success) transform(this) else this
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverEditContent.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverEditContent.kt
index 12791f9ea6..67334bc8d1 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverEditContent.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverEditContent.kt
@@ -31,10 +31,12 @@ internal fun ReceiverEditContent(
             title = "수신자 수정",
             actionText = "수정",
             isPhoneRequired = true,
-            isLoading = uiState.isSaving,
+            isActionLocked = uiState.isSaveLocked,
             errorMessage = uiState.errorMessage,
             onBackClick = onBackClick,
             onRegister = onRegister,
+            // 초대는 새 수신자를 만드는 흐름이라 수정 화면엔 없다.
+            onInviteClick = null,
             modifier = modifier,
             initialName = receiver.name,
             initialRelation = receiver.relation,
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverEditContract.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverEditContract.kt
new file mode 100644
index 0000000000..d3d586e4bc
--- /dev/null
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverEditContract.kt
@@ -0,0 +1,43 @@
+package com.afternote.feature.setting.presentation.receiver
+
+import com.afternote.core.model.user.ReceiverDetail
+import com.afternote.core.ui.UiText
+import com.afternote.core.ui.mvi.MviIntent
+import com.afternote.core.ui.mvi.ReducerEvent
+
+internal sealed interface ReceiverEditIntent : MviIntent {
+    data class Update(
+        val name: String,
+        val relation: String,
+        val phone: String,
+        val email: String,
+        val message: String,
+    ) : ReceiverEditIntent
+
+    data object ConsumeSuccess : ReceiverEditIntent
+}
+
+internal sealed interface ReceiverEditReducerEvent : ReducerEvent {
+    data class Loaded(
+        val receiver: ReceiverDetail,
+    ) : ReceiverEditReducerEvent
+
+    data class LoadFailed(
+        val message: UiText,
+    ) : ReceiverEditReducerEvent
+
+    /** 요청을 보내기 전의 입력 형식 검증 실패. 서버 저장 실패([SaveFailed])와 구분한다. */
+    data class ValidationFailed(
+        val message: UiText,
+    ) : ReceiverEditReducerEvent
+
+    data object Saving : ReceiverEditReducerEvent
+
+    data object Saved : ReceiverEditReducerEvent
+
+    data class SaveFailed(
+        val message: UiText,
+    ) : ReceiverEditReducerEvent
+
+    data object SuccessConsumed : ReceiverEditReducerEvent
+}
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverEditScreen.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverEditScreen.kt
index 96280cd46d..4bfae88406 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverEditScreen.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverEditScreen.kt
@@ -1,11 +1,10 @@
 package com.afternote.feature.setting.presentation.receiver
 
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
-import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.ui.Modifier
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.afternote.core.ui.mvi.ObserveSignal
 
 @Composable
 internal fun ReceiverEditScreen(
@@ -15,20 +14,19 @@ internal fun ReceiverEditScreen(
     modifier: Modifier = Modifier,
 ) {
     val uiState by viewModel.uiState.collectAsStateWithLifecycle()
-    val currentOnEditSuccess by rememberUpdatedState(onEditSuccess)
-
-    LaunchedEffect(Unit) {
-        viewModel.events.collect { event ->
-            when (event) {
-                ReceiverEditEvent.EditSuccess -> currentOnEditSuccess()
-            }
-        }
-    }
+    ObserveSignal(
+        signal = uiState.pendingEvent,
+        consumed = ReceiverEditIntent.ConsumeSuccess,
+        onIntent = viewModel::onIntent,
+        onSignal = { onEditSuccess() },
+    )
 
     ReceiverEditContent(
         uiState = uiState,
         onBackClick = onBackClick,
-        onRegister = viewModel::update,
+        onRegister = { name, relation, phone, email, message ->
+            viewModel.onIntent(ReceiverEditIntent.Update(name, relation, phone, email, message))
+        },
         modifier = modifier,
     )
 }
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverEditUiState.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverEditUiState.kt
index 376bb44a08..76d436b7c5 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverEditUiState.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverEditUiState.kt
@@ -2,14 +2,20 @@ package com.afternote.feature.setting.presentation.receiver
 
 import com.afternote.core.model.user.ReceiverDetail
 import com.afternote.core.ui.UiText
+import com.afternote.core.ui.mvi.UiState
 
-data class ReceiverEditUiState(
+internal data class ReceiverEditUiState(
     val isLoading: Boolean = true,
     val isSaving: Boolean = false,
+    /** 저장을 마쳤다는 사실. 소비되는 [pendingEvent] 와 달리 되돌리지 않아, 화면이 닫히는 동안에도 재제출을 막는다. */
+    val isSaved: Boolean = false,
     val receiver: ReceiverDetail? = null,
     val errorMessage: UiText? = null,
-)
+    val pendingEvent: ReceiverEditEvent? = null,
+) : UiState {
+    val isSaveLocked: Boolean get() = isSaving || isSaved
+}
 
-sealed interface ReceiverEditEvent {
+internal sealed interface ReceiverEditEvent {
     data object EditSuccess : ReceiverEditEvent
 }
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverEditViewModel.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverEditViewModel.kt
index 7c190f0cbb..5cf492243b 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverEditViewModel.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverEditViewModel.kt
@@ -1,21 +1,18 @@
 package com.afternote.feature.setting.presentation.receiver
 
-import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
-import com.afternote.core.common.result.runCatchingCancellable
 import com.afternote.core.domain.repository.UserReceiverRepository
+import com.afternote.core.domain.result.runCatchingCancellable
 import com.afternote.core.ui.UiText
+import com.afternote.core.ui.mvi.MviViewModel
+import com.afternote.feature.setting.domain.UpdateReceiverInfoResult
+import com.afternote.feature.setting.domain.UpdateReceiverInfoUseCase
 import com.afternote.feature.setting.presentation.R
 import com.afternote.feature.setting.presentation.navigation.SettingRoute
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
 import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.receiveAsFlow
-import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 
 /**
@@ -28,14 +25,30 @@ internal class ReceiverEditViewModel
     constructor(
         @Assisted route: SettingRoute.RecipientEditRoute,
         private val receiverRepository: UserReceiverRepository,
-    ) : ViewModel() {
+        private val updateReceiverInfo: UpdateReceiverInfoUseCase,
+    ) : MviViewModel<ReceiverEditIntent, ReceiverEditUiState, ReceiverEditReducerEvent>(ReceiverEditUiState()) {
         private val receiverId = route.receiverId
 
-        private val _uiState = MutableStateFlow(ReceiverEditUiState())
-        val uiState = _uiState.asStateFlow()
+        override fun onIntent(intent: ReceiverEditIntent) {
+            when (intent) {
+                is ReceiverEditIntent.Update -> update(intent.name, intent.relation, intent.phone, intent.email, intent.message)
+                ReceiverEditIntent.ConsumeSuccess -> dispatch(ReceiverEditReducerEvent.SuccessConsumed)
+            }
+        }
 
-        private val _events = Channel<ReceiverEditEvent>(Channel.BUFFERED)
-        val events = _events.receiveAsFlow()
+        override fun reduce(
+            state: ReceiverEditUiState,
+            event: ReceiverEditReducerEvent,
+        ): ReceiverEditUiState =
+            when (event) {
+                is ReceiverEditReducerEvent.Loaded -> state.copy(isLoading = false, receiver = event.receiver)
+                is ReceiverEditReducerEvent.LoadFailed -> state.copy(isLoading = false, errorMessage = event.message)
+                is ReceiverEditReducerEvent.ValidationFailed -> state.copy(errorMessage = event.message)
+                ReceiverEditReducerEvent.Saving -> state.copy(isSaving = true, errorMessage = null)
+                ReceiverEditReducerEvent.Saved -> state.copy(isSaving = false, isSaved = true, pendingEvent = ReceiverEditEvent.EditSuccess)
+                is ReceiverEditReducerEvent.SaveFailed -> state.copy(isSaving = false, errorMessage = event.message)
+                ReceiverEditReducerEvent.SuccessConsumed -> state.copy(pendingEvent = null)
+            }
 
         init {
             loadReceiver()
@@ -45,25 +58,23 @@ internal class ReceiverEditViewModel
             viewModelScope.launch {
                 runCatchingCancellable { receiverRepository.getReceiverDetail(receiverId) }
                     .onSuccess { receiver ->
-                        _uiState.update { it.copy(isLoading = false, receiver = receiver) }
+                        dispatch(ReceiverEditReducerEvent.Loaded(receiver))
                     }.onFailure {
-                        _uiState.update {
-                            it.copy(isLoading = false, errorMessage = UiText.Resource(R.string.setting_receiver_load_failed))
-                        }
+                        dispatch(ReceiverEditReducerEvent.LoadFailed(UiText.Resource(R.string.setting_receiver_load_failed)))
                     }
             }
         }
 
-        fun update(
+        private fun update(
             name: String,
             relation: String,
             phone: String,
             email: String,
             message: String,
         ) {
-            if (_uiState.value.isSaving) return
+            if (currentState.isSaveLocked) return
             if (!email.isValidReceiverEmail()) {
-                _uiState.update { it.copy(errorMessage = UiText.Resource(R.string.setting_receiver_email_invalid)) }
+                dispatch(ReceiverEditReducerEvent.ValidationFailed(UiText.Resource(R.string.setting_receiver_email_invalid)))
                 return
             }
             val phoneValidation = phone.validateReceiverPhone(isRequired = true)
@@ -74,46 +85,40 @@ internal class ReceiverEditViewModel
                     } else {
                         R.string.setting_receiver_phone_invalid
                     }
-                _uiState.update { it.copy(errorMessage = UiText.Resource(messageRes)) }
+                dispatch(ReceiverEditReducerEvent.ValidationFailed(UiText.Resource(messageRes)))
                 return
             }
 
-            _uiState.update { it.copy(isSaving = true, errorMessage = null) }
+            dispatch(ReceiverEditReducerEvent.Saving)
             viewModelScope.launch {
-                val receiverUpdateResult =
-                    runCatchingCancellable {
-                        receiverRepository.updateReceiver(
-                            receiverId = receiverId,
-                            name = name,
-                            phone = phone.normalizeReceiverPhone(),
-                            relation = relation,
-                            email = email.trim(),
+                val result =
+                    updateReceiverInfo(
+                        receiverId = receiverId,
+                        name = name,
+                        phone = phone.normalizeReceiverPhone(),
+                        relation = relation,
+                        email = email.trim(),
+                        message = message,
+                    )
+                when (result) {
+                    is UpdateReceiverInfoResult.BasicInfoFailed -> {
+                        dispatch(
+                            ReceiverEditReducerEvent.SaveFailed(
+                                result.cause.toReceiverFailureMessage(R.string.setting_receiver_edit_failed),
+                            ),
                         )
                     }
-                receiverUpdateResult.exceptionOrNull()?.let { error ->
-                    _uiState.update {
-                        it.copy(
-                            isSaving = false,
-                            errorMessage = error.toReceiverFailureMessage(R.string.setting_receiver_edit_failed),
+
+                    UpdateReceiverInfoResult.MessageFailedAfterBasicInfoUpdated -> {
+                        dispatch(
+                            ReceiverEditReducerEvent.SaveFailed(
+                                UiText.Resource(R.string.setting_receiver_message_update_partial_failed),
+                            ),
                         )
                     }
-                    return@launch
-                }
 
-                runCatchingCancellable {
-                    receiverRepository.updateReceiverMessage(
-                        receiverId = receiverId,
-                        message = message,
-                    )
-                }.onSuccess {
-                    _uiState.update { it.copy(isSaving = false) }
-                    _events.send(ReceiverEditEvent.EditSuccess)
-                }.onFailure {
-                    _uiState.update {
-                        it.copy(
-                            isSaving = false,
-                            errorMessage = UiText.Resource(R.string.setting_receiver_message_update_partial_failed),
-                        )
+                    UpdateReceiverInfoResult.Success -> {
+                        dispatch(ReceiverEditReducerEvent.Saved)
                     }
                 }
             }
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverInviteContract.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverInviteContract.kt
new file mode 100644
index 0000000000..74087b4bc0
--- /dev/null
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverInviteContract.kt
@@ -0,0 +1,102 @@
+package com.afternote.feature.setting.presentation.receiver
+
+import androidx.compose.runtime.Immutable
+import com.afternote.core.ui.UiText
+import com.afternote.core.ui.mvi.MviIntent
+import com.afternote.core.ui.mvi.ReducerEvent
+import com.afternote.core.ui.mvi.UiState
+
+/** 수신자 등록 화면의 카카오톡 초대 시트(4996:39786) 의도 (#944). */
+internal sealed interface ReceiverInviteIntent : MviIntent {
+    /** «카카오톡으로 초대 보내기» CTA — 폼의 이름을 들고 시트를 연다. */
+    data class OpenSheet(
+        val receiverName: String,
+    ) : ReceiverInviteIntent
+
+    /** «나중에 보내기»·시트 밖 탭. */
+    data object CloseSheet : ReceiverInviteIntent
+
+    /** 시트의 «카카오톡으로 초대 보내기» — 초대를 만들고 공유 요청을 낸다. */
+    data object SendInvite : ReceiverInviteIntent
+
+    /** 화면이 카카오 공유를 띄웠다 — 시트를 닫고 «초대를 보냈어요» 로 넘어간다. */
+    data object ShareLaunched : ReceiverInviteIntent
+
+    /** 화면이 카카오 공유를 띄우지 못했다 — 시트를 유지한 채 안내를 얹고, 원인은 진단에 남긴다. */
+    data class ShareFailed(
+        val message: UiText,
+        val cause: Throwable,
+    ) : ReceiverInviteIntent
+
+    /** «초대 링크 다시 보내기» — 새 초대를 만들지 않고 같은 토큰으로 공유 요청을 다시 낸다. */
+    data object Resend : ReceiverInviteIntent
+
+    data object ConsumeShareRequest : ReceiverInviteIntent
+
+    data object ConsumeError : ReceiverInviteIntent
+}
+
+/**
+ * 화면이 카카오 SDK 로 공유를 띄우는 데 필요한 값. SDK 가 Activity 컨텍스트를 요구해 ViewModel 이
+ * 직접 띄우지 않고 신호로 넘긴다 — 소셜 로그인의 토큰 획득이 UI 계층에 있는 것과 같은 이유다.
+ *
+ * @property token 초대 토큰(비밀값). 로그·리포팅에 남기지 않는다.
+ * @property senderName 템플릿 제목 «{senderName}님이 …» 에 실리는 내 표시 이름.
+ */
+@Immutable
+internal data class ReceiverInviteShareRequest(
+    val token: String,
+    val senderName: String,
+    val receiverName: String,
+)
+
+/**
+ * @property sheetReceiverName 시트가 열려 있으면 시트 본문에 쓸 수신자 이름, 닫혀 있으면 null.
+ * @property shareRequest 초대가 만들어졌다 — 화면이 공유를 띄우고 소비한다.
+ * @property sentInvitation 공유를 띄운 초대. 있으면 등록 화면이 폼 대신 «초대를 보냈어요»(4996:39909) 를
+ *   그린다 — 별도 destination 이 아니라 같은 화면의 phase 다(설정 네비게이션 축은 #1695 소유).
+ */
+@Immutable
+internal data class ReceiverInviteUiState(
+    val sheetReceiverName: String? = null,
+    val isCreating: Boolean = false,
+    val shareRequest: ReceiverInviteShareRequest? = null,
+    val sentInvitation: ReceiverInviteShareRequest? = null,
+    val errorMessage: UiText? = null,
+) : UiState
+
+internal sealed interface ReceiverInviteReducerEvent : ReducerEvent {
+    data class SheetOpened(
+        val receiverName: String,
+    ) : ReceiverInviteReducerEvent
+
+    data object SheetClosed : ReceiverInviteReducerEvent
+
+    data object Creating : ReceiverInviteReducerEvent
+
+    data class Created(
+        val request: ReceiverInviteShareRequest,
+    ) : ReceiverInviteReducerEvent
+
+    data class CreateFailed(
+        val message: UiText,
+    ) : ReceiverInviteReducerEvent
+
+    data class ShareFailed(
+        val message: UiText,
+    ) : ReceiverInviteReducerEvent
+
+    /** 공유가 떴다 — 시트를 닫고 보냈어요 phase 로. */
+    data class Sent(
+        val invitation: ReceiverInviteShareRequest,
+    ) : ReceiverInviteReducerEvent
+
+    /** «다시 보내기» — 같은 값으로 공유 신호만 다시 올린다. */
+    data class ResendRequested(
+        val request: ReceiverInviteShareRequest,
+    ) : ReceiverInviteReducerEvent
+
+    data object ShareRequestConsumed : ReceiverInviteReducerEvent
+
+    data object ErrorConsumed : ReceiverInviteReducerEvent
+}
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverInviteSentContent.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverInviteSentContent.kt
new file mode 100644
index 0000000000..9460bdb36d
--- /dev/null
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverInviteSentContent.kt
@@ -0,0 +1,126 @@
+package com.afternote.feature.setting.presentation.receiver
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material3.Icon
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.SnackbarHost
+import androidx.compose.material3.SnackbarHostState
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import com.afternote.core.ui.button.AfternoteButton
+import com.afternote.core.ui.button.AfternoteButtonType
+import com.afternote.core.ui.theme.AfternoteDesign
+import com.afternote.core.ui.topbar.DetailTopBar
+import com.afternote.feature.setting.presentation.R
+import com.afternote.feature.setting.presentation.receiver.social.shareReceiverInvitationViaKakao
+import kotlinx.coroutines.launch
+import com.afternote.core.ui.R as CoreR
+
+/** «초대를 보냈어요»(4996:39909) 본문 — [ReceiverRegisterScreen] 이 phase 로 그린다. «다시 보내기» 의 공유 호출은 그 화면이 갖는다. */
+@Composable
+internal fun ReceiverInviteSentContent(
+    receiverName: String,
+    snackbarHostState: SnackbarHostState,
+    onBackClick: () -> Unit,
+    onOpenReceiverList: () -> Unit,
+    onResend: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Scaffold(
+        modifier = modifier.fillMaxSize(),
+        containerColor = Color.Transparent,
+        topBar = {
+            DetailTopBar(
+                title = stringResource(R.string.setting_receiver_invite_sent_top_bar_title),
+                onBackClick = onBackClick,
+            )
+        },
+        snackbarHost = { SnackbarHost(hostState = snackbarHostState) },
+    ) { innerPadding ->
+        Column(
+            modifier =
+                Modifier
+                    .padding(innerPadding)
+                    .fillMaxSize()
+                    .padding(horizontal = 20.dp)
+                    .padding(bottom = 32.dp),
+            horizontalAlignment = Alignment.CenterHorizontally,
+        ) {
+            Spacer(modifier = Modifier.height(96.dp))
+            Box(
+                modifier =
+                    Modifier
+                        .size(96.dp)
+                        .clip(CircleShape)
+                        .background(SentCircleColor),
+                contentAlignment = Alignment.Center,
+            ) {
+                Icon(
+                    painter = painterResource(CoreR.drawable.core_ui_ic_check),
+                    contentDescription = stringResource(R.string.setting_receiver_invite_sent_check_description),
+                    tint = SentCheckColor,
+                    modifier = Modifier.size(width = 36.dp, height = 27.dp),
+                )
+            }
+            Spacer(modifier = Modifier.height(32.dp))
+            Text(
+                text = stringResource(R.string.setting_receiver_invite_sent_title),
+                style = AfternoteDesign.typography.h1,
+                color = AfternoteDesign.colors.gray9,
+                textAlign = TextAlign.Center,
+            )
+            Spacer(modifier = Modifier.height(16.dp))
+            Text(
+                text = stringResource(R.string.setting_receiver_invite_sent_description, receiverName),
+                style = AfternoteDesign.typography.bodySmallR,
+                color = AfternoteDesign.colors.gray7,
+                textAlign = TextAlign.Center,
+            )
+            Spacer(modifier = Modifier.weight(1f))
+            AfternoteButton(
+                text = stringResource(R.string.setting_receiver_invite_sent_open_list),
+                onClick = onOpenReceiverList,
+                modifier = Modifier.fillMaxWidth(),
+            )
+            Spacer(modifier = Modifier.height(12.dp))
+            AfternoteButton(
+                text = stringResource(R.string.setting_receiver_invite_sent_resend),
+                onClick = onResend,
+                type = AfternoteButtonType.Plain,
+                modifier = Modifier.fillMaxWidth(),
+            )
+            Spacer(modifier = Modifier.height(16.dp))
+            Text(
+                text = stringResource(R.string.setting_receiver_invite_sent_caption),
+                style = AfternoteDesign.typography.captionLargeR,
+                color = AfternoteDesign.colors.gray6,
+                textAlign = TextAlign.Center,
+                modifier = Modifier.fillMaxWidth(),
+            )
+        }
+    }
+}
+
+/** 시안의 초록 체크 — 테마에 초록 토큰이 없어 시안 실측값을 이 화면 안에만 둔다. */
+private val SentCircleColor = Color(0xFFD5EBDB)
+private val SentCheckColor = Color(0xFF2E9E4F)
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverInviteViewModel.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverInviteViewModel.kt
new file mode 100644
index 0000000000..c4e136a0c9
--- /dev/null
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverInviteViewModel.kt
@@ -0,0 +1,183 @@
+package com.afternote.feature.setting.presentation.receiver
+
+import androidx.lifecycle.SavedStateHandle
+import androidx.lifecycle.viewModelScope
+import com.afternote.core.common.reporting.ErrorReporter
+import com.afternote.core.common.result.runCatchingCancellable
+import com.afternote.core.domain.error.ReceiverInvitationFailure
+import com.afternote.core.domain.repository.MyProfileRepository
+import com.afternote.core.domain.repository.ReceiverInvitationRepository
+import com.afternote.core.domain.repository.UserProfileCacheRepository
+import com.afternote.core.ui.UiText
+import com.afternote.core.ui.mvi.MviViewModel
+import com.afternote.feature.setting.presentation.R
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+/**
+ * 수신자 등록 화면의 카카오톡 초대 발급 (#944).
+ *
+ * 초대 발급(`POST receiver-invitations`)까지만 담당한다. 공유 자체는 카카오 SDK 가 Activity 를
+ * 요구해 화면이 [ReceiverInviteUiState.shareRequest] 를 받아 띄운다.
+ *
+ * 템플릿 제목이 «{senderName}님이 …» 라 내 이름이 비면 문구가 깨진다. 홈 캐시(`UserProfileCacheRepository`)를
+ * 먼저 보고, 없으면 서버 프로필을 읽는다. 둘 다 못 읽으면 공유를 열지 않고 실패로 알린다.
+ *
+ * 공유를 띄운 초대(토큰·내 이름·수신자 이름)는 [SavedStateHandle] 에 둔다 — «초대 링크 다시 보내기» 가
+ * 같은 토큰으로 공유를 다시 열어야 하고, 회전으로 ViewModel 이 재생성돼도 «보냈어요» phase 가 남아야 한다.
+ * 토큰은 비밀값이라 로그·리포팅에 싣지 않는다.
+ */
+@HiltViewModel
+internal class ReceiverInviteViewModel
+    @Inject
+    constructor(
+        private val invitationRepository: ReceiverInvitationRepository,
+        private val profileCacheRepository: UserProfileCacheRepository,
+        private val myProfileRepository: MyProfileRepository,
+        private val errorReporter: ErrorReporter,
+        private val savedStateHandle: SavedStateHandle,
+    ) : MviViewModel<ReceiverInviteIntent, ReceiverInviteUiState, ReceiverInviteReducerEvent>(
+            ReceiverInviteUiState(sentInvitation = savedStateHandle.restoreSentInvitation()),
+        ) {
+        /** 가장 최근에 발급한 초대 — 공유가 뜬 것이 확인되면 [markSent] 가 SavedState 로 올린다. */
+        private var lastCreated: ReceiverInviteShareRequest? = null
+
+        override fun onIntent(intent: ReceiverInviteIntent) {
+            when (intent) {
+                is ReceiverInviteIntent.OpenSheet -> {
+                    dispatch(ReceiverInviteReducerEvent.SheetOpened(intent.receiverName))
+                }
+
+                ReceiverInviteIntent.CloseSheet -> {
+                    dispatch(ReceiverInviteReducerEvent.SheetClosed)
+                }
+
+                ReceiverInviteIntent.SendInvite -> {
+                    sendInvite()
+                }
+
+                ReceiverInviteIntent.ShareLaunched -> {
+                    markSent()
+                }
+
+                is ReceiverInviteIntent.ShareFailed -> {
+                    // 카카오 SDK 오류·startActivity 실패의 원문은 여기서만 남는다(토큰은 실리지 않는다).
+                    errorReporter.recordFailure(intent.cause, mapOf(KEY_STAGE to STAGE_SHARE))
+                    dispatch(ReceiverInviteReducerEvent.ShareFailed(intent.message))
+                }
+
+                ReceiverInviteIntent.Resend -> {
+                    resend()
+                }
+
+                ReceiverInviteIntent.ConsumeShareRequest -> {
+                    dispatch(ReceiverInviteReducerEvent.ShareRequestConsumed)
+                }
+
+                ReceiverInviteIntent.ConsumeError -> {
+                    dispatch(ReceiverInviteReducerEvent.ErrorConsumed)
+                }
+            }
+        }
+
+        override fun reduce(
+            state: ReceiverInviteUiState,
+            event: ReceiverInviteReducerEvent,
+        ): ReceiverInviteUiState =
+            when (event) {
+                is ReceiverInviteReducerEvent.SheetOpened -> state.copy(sheetReceiverName = event.receiverName, errorMessage = null)
+                ReceiverInviteReducerEvent.SheetClosed -> state.copy(sheetReceiverName = null, isCreating = false)
+                ReceiverInviteReducerEvent.Creating -> state.copy(isCreating = true, errorMessage = null)
+                is ReceiverInviteReducerEvent.Created -> state.copy(isCreating = false, shareRequest = event.request)
+                is ReceiverInviteReducerEvent.CreateFailed -> state.copy(isCreating = false, errorMessage = event.message)
+                is ReceiverInviteReducerEvent.ShareFailed -> state.copy(errorMessage = event.message)
+                is ReceiverInviteReducerEvent.Sent -> state.copy(sheetReceiverName = null, sentInvitation = event.invitation)
+                is ReceiverInviteReducerEvent.ResendRequested -> state.copy(shareRequest = event.request)
+                ReceiverInviteReducerEvent.ShareRequestConsumed -> state.copy(shareRequest = null)
+                ReceiverInviteReducerEvent.ErrorConsumed -> state.copy(errorMessage = null)
+            }
+
+        private fun sendInvite() {
+            val receiverName = currentState.sheetReceiverName ?: return
+            if (currentState.isCreating) return
+            viewModelScope.launch {
+                dispatch(ReceiverInviteReducerEvent.Creating)
+                val senderName = resolveSenderName()
+                if (senderName == null) {
+                    dispatch(
+                        ReceiverInviteReducerEvent.CreateFailed(
+                            UiText.Resource(R.string.setting_receiver_invite_sender_name_unavailable),
+                        ),
+                    )
+                    return@launch
+                }
+                invitationRepository
+                    .create()
+                    .onSuccess { created ->
+                        val request =
+                            ReceiverInviteShareRequest(
+                                token = created.token,
+                                senderName = senderName,
+                                receiverName = receiverName,
+                            )
+                        lastCreated = request
+                        dispatch(ReceiverInviteReducerEvent.Created(request))
+                    }.onFailure { failure ->
+                        val messageRes =
+                            if (failure is ReceiverInvitationFailure.Unauthenticated) {
+                                R.string.setting_receiver_invite_create_unauthenticated
+                            } else {
+                                R.string.setting_receiver_invite_create_failed
+                            }
+                        errorReporter.recordFailure(failure, mapOf(KEY_STAGE to STAGE_CREATE))
+                        dispatch(ReceiverInviteReducerEvent.CreateFailed(UiText.Resource(messageRes)))
+                    }
+            }
+        }
+
+        /** 공유가 떴다 — 마지막 발급분을 보냈어요 phase 로 올리고 SavedState 에 남긴다. */
+        private fun markSent() {
+            val request = lastCreated ?: return
+            savedStateHandle.storeSentInvitation(request)
+            dispatch(ReceiverInviteReducerEvent.Sent(request))
+        }
+
+        private fun resend() {
+            val sent = currentState.sentInvitation ?: return
+            dispatch(ReceiverInviteReducerEvent.ResendRequested(sent))
+        }
+
+        private suspend fun resolveSenderName(): String? {
+            val cached = runCatchingCancellable { profileCacheRepository.getCachedUserName() }.getOrNull()
+            if (!cached.isNullOrBlank()) return cached
+            return runCatchingCancellable { myProfileRepository.getMyProfile().name }
+                .onFailure { errorReporter.recordFailure(it, mapOf(KEY_STAGE to STAGE_SENDER_NAME)) }
+                .getOrNull()
+                ?.takeIf { it.isNotBlank() }
+        }
+
+        private companion object {
+            const val KEY_STAGE = "stage"
+            const val STAGE_CREATE = "receiver_invite_create"
+            const val STAGE_SENDER_NAME = "receiver_invite_sender_name"
+            const val STAGE_SHARE = "receiver_invite_share"
+        }
+    }
+
+private const val SAVED_SENT_TOKEN = "receiver_invite_sent_token"
+private const val SAVED_SENT_SENDER_NAME = "receiver_invite_sent_sender_name"
+private const val SAVED_SENT_RECEIVER_NAME = "receiver_invite_sent_receiver_name"
+
+private fun SavedStateHandle.restoreSentInvitation(): ReceiverInviteShareRequest? {
+    val token = get<String>(SAVED_SENT_TOKEN) ?: return null
+    val senderName = get<String>(SAVED_SENT_SENDER_NAME) ?: return null
+    val receiverName = get<String>(SAVED_SENT_RECEIVER_NAME) ?: return null
+    return ReceiverInviteShareRequest(token = token, senderName = senderName, receiverName = receiverName)
+}
+
+private fun SavedStateHandle.storeSentInvitation(request: ReceiverInviteShareRequest) {
+    this[SAVED_SENT_TOKEN] = request.token
+    this[SAVED_SENT_SENDER_NAME] = request.senderName
+    this[SAVED_SENT_RECEIVER_NAME] = request.receiverName
+}
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverRegisterScreen.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverRegisterScreen.kt
index d140f22595..042edc49b0 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverRegisterScreen.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverRegisterScreen.kt
@@ -12,6 +12,7 @@ import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.foundation.text.input.rememberTextFieldState
 import androidx.compose.material3.ButtonDefaults
 import androidx.compose.material3.DropdownMenu
@@ -19,19 +20,22 @@ import androidx.compose.material3.DropdownMenuItem
 import androidx.compose.material3.HorizontalDivider
 import androidx.compose.material3.Icon
 import androidx.compose.material3.Scaffold
+import androidx.compose.material3.SnackbarHostState
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
 import androidx.compose.ui.draw.rotate
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.input.KeyboardType
@@ -43,41 +47,114 @@ import com.afternote.core.ui.PhoneNumberInputTransformation
 import com.afternote.core.ui.PhoneNumberVisualTransformation
 import com.afternote.core.ui.UiText
 import com.afternote.core.ui.asString
+import com.afternote.core.ui.button.AfternoteButton
+import com.afternote.core.ui.button.AfternoteButtonType
+import com.afternote.core.ui.mvi.ObserveSignal
 import com.afternote.core.ui.theme.AfternoteDesign
 import com.afternote.core.ui.topbar.DetailTopBar
 import com.afternote.feature.setting.presentation.R
+import com.afternote.feature.setting.presentation.receiver.component.KakaoContainerColor
+import com.afternote.feature.setting.presentation.receiver.component.KakaoContentColor
+import com.afternote.feature.setting.presentation.receiver.component.ReceiverInviteSheet
+import com.afternote.feature.setting.presentation.receiver.social.shareReceiverInvitationViaKakao
 import com.afternote.feature.setting.presentation.shared.component.ProfilePhotoWithAddBadge
+import kotlinx.coroutines.launch
 import com.afternote.core.ui.R as CoreR
 
 private const val CUSTOM_RELATION_OPTION = "직접 추가하기"
 private val relationOptions = listOf("어머니", "아버지", "아들", "딸", CUSTOM_RELATION_OPTION)
 
+/**
+ * 수신자 등록. 폼(이메일 «등록») 과 카카오톡 초대(폼 아래 CTA → 시트 → «초대를 보냈어요») 를 한 화면이 갖는다 (#944).
+ *
+ * «초대를 보냈어요»(4996:39909) 는 별도 destination 이 아니라 이 화면의 phase 다 — 설정 네비게이션 축은
+ * Nav3 이관(#1695)이 소유해 Nav2 표면을 새로 만들지 않는다. 그 화면의 back·«수신자 목록으로 이동하기» 는
+ * 둘 다 [onBackClick] 이다(등록 진입 전 화면으로 돌아간다).
+ */
 @Composable
-fun ReceiverRegisterScreen(
+internal fun ReceiverRegisterScreen(
     onBackClick: () -> Unit,
     onRegisterSuccess: () -> Unit,
     modifier: Modifier = Modifier,
     viewModel: ReceiverRegisterViewModel = hiltViewModel(),
+    inviteViewModel: ReceiverInviteViewModel = hiltViewModel(),
 ) {
     val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+    val inviteState by inviteViewModel.uiState.collectAsStateWithLifecycle()
     val currentOnRegisterSuccess by rememberUpdatedState(onRegisterSuccess)
+    val context = LocalContext.current
+    val scope = rememberCoroutineScope()
+    val snackbarHostState = remember { SnackbarHostState() }
+    val shareFailedMessage = UiText.Resource(R.string.setting_receiver_invite_share_failed)
+    val shareFailedText = stringResource(R.string.setting_receiver_invite_share_failed)
 
-    LaunchedEffect(Unit) {
-        viewModel.events.collect { event ->
+    uiState.pendingEvent?.let { event ->
+        ObserveSignal(
+            signal = event,
+            consumed = ReceiverRegisterIntent.ConsumeEvent(event),
+            onIntent = viewModel::onIntent,
+        ) {
             when (event) {
                 ReceiverRegisterEvent.RegisterSuccess -> currentOnRegisterSuccess()
             }
         }
     }
 
+    // 초대가 만들어졌다(또는 다시 보내기) — 카카오 SDK 가 Activity 컨텍스트를 요구해 공유는 여기서 띄운다.
+    // suspend 를 effect 안에서 기다리지 않고 별도 scope 에 띄운다 — 소비 직후 상태 변화가 effect 를 재시작시킨다.
+    ObserveSignal(
+        signal = inviteState.shareRequest,
+        consumed = ReceiverInviteIntent.ConsumeShareRequest,
+        onIntent = inviteViewModel::onIntent,
+    ) { request ->
+        val isResend = inviteState.sentInvitation != null
+        scope.launch {
+            shareReceiverInvitationViaKakao(context, token = request.token, senderName = request.senderName)
+                .onSuccess {
+                    if (!isResend) inviteViewModel.onIntent(ReceiverInviteIntent.ShareLaunched)
+                }.onFailure { cause ->
+                    // 공유를 못 띄웠다(취소·카카오톡 없음·SDK 오류) — 원인은 ViewModel 이 진단에 남기고,
+                    // 시트면 안내를 얹고, 보냈어요 화면이면 스낵바.
+                    inviteViewModel.onIntent(ReceiverInviteIntent.ShareFailed(shareFailedMessage, cause))
+                    if (isResend) snackbarHostState.showSnackbar(shareFailedText)
+                }
+        }
+    }
+
+    val sentInvitation = inviteState.sentInvitation
+    if (sentInvitation != null) {
+        ReceiverInviteSentContent(
+            receiverName = sentInvitation.receiverName,
+            snackbarHostState = snackbarHostState,
+            onBackClick = onBackClick,
+            onOpenReceiverList = onBackClick,
+            onResend = { inviteViewModel.onIntent(ReceiverInviteIntent.Resend) },
+            modifier = modifier,
+        )
+        return
+    }
+
+    inviteState.sheetReceiverName?.let { receiverName ->
+        ReceiverInviteSheet(
+            receiverName = receiverName,
+            isSending = inviteState.isCreating,
+            errorMessage = inviteState.errorMessage,
+            onSend = { inviteViewModel.onIntent(ReceiverInviteIntent.SendInvite) },
+            onDismiss = { inviteViewModel.onIntent(ReceiverInviteIntent.CloseSheet) },
+        )
+    }
+
     ReceiverRegisterContent(
         title = "수신자 등록",
         actionText = "등록",
         isPhoneRequired = true,
-        isLoading = uiState.isLoading,
+        isActionLocked = uiState.isLoading,
         errorMessage = uiState.errorMessage,
         onBackClick = onBackClick,
-        onRegister = viewModel::register,
+        onRegister = { name, relation, phone, email, message ->
+            viewModel.onIntent(ReceiverRegisterIntent.Register(name, relation, phone, email, message))
+        },
+        onInviteClick = { name -> inviteViewModel.onIntent(ReceiverInviteIntent.OpenSheet(name)) },
         modifier = modifier,
     )
 }
@@ -87,10 +164,11 @@ internal fun ReceiverRegisterContent(
     title: String,
     actionText: String,
     isPhoneRequired: Boolean,
-    isLoading: Boolean,
+    isActionLocked: Boolean,
     errorMessage: UiText?,
     onBackClick: () -> Unit,
     onRegister: (name: String, relation: String, phone: String, email: String, message: String) -> Unit,
+    onInviteClick: ((name: String) -> Unit)?,
     modifier: Modifier = Modifier,
     initialName: String = "",
     initialRelation: String = "",
@@ -149,7 +227,7 @@ internal fun ReceiverRegisterContent(
                                 messageState.text.toString(),
                             )
                         },
-                        enabled = isFormValid && !isLoading,
+                        enabled = isFormValid && !isActionLocked,
                         colors =
                             ButtonDefaults.textButtonColors(
                                 contentColor = AfternoteDesign.colors.gray9,
@@ -317,6 +395,14 @@ internal fun ReceiverRegisterContent(
                     placeholder = stringResource(R.string.setting_receiver_last_greeting_placeholder),
                 )
             }
+            if (onInviteClick != null) {
+                item {
+                    ReceiverInviteCta(
+                        isNameFilled = nameState.text.isNotBlank(),
+                        onClick = { onInviteClick(nameState.text.toString().trim()) },
+                    )
+                }
+            }
             if (errorMessage != null) {
                 item {
                     Spacer(modifier = Modifier.height(12.dp))
@@ -331,3 +417,38 @@ internal fun ReceiverRegisterContent(
         }
     }
 }
+
+/**
+ * 폼 아래의 카카오톡 초대 진입 (시안 4996:39735 하단, #944). 이메일 «등록» 흐름과 별개다 —
+ * 폼의 나머지 칸을 로컬에 보관하는 일은 PM·BE 결정 대기(#1948)라 여기서 하지 않는다.
+ *
+ * 이름이 비어 있으면 누르지 못한다 — 시트 본문과 «초대를 보냈어요» 가 그 이름을 부른다.
+ */
+@Composable
+private fun ReceiverInviteCta(
+    isNameFilled: Boolean,
+    onClick: () -> Unit,
+) {
+    Spacer(modifier = Modifier.height(40.dp))
+    Text(
+        text = stringResource(R.string.setting_receiver_invite_form_notice),
+        style = AfternoteDesign.typography.captionLargeR,
+        color = AfternoteDesign.colors.gray6,
+        modifier =
+            Modifier
+                .fillMaxWidth()
+                .clip(RoundedCornerShape(12.dp))
+                .background(AfternoteDesign.colors.gray2)
+                .padding(16.dp),
+    )
+    Spacer(modifier = Modifier.height(16.dp))
+    AfternoteButton(
+        text = stringResource(R.string.setting_receiver_invite_cta),
+        onClick = onClick,
+        type = if (isNameFilled) AfternoteButtonType.Default else AfternoteButtonType.Un,
+        containerColor = if (isNameFilled) KakaoContainerColor else null,
+        contentColor = if (isNameFilled) KakaoContentColor else null,
+        modifier = Modifier.fillMaxWidth(),
+    )
+    Spacer(modifier = Modifier.height(24.dp))
+}
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverRegisterUiState.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverRegisterUiState.kt
index 2c502ea57f..92c1504c62 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverRegisterUiState.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverRegisterUiState.kt
@@ -1,12 +1,44 @@
 package com.afternote.feature.setting.presentation.receiver
 
 import com.afternote.core.ui.UiText
+import com.afternote.core.ui.mvi.MviIntent
+import com.afternote.core.ui.mvi.ReducerEvent
+import com.afternote.core.ui.mvi.UiState
 
-data class ReceiverRegisterUiState(
+internal data class ReceiverRegisterUiState(
     val isLoading: Boolean = false,
     val errorMessage: UiText? = null,
-)
+    val pendingEvent: ReceiverRegisterEvent? = null,
+) : UiState
 
-sealed interface ReceiverRegisterEvent {
+internal sealed interface ReceiverRegisterIntent : MviIntent {
+    data class Register(
+        val name: String,
+        val relation: String,
+        val phone: String?,
+        val email: String,
+        val message: String?,
+    ) : ReceiverRegisterIntent
+
+    data class ConsumeEvent(
+        val event: ReceiverRegisterEvent,
+    ) : ReceiverRegisterIntent
+}
+
+internal sealed interface ReceiverRegisterReducerEvent : ReducerEvent {
+    data object RegisterStarted : ReceiverRegisterReducerEvent
+
+    data object RegisterSucceeded : ReceiverRegisterReducerEvent
+
+    data class RegisterFailed(
+        val message: UiText,
+    ) : ReceiverRegisterReducerEvent
+
+    data class EventConsumed(
+        val event: ReceiverRegisterEvent,
+    ) : ReceiverRegisterReducerEvent
+}
+
+internal sealed interface ReceiverRegisterEvent {
     data object RegisterSuccess : ReceiverRegisterEvent
 }
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverRegisterViewModel.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverRegisterViewModel.kt
index 0fed507c84..ea4995f219 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverRegisterViewModel.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverRegisterViewModel.kt
@@ -1,43 +1,61 @@
 package com.afternote.feature.setting.presentation.receiver
 
-import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
-import com.afternote.core.common.result.runCatchingCancellable
 import com.afternote.core.domain.repository.UserReceiverRepository
+import com.afternote.core.domain.result.runCatchingCancellable
 import com.afternote.core.ui.UiText
+import com.afternote.core.ui.mvi.MviViewModel
 import com.afternote.feature.setting.presentation.R
 import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.receiveAsFlow
-import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import javax.inject.Inject
 
 @HiltViewModel
-class ReceiverRegisterViewModel
+internal class ReceiverRegisterViewModel
     @Inject
     constructor(
         private val receiverRepository: UserReceiverRepository,
-    ) : ViewModel() {
-        private val _uiState = MutableStateFlow(ReceiverRegisterUiState())
-        val uiState = _uiState.asStateFlow()
+    ) : MviViewModel<ReceiverRegisterIntent, ReceiverRegisterUiState, ReceiverRegisterReducerEvent>(ReceiverRegisterUiState()) {
+        override fun onIntent(intent: ReceiverRegisterIntent) {
+            when (intent) {
+                is ReceiverRegisterIntent.Register -> register(intent)
+                is ReceiverRegisterIntent.ConsumeEvent -> dispatch(ReceiverRegisterReducerEvent.EventConsumed(intent.event))
+            }
+        }
+
+        override fun reduce(
+            state: ReceiverRegisterUiState,
+            event: ReceiverRegisterReducerEvent,
+        ): ReceiverRegisterUiState =
+            when (event) {
+                ReceiverRegisterReducerEvent.RegisterStarted -> {
+                    state.copy(isLoading = true, errorMessage = null)
+                }
+
+                ReceiverRegisterReducerEvent.RegisterSucceeded -> {
+                    state.copy(isLoading = false, pendingEvent = ReceiverRegisterEvent.RegisterSuccess)
+                }
+
+                is ReceiverRegisterReducerEvent.RegisterFailed -> {
+                    state.copy(isLoading = false, errorMessage = event.message)
+                }
 
-        private val _events = Channel<ReceiverRegisterEvent>(Channel.BUFFERED)
-        val events = _events.receiveAsFlow()
+                is ReceiverRegisterReducerEvent.EventConsumed -> {
+                    if (state.pendingEvent == event.event) state.copy(pendingEvent = null) else state
+                }
+            }
 
-        fun register(
-            name: String,
-            relation: String,
-            phone: String?,
-            email: String,
-            message: String?,
-        ) {
+        private fun register(intent: ReceiverRegisterIntent.Register) {
+            if (currentState.isLoading) return
+            val name = intent.name
+            val relation = intent.relation
+            val phone = intent.phone
+            val email = intent.email
+            val message = intent.message
             if (!email.isValidReceiverEmail()) {
                 val messageRes =
                     if (email.isBlank()) R.string.setting_receiver_email_required else R.string.setting_receiver_email_invalid
-                _uiState.update { it.copy(errorMessage = UiText.Resource(messageRes)) }
+                dispatch(ReceiverRegisterReducerEvent.RegisterFailed(UiText.Resource(messageRes)))
                 return
             }
             val phoneValidation = phone.orEmpty().validateReceiverPhone(isRequired = true)
@@ -48,12 +66,12 @@ class ReceiverRegisterViewModel
                     } else {
                         R.string.setting_receiver_phone_invalid
                     }
-                _uiState.update { it.copy(errorMessage = UiText.Resource(messageRes)) }
+                dispatch(ReceiverRegisterReducerEvent.RegisterFailed(UiText.Resource(messageRes)))
                 return
             }
             val normalizedEmail = email.trim()
 
-            _uiState.update { it.copy(isLoading = true, errorMessage = null) }
+            dispatch(ReceiverRegisterReducerEvent.RegisterStarted)
             viewModelScope.launch {
                 runCatchingCancellable {
                     receiverRepository.createReceiver(
@@ -64,10 +82,10 @@ class ReceiverRegisterViewModel
                         message = message?.takeIf { it.isNotBlank() },
                     )
                 }.onSuccess {
-                    _events.send(ReceiverRegisterEvent.RegisterSuccess)
+                    dispatch(ReceiverRegisterReducerEvent.RegisterSucceeded)
                 }.onFailure { error ->
                     val errorMessage = error.toReceiverFailureMessage(R.string.setting_receiver_register_failed)
-                    _uiState.update { it.copy(isLoading = false, errorMessage = errorMessage) }
+                    dispatch(ReceiverRegisterReducerEvent.RegisterFailed(errorMessage))
                 }
             }
         }
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/component/ReceiverInviteSheet.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/component/ReceiverInviteSheet.kt
new file mode 100644
index 0000000000..6be9355cec
--- /dev/null
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/component/ReceiverInviteSheet.kt
@@ -0,0 +1,52 @@
+package com.afternote.feature.setting.presentation.receiver.component
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.ModalBottomSheet
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import com.afternote.core.ui.UiText
+import com.afternote.core.ui.asString
+import com.afternote.core.ui.button.AfternoteButton
+import com.afternote.core.ui.button.AfternoteButtonType
+import com.afternote.core.ui.theme.AfternoteDesign
+import com.afternote.feature.setting.presentation.R
+
+/**
+ * «카카오톡으로 이동합니다.» 바텀시트 (시안 4996:39786, #944).
+ *
+ * @param receiverName 폼에 적힌 수신자 이름 — 본문 «{이름} 님에게 보낼 초대메세지를 …» 에 실린다.
+ * @param errorMessage 초대 발급·공유 실패 안내. 시트를 닫지 않고 그 자리에서 보인다 — 다시 누르면 재시도다.
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+internal fun ReceiverInviteSheet(
+    receiverName: String,
+    isSending: Boolean,
+    errorMessage: UiText?,
+    onSend: () -> Unit,
+    onDismiss: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    ModalBottomSheet(
+        onDismissRequest = onDismiss,
+        containerColor = AfternoteDesign.colors.gray1,
+        modifier = modifier,
+    ) {
+        ReceiverInviteSheetContent(
+            receiverName = receiverName,
+            isSending = isSending,
+            errorMessage = errorMessage,
+            onSend = onSend,
+            onDismiss = onDismiss,
+        )
+    }
+}
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/component/ReceiverInviteSheetContent.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/component/ReceiverInviteSheetContent.kt
new file mode 100644
index 0000000000..58e32ea438
--- /dev/null
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/component/ReceiverInviteSheetContent.kt
@@ -0,0 +1,82 @@
+package com.afternote.feature.setting.presentation.receiver.component
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.ModalBottomSheet
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import com.afternote.core.ui.UiText
+import com.afternote.core.ui.asString
+import com.afternote.core.ui.button.AfternoteButton
+import com.afternote.core.ui.button.AfternoteButtonType
+import com.afternote.core.ui.theme.AfternoteDesign
+import com.afternote.feature.setting.presentation.R
+
+/** [ReceiverInviteSheet] 의 본문 — 시트 래퍼 없이 그려 스크린샷 baseline 을 잡는다. */
+@Composable
+internal fun ReceiverInviteSheetContent(
+    receiverName: String,
+    isSending: Boolean,
+    errorMessage: UiText?,
+    onSend: () -> Unit,
+    onDismiss: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Column(
+        modifier =
+            modifier
+                .fillMaxWidth()
+                .padding(horizontal = 20.dp)
+                .padding(bottom = 32.dp),
+    ) {
+        Text(
+            text = stringResource(R.string.setting_receiver_invite_sheet_title),
+            style = AfternoteDesign.typography.h3,
+            color = AfternoteDesign.colors.gray9,
+        )
+        Spacer(modifier = Modifier.height(12.dp))
+        Text(
+            text = stringResource(R.string.setting_receiver_invite_sheet_description, receiverName),
+            style = AfternoteDesign.typography.bodySmallR,
+            color = AfternoteDesign.colors.gray7,
+        )
+        if (errorMessage != null) {
+            Spacer(modifier = Modifier.height(12.dp))
+            Text(
+                text = errorMessage.asString(),
+                style = AfternoteDesign.typography.captionLargeR,
+                color = AfternoteDesign.colors.error,
+            )
+        }
+        Spacer(modifier = Modifier.height(24.dp))
+        AfternoteButton(
+            text = stringResource(R.string.setting_receiver_invite_send),
+            onClick = onSend,
+            containerColor = KakaoContainerColor,
+            contentColor = KakaoContentColor,
+            isLoading = isSending,
+            modifier = Modifier.fillMaxWidth(),
+        )
+        Spacer(modifier = Modifier.height(12.dp))
+        AfternoteButton(
+            text = stringResource(R.string.setting_receiver_invite_send_later),
+            onClick = onDismiss,
+            type = AfternoteButtonType.Plain,
+            modifier = Modifier.fillMaxWidth(),
+        )
+    }
+}
+
+/** 카카오 브랜드 노랑 — 온보딩 로그인 버튼과 같은 값. 라벨은 [AfternoteButtonType.Default] 의 흰색 대신 검정이어야 한다. */
+internal val KakaoContainerColor = Color(0xFFFEE500)
+
+/** 카카오 버튼 라벨 색 — 심볼과 같은 #212121·알파 90.2%. */
+internal val KakaoContentColor = Color(0xE6212121)
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/social/KakaoReceiverInvitationShare.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/social/KakaoReceiverInvitationShare.kt
new file mode 100644
index 0000000000..80b9853790
--- /dev/null
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/receiver/social/KakaoReceiverInvitationShare.kt
@@ -0,0 +1,71 @@
+package com.afternote.feature.setting.presentation.receiver.social
+
+import android.content.Context
+import android.util.Log
+import com.kakao.sdk.common.util.KakaoCustomTabsClient
+import com.kakao.sdk.share.ShareClient
+import com.kakao.sdk.share.WebSharerClient
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlin.coroutines.resume
+
+/**
+ * 카카오디벨로퍼스 «애프터노트 수신자 초대링크» 사용자 정의 템플릿 (2026-09-08 생성).
+ *
+ * 비밀값이 아니라 코드 상수다. 사용자 인자는 `inviteToken`·`senderName` 둘이고, 버튼의 Android 실행
+ * 파라미터가 `inviteToken=${inviteToken}` 으로 `kakao{앱키}://kakaolink` 를 연다.
+ */
+private const val KAKAO_RECEIVER_INVITATION_TEMPLATE_ID: Long = 136940L
+
+private const val LOG_TAG = "KakaoInviteShare"
+private const val TEMPLATE_ARG_INVITE_TOKEN = "inviteToken"
+private const val TEMPLATE_ARG_SENDER_NAME = "senderName"
+
+/**
+ * 수신자 초대를 카카오톡으로 보낸다 (#944).
+ *
+ * 카카오톡이 있으면 앱 공유 Intent 를 띄우고, 없으면 웹 공유 URL 을 브라우저(CustomTab)로 연다.
+ * 성공은 «공유 화면을 띄웠다» 까지다 — 사용자가 카카오톡 안에서 실제로 보냈는지는 SDK 가 알려주지 않는다.
+ * 실패는 `Result.failure` 로만 돌려주고 던지지 않는다 — 공유 취소·브라우저 부재로 앱이 죽지 않게 한다.
+ *
+ * [KakaoLoginHelper][requestKakaoAccessToken] 과 같은 결로 콜백 SDK 를 코루틴으로 감싼다.
+ * 토큰은 템플릿 인자로만 실리고 로그에 남기지 않는다.
+ */
+internal suspend fun shareReceiverInvitationViaKakao(
+    context: Context,
+    token: String,
+    senderName: String,
+): Result<Unit> {
+    val templateArgs =
+        mapOf(
+            TEMPLATE_ARG_INVITE_TOKEN to token,
+            TEMPLATE_ARG_SENDER_NAME to senderName,
+        )
+    val shareClient = ShareClient.instance
+    if (shareClient.isKakaoTalkSharingAvailable(context)) {
+        return suspendCancellableCoroutine { continuation ->
+            shareClient.shareCustom(context, KAKAO_RECEIVER_INVITATION_TEMPLATE_ID, templateArgs) { result, error ->
+                if (!continuation.isActive) return@shareCustom
+                val outcome =
+                    when {
+                        error != null -> {
+                            Log.w(LOG_TAG, "카카오톡 공유 실패", error)
+                            Result.failure(error)
+                        }
+
+                        result != null -> {
+                            runCatching { context.startActivity(result.intent) }
+                        }
+
+                        else -> {
+                            Result.failure(IllegalStateException("카카오톡 공유 실패: 결과값 없음"))
+                        }
+                    }
+                continuation.resume(outcome)
+            }
+        }
+    }
+    return runCatching {
+        val url = WebSharerClient.instance.makeCustomUrl(KAKAO_RECEIVER_INVITATION_TEMPLATE_ID, templateArgs)
+        KakaoCustomTabsClient.openWithDefault(context, url)
+    }
+}
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/shared/component/ProfilePhotoWithAddBadge.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/shared/component/ProfilePhotoWithAddBadge.kt
index 6636c642be..b7082c635b 100644
--- a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/shared/component/ProfilePhotoWithAddBadge.kt
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/shared/component/ProfilePhotoWithAddBadge.kt
@@ -13,16 +13,14 @@ import androidx.compose.ui.unit.dp
 import com.afternote.feature.setting.presentation.R
 
 /**
- * 프로필 사진 자리 + 우하단 「추가」 배지. 표시 전용이며 아직 picker 가 붙어 있지 않다.
+ * 프로필 사진 자리 + 우하단 「추가」 배지. 표시 전용이며 picker 가 붙어 있지 않다.
  *
- * 프로필 이미지 크기 134dp 의 단일 출처다(#1782). setting 의 프로필 편집·수신인 등록 두 화면이
- * 같은 블록을 복제하고 있어 여기로 모았다.
+ * 남은 소비처는 수신인 등록 화면 하나다. 프로필 편집 화면은 사진 선택을 붙이면서(#1438) core:ui 의
+ * [ProfileImagePicker][com.afternote.core.ui.ProfileImagePicker] 로 옮겼다. 시안의 프로필 노드가
+ * core 자산(`core_ui_ic_profile_placeholder`, 48dp 배지)과 같다는 #2003 의 판정을 따랐다.
  *
- * core:ui 의 [ProfileImagePicker][com.afternote.core.ui.ProfileImagePicker] 로 흡수하지 않은
- * 이유는 자산과 배지 기하가 달라서다 — 이쪽은 `ic_default_profile`(60dp 뷰포트) 과
- * 48dp 칸 안에 72dp 로 넘쳐 그려지는 `ic_plus` 를 쓰고, core 쪽은
- * `core_ui_ic_profile_placeholder` 와 48dp `PlusBadgeButton` 을 쓴다. 바꾸면 픽셀이 움직인다.
- * 수렴은 시안 대조가 선행돼야 하므로 #2003 으로 분리했다.
+ * 이쪽은 `ic_default_profile`(60dp 뷰포트)과 48dp 칸 안에 72dp 로 넘쳐 그려지는 `ic_plus` 를 쓴다.
+ * 수신인 등록 화면의 수렴은 #2003 에 남아 있다.
  */
 @Composable
 fun ProfilePhotoWithAddBadge(modifier: Modifier = Modifier) {
diff --git a/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/shared/component/SettingLoadErrorContent.kt b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/shared/component/SettingLoadErrorContent.kt
new file mode 100644
index 0000000000..a742b55256
--- /dev/null
+++ b/feature/setting/presentation/src/main/kotlin/com/afternote/feature/setting/presentation/shared/component/SettingLoadErrorContent.kt
@@ -0,0 +1,42 @@
+package com.afternote.feature.setting.presentation.shared.component
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import com.afternote.core.ui.theme.AfternoteDesign
+import com.afternote.feature.setting.presentation.R
+
+@Composable
+internal fun SettingLoadErrorContent(
+    message: String,
+    onRetry: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Column(
+        modifier = modifier.fillMaxSize().padding(horizontal = 20.dp),
+        verticalArrangement = Arrangement.Center,
+        horizontalAlignment = Alignment.CenterHorizontally,
+    ) {
+        Text(
+            text = message,
+            style = AfternoteDesign.typography.bodySmallR,
+            color = AfternoteDesign.colors.gray6,
+            textAlign = TextAlign.Center,
+        )
+        Spacer(modifier = Modifier.height(8.dp))
+        TextButton(onClick = onRetry) {
+            Text(text = stringResource(R.string.setting_load_retry))
+        }
+    }
+}
diff --git a/feature/setting/presentation/src/main/res/values/strings.xml b/feature/setting/presentation/src/main/res/values/strings.xml
index 1bcff3c581..540b00bc6c 100644
--- a/feature/setting/presentation/src/main/res/values/strings.xml
+++ b/feature/setting/presentation/src/main/res/values/strings.xml
@@ -130,6 +130,16 @@
     <string name="setting_btn_password_auth">비밀번호로 인증하기</string>
     <string name="setting_insert_password">비밀번호를 입력해주세요</string>
 
+    <!-- 패스키 등록 생체 인증 프롬프트 -->
+    <string name="setting_biometric_prompt_title">패스키 등록</string>
+    <string name="setting_biometric_prompt_subtitle">패스키로 사용할 지문을 인식해 주세요.</string>
+    <string name="setting_biometric_verification_failed">지문 확인에 실패했어요. 다시 시도해 주세요.</string>
+    <string name="setting_biometric_not_available">지문 인증을 사용할 수 없습니다.</string>
+    <string name="setting_biometric_init_failed">인증 화면을 불러오지 못했습니다. 앱을 다시 시작해 주세요.</string>
+    <string name="setting_biometric_no_hardware">이 기기는 생체 인식을 지원하지 않습니다.</string>
+    <string name="setting_biometric_none_enrolled">등록된 지문이나 화면 잠금이 없습니다. 설정에서 등록해 주세요.</string>
+    <string name="setting_biometric_hw_unavailable">생체 인식을 일시적으로 사용할 수 없습니다. 잠시 후 다시 시도해 주세요.</string>
+
     <!-- 안내 텍스트 -->
     <string name="setting_passkey_section_title">패스키 관리</string>
     <string name="setting_passkey_description">패스키를 만들어 비밀번호 대신 지문 및 얼굴 인식으로\n쉽고 안전하게 로그인할 수 있습니다.\n패스키는 본인 소유의 기기에서만 생성해주세요.</string>
@@ -170,15 +180,41 @@
     <string name="setting_receiver_load_failed">수신자 정보를 불러오지 못했습니다.</string>
     <string name="setting_menu_unavailable">현재 이 메뉴는 이용할 수 없습니다.</string>
     <string name="setting_menu_acknowledge">확인</string>
+    <!-- 카카오톡 수신자 초대 (#944). -->
+    <string name="setting_receiver_invite_cta">카카오톡으로 초대 보내기</string>
+    <string name="setting_receiver_invite_form_notice">카카오톡 친구 목록은 불러오지 않으며, 초대 링크를 상대방이 수락하기 전에는 연락처가 저장되지 않습니다.</string>
+    <string name="setting_receiver_invite_sheet_title">카카오톡으로 이동합니다.</string>
+    <string name="setting_receiver_invite_sent_top_bar_title">수신자 등록</string>
+    <string name="setting_receiver_invite_sheet_description">%1$s 님에게 보낼 초대메세지를 카카오톡에서 확인 후 보내주세요. 전송 후 애프터노트로 자동으로 돌아옵니다.</string>
+    <string name="setting_receiver_invite_send">카카오톡으로 초대 보내기</string>
+    <string name="setting_receiver_invite_send_later">나중에 보내기</string>
+    <string name="setting_receiver_invite_sent_title">초대를 보냈어요.</string>
+    <string name="setting_receiver_invite_sent_description">%1$s 님이 링크를 열고 수락하면\n연결이 완료돼요.</string>
+    <string name="setting_receiver_invite_sent_open_list">수신자 목록으로 이동하기</string>
+    <string name="setting_receiver_invite_sent_resend">초대 링크 다시 보내기</string>
+    <string name="setting_receiver_invite_sent_caption">7일이 지나도 수락하지 않으면 다시 안내해 드려요.</string>
+    <string name="setting_receiver_invite_sent_check_description">초대 전송 완료</string>
+    <string name="setting_receiver_invite_create_failed">초대를 만들지 못했습니다. 잠시 후 다시 시도해주세요.</string>
+    <string name="setting_receiver_invite_create_unauthenticated">로그인이 필요합니다. 다시 로그인한 뒤 시도해주세요.</string>
+    <string name="setting_receiver_invite_sender_name_unavailable">내 이름을 확인하지 못해 초대를 보낼 수 없습니다. 잠시 후 다시 시도해주세요.</string>
+    <string name="setting_receiver_invite_share_failed">카카오톡 공유를 열지 못했습니다. 카카오톡 설치 여부를 확인해주세요.</string>
     <!-- 비밀번호 변경 -->
     <string name="setting_password_change_current_label">현재 비밀번호</string>
     <string name="setting_password_change_current_placeholder">현재 비밀번호를 입력해주세요</string>
     <string name="setting_password_change_new_label">새 비밀번호</string>
     <string name="setting_password_change_new_placeholder">새 비밀번호를 입력해주세요</string>
-    <string name="setting_password_change_rule">8 ~ 15자의 영문, 숫자, 특수문자(@, $, !, %, *, #, ?, &amp;)를 각각 1자 이상 사용해 주세요.</string>
     <string name="setting_password_change_submit">변경하기</string>
     <string name="setting_password_change_unchanged">지금 쓰고 있는 비밀번호입니다. 다른 비밀번호를 입력해 주세요.</string>
     <string name="setting_password_change_social_blocked">소셜 로그인으로 가입한 계정은 비밀번호를 변경할 수 없습니다.</string>
     <string name="setting_password_change_network_error">네트워크 연결을 확인해주세요.</string>
     <string name="setting_password_change_failed">비밀번호를 변경하지 못했습니다. 입력하신 내용을 확인해 주세요.</string>
+    <string name="setting_profile_load_error">프로필을 불러올 수 없습니다.</string>
+    <string name="setting_profile_update_error">프로필 수정에 실패했습니다. 다시 시도해 주세요.</string>
+    <string name="setting_push_load_error">알림 설정을 불러올 수 없습니다.</string>
+    <string name="setting_load_retry">다시 시도</string>
+    <string name="setting_passkey_list_retry">다시 시도</string>
+    <string name="setting_passkey_list_error">패스키 목록을 불러올 수 없습니다.</string>
+    <string name="setting_passkey_options_error">패스키 등록 준비에 실패했습니다. 다시 시도해 주세요.</string>
+    <string name="setting_passkey_registration_error">패스키 등록에 실패했습니다. 다시 시도해 주세요.</string>
+    <string name="setting_passkey_registration_complete">패스키 생성이 완료되었습니다</string>
 </resources>
diff --git a/feature/setting/presentation/src/screenshotTest/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsScreenScreenshotTest.kt b/feature/setting/presentation/src/screenshotTest/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsScreenScreenshotTest.kt
index 680fa0fba8..cca855c10c 100644
--- a/feature/setting/presentation/src/screenshotTest/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsScreenScreenshotTest.kt
+++ b/feature/setting/presentation/src/screenshotTest/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsScreenScreenshotTest.kt
@@ -24,10 +24,11 @@ internal fun connectedAccountsScreenCompactScreenshot() {
 }
 
 @Composable
-private fun ConnectedAccountsScreenScreenshotContent() {
+private fun ConnectedAccountsScreenScreenshotContent(uiState: ConnectedAccountsUiState = connectedAccountsPreviewState) {
     AfternoteTheme {
         ConnectedAccountsContent(
-            uiState = connectedAccountsPreviewState,
+            onRetry = {},
+            uiState = uiState,
             snackbarHostState = remember { SnackbarHostState() },
             onBack = {},
             onToggle = { _, _ -> },
@@ -68,3 +69,19 @@ private val connectedAccountsPreviewState =
                 ),
             ),
     )
+
+@PreviewTest
+@Preview(showBackground = true)
+@Preview(showBackground = true, device = COMPACT_DEVICE_SPEC)
+@Composable
+internal fun connectedAccountsLoadingScreenshot() {
+    ConnectedAccountsScreenScreenshotContent(ConnectedAccountsUiState(isLoading = true))
+}
+
+@PreviewTest
+@Preview(showBackground = true)
+@Preview(showBackground = true, device = COMPACT_DEVICE_SPEC)
+@Composable
+internal fun connectedAccountsLoadErrorScreenshot() {
+    ConnectedAccountsScreenScreenshotContent(ConnectedAccountsUiState(errorMessage = "계정 정보를 불러올 수 없습니다."))
+}
diff --git a/feature/setting/presentation/src/screenshotTest/kotlin/com/afternote/feature/setting/presentation/home/SettingProfileScreenshotTest.kt b/feature/setting/presentation/src/screenshotTest/kotlin/com/afternote/feature/setting/presentation/home/SettingProfileScreenshotTest.kt
new file mode 100644
index 0000000000..ea8aa9fc20
--- /dev/null
+++ b/feature/setting/presentation/src/screenshotTest/kotlin/com/afternote/feature/setting/presentation/home/SettingProfileScreenshotTest.kt
@@ -0,0 +1,66 @@
+package com.afternote.feature.setting.presentation.home
+
+import android.graphics.Bitmap
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.ui.tooling.preview.Preview
+import coil3.annotation.ExperimentalCoilApi
+import coil3.asImage
+import coil3.compose.AsyncImagePainter
+import coil3.compose.AsyncImagePreviewHandler
+import coil3.compose.LocalAsyncImagePreviewHandler
+import coil3.request.ErrorResult
+import com.afternote.core.ui.theme.AfternoteTheme
+import com.afternote.feature.setting.presentation.home.component.SettingProfile
+import com.android.tools.screenshot.PreviewTest
+import java.io.IOException
+
+@PreviewTest
+@Preview(showBackground = true, widthDp = 360)
+@Composable
+internal fun settingProfileDefaultScreenshot() {
+    SettingProfileScreenshotContent(profileImageUrl = null)
+}
+
+@OptIn(ExperimentalCoilApi::class)
+@PreviewTest
+@Preview(showBackground = true, widthDp = 360)
+@Composable
+internal fun settingProfilePhotoScreenshot() {
+    val photo =
+        Bitmap
+            .createBitmap(160, 120, Bitmap.Config.ARGB_8888)
+            .apply { eraseColor(0xFF5B7DB1.toInt()) }
+            .asImage()
+    CompositionLocalProvider(LocalAsyncImagePreviewHandler provides AsyncImagePreviewHandler { photo }) {
+        SettingProfileScreenshotContent(profileImageUrl = "content://preview/profile-photo")
+    }
+}
+
+@OptIn(ExperimentalCoilApi::class)
+@PreviewTest
+@Preview(showBackground = true, widthDp = 360)
+@Composable
+internal fun settingProfilePhotoFailureScreenshot() {
+    val failedRequest =
+        AsyncImagePreviewHandler { _, request ->
+            AsyncImagePainter.State.Error(null, ErrorResult(null, request, IOException("missing image")))
+        }
+    CompositionLocalProvider(LocalAsyncImagePreviewHandler provides failedRequest) {
+        SettingProfileScreenshotContent(profileImageUrl = "content://preview/missing-photo")
+    }
+}
+
+@Composable
+private fun SettingProfileScreenshotContent(profileImageUrl: String?) {
+    AfternoteTheme {
+        SettingProfile(
+            name = "홍길동",
+            email = "user@example.com",
+            profileImageUrl = profileImageUrl,
+            onInquiryClick = {},
+            onNoticeClick = {},
+            onRecipientListClick = {},
+        )
+    }
+}
diff --git a/feature/setting/presentation/src/screenshotTest/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationScreenScreenshotTest.kt b/feature/setting/presentation/src/screenshotTest/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationScreenScreenshotTest.kt
index d3168b6c7b..07e49c4ead 100644
--- a/feature/setting/presentation/src/screenshotTest/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationScreenScreenshotTest.kt
+++ b/feature/setting/presentation/src/screenshotTest/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationScreenScreenshotTest.kt
@@ -2,8 +2,10 @@ package com.afternote.feature.setting.presentation.notification
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.tooling.preview.Preview
+import com.afternote.core.ui.UiText
 import com.afternote.core.ui.theme.AfternoteTheme
 import com.afternote.feature.setting.presentation.COMPACT_DEVICE_SPEC
+import com.afternote.feature.setting.presentation.R
 import com.android.tools.screenshot.PreviewTest
 
 @PreviewTest
@@ -21,10 +23,11 @@ internal fun pushNotificationCompactScreenshot() {
 }
 
 @Composable
-private fun PushNotificationScreenshotContent() {
+private fun PushNotificationScreenshotContent(uiState: PushNotificationUiState = PushNotificationUiState(isAfternoteOn = true)) {
     AfternoteTheme {
         PushNotificationContent(
-            uiState = PushNotificationUiState(isAfternoteOn = true),
+            onRetry = {},
+            uiState = uiState,
             onBack = {},
             onNewsletterToggle = {},
             onMindRecordToggle = {},
@@ -32,3 +35,19 @@ private fun PushNotificationScreenshotContent() {
         )
     }
 }
+
+@PreviewTest
+@Preview(showBackground = true)
+@Preview(showBackground = true, device = COMPACT_DEVICE_SPEC)
+@Composable
+internal fun pushNotificationLoadingScreenshot() {
+    PushNotificationScreenshotContent(PushNotificationUiState(isLoading = true))
+}
+
+@PreviewTest
+@Preview(showBackground = true)
+@Preview(showBackground = true, device = COMPACT_DEVICE_SPEC)
+@Composable
+internal fun pushNotificationLoadErrorScreenshot() {
+    PushNotificationScreenshotContent(PushNotificationUiState(errorMessage = UiText.Resource(R.string.setting_push_load_error)))
+}
diff --git a/feature/setting/presentation/src/screenshotTest/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyListStateScreenshotTest.kt b/feature/setting/presentation/src/screenshotTest/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyListStateScreenshotTest.kt
new file mode 100644
index 0000000000..555922aa3c
--- /dev/null
+++ b/feature/setting/presentation/src/screenshotTest/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyListStateScreenshotTest.kt
@@ -0,0 +1,70 @@
+package com.afternote.feature.setting.presentation.passkey
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import com.afternote.core.ui.theme.AfternoteTheme
+import com.afternote.feature.setting.domain.Passkey
+import com.afternote.feature.setting.presentation.COMPACT_DEVICE_SPEC
+import com.afternote.feature.setting.presentation.R
+import com.android.tools.screenshot.PreviewTest
+
+@PreviewTest
+@Preview(showBackground = true)
+@Preview(showBackground = true, device = COMPACT_DEVICE_SPEC)
+@Composable
+internal fun passkeyListLoadingScreenshot() {
+    PasskeyListScreenshotContent(isLoading = true)
+}
+
+@PreviewTest
+@Preview(showBackground = true)
+@Preview(showBackground = true, device = COMPACT_DEVICE_SPEC)
+@Composable
+internal fun passkeyListErrorScreenshot() {
+    PasskeyListScreenshotContent(errorMessage = stringResource(R.string.setting_passkey_list_error))
+}
+
+@PreviewTest
+@Preview(showBackground = true)
+@Preview(showBackground = true, device = COMPACT_DEVICE_SPEC)
+@Composable
+internal fun passkeyListEmptyScreenshot() {
+    PasskeyListScreenshotContent()
+}
+
+@PreviewTest
+@Preview(showBackground = true)
+@Preview(showBackground = true, device = COMPACT_DEVICE_SPEC)
+@Composable
+internal fun passkeyListRegisteredScreenshot() {
+    PasskeyListScreenshotContent(
+        passkeys =
+            listOf(
+                Passkey(7L, "휴대전화 패스키", "2026-09-06T10:00:00"),
+                Passkey(
+                    8L,
+                    "회사에서 사용하는 태블릿에 저장한 아주 긴 이름의 패스키",
+                    "2026-09-08T15:30:00.123456789+09:00",
+                ),
+            ),
+    )
+}
+
+@Composable
+private fun PasskeyListScreenshotContent(
+    passkeys: List<Passkey> = emptyList(),
+    isLoading: Boolean = false,
+    errorMessage: String? = null,
+) {
+    AfternoteTheme {
+        PassKeyListScreen(
+            passkeys = passkeys,
+            isLoading = isLoading,
+            errorMessage = errorMessage,
+            onBackClick = {},
+            onRegisterClick = {},
+            onRetryClick = {},
+        )
+    }
+}
diff --git a/feature/setting/presentation/src/screenshotTest/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverInviteSentScreenScreenshotTest.kt b/feature/setting/presentation/src/screenshotTest/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverInviteSentScreenScreenshotTest.kt
new file mode 100644
index 0000000000..3639fa5033
--- /dev/null
+++ b/feature/setting/presentation/src/screenshotTest/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverInviteSentScreenScreenshotTest.kt
@@ -0,0 +1,36 @@
+package com.afternote.feature.setting.presentation.receiver
+
+import androidx.compose.material3.SnackbarHostState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.tooling.preview.Preview
+import com.afternote.core.ui.theme.AfternoteTheme
+import com.afternote.feature.setting.presentation.COMPACT_DEVICE_SPEC
+import com.android.tools.screenshot.PreviewTest
+
+@PreviewTest
+@Preview(showBackground = true)
+@Composable
+internal fun receiverInviteSentScreenScreenshot() {
+    ReceiverInviteSentScreenshotContent()
+}
+
+@PreviewTest
+@Preview(showBackground = true, device = COMPACT_DEVICE_SPEC)
+@Composable
+internal fun receiverInviteSentScreenCompactScreenshot() {
+    ReceiverInviteSentScreenshotContent()
+}
+
+@Composable
+private fun ReceiverInviteSentScreenshotContent() {
+    AfternoteTheme {
+        ReceiverInviteSentContent(
+            receiverName = "김민서",
+            snackbarHostState = remember { SnackbarHostState() },
+            onBackClick = {},
+            onOpenReceiverList = {},
+            onResend = {},
+        )
+    }
+}
diff --git a/feature/setting/presentation/src/screenshotTest/kotlin/com/afternote/feature/setting/presentation/receiver/component/ReceiverInviteSheetScreenshotTest.kt b/feature/setting/presentation/src/screenshotTest/kotlin/com/afternote/feature/setting/presentation/receiver/component/ReceiverInviteSheetScreenshotTest.kt
new file mode 100644
index 0000000000..f641451968
--- /dev/null
+++ b/feature/setting/presentation/src/screenshotTest/kotlin/com/afternote/feature/setting/presentation/receiver/component/ReceiverInviteSheetScreenshotTest.kt
@@ -0,0 +1,38 @@
+package com.afternote.feature.setting.presentation.receiver.component
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.tooling.preview.Preview
+import com.afternote.core.ui.UiText
+import com.afternote.core.ui.theme.AfternoteTheme
+import com.afternote.feature.setting.presentation.R
+import com.android.tools.screenshot.PreviewTest
+
+@PreviewTest
+@Preview(showBackground = true)
+@Composable
+internal fun receiverInviteSheetContentScreenshot() {
+    AfternoteTheme {
+        ReceiverInviteSheetContent(
+            receiverName = "김민서",
+            isSending = false,
+            errorMessage = null,
+            onSend = {},
+            onDismiss = {},
+        )
+    }
+}
+
+@PreviewTest
+@Preview(showBackground = true)
+@Composable
+internal fun receiverInviteSheetContentErrorScreenshot() {
+    AfternoteTheme {
+        ReceiverInviteSheetContent(
+            receiverName = "김민서",
+            isSending = false,
+            errorMessage = UiText.Resource(R.string.setting_receiver_invite_share_failed),
+            onSend = {},
+            onDismiss = {},
+        )
+    }
+}
diff --git a/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/account/ConnectedAccountsScreenScreenshotTestKt/connectedAccountsLoadErrorScreenshot_748aa731_0.png b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/account/ConnectedAccountsScreenScreenshotTestKt/connectedAccountsLoadErrorScreenshot_748aa731_0.png
new file mode 100644
index 0000000000..6852feed9e
Binary files /dev/null and b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/account/ConnectedAccountsScreenScreenshotTestKt/connectedAccountsLoadErrorScreenshot_748aa731_0.png differ
diff --git a/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/account/ConnectedAccountsScreenScreenshotTestKt/connectedAccountsLoadErrorScreenshot_c2abd7e6_0.png b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/account/ConnectedAccountsScreenScreenshotTestKt/connectedAccountsLoadErrorScreenshot_c2abd7e6_0.png
new file mode 100644
index 0000000000..74ab59ac8d
Binary files /dev/null and b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/account/ConnectedAccountsScreenScreenshotTestKt/connectedAccountsLoadErrorScreenshot_c2abd7e6_0.png differ
diff --git a/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/account/ConnectedAccountsScreenScreenshotTestKt/connectedAccountsLoadingScreenshot_748aa731_0.png b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/account/ConnectedAccountsScreenScreenshotTestKt/connectedAccountsLoadingScreenshot_748aa731_0.png
new file mode 100644
index 0000000000..8332c47afb
Binary files /dev/null and b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/account/ConnectedAccountsScreenScreenshotTestKt/connectedAccountsLoadingScreenshot_748aa731_0.png differ
diff --git a/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/account/ConnectedAccountsScreenScreenshotTestKt/connectedAccountsLoadingScreenshot_c2abd7e6_0.png b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/account/ConnectedAccountsScreenScreenshotTestKt/connectedAccountsLoadingScreenshot_c2abd7e6_0.png
new file mode 100644
index 0000000000..04fd32d7af
Binary files /dev/null and b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/account/ConnectedAccountsScreenScreenshotTestKt/connectedAccountsLoadingScreenshot_c2abd7e6_0.png differ
diff --git a/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/home/SettingProfileScreenshotTestKt/settingProfileDefaultScreenshot_74131fac_0.png b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/home/SettingProfileScreenshotTestKt/settingProfileDefaultScreenshot_74131fac_0.png
new file mode 100644
index 0000000000..a0942fdfd1
Binary files /dev/null and b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/home/SettingProfileScreenshotTestKt/settingProfileDefaultScreenshot_74131fac_0.png differ
diff --git a/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/home/SettingProfileScreenshotTestKt/settingProfilePhotoFailureScreenshot_74131fac_0.png b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/home/SettingProfileScreenshotTestKt/settingProfilePhotoFailureScreenshot_74131fac_0.png
new file mode 100644
index 0000000000..a0942fdfd1
Binary files /dev/null and b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/home/SettingProfileScreenshotTestKt/settingProfilePhotoFailureScreenshot_74131fac_0.png differ
diff --git a/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/home/SettingProfileScreenshotTestKt/settingProfilePhotoScreenshot_74131fac_0.png b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/home/SettingProfileScreenshotTestKt/settingProfilePhotoScreenshot_74131fac_0.png
new file mode 100644
index 0000000000..bd8e9805d5
Binary files /dev/null and b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/home/SettingProfileScreenshotTestKt/settingProfilePhotoScreenshot_74131fac_0.png differ
diff --git a/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/notification/PushNotificationScreenScreenshotTestKt/pushNotificationLoadErrorScreenshot_748aa731_0.png b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/notification/PushNotificationScreenScreenshotTestKt/pushNotificationLoadErrorScreenshot_748aa731_0.png
new file mode 100644
index 0000000000..236b375198
Binary files /dev/null and b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/notification/PushNotificationScreenScreenshotTestKt/pushNotificationLoadErrorScreenshot_748aa731_0.png differ
diff --git a/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/notification/PushNotificationScreenScreenshotTestKt/pushNotificationLoadErrorScreenshot_c2abd7e6_0.png b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/notification/PushNotificationScreenScreenshotTestKt/pushNotificationLoadErrorScreenshot_c2abd7e6_0.png
new file mode 100644
index 0000000000..42ec702aad
Binary files /dev/null and b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/notification/PushNotificationScreenScreenshotTestKt/pushNotificationLoadErrorScreenshot_c2abd7e6_0.png differ
diff --git a/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/notification/PushNotificationScreenScreenshotTestKt/pushNotificationLoadingScreenshot_748aa731_0.png b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/notification/PushNotificationScreenScreenshotTestKt/pushNotificationLoadingScreenshot_748aa731_0.png
new file mode 100644
index 0000000000..ff4783be9e
Binary files /dev/null and b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/notification/PushNotificationScreenScreenshotTestKt/pushNotificationLoadingScreenshot_748aa731_0.png differ
diff --git a/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/notification/PushNotificationScreenScreenshotTestKt/pushNotificationLoadingScreenshot_c2abd7e6_0.png b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/notification/PushNotificationScreenScreenshotTestKt/pushNotificationLoadingScreenshot_c2abd7e6_0.png
new file mode 100644
index 0000000000..cd52495352
Binary files /dev/null and b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/notification/PushNotificationScreenScreenshotTestKt/pushNotificationLoadingScreenshot_c2abd7e6_0.png differ
diff --git a/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/passkey/PassKeyListStateScreenshotTestKt/passkeyListEmptyScreenshot_748aa731_0.png b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/passkey/PassKeyListStateScreenshotTestKt/passkeyListEmptyScreenshot_748aa731_0.png
new file mode 100644
index 0000000000..bcabda7f1a
Binary files /dev/null and b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/passkey/PassKeyListStateScreenshotTestKt/passkeyListEmptyScreenshot_748aa731_0.png differ
diff --git a/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/passkey/PassKeyListStateScreenshotTestKt/passkeyListEmptyScreenshot_c2abd7e6_0.png b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/passkey/PassKeyListStateScreenshotTestKt/passkeyListEmptyScreenshot_c2abd7e6_0.png
new file mode 100644
index 0000000000..baa6cec5f4
Binary files /dev/null and b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/passkey/PassKeyListStateScreenshotTestKt/passkeyListEmptyScreenshot_c2abd7e6_0.png differ
diff --git a/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/passkey/PassKeyListStateScreenshotTestKt/passkeyListErrorScreenshot_748aa731_0.png b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/passkey/PassKeyListStateScreenshotTestKt/passkeyListErrorScreenshot_748aa731_0.png
new file mode 100644
index 0000000000..dcd6a6c8fc
Binary files /dev/null and b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/passkey/PassKeyListStateScreenshotTestKt/passkeyListErrorScreenshot_748aa731_0.png differ
diff --git a/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/passkey/PassKeyListStateScreenshotTestKt/passkeyListErrorScreenshot_c2abd7e6_0.png b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/passkey/PassKeyListStateScreenshotTestKt/passkeyListErrorScreenshot_c2abd7e6_0.png
new file mode 100644
index 0000000000..d6d28345f3
Binary files /dev/null and b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/passkey/PassKeyListStateScreenshotTestKt/passkeyListErrorScreenshot_c2abd7e6_0.png differ
diff --git a/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/passkey/PassKeyListStateScreenshotTestKt/passkeyListLoadingScreenshot_748aa731_0.png b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/passkey/PassKeyListStateScreenshotTestKt/passkeyListLoadingScreenshot_748aa731_0.png
new file mode 100644
index 0000000000..b3601627fc
Binary files /dev/null and b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/passkey/PassKeyListStateScreenshotTestKt/passkeyListLoadingScreenshot_748aa731_0.png differ
diff --git a/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/passkey/PassKeyListStateScreenshotTestKt/passkeyListLoadingScreenshot_c2abd7e6_0.png b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/passkey/PassKeyListStateScreenshotTestKt/passkeyListLoadingScreenshot_c2abd7e6_0.png
new file mode 100644
index 0000000000..833c5eeea2
Binary files /dev/null and b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/passkey/PassKeyListStateScreenshotTestKt/passkeyListLoadingScreenshot_c2abd7e6_0.png differ
diff --git a/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/passkey/PassKeyListStateScreenshotTestKt/passkeyListRegisteredScreenshot_748aa731_0.png b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/passkey/PassKeyListStateScreenshotTestKt/passkeyListRegisteredScreenshot_748aa731_0.png
new file mode 100644
index 0000000000..3d3f04f119
Binary files /dev/null and b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/passkey/PassKeyListStateScreenshotTestKt/passkeyListRegisteredScreenshot_748aa731_0.png differ
diff --git a/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/passkey/PassKeyListStateScreenshotTestKt/passkeyListRegisteredScreenshot_c2abd7e6_0.png b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/passkey/PassKeyListStateScreenshotTestKt/passkeyListRegisteredScreenshot_c2abd7e6_0.png
new file mode 100644
index 0000000000..f1c1b03cae
Binary files /dev/null and b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/passkey/PassKeyListStateScreenshotTestKt/passkeyListRegisteredScreenshot_c2abd7e6_0.png differ
diff --git a/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/receiver/ReceiverInviteSentScreenScreenshotTestKt/receiverInviteSentScreenCompactScreenshot_c2abd7e6_0.png b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/receiver/ReceiverInviteSentScreenScreenshotTestKt/receiverInviteSentScreenCompactScreenshot_c2abd7e6_0.png
new file mode 100644
index 0000000000..13b10b94ff
Binary files /dev/null and b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/receiver/ReceiverInviteSentScreenScreenshotTestKt/receiverInviteSentScreenCompactScreenshot_c2abd7e6_0.png differ
diff --git a/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/receiver/ReceiverInviteSentScreenScreenshotTestKt/receiverInviteSentScreenScreenshot_748aa731_0.png b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/receiver/ReceiverInviteSentScreenScreenshotTestKt/receiverInviteSentScreenScreenshot_748aa731_0.png
new file mode 100644
index 0000000000..2fbca58e06
Binary files /dev/null and b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/receiver/ReceiverInviteSentScreenScreenshotTestKt/receiverInviteSentScreenScreenshot_748aa731_0.png differ
diff --git a/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/receiver/component/ReceiverInviteSheetScreenshotTestKt/receiverInviteSheetContentErrorScreenshot_748aa731_0.png b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/receiver/component/ReceiverInviteSheetScreenshotTestKt/receiverInviteSheetContentErrorScreenshot_748aa731_0.png
new file mode 100644
index 0000000000..aa3b968aba
Binary files /dev/null and b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/receiver/component/ReceiverInviteSheetScreenshotTestKt/receiverInviteSheetContentErrorScreenshot_748aa731_0.png differ
diff --git a/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/receiver/component/ReceiverInviteSheetScreenshotTestKt/receiverInviteSheetContentScreenshot_748aa731_0.png b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/receiver/component/ReceiverInviteSheetScreenshotTestKt/receiverInviteSheetContentScreenshot_748aa731_0.png
new file mode 100644
index 0000000000..d3bc51bc7c
Binary files /dev/null and b/feature/setting/presentation/src/screenshotTestDebug/reference/com/afternote/feature/setting/presentation/receiver/component/ReceiverInviteSheetScreenshotTestKt/receiverInviteSheetContentScreenshot_748aa731_0.png differ
diff --git a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/ProfileReentryFormTest.kt b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/ProfileReentryFormTest.kt
new file mode 100644
index 0000000000..ecc217b4a3
--- /dev/null
+++ b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/ProfileReentryFormTest.kt
@@ -0,0 +1,93 @@
+package com.afternote.feature.setting.presentation
+
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.hasSetTextAction
+import androidx.compose.ui.test.hasText
+import androidx.compose.ui.test.junit4.v2.createComposeRule
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performScrollTo
+import androidx.compose.ui.test.performTextReplacement
+import com.afternote.core.domain.testing.FakeMyProfileRepository
+import com.afternote.core.domain.testing.FakePhotoUploadRepository
+import com.afternote.core.model.user.User
+import com.afternote.core.ui.theme.AfternoteTheme
+import com.afternote.feature.setting.presentation.profile.ProfileEditIntent
+import com.afternote.feature.setting.presentation.profile.ProfileEditScreen
+import com.afternote.feature.setting.presentation.profile.ProfileEditUiState
+import com.afternote.feature.setting.presentation.profile.ProfileEditViewModel
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import org.robolectric.annotation.GraphicsMode
+
+@RunWith(RobolectricTestRunner::class)
+@GraphicsMode(GraphicsMode.Mode.NATIVE)
+@Config(sdk = [35])
+class ProfileReentryFormTest {
+    @get:Rule
+    val composeRule = createComposeRule()
+
+    @Test
+    fun successfulRefresh_preservesEditedNameAndUpdatesUntouchedFields() {
+        val repository =
+            FakeMyProfileRepository.strict().apply {
+                onGetMyProfile = { User("초기 이름", "before@example.com", "01011112222", null) }
+            }
+        val viewModel = ProfileEditViewModel(repository, FakePhotoUploadRepository.strict())
+        setContent(viewModel)
+        composeRule.onNode(hasSetTextAction() and hasText("초기 이름")).performScrollTo().performTextReplacement("작성 중인 이름")
+
+        composeRule.runOnIdle {
+            repository.onGetMyProfile = { User("서버 이름", "after@example.com", "01033334444", null) }
+            viewModel.onIntent(ProfileEditIntent.RefreshOnReturn)
+        }
+        composeRule.waitUntil(timeoutMillis = 5_000) {
+            (viewModel.uiState.value as? ProfileEditUiState.Success)?.name == "서버 이름"
+        }
+
+        composeRule.onNodeWithText("작성 중인 이름").performScrollTo().assertIsDisplayed()
+        composeRule.onNodeWithText("01033334444").performScrollTo().assertIsDisplayed()
+        composeRule.onNodeWithText("after@example.com").performScrollTo().assertIsDisplayed()
+    }
+
+    @Test
+    fun failedRefresh_keepsEditedFormMounted() {
+        var calls = 0
+        val repository =
+            FakeMyProfileRepository.strict().apply {
+                onGetMyProfile = {
+                    calls++
+                    User("초기 이름", "before@example.com", "01011112222", null)
+                }
+            }
+        val viewModel = ProfileEditViewModel(repository, FakePhotoUploadRepository.strict())
+        setContent(viewModel)
+        composeRule.onNode(hasSetTextAction() and hasText("초기 이름")).performScrollTo().performTextReplacement("작성 중인 이름")
+        composeRule.onNode(hasSetTextAction() and hasText("01011112222")).performScrollTo().performTextReplacement("01099998888")
+
+        composeRule.runOnIdle {
+            repository.onGetMyProfile = {
+                calls++
+                error("offline")
+            }
+            viewModel.onIntent(ProfileEditIntent.RefreshOnReturn)
+        }
+        composeRule.waitUntil(timeoutMillis = 5_000) { calls == 2 }
+
+        assertTrue(viewModel.uiState.value is ProfileEditUiState.Success)
+        composeRule.onNodeWithText("작성 중인 이름").performScrollTo().assertIsDisplayed()
+        composeRule.onNodeWithText("01099998888").performScrollTo().assertIsDisplayed()
+    }
+
+    private fun setContent(viewModel: ProfileEditViewModel) {
+        composeRule.setContent {
+            AfternoteTheme {
+                ProfileEditScreen(onBackClick = {}, onWithdrawGuideClick = {}, viewModel = viewModel)
+            }
+        }
+        composeRule.waitUntil(timeoutMillis = 5_000) { viewModel.uiState.value is ProfileEditUiState.Success }
+    }
+}
diff --git a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/SettingAccountSecurityTest.kt b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/SettingAccountSecurityTest.kt
index cb449670ea..91b5f5f0d8 100644
--- a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/SettingAccountSecurityTest.kt
+++ b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/SettingAccountSecurityTest.kt
@@ -6,9 +6,11 @@ import androidx.compose.ui.test.junit4.v2.createComposeRule
 import androidx.compose.ui.test.onNodeWithText
 import androidx.compose.ui.test.performClick
 import androidx.compose.ui.test.performTextInput
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.afternote.core.domain.testing.FakeAuthRepository
 import com.afternote.core.domain.testing.FakeMyProfileRepository
 import com.afternote.core.domain.testing.FakeMyProfileRepository.ProfileUpdateCall
+import com.afternote.core.domain.testing.FakePhotoUploadRepository
 import com.afternote.core.domain.testing.FakeUserReceiverRepository
 import com.afternote.core.domain.testing.FakeUserReceiverRepository.DeliveryUpdateCall
 import com.afternote.core.model.delivery.ConditionState
@@ -22,16 +24,18 @@ import com.afternote.core.model.user.User
 import com.afternote.core.model.user.UserConnectedAccount
 import com.afternote.core.ui.UiText
 import com.afternote.core.ui.theme.AfternoteTheme
+import com.afternote.feature.setting.domain.Passkey
+import com.afternote.feature.setting.domain.UpdateTimeLetterDeliveryConditionUseCase
 import com.afternote.feature.setting.domain.testing.FakeSettingAccountRepository
 import com.afternote.feature.setting.domain.testing.FakeSettingAccountRepository.ConnectedAccountLinkCall
-import com.afternote.feature.setting.presentation.account.ConnectedAccountsEvent
+import com.afternote.feature.setting.presentation.account.ConnectedAccountsIntent
 import com.afternote.feature.setting.presentation.account.ConnectedAccountsViewModel
 import com.afternote.feature.setting.presentation.applock.AppLockSetupScreen
 import com.afternote.feature.setting.presentation.applock.AppLockSetupViewModel
 import com.afternote.feature.setting.presentation.applock.PinSetupStep
 import com.afternote.feature.setting.presentation.delivery.DeliveryConditionError
+import com.afternote.feature.setting.presentation.delivery.DeliveryConditionIntent
 import com.afternote.feature.setting.presentation.delivery.DeliveryConditionViewModel
-import com.afternote.feature.setting.presentation.home.SettingUiState
 import com.afternote.feature.setting.presentation.home.SettingViewModel
 import com.afternote.feature.setting.presentation.home.WithdrawConfirmScreen
 import com.afternote.feature.setting.presentation.home.WithdrawUiState
@@ -39,14 +43,14 @@ import com.afternote.feature.setting.presentation.navigation.SettingRoute
 import com.afternote.feature.setting.presentation.passkey.PassKeyListScreen
 import com.afternote.feature.setting.presentation.passkey.PassKeyScreen
 import com.afternote.feature.setting.presentation.profile.ProfileEditEvent
+import com.afternote.feature.setting.presentation.profile.ProfileEditIntent
 import com.afternote.feature.setting.presentation.profile.ProfileEditScreen
 import com.afternote.feature.setting.presentation.profile.ProfileEditUiState
 import com.afternote.feature.setting.presentation.profile.ProfileEditViewModel
+import com.afternote.feature.setting.presentation.receiver.ReceiverRegisterIntent
 import com.afternote.feature.setting.presentation.receiver.ReceiverRegisterViewModel
-import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.runBlocking
-import kotlinx.coroutines.withTimeout
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
 import org.junit.Assert.assertTrue
@@ -71,7 +75,7 @@ class SettingAccountSecurityTest {
             settingContractProfileRepository().apply {
                 onGetMyProfile = { throw IllegalStateException("profile unavailable") }
             }
-        val loadFailureViewModel = ProfileEditViewModel(loadFailureRepository)
+        val loadFailureViewModel = ProfileEditViewModel(loadFailureRepository, FakePhotoUploadRepository.strict())
 
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
             loadFailureViewModel.uiState.value == ProfileEditUiState.Error
@@ -87,18 +91,21 @@ class SettingAccountSecurityTest {
         }
 
         composeRule.onNodeWithText("프로필을 불러올 수 없습니다.").assertIsDisplayed()
-        composeRule.runOnIdle { loadFailureViewModel.updateProfile("새 이름", "01012345678") }
+        composeRule.runOnIdle { loadFailureViewModel.onIntent(ProfileEditIntent.UpdateProfile("새 이름", "01012345678")) }
         assertTrue(loadFailureRepository.profileUpdateCalls.isEmpty())
 
         val updateFailureRepository = settingContractProfileRepository()
-        val updateFailureViewModel = ProfileEditViewModel(updateFailureRepository)
+        val updateFailureViewModel = ProfileEditViewModel(updateFailureRepository, FakePhotoUploadRepository.strict())
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
             updateFailureViewModel.uiState.value is ProfileEditUiState.Success
         }
         updateFailureRepository.onUpdateMyProfile = { _, _, _ -> throw IllegalStateException("offline") }
 
-        composeRule.runOnIdle { updateFailureViewModel.updateProfile("   ", "") }
-        val event = awaitEvent(updateFailureViewModel.events)
+        composeRule.runOnIdle { updateFailureViewModel.onIntent(ProfileEditIntent.UpdateProfile("   ", "")) }
+        composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
+            (updateFailureViewModel.uiState.value as? ProfileEditUiState.Success)?.pendingEvent != null
+        }
+        val event = (updateFailureViewModel.uiState.value as ProfileEditUiState.Success).pendingEvent
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
             (updateFailureViewModel.uiState.value as? ProfileEditUiState.Success)?.isUpdating == false
         }
@@ -118,16 +125,15 @@ class SettingAccountSecurityTest {
             !linkViewModel.uiState.value.isLoading
         }
 
-        composeRule.runOnIdle { linkViewModel.onToggle(provider = "google", enabled = true) }
-        val request = awaitEvent(linkViewModel.events)
+        composeRule.runOnIdle { linkViewModel.onIntent(ConnectedAccountsIntent.Toggle(provider = "google", enabled = true)) }
 
-        assertEquals(ConnectedAccountsEvent.RequestLink("google"), request)
+        assertEquals("google", linkViewModel.uiState.value.pendingLinkProvider)
         assertTrue(linkRepository.connectedLinkCalls.isEmpty())
 
         linkRepository.onLinkConnectedAccount = { _, _ -> throw IllegalStateException("oauth rejected") }
-        composeRule.runOnIdle { linkViewModel.link(provider = "google", accessToken = "google-token") }
+        composeRule.runOnIdle { linkViewModel.onIntent(ConnectedAccountsIntent.Link(provider = "google", accessToken = "google-token")) }
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
-            linkViewModel.uiState.value.errorMessage == "계정 연결에 실패했습니다."
+            linkViewModel.uiState.value.pendingError == "계정 연결에 실패했습니다."
         }
 
         assertEquals(
@@ -146,13 +152,13 @@ class SettingAccountSecurityTest {
         }
 
         assertTrue(unlinkRepository.connectedUnlinkCalls.isEmpty())
-        composeRule.runOnIdle { unlinkViewModel.onToggle(provider = "google", enabled = false) }
+        composeRule.runOnIdle { unlinkViewModel.onIntent(ConnectedAccountsIntent.Toggle(provider = "google", enabled = false)) }
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
             unlinkRepository.connectedUnlinkCalls.size == 1
         }
 
         assertEquals(listOf("google"), unlinkRepository.connectedUnlinkCalls)
-        assertEquals("계정 연결 해제에 실패했습니다.", unlinkViewModel.uiState.value.errorMessage)
+        assertEquals("계정 연결 해제에 실패했습니다.", unlinkViewModel.uiState.value.pendingError)
     }
 
     @Test
@@ -161,12 +167,14 @@ class SettingAccountSecurityTest {
         val viewModel = ReceiverRegisterViewModel(repository)
 
         composeRule.runOnIdle {
-            viewModel.register(
-                name = "김수신",
-                relation = "가족",
-                phone = "   ",
-                email = "",
-                message = null,
+            viewModel.onIntent(
+                ReceiverRegisterIntent.Register(
+                    name = "김수신",
+                    relation = "가족",
+                    phone = "   ",
+                    email = "",
+                    message = null,
+                ),
             )
         }
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
@@ -206,14 +214,15 @@ class SettingAccountSecurityTest {
             DeliveryConditionViewModel(
                 route = SettingRoute.AfterDeliveryRoute(RECEIVER_ID),
                 receiverRepository = repository,
+                updateTimeLetterDeliveryCondition = UpdateTimeLetterDeliveryConditionUseCase(repository),
             )
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
             viewModel.uiState.value.isInitialized
         }
 
         composeRule.runOnIdle {
-            viewModel.onConditionTypeSelected(index = 1)
-            viewModel.onSave()
+            viewModel.onIntent(DeliveryConditionIntent.SelectConditionType(DeliveryConditionType.RECEIVER_REQUEST))
+            viewModel.onIntent(DeliveryConditionIntent.Save)
         }
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
             viewModel.uiState.value.error == DeliveryConditionError.SAVE_FAILED
@@ -268,7 +277,14 @@ class SettingAccountSecurityTest {
                     }
 
                     SecurityContractScreen.PASSKEY_LIST -> {
-                        PassKeyListScreen(onBackClick = {})
+                        PassKeyListScreen(
+                            passkeys = listOf(Passkey(7L, "서버 패스키", "2026-09-06T10:00:00")),
+                            isLoading = false,
+                            errorMessage = null,
+                            onBackClick = {},
+                            onRegisterClick = {},
+                            onRetryClick = {},
+                        )
                     }
                 }
             }
@@ -292,8 +308,8 @@ class SettingAccountSecurityTest {
         assertEquals(1, registerCalls)
 
         composeRule.onNodeWithText("패스키 목록").assertIsDisplayed()
-        composeRule.onNodeWithText("이름").assertIsDisplayed()
-        composeRule.onNodeWithText("생성일시").assertIsDisplayed()
+        composeRule.onNodeWithText("서버 패스키").assertIsDisplayed()
+        composeRule.onNodeWithText("2026.09.06 10:00").assertIsDisplayed()
     }
 
     @Test
@@ -308,7 +324,7 @@ class SettingAccountSecurityTest {
         composeRule.setContent {
             AfternoteTheme {
                 WithdrawConfirmScreen(
-                    uiState = SettingUiState.Success(name = DEFAULT_USER.name, email = DEFAULT_USER.email),
+                    uiState = viewModel.uiState.collectAsStateWithLifecycle().value,
                     onBackClick = {},
                     onWithdrawSuccess = { successCalls += 1 },
                     viewModel = viewModel,
@@ -327,7 +343,7 @@ class SettingAccountSecurityTest {
         }
 
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
-            viewModel.withdrawUiState.value == WithdrawUiState.Error
+            viewModel.uiState.value.withdraw == WithdrawUiState.Error
         }
         composeRule
             .onNodeWithText("회원 탈퇴에 실패했습니다. 잠시 후 다시 시도해 주세요.")
@@ -337,11 +353,6 @@ class SettingAccountSecurityTest {
         assertTrue(runBlocking { authRepository.isLoggedIn.first() })
     }
 
-    private fun <T> awaitEvent(events: Flow<T>): T =
-        runBlocking {
-            withTimeout(TIMEOUT_MILLIS) { events.first() }
-        }
-
     private companion object {
         const val TIMEOUT_MILLIS = 5_000L
         const val RECEIVER_ID = 77L
diff --git a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/SettingCompletionTest.kt b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/SettingCompletionTest.kt
index 52472d7104..7cbd697b3a 100644
--- a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/SettingCompletionTest.kt
+++ b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/SettingCompletionTest.kt
@@ -14,10 +14,14 @@ import androidx.compose.ui.test.performScrollToIndex
 import androidx.compose.ui.test.performScrollToNode
 import androidx.compose.ui.test.performTextClearance
 import androidx.compose.ui.test.performTextInput
+import androidx.lifecycle.SavedStateHandle
 import androidx.test.core.app.ApplicationProvider
 import com.afternote.core.common.reporting.ErrorReporter
 import com.afternote.core.domain.testing.FakeAuthRepository
 import com.afternote.core.domain.testing.FakeMyProfileRepository
+import com.afternote.core.domain.testing.FakePhotoUploadRepository
+import com.afternote.core.domain.testing.FakeReceiverInvitationRepository
+import com.afternote.core.domain.testing.FakeUserProfileCacheRepository
 import com.afternote.core.domain.testing.FakeUserReceiverRepository
 import com.afternote.core.model.delivery.ConditionState
 import com.afternote.core.model.delivery.DeliveryConditionItem
@@ -34,23 +38,36 @@ import com.afternote.core.model.user.UserMarketingConsent
 import com.afternote.core.model.user.UserPushSetting
 import com.afternote.core.ui.UiText
 import com.afternote.core.ui.theme.AfternoteTheme
+import com.afternote.feature.setting.domain.UpdateReceiverInfoUseCase
+import com.afternote.feature.setting.domain.UpdateTimeLetterDeliveryConditionUseCase
 import com.afternote.feature.setting.domain.testing.FakeSettingAccountRepository
 import com.afternote.feature.setting.domain.testing.FakeSettingNotificationRepository
+import com.afternote.feature.setting.presentation.account.ConnectedAccountsIntent
 import com.afternote.feature.setting.presentation.account.ConnectedAccountsViewModel
 import com.afternote.feature.setting.presentation.delivery.DeliveryConditionError
+import com.afternote.feature.setting.presentation.delivery.DeliveryConditionIntent
 import com.afternote.feature.setting.presentation.delivery.DeliveryConditionViewModel
+import com.afternote.feature.setting.presentation.home.SettingIntent
+import com.afternote.feature.setting.presentation.home.SettingProfileState
 import com.afternote.feature.setting.presentation.home.SettingUiState
 import com.afternote.feature.setting.presentation.home.SettingViewModel
 import com.afternote.feature.setting.presentation.home.WithdrawUiState
 import com.afternote.feature.setting.presentation.navigation.SettingRoute
+import com.afternote.feature.setting.presentation.notification.MarketingConsent
+import com.afternote.feature.setting.presentation.notification.PushNotificationIntent
 import com.afternote.feature.setting.presentation.notification.PushNotificationViewModel
+import com.afternote.feature.setting.presentation.notification.PushSetting
 import com.afternote.feature.setting.presentation.profile.ProfileEditEvent
+import com.afternote.feature.setting.presentation.profile.ProfileEditIntent
 import com.afternote.feature.setting.presentation.profile.ProfileEditUiState
 import com.afternote.feature.setting.presentation.profile.ProfileEditViewModel
 import com.afternote.feature.setting.presentation.receiver.ReceiverEditEvent
+import com.afternote.feature.setting.presentation.receiver.ReceiverEditIntent
 import com.afternote.feature.setting.presentation.receiver.ReceiverEditScreen
 import com.afternote.feature.setting.presentation.receiver.ReceiverEditViewModel
+import com.afternote.feature.setting.presentation.receiver.ReceiverInviteViewModel
 import com.afternote.feature.setting.presentation.receiver.ReceiverRegisterEvent
+import com.afternote.feature.setting.presentation.receiver.ReceiverRegisterIntent
 import com.afternote.feature.setting.presentation.receiver.ReceiverRegisterScreen
 import com.afternote.feature.setting.presentation.receiver.ReceiverRegisterViewModel
 import kotlinx.coroutines.CompletableDeferred
@@ -91,13 +108,13 @@ class SettingCompletionTest {
         val scenario = CompletionUserScenario()
         val repository = scenario.profileRepository
         val updateGate = scenario.enqueueProfileUpdate()
-        val viewModel = ProfileEditViewModel(repository)
+        val viewModel = ProfileEditViewModel(repository, FakePhotoUploadRepository.strict())
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
             viewModel.uiState.value is ProfileEditUiState.Success
         }
 
         composeRule.runOnIdle {
-            viewModel.updateProfile(name = "새 이름", phone = "01098765432")
+            viewModel.onIntent(ProfileEditIntent.UpdateProfile(name = "새 이름", phone = "01098765432"))
         }
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
             repository.profileUpdateCalls.size == 1
@@ -113,7 +130,11 @@ class SettingCompletionTest {
             Result.success(COMPLETION_DEFAULT_USER.copy(name = "새 이름", phone = "01098765432")),
         )
 
-        assertEquals(ProfileEditEvent.UpdateSuccess, awaitEvent(viewModel.events))
+        composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
+            (viewModel.uiState.value as? ProfileEditUiState.Success)?.pendingEvent == ProfileEditEvent.UpdateSuccess
+        }
+        composeRule.runOnIdle { viewModel.onIntent(ProfileEditIntent.ConsumeEvent(ProfileEditEvent.UpdateSuccess)) }
+        assertEquals(null, (viewModel.uiState.value as ProfileEditUiState.Success).pendingEvent)
     }
 
     @Test
@@ -134,7 +155,7 @@ class SettingCompletionTest {
             !viewModel.uiState.value.isLoading
         }
 
-        composeRule.runOnIdle { viewModel.onNewsletterToggle(false) }
+        composeRule.runOnIdle { viewModel.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.NEWSLETTER, false)) }
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
             repository.pushUpdateCalls.size == 1
         }
@@ -153,7 +174,7 @@ class SettingCompletionTest {
         }
         assertFalse(viewModel.uiState.value.isNewsletterOn)
 
-        composeRule.runOnIdle { viewModel.onMindRecordToggle(false) }
+        composeRule.runOnIdle { viewModel.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.MIND_RECORD, false)) }
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
             repository.pushUpdateCalls.size == 2
         }
@@ -177,10 +198,10 @@ class SettingCompletionTest {
         assertTrue(viewModel.uiState.value.saveFailure != null)
 
         composeRule.runOnIdle {
-            viewModel.onAfternoteToggle(false)
-            viewModel.onSmsChecked(true)
-            viewModel.onEmailChecked(true)
-            viewModel.onPushChecked(true)
+            viewModel.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.AFTERNOTE, false))
+            viewModel.onIntent(PushNotificationIntent.ChangeMarketingConsent(MarketingConsent.SMS, true))
+            viewModel.onIntent(PushNotificationIntent.ChangeMarketingConsent(MarketingConsent.EMAIL, true))
+            viewModel.onIntent(PushNotificationIntent.ChangeMarketingConsent(MarketingConsent.PUSH, true))
         }
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
             repository.pushUpdateCalls.size == 3
@@ -219,7 +240,7 @@ class SettingCompletionTest {
         }
 
         composeRule.runOnIdle {
-            viewModel.link(provider = "google", accessToken = "google-access-token")
+            viewModel.onIntent(ConnectedAccountsIntent.Link(provider = "google", accessToken = "google-access-token"))
         }
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
             repository.connectedLinkCalls.size == 1
@@ -250,7 +271,7 @@ class SettingCompletionTest {
         )
 
         composeRule.runOnIdle {
-            viewModel.onToggle(provider = "google", enabled = false)
+            viewModel.onIntent(ConnectedAccountsIntent.Toggle(provider = "google", enabled = false))
         }
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
             repository.connectedUnlinkCalls.size == 1
@@ -290,12 +311,14 @@ class SettingCompletionTest {
             )
 
         composeRule.runOnIdle {
-            viewModel.register(
-                name = expectedCall.name,
-                relation = expectedCall.relation,
-                phone = expectedCall.phone,
-                email = expectedCall.email,
-                message = "",
+            viewModel.onIntent(
+                ReceiverRegisterIntent.Register(
+                    name = expectedCall.name,
+                    relation = expectedCall.relation,
+                    phone = expectedCall.phone,
+                    email = expectedCall.email,
+                    message = "",
+                ),
             )
         }
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
@@ -310,12 +333,14 @@ class SettingCompletionTest {
         assertFalse(viewModel.uiState.value.isLoading)
 
         composeRule.runOnIdle {
-            viewModel.register(
-                name = expectedCall.name,
-                relation = expectedCall.relation,
-                phone = expectedCall.phone,
-                email = expectedCall.email,
-                message = "",
+            viewModel.onIntent(
+                ReceiverRegisterIntent.Register(
+                    name = expectedCall.name,
+                    relation = expectedCall.relation,
+                    phone = expectedCall.phone,
+                    email = expectedCall.email,
+                    message = "",
+                ),
             )
         }
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
@@ -328,7 +353,9 @@ class SettingCompletionTest {
 
         retryGate.complete(Result.success(ReceiverCreated(receiverId = RECEIVER_ID, authCode = "AUTH-77")))
 
-        assertEquals(ReceiverRegisterEvent.RegisterSuccess, awaitEvent(viewModel.events))
+        composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
+            viewModel.uiState.value.pendingEvent == ReceiverRegisterEvent.RegisterSuccess
+        }
     }
 
     @Test
@@ -340,6 +367,7 @@ class SettingCompletionTest {
                     onBackClick = {},
                     onRegisterSuccess = {},
                     viewModel = viewModel,
+                    inviteViewModel = receiverInviteViewModel(),
                 )
             }
         }
@@ -380,6 +408,7 @@ class SettingCompletionTest {
             ReceiverEditViewModel(
                 route = SettingRoute.RecipientEditRoute(RECEIVER_ID),
                 receiverRepository = repository,
+                updateReceiverInfo = UpdateReceiverInfoUseCase(repository),
             )
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
             viewModel.uiState.value.receiver == COMPLETION_DEFAULT_RECEIVER_DETAIL
@@ -398,12 +427,14 @@ class SettingCompletionTest {
                 message = "수정한 마지막 인사말",
             )
         val update: () -> Unit = {
-            viewModel.update(
-                name = expectedBasicCall.name,
-                relation = expectedBasicCall.relation,
-                phone = expectedBasicCall.phone,
-                email = expectedBasicCall.email,
-                message = expectedMessageCall.message,
+            viewModel.onIntent(
+                ReceiverEditIntent.Update(
+                    name = expectedBasicCall.name,
+                    relation = expectedBasicCall.relation,
+                    phone = expectedBasicCall.phone,
+                    email = expectedBasicCall.email,
+                    message = expectedMessageCall.message,
+                ),
             )
         }
 
@@ -450,10 +481,16 @@ class SettingCompletionTest {
         }
         finalMessageGate.complete(Result.success(Unit))
 
-        assertEquals(ReceiverEditEvent.EditSuccess, awaitEvent(viewModel.events))
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
-            !viewModel.uiState.value.isSaving
+            viewModel.uiState.value.pendingEvent == ReceiverEditEvent.EditSuccess
         }
+        composeRule.runOnIdle { viewModel.onIntent(ReceiverEditIntent.ConsumeSuccess) }
+        assertEquals(null, viewModel.uiState.value.pendingEvent)
+        // 신호를 소비해도 저장 완료 사실은 남아, 화면이 닫히는 동안의 재제출을 무시한다.
+        assertFalse(viewModel.uiState.value.isSaving)
+        assertTrue(viewModel.uiState.value.isSaved)
+        composeRule.runOnIdle(update)
+        composeRule.waitForIdle()
         assertEquals(
             listOf(expectedBasicCall, expectedBasicCall, expectedBasicCall),
             repository.receiverUpdateCalls,
@@ -473,6 +510,7 @@ class SettingCompletionTest {
             ReceiverEditViewModel(
                 route = SettingRoute.RecipientEditRoute(RECEIVER_ID),
                 receiverRepository = repository,
+                updateReceiverInfo = UpdateReceiverInfoUseCase(repository),
             )
 
         composeRule.setContent {
@@ -488,7 +526,7 @@ class SettingCompletionTest {
             viewModel.uiState.value.receiver == scenario.receiverDetail
         }
 
-        composeRule.onNodeWithText("연락처를 입력해주세요.").assertIsDisplayed()
+        composeRule.onNodeWithText("연락처를 입력해주세요.").assertExists()
         composeRule.onNodeWithText("수정").assertIsNotEnabled()
         assertTrue(repository.receiverUpdateCalls.isEmpty())
     }
@@ -504,6 +542,7 @@ class SettingCompletionTest {
                     onBackClick = {},
                     onRegisterSuccess = {},
                     viewModel = viewModel,
+                    inviteViewModel = receiverInviteViewModel(),
                 )
             }
         }
@@ -511,6 +550,7 @@ class SettingCompletionTest {
         composeRule.onNodeWithText("이름을 입력하세요").performTextInput("김수신")
         composeRule.onNode(hasScrollToNodeAction()).performScrollToNode(hasText("afternote@email.com"))
         composeRule.onNodeWithText("afternote@email.com").performTextInput("receiver@afternote.local")
+        composeRule.onNode(hasScrollToNodeAction()).performScrollToNode(hasText("연락처를 지정해주세요"))
 
         composeRule.onNodeWithText("연락처를 입력해주세요.").assertIsDisplayed()
         composeRule.onNodeWithText("등록").assertIsNotEnabled()
@@ -531,6 +571,7 @@ class SettingCompletionTest {
             DeliveryConditionViewModel(
                 route = SettingRoute.AfterDeliveryRoute(RECEIVER_ID),
                 receiverRepository = repository,
+                updateTimeLetterDeliveryCondition = UpdateTimeLetterDeliveryConditionUseCase(repository),
             )
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
             viewModel.uiState.value.isInitialized
@@ -546,8 +587,8 @@ class SettingCompletionTest {
         val expectedCall = CompletionDeliveryUpdateCall(RECEIVER_ID, expectedConditions)
 
         composeRule.runOnIdle {
-            viewModel.onConditionTypeSelected(index = 1)
-            viewModel.onSave()
+            viewModel.onIntent(DeliveryConditionIntent.SelectConditionType(DeliveryConditionType.RECEIVER_REQUEST))
+            viewModel.onIntent(DeliveryConditionIntent.Save)
         }
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
             repository.deliveryUpdateCalls.size == 1
@@ -563,7 +604,7 @@ class SettingCompletionTest {
         assertFalse(viewModel.uiState.value.isSaving)
         assertEquals(initialConditions, viewModel.uiState.value.conditions)
 
-        composeRule.runOnIdle { viewModel.onSave() }
+        composeRule.runOnIdle { viewModel.onIntent(DeliveryConditionIntent.Save) }
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
             repository.deliveryUpdateCalls.size == 2
         }
@@ -584,11 +625,18 @@ class SettingCompletionTest {
             ),
         )
 
-        assertEquals(Unit, awaitEvent(viewModel.saveSuccess))
+        composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) { viewModel.uiState.value.isSaveSuccessPending }
+        composeRule.runOnIdle { viewModel.onIntent(DeliveryConditionIntent.ConsumeSuccess) }
+        assertFalse(viewModel.uiState.value.isSaveSuccessPending)
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
             viewModel.uiState.value.conditions == serverConditions
         }
+        // 신호를 소비해도 저장 완료 사실은 남아, 화면이 닫히는 동안의 재제출을 무시한다.
         assertFalse(viewModel.uiState.value.isSaving)
+        assertTrue(viewModel.uiState.value.isSaved)
+        composeRule.runOnIdle { viewModel.onIntent(DeliveryConditionIntent.Save) }
+        composeRule.waitForIdle()
+        assertEquals(listOf(expectedCall, expectedCall), repository.deliveryUpdateCalls)
     }
 
     @Test
@@ -618,28 +666,28 @@ class SettingCompletionTest {
             }
         val viewModel = SettingViewModel(authRepository, profileRepository, repository)
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
-            viewModel.uiState.value is SettingUiState.Success
+            viewModel.uiState.value.profile is SettingProfileState.Success
         }
 
-        composeRule.runOnIdle { viewModel.deleteAccount() }
+        composeRule.runOnIdle { viewModel.onIntent(SettingIntent.DeleteAccount) }
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
             repository.deleteAccountCalls == 1
         }
-        assertEquals(WithdrawUiState.Loading, viewModel.withdrawUiState.value)
+        assertEquals(WithdrawUiState.Loading, viewModel.uiState.value.withdraw)
 
         firstGate.completeExceptionally(IllegalStateException("서버가 503 으로 거절했다"))
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
-            viewModel.withdrawUiState.value == WithdrawUiState.Error
+            viewModel.uiState.value.withdraw == WithdrawUiState.Error
         }
 
-        composeRule.runOnIdle { viewModel.deleteAccount() }
+        composeRule.runOnIdle { viewModel.onIntent(SettingIntent.DeleteAccount) }
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
             repository.deleteAccountCalls == 2
         }
 
         retryGate.complete(Unit)
         composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
-            viewModel.withdrawUiState.value == WithdrawUiState.Success
+            viewModel.uiState.value.withdraw == WithdrawUiState.Success
         }
         assertEquals(2, repository.deleteAccountCalls)
     }
@@ -875,3 +923,12 @@ internal object NoOpErrorReporter : ErrorReporter {
         attributes: Map<String, String>,
     ) = Unit
 }
+
+private fun receiverInviteViewModel() =
+    ReceiverInviteViewModel(
+        invitationRepository = FakeReceiverInvitationRepository(),
+        profileCacheRepository = FakeUserProfileCacheRepository(),
+        myProfileRepository = FakeMyProfileRepository(),
+        errorReporter = NoOpErrorReporter,
+        savedStateHandle = SavedStateHandle(),
+    )
diff --git a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/SettingCoroutineCancellationTest.kt b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/SettingCoroutineCancellationTest.kt
new file mode 100644
index 0000000000..a2a78bae53
--- /dev/null
+++ b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/SettingCoroutineCancellationTest.kt
@@ -0,0 +1,393 @@
+package com.afternote.feature.setting.presentation
+
+import android.util.Log
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.ViewModelStore
+import androidx.test.core.app.ApplicationProvider
+import com.afternote.core.common.reporting.ErrorReporter
+import com.afternote.core.domain.testing.FakeAuthRepository
+import com.afternote.core.domain.testing.FakeMyProfileRepository
+import com.afternote.core.domain.testing.FakePhotoUploadRepository
+import com.afternote.core.model.user.User
+import com.afternote.core.model.user.UserMarketingConsent
+import com.afternote.core.model.user.UserPushSetting
+import com.afternote.feature.setting.domain.testing.FakeSettingAccountRepository
+import com.afternote.feature.setting.domain.testing.FakeSettingNotificationRepository
+import com.afternote.feature.setting.presentation.account.ConnectedAccountsIntent
+import com.afternote.feature.setting.presentation.account.ConnectedAccountsViewModel
+import com.afternote.feature.setting.presentation.home.SettingProfileState
+import com.afternote.feature.setting.presentation.home.SettingUiState
+import com.afternote.feature.setting.presentation.home.SettingViewModel
+import com.afternote.feature.setting.presentation.notification.PushNotificationIntent
+import com.afternote.feature.setting.presentation.notification.PushNotificationViewModel
+import com.afternote.feature.setting.presentation.profile.ProfileEditIntent
+import com.afternote.feature.setting.presentation.profile.ProfileEditUiState
+import com.afternote.feature.setting.presentation.profile.ProfileEditViewModel
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runCurrent
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import org.robolectric.shadows.ShadowLog
+
+/**
+ * 설정 화면 ViewModel 의 suspend 저장소 호출이 코루틴 취소를 실패로 둔갑시키지 않는지 검증한다 (#1501).
+ *
+ * 취소는 화면 이탈로 [ViewModel.onCleared] 가 불릴 때 실제로 일어나므로, 여기서는 진짜
+ * [ViewModelStore] 에 담았다가 [ViewModelStore.clear] 로 끊는다. 저장소 fake 는 응답하지 않고
+ * 매달려 있어, 취소가 대기 중인 호출까지 닿았는지를 [PendingRepositoryCall.isCancelled] 로 본다.
+ * 예외를 직접 던지는 검사에 더해, 실제 ViewModel 종료가 진행 중 요청을 취소하는 경로까지 검증한다.
+ */
+@OptIn(ExperimentalCoroutinesApi::class)
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [35])
+class SettingCoroutineCancellationTest {
+    private val dispatcher = StandardTestDispatcher()
+
+    @Before
+    fun setUp() {
+        Dispatchers.setMain(dispatcher)
+        ShadowLog.clear()
+    }
+
+    @After
+    fun tearDown() {
+        Dispatchers.resetMain()
+    }
+
+    @Test
+    fun `연결 계정 조회 중 화면을 떠나면 오류 문구로 덮지 않는다`() =
+        runTest(dispatcher) {
+            val pending = PendingRepositoryCall()
+            val repository =
+                FakeSettingAccountRepository().apply {
+                    onGetConnectedAccounts = { pending.await() }
+                }
+            val viewModel = ConnectedAccountsViewModel(repository)
+            val store = storeHolding(viewModel)
+            runCurrent()
+            assertTrue(pending.isStarted)
+            val pendingState = viewModel.uiState.value
+
+            store.clear()
+            runCurrent()
+
+            assertTrue(pending.isCancelled)
+            assertEquals(pendingState, viewModel.uiState.value)
+            assertTrue(viewModel.uiState.value.isLoading)
+            assertEquals(null, viewModel.uiState.value.errorMessage)
+        }
+
+    @Test
+    fun `계정 연결 중 화면을 떠나면 연결 실패 문구를 띄우지 않는다`() =
+        runTest(dispatcher) {
+            val pending = PendingRepositoryCall()
+            val repository =
+                FakeSettingAccountRepository().apply {
+                    onLinkConnectedAccount = { _, _ -> pending.await() }
+                }
+            val viewModel = ConnectedAccountsViewModel(repository)
+            val store = storeHolding(viewModel)
+            runCurrent()
+
+            viewModel.onIntent(ConnectedAccountsIntent.Link(provider = "google", accessToken = "google-token"))
+            runCurrent()
+            assertTrue(pending.isStarted)
+            val pendingState = viewModel.uiState.value
+
+            store.clear()
+            runCurrent()
+
+            assertTrue(pending.isCancelled)
+            assertEquals(pendingState, viewModel.uiState.value)
+            assertEquals(null, viewModel.uiState.value.errorMessage)
+        }
+
+    @Test
+    fun `계정 연결 해제 중 화면을 떠나면 해제 실패 문구를 띄우지 않는다`() =
+        runTest(dispatcher) {
+            val pending = PendingRepositoryCall()
+            val repository =
+                FakeSettingAccountRepository().apply {
+                    onUnlinkConnectedAccount = { pending.await() }
+                }
+            val viewModel = ConnectedAccountsViewModel(repository)
+            val store = storeHolding(viewModel)
+            runCurrent()
+
+            viewModel.onIntent(ConnectedAccountsIntent.Toggle(provider = "naver", enabled = false))
+            runCurrent()
+            assertTrue(pending.isStarted)
+            val pendingState = viewModel.uiState.value
+
+            store.clear()
+            runCurrent()
+
+            assertTrue(pending.isCancelled)
+            assertEquals(pendingState, viewModel.uiState.value)
+            assertEquals(null, viewModel.uiState.value.errorMessage)
+        }
+
+    @Test
+    fun `프로필 편집 조회 중 화면을 떠나면 Error 상태로 바꾸지 않는다`() =
+        runTest(dispatcher) {
+            val pending = PendingRepositoryCall()
+            val repository =
+                FakeMyProfileRepository().apply {
+                    onGetMyProfile = { pending.await() }
+                }
+            val viewModel = ProfileEditViewModel(repository, FakePhotoUploadRepository.strict())
+            val store = storeHolding(viewModel)
+            runCurrent()
+            assertTrue(pending.isStarted)
+
+            store.clear()
+            runCurrent()
+
+            assertTrue(pending.isCancelled)
+            assertEquals(ProfileEditUiState.Loading, viewModel.uiState.value)
+        }
+
+    @Test
+    fun `프로필 수정 중 화면을 떠나면 갱신 표시를 풀거나 실패 이벤트를 보내지 않는다`() =
+        runTest(dispatcher) {
+            val pending = PendingRepositoryCall()
+            val repository =
+                FakeMyProfileRepository(profile = PROFILE).apply {
+                    onUpdateMyProfile = { _, _, _ -> pending.await() }
+                }
+            val viewModel = ProfileEditViewModel(repository, FakePhotoUploadRepository.strict())
+            val store = storeHolding(viewModel)
+            runCurrent()
+
+            viewModel.onIntent(ProfileEditIntent.UpdateProfile(name = "새 이름", phone = "01011112222"))
+            runCurrent()
+            assertTrue(pending.isStarted)
+
+            store.clear()
+            runCurrent()
+
+            assertTrue(pending.isCancelled)
+            assertEquals(
+                ProfileEditUiState.Success(
+                    name = PROFILE.name,
+                    phone = PROFILE.phone.orEmpty(),
+                    email = PROFILE.email,
+                    profileImageUrl = PROFILE.profileImageUrl,
+                    isUpdating = true,
+                ),
+                viewModel.uiState.value,
+            )
+        }
+
+    @Test
+    fun `프로필 사진 업로드 중 화면을 떠나면 수정 요청도 실패 이벤트도 보내지 않는다`() =
+        runTest(dispatcher) {
+            val pending = PendingRepositoryCall()
+            val profileRepository =
+                FakeMyProfileRepository.strict().apply {
+                    onGetMyProfile = { PROFILE }
+                }
+            val uploadRepository = FakePhotoUploadRepository(onUpload = { _, _ -> pending.await() })
+            val viewModel = ProfileEditViewModel(profileRepository, uploadRepository)
+            val store = storeHolding(viewModel)
+            runCurrent()
+
+            viewModel.onIntent(ProfileEditIntent.SelectPhoto(PICKED_PHOTO))
+            viewModel.onIntent(ProfileEditIntent.UpdateProfile(name = "새 이름", phone = "01011112222"))
+            runCurrent()
+            assertTrue(pending.isStarted)
+
+            store.clear()
+            runCurrent()
+
+            assertTrue(pending.isCancelled)
+            assertTrue(profileRepository.profileUpdateCalls.isEmpty())
+            assertEquals(null, (viewModel.uiState.value as ProfileEditUiState.Success).pendingEvent)
+        }
+
+    @Test
+    fun `설정 홈 프로필 조회 중 화면을 떠나면 Error 상태로 바꾸지 않는다`() =
+        runTest(dispatcher) {
+            val pending = PendingRepositoryCall()
+            val viewModel =
+                SettingViewModel(
+                    authRepository = FakeAuthRepository.strict(),
+                    myProfileRepository =
+                        FakeMyProfileRepository.strict().apply {
+                            onGetMyProfile = { pending.await() }
+                        },
+                    accountRepository = FakeSettingAccountRepository.strict(),
+                )
+            val store = storeHolding(viewModel)
+            runCurrent()
+            assertTrue(pending.isStarted)
+
+            store.clear()
+            runCurrent()
+
+            assertTrue(pending.isCancelled)
+            assertEquals(SettingProfileState.Loading, viewModel.uiState.value.profile)
+        }
+
+    @Test
+    fun `마케팅 동의 조회 중 화면을 떠나면 상태 진단 어느 것도 남기지 않는다`() =
+        runTest(dispatcher) {
+            val pending = PendingRepositoryCall()
+            val repository =
+                FakeSettingNotificationRepository().apply {
+                    onGetMyPushSettings = { UserPushSetting(timeLetter = true, mindRecord = false, afterNote = true) }
+                    onGetMyMarketingConsents = { pending.await() }
+                }
+            val reporter = RecordingErrorReporter()
+            val viewModel = pushViewModel(repository, reporter)
+            val store = storeHolding(viewModel)
+            viewModel.onIntent(PushNotificationIntent.MarketingFeedbackStarted)
+            runCurrent()
+
+            // 푸시 설정 조회는 먼저 정상 종료해 안정된 상태를 만든다. 매달린 것은 마케팅 조회뿐이다.
+            assertFalse(viewModel.uiState.value.isLoading)
+            assertTrue(pending.isStarted)
+            val stableState = viewModel.uiState.value
+
+            store.clear()
+            runCurrent()
+
+            assertTrue(pending.isCancelled)
+            assertEquals(stableState, viewModel.uiState.value)
+            assertFalse(viewModel.uiState.value.isMarketingConsentSaveFailed)
+            assertEquals(0, reporter.recordedStages.size)
+            assertEquals(emptyList<String>(), pushFailureLogs())
+        }
+
+    @Test
+    fun `마케팅 동의 조회는 성공하면 상태에 반영하고 평범한 실패는 로그만 남긴다`() =
+        runTest(dispatcher) {
+            val successReporter = RecordingErrorReporter()
+            val successViewModel =
+                pushViewModel(
+                    FakeSettingNotificationRepository().apply {
+                        onGetMyPushSettings = { UserPushSetting(timeLetter = false, mindRecord = false, afterNote = false) }
+                        onGetMyMarketingConsents = { UserMarketingConsent(sms = false, email = true, push = true) }
+                    },
+                    successReporter,
+                )
+            runCurrent()
+
+            assertFalse(successViewModel.uiState.value.isSmsChecked)
+            assertTrue(successViewModel.uiState.value.isEmailChecked)
+            assertTrue(successViewModel.uiState.value.isPushChecked)
+            assertEquals(emptyList<String>(), pushFailureLogs())
+
+            ShadowLog.clear()
+            val failureReporter = RecordingErrorReporter()
+            val failureViewModel =
+                pushViewModel(
+                    FakeSettingNotificationRepository().apply {
+                        onGetMyPushSettings = { UserPushSetting(timeLetter = false, mindRecord = false, afterNote = false) }
+                        onGetMyMarketingConsents = { error("marketing consents unavailable") }
+                    },
+                    failureReporter,
+                )
+            failureViewModel.onIntent(PushNotificationIntent.MarketingFeedbackStarted)
+            runCurrent()
+
+            // 평범한 실패는 진단 로그 한 줄로 끝난다. 화면 값은 기본값 그대로이고 안내도 띄우지 않는다.
+            assertEquals(listOf("loadMarketingConsents: failed"), pushFailureLogs())
+            assertTrue(failureViewModel.uiState.value.isSmsChecked)
+            assertTrue(failureViewModel.uiState.value.isEmailChecked)
+            assertFalse(failureViewModel.uiState.value.isPushChecked)
+            assertFalse(failureViewModel.uiState.value.isMarketingConsentSaveFailed)
+            assertEquals(0, failureReporter.recordedStages.size)
+        }
+
+    @Test
+    fun `Exception 이 아닌 Throwable 실패도 평소대로 오류 상태로 매핑한다`() =
+        runTest(dispatcher) {
+            val viewModel =
+                SettingViewModel(
+                    authRepository = FakeAuthRepository.strict(),
+                    myProfileRepository =
+                        FakeMyProfileRepository.strict().apply {
+                            onGetMyProfile = { throw NonExceptionFailure() }
+                        },
+                    accountRepository = FakeSettingAccountRepository.strict(),
+                )
+            runCurrent()
+
+            assertEquals(SettingProfileState.Error, viewModel.uiState.value.profile)
+        }
+
+    private fun pushViewModel(
+        repository: FakeSettingNotificationRepository,
+        reporter: ErrorReporter,
+    ) = PushNotificationViewModel(
+        context = ApplicationProvider.getApplicationContext(),
+        notificationRepository = repository,
+        errorReporter = reporter,
+    )
+
+    /** 푸시 ViewModel 이 남긴 실패 진단 로그의 메시지 목록. 성공 경로의 `Log.d` 는 세지 않는다. */
+    private fun pushFailureLogs(): List<String> =
+        ShadowLog
+            .getLogsForTag(PUSH_TAG)
+            .filter { it.type >= Log.ERROR }
+            .map { it.msg }
+
+    private fun storeHolding(viewModel: ViewModel): ViewModelStore = ViewModelStore().apply { put(STORE_KEY, viewModel) }
+
+    private class RecordingErrorReporter : ErrorReporter {
+        val recordedStages = mutableListOf<String?>()
+
+        override fun writeFailure(
+            throwable: Throwable,
+            attributes: Map<String, String>,
+        ) {
+            recordedStages += attributes["stage"]
+        }
+    }
+
+    /** `Exception` 을 상속하지 않는 실패. `runCatching` 계열이 `Throwable` 까지 잡는다는 계약을 고정한다. */
+    private class NonExceptionFailure : Throwable("profile backend down")
+
+    private companion object {
+        const val STORE_KEY = "setting-cancellation"
+        const val PUSH_TAG = "PushNotificationVM"
+        const val PICKED_PHOTO = "content://media/picker/0/profile/1"
+        val PROFILE = User(name = "기존 이름", email = "user@afternote.local", phone = "01000000000", profileImageUrl = null)
+    }
+}
+
+/**
+ * 응답하지 않는 저장소 호출. 취소가 이 자리까지 닿았는지를 [isCancelled] 로 드러낸다.
+ *
+ * 취소 콜백(`invokeOnCancellation`)은 코루틴이 취소될 때만 호출되므로, 대기 중인 suspend 호출이
+ * 실제로 끊겼다는 증거가 된다.
+ */
+private class PendingRepositoryCall {
+    @Volatile
+    var isStarted = false
+        private set
+
+    @Volatile
+    var isCancelled = false
+        private set
+
+    suspend fun <T> await(): T =
+        suspendCancellableCoroutine { continuation ->
+            isStarted = true
+            continuation.invokeOnCancellation { isCancelled = true }
+        }
+}
diff --git a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/SettingFlowTest.kt b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/SettingFlowTest.kt
index 0f68bccef2..adac4e7fb9 100644
--- a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/SettingFlowTest.kt
+++ b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/SettingFlowTest.kt
@@ -14,9 +14,12 @@ import com.afternote.core.domain.testing.FakeMyProfileRepository
 import com.afternote.core.ui.theme.AfternoteTheme
 import com.afternote.feature.setting.domain.testing.FakeSettingAccountRepository
 import com.afternote.feature.setting.domain.testing.FakeSettingNotificationRepository
+import com.afternote.feature.setting.presentation.home.SettingIntent
 import com.afternote.feature.setting.presentation.home.SettingScreen
 import com.afternote.feature.setting.presentation.home.SettingViewModel
+import com.afternote.feature.setting.presentation.notification.PushNotificationIntent
 import com.afternote.feature.setting.presentation.notification.PushNotificationViewModel
+import com.afternote.feature.setting.presentation.notification.PushSetting
 import org.junit.Assert.assertEquals
 import org.junit.Rule
 import org.junit.Test
@@ -32,6 +35,30 @@ class SettingFlowTest {
     @get:Rule
     val composeRule = createComposeRule()
 
+    @Test
+    fun profileLoadFailureKeepsSettingsEntriesAndRetryRecoversProfile() {
+        var reads = 0
+        var offline = true
+        val profile =
+            com.afternote.core.domain.testing.FakeMyProfileRepository.strict().apply {
+                onGetMyProfile = {
+                    reads++
+                    if (offline) throw java.io.IOException("offline")
+                    com.afternote.core.model.user
+                        .User("복구 사용자", "test@example.com", null, null)
+                }
+            }
+        val viewModel = SettingViewModel(settingFlowAuthRepository(loggedIn = true), profile, settingFlowAccountRepository())
+        setSettingContent(viewModel)
+        composeRule.onNodeWithText("프로필을 불러올 수 없습니다.").assertIsDisplayed()
+        composeRule.onNodeWithText("프로필 수정").assertIsDisplayed()
+        val failedReads = reads
+        composeRule.runOnIdle { offline = false }
+        composeRule.onNodeWithText("다시 시도").performClick()
+        composeRule.onNodeWithText("복구 사용자").assertIsDisplayed()
+        assertEquals(failedReads + 1, reads)
+    }
+
     @Test
     fun profileAndSecurityEntries_emitExpectedNavigation() {
         val auth = settingFlowAuthRepository(loggedIn = true)
@@ -83,7 +110,7 @@ class SettingFlowTest {
         composeRule.setContent { AfternoteTheme {} }
 
         assertEquals(0, account.deleteAccountCalls)
-        composeRule.runOnIdle { viewModel.deleteAccount() }
+        composeRule.runOnIdle { viewModel.onIntent(SettingIntent.DeleteAccount) }
         composeRule.waitUntil(timeoutMillis = 5_000) { account.deleteAccountCalls == 1 }
 
         assertEquals(1, account.deleteAccountCalls)
@@ -106,7 +133,7 @@ class SettingFlowTest {
         composeRule.setContent { AfternoteTheme {} }
         composeRule.waitUntil(timeoutMillis = 5_000) { !viewModel.uiState.value.isLoading }
 
-        composeRule.runOnIdle { viewModel.onNewsletterToggle(false) }
+        composeRule.runOnIdle { viewModel.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.NEWSLETTER, false)) }
         composeRule.waitUntil(timeoutMillis = 5_000) {
             viewModel.uiState.value.isNewsletterOn
         }
diff --git a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/SettingLoadFeedbackTest.kt b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/SettingLoadFeedbackTest.kt
new file mode 100644
index 0000000000..80e9b32004
--- /dev/null
+++ b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/SettingLoadFeedbackTest.kt
@@ -0,0 +1,111 @@
+package com.afternote.feature.setting.presentation
+
+import androidx.compose.material3.SnackbarHostState
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.hasClickAction
+import androidx.compose.ui.test.hasScrollToIndexAction
+import androidx.compose.ui.test.hasText
+import androidx.compose.ui.test.junit4.createComposeRule
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import androidx.compose.ui.test.performScrollTo
+import androidx.compose.ui.test.performScrollToNode
+import com.afternote.core.domain.testing.FakeMyProfileRepository
+import com.afternote.core.domain.testing.FakePhotoUploadRepository
+import com.afternote.core.model.user.User
+import com.afternote.core.ui.UiText
+import com.afternote.core.ui.theme.AfternoteTheme
+import com.afternote.feature.setting.domain.testing.FakeSettingAccountRepository
+import com.afternote.feature.setting.presentation.account.ConnectedAccountsContent
+import com.afternote.feature.setting.presentation.account.ConnectedAccountsIntent
+import com.afternote.feature.setting.presentation.account.ConnectedAccountsScreen
+import com.afternote.feature.setting.presentation.account.ConnectedAccountsUiState
+import com.afternote.feature.setting.presentation.account.ConnectedAccountsViewModel
+import com.afternote.feature.setting.presentation.notification.PushNotificationContent
+import com.afternote.feature.setting.presentation.notification.PushNotificationUiState
+import com.afternote.feature.setting.presentation.profile.ProfileEditIntent
+import com.afternote.feature.setting.presentation.profile.ProfileEditScreen
+import com.afternote.feature.setting.presentation.profile.ProfileEditUiState
+import com.afternote.feature.setting.presentation.profile.ProfileEditViewModel
+import org.junit.Assert.assertEquals
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import org.robolectric.annotation.GraphicsMode
+import java.io.IOException
+
+@RunWith(RobolectricTestRunner::class)
+@GraphicsMode(GraphicsMode.Mode.NATIVE)
+@Config(sdk = [35])
+class SettingLoadFeedbackTest {
+    @get:Rule val composeRule = createComposeRule()
+
+    @Test fun pushLoadErrorHidesSwitchesAndExposesRetry() {
+        var retries = 0
+        composeRule.setContent {
+            AfternoteTheme {
+                PushNotificationContent(
+                    uiState = PushNotificationUiState(errorMessage = UiText.Resource(R.string.setting_push_load_error)),
+                    onBack = {},
+                    onNewsletterToggle = {},
+                    onMindRecordToggle = {},
+                    onAfternoteToggle = {},
+                    onRetry = { retries++ },
+                )
+            }
+        }
+        composeRule.onNodeWithText("알림 설정을 불러올 수 없습니다.").assertIsDisplayed()
+        composeRule.onNodeWithText("뉴스레터").assertDoesNotExist()
+        composeRule.onNodeWithText("다시 시도").performClick()
+        assertEquals(1, retries)
+    }
+
+    @Test fun accountLoadErrorExposesRetryInsteadOfAnEmptyAccountList() {
+        var retries = 0
+        composeRule.setContent {
+            AfternoteTheme {
+                ConnectedAccountsContent(
+                    uiState = ConnectedAccountsUiState(errorMessage = "계정 정보를 불러올 수 없습니다."),
+                    snackbarHostState = SnackbarHostState(),
+                    onBack = {},
+                    onToggle = { _, _ -> },
+                    onRetry = { retries++ },
+                )
+            }
+        }
+        composeRule.onNodeWithText("계정 정보를 불러올 수 없습니다.").assertIsDisplayed()
+        composeRule.onNodeWithText("다시 시도").performClick()
+        assertEquals(1, retries)
+    }
+
+    @Test fun profileLoadRetryRecoversAndSaveFailureIsVisible() {
+        var reads = 0
+        val repository =
+            FakeMyProfileRepository.strict().apply {
+                onGetMyProfile = { if (++reads == 1) throw IOException() else User("테스트", "test@example.com", "01012345678", null) }
+                onUpdateMyProfile = { _, _, _ -> throw IOException() }
+            }
+        val vm = ProfileEditViewModel(repository, FakePhotoUploadRepository.strict())
+        composeRule.setContent { AfternoteTheme { ProfileEditScreen({}, {}, viewModel = vm) } }
+        composeRule.onNodeWithText("프로필을 불러올 수 없습니다.").assertIsDisplayed()
+        composeRule.onNodeWithText("다시 시도").performClick()
+        composeRule.waitUntil(5_000) { vm.uiState.value is ProfileEditUiState.Success }
+        composeRule.onNode(hasScrollToIndexAction()).performScrollToNode(hasText("수정하기"))
+        composeRule.onNodeWithText("수정하기").performClick()
+        composeRule.onNodeWithText("프로필 수정에 실패했습니다. 다시 시도해 주세요.").assertIsDisplayed()
+        assertEquals(2, reads)
+    }
+
+    @Test fun unlinkFailureShowsFeedbackAndKeepsAccountRows() {
+        val repository = FakeSettingAccountRepository().apply { onUnlinkConnectedAccount = { throw IOException() } }
+        val vm = ConnectedAccountsViewModel(repository)
+        composeRule.setContent { AfternoteTheme { ConnectedAccountsScreen({}, viewModel = vm) } }
+        composeRule.waitUntil(5_000) { !vm.uiState.value.isLoading }
+        composeRule.runOnIdle { vm.onIntent(ConnectedAccountsIntent.Toggle("kakao", false)) }
+        composeRule.onNodeWithText("계정 연결 해제에 실패했습니다.").assertIsDisplayed()
+        assertEquals(4, vm.uiState.value.accounts.size)
+        assertEquals(null, vm.uiState.value.errorMessage)
+    }
+}
diff --git a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/SettingLoadRecoveryTest.kt b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/SettingLoadRecoveryTest.kt
new file mode 100644
index 0000000000..43ee6a4476
--- /dev/null
+++ b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/SettingLoadRecoveryTest.kt
@@ -0,0 +1,184 @@
+package com.afternote.feature.setting.presentation
+
+import androidx.test.core.app.ApplicationProvider
+import com.afternote.core.domain.testing.FakeAuthRepository
+import com.afternote.core.domain.testing.FakeMyProfileRepository
+import com.afternote.core.domain.testing.FakePhotoUploadRepository
+import com.afternote.core.model.user.User
+import com.afternote.core.model.user.UserPushSetting
+import com.afternote.feature.setting.domain.testing.FakeSettingAccountRepository
+import com.afternote.feature.setting.domain.testing.FakeSettingNotificationRepository
+import com.afternote.feature.setting.presentation.account.ConnectedAccountsIntent
+import com.afternote.feature.setting.presentation.account.ConnectedAccountsViewModel
+import com.afternote.feature.setting.presentation.home.SettingIntent
+import com.afternote.feature.setting.presentation.home.SettingProfileState
+import com.afternote.feature.setting.presentation.home.SettingViewModel
+import com.afternote.feature.setting.presentation.home.WithdrawUiState
+import com.afternote.feature.setting.presentation.notification.PushNotificationIntent
+import com.afternote.feature.setting.presentation.notification.PushNotificationViewModel
+import com.afternote.feature.setting.presentation.notification.PushSetting
+import com.afternote.feature.setting.presentation.profile.ProfileEditIntent
+import com.afternote.feature.setting.presentation.profile.ProfileEditUiState
+import com.afternote.feature.setting.presentation.profile.ProfileEditViewModel
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runCurrent
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import java.io.IOException
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [35])
+class SettingLoadRecoveryTest {
+    private val dispatcher = StandardTestDispatcher()
+    private val profile = User("테스트", "test@example.com", "01012345678", null)
+
+    @Before fun setUp() {
+        Dispatchers.setMain(dispatcher)
+    }
+
+    @After fun tearDown() {
+        Dispatchers.resetMain()
+    }
+
+    @Test fun `home retry recovers profile without resetting account operation`() =
+        runTest(dispatcher) {
+            var reads = 0
+            val gate = CompletableDeferred<User>()
+            val repository =
+                FakeMyProfileRepository.strict().apply {
+                    onGetMyProfile = { if (++reads == 1) throw IOException() else gate.await() }
+                }
+            val vm = SettingViewModel(FakeAuthRepository.strict(), repository, FakeSettingAccountRepository())
+            runCurrent()
+            assertEquals(SettingProfileState.Error, vm.uiState.value.profile)
+            vm.onIntent(SettingIntent.DeleteAccount)
+            runCurrent()
+            vm.onIntent(SettingIntent.Refresh)
+            vm.onIntent(SettingIntent.Refresh)
+            runCurrent()
+            assertEquals(2, reads)
+            assertEquals(WithdrawUiState.Success, vm.uiState.value.withdraw)
+            gate.complete(profile)
+            runCurrent()
+            assertEquals(SettingProfileState.Success(profile.name, profile.email), vm.uiState.value.profile)
+            assertEquals(WithdrawUiState.Success, vm.uiState.value.withdraw)
+        }
+
+    @Test fun `profile retry is single flight and failed load cannot submit a patch`() =
+        runTest(dispatcher) {
+            var reads = 0
+            val gate = CompletableDeferred<User>()
+            val repository =
+                FakeMyProfileRepository.strict().apply {
+                    onGetMyProfile = { if (++reads == 1) throw IOException() else gate.await() }
+                }
+            val vm = ProfileEditViewModel(repository, FakePhotoUploadRepository.strict())
+            runCurrent()
+            assertEquals(ProfileEditUiState.Error, vm.uiState.value)
+            vm.onIntent(ProfileEditIntent.UpdateProfile("new", "01012345678"))
+            assertTrue(repository.profileUpdateCalls.isEmpty())
+            vm.onIntent(ProfileEditIntent.RetryLoad)
+            vm.onIntent(ProfileEditIntent.RetryLoad)
+            assertEquals(ProfileEditUiState.Loading, vm.uiState.value)
+            runCurrent()
+            assertEquals(2, reads)
+            gate.complete(profile)
+            runCurrent()
+            assertEquals(profile.phone, (vm.uiState.value as ProfileEditUiState.Success).phone)
+            vm.onIntent(ProfileEditIntent.RetryLoad)
+            runCurrent()
+            assertEquals(2, reads)
+        }
+
+    @Test fun `account load failure blocks writes and retry restores rows`() =
+        runTest(dispatcher) {
+            var fail = true
+            val repository =
+                FakeSettingAccountRepository().apply {
+                    onGetConnectedAccounts = { if (fail) throw IOException() else connectedAccounts }
+                }
+            val vm = ConnectedAccountsViewModel(repository)
+            runCurrent()
+            assertNotNull(vm.uiState.value.errorMessage)
+            vm.onIntent(ConnectedAccountsIntent.Toggle("kakao", false))
+            vm.onIntent(ConnectedAccountsIntent.Link("kakao", "unused"))
+            runCurrent()
+            assertTrue(repository.connectedUnlinkCalls.isEmpty())
+            assertTrue(repository.connectedLinkCalls.isEmpty())
+            fail = false
+            vm.onIntent(ConnectedAccountsIntent.RetryLoad)
+            vm.onIntent(ConnectedAccountsIntent.RetryLoad)
+            runCurrent()
+            assertEquals(2, repository.getConnectedAccountsCalls)
+            assertNull(vm.uiState.value.errorMessage)
+            assertEquals(4, vm.uiState.value.accounts.size)
+        }
+
+    @Test fun `account write failure preserves rows and consumes feedback independently of load state`() =
+        runTest(dispatcher) {
+            val repository = FakeSettingAccountRepository().apply { onUnlinkConnectedAccount = { throw IOException() } }
+            val vm = ConnectedAccountsViewModel(repository)
+            runCurrent()
+            val rows = vm.uiState.value.accounts
+            vm.onIntent(ConnectedAccountsIntent.Toggle("kakao", false))
+            vm.onIntent(ConnectedAccountsIntent.Toggle("kakao", false))
+            runCurrent()
+            assertEquals(listOf("kakao"), repository.connectedUnlinkCalls)
+            assertEquals(rows, vm.uiState.value.accounts)
+            assertNull(vm.uiState.value.errorMessage)
+            val error = requireNotNull(vm.uiState.value.pendingError)
+            vm.onIntent(ConnectedAccountsIntent.ConsumeError("another message"))
+            assertEquals(error, vm.uiState.value.pendingError)
+            vm.onIntent(ConnectedAccountsIntent.ConsumeError(error))
+            assertNull(vm.uiState.value.pendingError)
+        }
+
+    @Test fun `push load error cannot save default values and retry reads real settings`() =
+        runTest(dispatcher) {
+            var reads = 0
+            var writes = 0
+            var fail = true
+            val repository =
+                FakeSettingNotificationRepository().apply {
+                    onGetMyPushSettings = {
+                        reads++
+                        if (fail) throw IOException() else UserPushSetting(timeLetter = true, mindRecord = true, afterNote = false)
+                    }
+                    onUpdateMyPushSettings = { _, _, _ ->
+                        writes++
+                        UserPushSetting(false, false, false)
+                    }
+                }
+            val vm = PushNotificationViewModel(ApplicationProvider.getApplicationContext(), repository, NoOpErrorReporter)
+            assertTrue(vm.uiState.value.isLoading)
+            vm.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.NEWSLETTER, true))
+            runCurrent()
+            assertNotNull(vm.uiState.value.errorMessage)
+            vm.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.NEWSLETTER, true))
+            runCurrent()
+            assertEquals(0, writes)
+            fail = false
+            vm.onIntent(PushNotificationIntent.RetryLoad)
+            vm.onIntent(PushNotificationIntent.RetryLoad)
+            runCurrent()
+            assertEquals(2, reads)
+            assertNull(vm.uiState.value.errorMessage)
+            assertTrue(vm.uiState.value.isNewsletterOn)
+            assertTrue(vm.uiState.value.isMindRecordOn)
+        }
+}
diff --git a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/SettingReentryViewModelTest.kt b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/SettingReentryViewModelTest.kt
new file mode 100644
index 0000000000..c47eb16c96
--- /dev/null
+++ b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/SettingReentryViewModelTest.kt
@@ -0,0 +1,611 @@
+package com.afternote.feature.setting.presentation
+
+import androidx.test.core.app.ApplicationProvider
+import com.afternote.core.domain.testing.FakeMyProfileRepository
+import com.afternote.core.domain.testing.FakePhotoUploadRepository
+import com.afternote.core.domain.testing.FakeUserReceiverRepository
+import com.afternote.core.model.delivery.ConditionState
+import com.afternote.core.model.delivery.DeliveryConditionItem
+import com.afternote.core.model.delivery.DeliveryConditionType
+import com.afternote.core.model.delivery.DeliveryContentType
+import com.afternote.core.model.delivery.InactivityPeriod
+import com.afternote.core.model.delivery.ReceiverDeliveryConditions
+import com.afternote.core.model.user.User
+import com.afternote.core.model.user.UserConnectedAccount
+import com.afternote.core.model.user.UserMarketingConsent
+import com.afternote.core.model.user.UserPushSetting
+import com.afternote.feature.setting.domain.UpdateTimeLetterDeliveryConditionUseCase
+import com.afternote.feature.setting.domain.testing.FakeSettingAccountRepository
+import com.afternote.feature.setting.domain.testing.FakeSettingNotificationRepository
+import com.afternote.feature.setting.presentation.NoOpErrorReporter
+import com.afternote.feature.setting.presentation.account.ConnectedAccountsIntent
+import com.afternote.feature.setting.presentation.account.ConnectedAccountsViewModel
+import com.afternote.feature.setting.presentation.delivery.DeliveryConditionError
+import com.afternote.feature.setting.presentation.delivery.DeliveryConditionIntent
+import com.afternote.feature.setting.presentation.delivery.DeliveryConditionViewModel
+import com.afternote.feature.setting.presentation.navigation.SettingRoute
+import com.afternote.feature.setting.presentation.notification.MarketingConsent
+import com.afternote.feature.setting.presentation.notification.PushNotificationIntent
+import com.afternote.feature.setting.presentation.notification.PushNotificationViewModel
+import com.afternote.feature.setting.presentation.notification.PushSetting
+import com.afternote.feature.setting.presentation.profile.ProfileEditIntent
+import com.afternote.feature.setting.presentation.profile.ProfileEditUiState
+import com.afternote.feature.setting.presentation.profile.ProfileEditViewModel
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runCurrent
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [35])
+class SettingReentryViewModelTest {
+    private val dispatcher = StandardTestDispatcher()
+
+    @Before
+    fun setUp() {
+        Dispatchers.setMain(dispatcher)
+    }
+
+    @After
+    fun tearDown() {
+        Dispatchers.resetMain()
+    }
+
+    @Test
+    fun connectedAccounts_firstResumeAndPendingLoadDoNotDuplicateAndRefreshKeepsContent() =
+        runTest(dispatcher) {
+            var calls = 0
+            var response = CompletableDeferred<UserConnectedAccount>()
+            val repository =
+                FakeSettingAccountRepository.strict().apply {
+                    onGetConnectedAccounts = {
+                        calls++
+                        response.await()
+                    }
+                }
+            val viewModel = ConnectedAccountsViewModel(repository)
+            viewModel.onIntent(ConnectedAccountsIntent.RefreshOnReturn)
+            viewModel.onIntent(ConnectedAccountsIntent.RefreshOnReturn)
+            runCurrent()
+            assertEquals(1, calls)
+            response.complete(accounts())
+            runCurrent()
+            val previous = viewModel.uiState.value
+
+            response = CompletableDeferred()
+            viewModel.onIntent(ConnectedAccountsIntent.RefreshOnReturn)
+            viewModel.onIntent(ConnectedAccountsIntent.RefreshOnReturn)
+            runCurrent()
+            assertEquals(2, calls)
+            assertEquals(previous, viewModel.uiState.value)
+            response.complete(accounts(google = true))
+            runCurrent()
+            assertTrue(
+                viewModel.uiState.value.accounts
+                    .single { it.provider == "google" }
+                    .isConnected,
+            )
+            assertFalse(viewModel.uiState.value.isLoading)
+        }
+
+    @Test
+    fun connectedAccounts_failedRefreshPreservesLoadedState() =
+        runTest(dispatcher) {
+            val repository = FakeSettingAccountRepository.strict().apply { onGetConnectedAccounts = { accounts() } }
+            val viewModel = ConnectedAccountsViewModel(repository)
+            runCurrent()
+            viewModel.onIntent(ConnectedAccountsIntent.RefreshOnReturn)
+            val previous = viewModel.uiState.value
+            repository.onGetConnectedAccounts = { error("offline") }
+            viewModel.onIntent(ConnectedAccountsIntent.RefreshOnReturn)
+            runCurrent()
+            assertEquals(previous, viewModel.uiState.value)
+        }
+
+    @Test
+    fun connectedAccounts_successfulReentryClearsInitialLoadError() =
+        runTest(dispatcher) {
+            val repository = FakeSettingAccountRepository.strict().apply { onGetConnectedAccounts = { error("offline") } }
+            val viewModel = ConnectedAccountsViewModel(repository)
+            runCurrent()
+            assertNotNull(viewModel.uiState.value.errorMessage)
+            repository.onGetConnectedAccounts = { accounts() }
+            viewModel.onIntent(ConnectedAccountsIntent.RefreshOnReturn)
+            viewModel.onIntent(ConnectedAccountsIntent.RefreshOnReturn)
+            runCurrent()
+            assertNull(viewModel.uiState.value.errorMessage)
+            assertEquals(4, viewModel.uiState.value.accounts.size)
+        }
+
+    @Test
+    fun connectedAccounts_linkCancelsStaleReadAndResumeWaitsForMutation() =
+        runTest(dispatcher) {
+            var reads = 0
+            val stale = CompletableDeferred<UserConnectedAccount>()
+            val linked = CompletableDeferred<UserConnectedAccount>()
+            val repository =
+                FakeSettingAccountRepository.strict().apply {
+                    onGetConnectedAccounts = { if (++reads == 1) accounts() else stale.await() }
+                    onLinkConnectedAccount = { _, _ -> linked.await() }
+                }
+            val viewModel = ConnectedAccountsViewModel(repository)
+            runCurrent()
+            viewModel.onIntent(ConnectedAccountsIntent.RefreshOnReturn)
+            viewModel.onIntent(ConnectedAccountsIntent.RefreshOnReturn)
+            runCurrent()
+            viewModel.onIntent(ConnectedAccountsIntent.Link("google", "token"))
+            viewModel.onIntent(ConnectedAccountsIntent.RefreshOnReturn)
+            runCurrent()
+            assertEquals(2, reads)
+            linked.complete(accounts(google = true))
+            runCurrent()
+            stale.complete(accounts())
+            runCurrent()
+            assertTrue(
+                viewModel.uiState.value.accounts
+                    .single { it.provider == "google" }
+                    .isConnected,
+            )
+            assertNull(viewModel.uiState.value.errorMessage)
+        }
+
+    @Test
+    fun connectedAccounts_unlinkCancelsStaleReadAndResumeWaitsForMutation() =
+        runTest(dispatcher) {
+            var reads = 0
+            val stale = CompletableDeferred<UserConnectedAccount>()
+            val unlinked = CompletableDeferred<UserConnectedAccount>()
+            val repository =
+                FakeSettingAccountRepository.strict().apply {
+                    onGetConnectedAccounts = { if (++reads == 1) accounts(google = true) else stale.await() }
+                    onUnlinkConnectedAccount = { unlinked.await() }
+                }
+            val viewModel = ConnectedAccountsViewModel(repository)
+            runCurrent()
+            viewModel.onIntent(ConnectedAccountsIntent.RefreshOnReturn)
+            viewModel.onIntent(ConnectedAccountsIntent.RefreshOnReturn)
+            runCurrent()
+            viewModel.onIntent(ConnectedAccountsIntent.Toggle("google", false))
+            viewModel.onIntent(ConnectedAccountsIntent.RefreshOnReturn)
+            runCurrent()
+            assertEquals(2, reads)
+            unlinked.complete(accounts())
+            runCurrent()
+            stale.complete(accounts(google = true))
+            runCurrent()
+            assertFalse(
+                viewModel.uiState.value.accounts
+                    .single { it.provider == "google" }
+                    .isConnected,
+            )
+        }
+
+    @Test
+    fun delivery_firstResumeAndPendingLoadDoNotDuplicateAndRefreshKeepsContent() =
+        runTest(dispatcher) {
+            var calls = 0
+            var response = CompletableDeferred<ReceiverDeliveryConditions>()
+            val repository =
+                FakeUserReceiverRepository.strict().apply {
+                    onGetReceiverDeliveryConditions = {
+                        calls++
+                        response.await()
+                    }
+                }
+            val viewModel = deliveryViewModel(repository)
+            viewModel.onIntent(DeliveryConditionIntent.RefreshOnReturn)
+            viewModel.onIntent(DeliveryConditionIntent.RefreshOnReturn)
+            runCurrent()
+            assertEquals(1, calls)
+            response.complete(delivery())
+            runCurrent()
+            val previous = viewModel.uiState.value
+            response = CompletableDeferred()
+            viewModel.onIntent(DeliveryConditionIntent.RefreshOnReturn)
+            viewModel.onIntent(DeliveryConditionIntent.RefreshOnReturn)
+            runCurrent()
+            assertEquals(2, calls)
+            assertEquals(previous, viewModel.uiState.value)
+            response.complete(delivery(DeliveryConditionType.RECEIVER_REQUEST))
+            runCurrent()
+            assertEquals(DeliveryConditionType.RECEIVER_REQUEST, viewModel.uiState.value.conditionType)
+            assertFalse(viewModel.uiState.value.isLoading)
+        }
+
+    @Test
+    fun delivery_refreshPreservesUnsavedSelectionAndSavesItWithRefreshedConditions() =
+        runTest(dispatcher) {
+            val response = CompletableDeferred<ReceiverDeliveryConditions>()
+            val repository =
+                FakeUserReceiverRepository.strict().apply {
+                    onGetReceiverDeliveryConditions = { delivery() }
+                    onUpdateReceiverDeliveryConditions = { id, conditions -> ReceiverDeliveryConditions(id, conditions) }
+                }
+            val viewModel = deliveryViewModel(repository)
+            runCurrent()
+            viewModel.onIntent(DeliveryConditionIntent.RefreshOnReturn)
+            viewModel.onIntent(DeliveryConditionIntent.SelectConditionType(DeliveryConditionType.RECEIVER_REQUEST))
+            repository.onGetReceiverDeliveryConditions = { response.await() }
+            viewModel.onIntent(DeliveryConditionIntent.RefreshOnReturn)
+            runCurrent()
+            assertEquals(DeliveryConditionType.RECEIVER_REQUEST, viewModel.uiState.value.conditionType)
+            val refreshed =
+                delivery().let {
+                    it.copy(
+                        conditions =
+                            it.conditions + it.conditions.single().copy(contentType = DeliveryContentType.DIARY),
+                    )
+                }
+            response.complete(refreshed)
+            runCurrent()
+            assertEquals(DeliveryConditionType.RECEIVER_REQUEST, viewModel.uiState.value.conditionType)
+            viewModel.onIntent(DeliveryConditionIntent.Save)
+            runCurrent()
+            val saved = repository.deliveryUpdateCalls.single().conditions
+            assertEquals(DeliveryConditionType.RECEIVER_REQUEST, saved.first().conditionType)
+            assertNull(saved.first().inactivityPeriod)
+            assertEquals(refreshed.conditions.last(), saved.last())
+        }
+
+    @Test
+    fun delivery_editWhileRefreshIsPendingIsNotOverwritten() =
+        runTest(dispatcher) {
+            val response = CompletableDeferred<ReceiverDeliveryConditions>()
+            val repository = FakeUserReceiverRepository.strict().apply { onGetReceiverDeliveryConditions = { delivery() } }
+            val viewModel = deliveryViewModel(repository)
+            runCurrent()
+            viewModel.onIntent(DeliveryConditionIntent.RefreshOnReturn)
+            repository.onGetReceiverDeliveryConditions = { response.await() }
+            viewModel.onIntent(DeliveryConditionIntent.RefreshOnReturn)
+            runCurrent()
+            viewModel.onIntent(DeliveryConditionIntent.SelectConditionType(DeliveryConditionType.RECEIVER_REQUEST))
+            response.complete(delivery())
+            runCurrent()
+            assertEquals(DeliveryConditionType.RECEIVER_REQUEST, viewModel.uiState.value.conditionType)
+        }
+
+    @Test
+    fun delivery_failedRefreshPreservesLoadedStateAndSuccessfulRetryClearsInitialError() =
+        runTest(dispatcher) {
+            val repository = FakeUserReceiverRepository.strict().apply { onGetReceiverDeliveryConditions = { error("offline") } }
+            val viewModel = deliveryViewModel(repository)
+            runCurrent()
+            assertEquals(DeliveryConditionError.LOAD_FAILED, viewModel.uiState.value.error)
+            viewModel.onIntent(DeliveryConditionIntent.RefreshOnReturn)
+            repository.onGetReceiverDeliveryConditions = { delivery() }
+            viewModel.onIntent(DeliveryConditionIntent.RefreshOnReturn)
+            runCurrent()
+            assertNull(viewModel.uiState.value.error)
+            val previous = viewModel.uiState.value
+            repository.onGetReceiverDeliveryConditions = { error("offline") }
+            viewModel.onIntent(DeliveryConditionIntent.RefreshOnReturn)
+            runCurrent()
+            assertEquals(previous, viewModel.uiState.value)
+        }
+
+    @Test
+    fun delivery_saveCancelsStaleReadAndResumeDoesNotReloadDuringSave() =
+        runTest(dispatcher) {
+            var reads = 0
+            val stale = CompletableDeferred<ReceiverDeliveryConditions>()
+            val saved = CompletableDeferred<ReceiverDeliveryConditions>()
+            val repository =
+                FakeUserReceiverRepository.strict().apply {
+                    onGetReceiverDeliveryConditions = { if (++reads == 1) delivery() else stale.await() }
+                    onUpdateReceiverDeliveryConditions = { _, _ -> saved.await() }
+                }
+            val viewModel = deliveryViewModel(repository)
+            runCurrent()
+            viewModel.onIntent(DeliveryConditionIntent.RefreshOnReturn)
+            viewModel.onIntent(DeliveryConditionIntent.RefreshOnReturn)
+            runCurrent()
+            viewModel.onIntent(DeliveryConditionIntent.SelectConditionType(DeliveryConditionType.RECEIVER_REQUEST))
+            viewModel.onIntent(DeliveryConditionIntent.Save)
+            viewModel.onIntent(DeliveryConditionIntent.Save)
+            viewModel.onIntent(DeliveryConditionIntent.RefreshOnReturn)
+            runCurrent()
+            assertEquals(1, repository.deliveryUpdateCalls.size)
+            assertEquals(2, reads)
+            saved.complete(delivery(DeliveryConditionType.RECEIVER_REQUEST))
+            runCurrent()
+            stale.complete(delivery())
+            runCurrent()
+            assertEquals(
+                DeliveryConditionType.RECEIVER_REQUEST,
+                viewModel.uiState.value.conditions
+                    .single()
+                    .conditionType,
+            )
+        }
+
+    @Test
+    fun profile_firstResumeAndPendingLoadDoNotDuplicateAndRefreshKeepsContent() =
+        runTest(dispatcher) {
+            var calls = 0
+            var response = CompletableDeferred<User>()
+            val repository =
+                FakeMyProfileRepository.strict().apply {
+                    onGetMyProfile = {
+                        calls++
+                        response.await()
+                    }
+                }
+            val viewModel = ProfileEditViewModel(repository, FakePhotoUploadRepository.strict())
+            viewModel.onIntent(ProfileEditIntent.RefreshOnReturn)
+            viewModel.onIntent(ProfileEditIntent.RefreshOnReturn)
+            runCurrent()
+            assertEquals(1, calls)
+            response.complete(user())
+            runCurrent()
+            val previous = viewModel.uiState.value
+            response = CompletableDeferred()
+            viewModel.onIntent(ProfileEditIntent.RefreshOnReturn)
+            viewModel.onIntent(ProfileEditIntent.RefreshOnReturn)
+            runCurrent()
+            assertEquals(2, calls)
+            assertEquals(previous, viewModel.uiState.value)
+            response.complete(user().copy(name = "새 이름"))
+            runCurrent()
+            assertEquals("새 이름", (viewModel.uiState.value as ProfileEditUiState.Success).name)
+        }
+
+    @Test
+    fun profile_failedRefreshPreservesLoadedForm() =
+        runTest(dispatcher) {
+            val repository = FakeMyProfileRepository.strict().apply { onGetMyProfile = { user() } }
+            val viewModel = ProfileEditViewModel(repository, FakePhotoUploadRepository.strict())
+            runCurrent()
+            viewModel.onIntent(ProfileEditIntent.RefreshOnReturn)
+            val previous = viewModel.uiState.value
+            repository.onGetMyProfile = { error("offline") }
+            viewModel.onIntent(ProfileEditIntent.RefreshOnReturn)
+            runCurrent()
+            assertEquals(previous, viewModel.uiState.value)
+        }
+
+    @Test
+    fun profile_successfulReentryRecoversInitialError() =
+        runTest(dispatcher) {
+            val repository = FakeMyProfileRepository.strict().apply { onGetMyProfile = { error("offline") } }
+            val viewModel = ProfileEditViewModel(repository, FakePhotoUploadRepository.strict())
+            runCurrent()
+            assertEquals(ProfileEditUiState.Error, viewModel.uiState.value)
+            repository.onGetMyProfile = { user() }
+            viewModel.onIntent(ProfileEditIntent.RefreshOnReturn)
+            viewModel.onIntent(ProfileEditIntent.RefreshOnReturn)
+            runCurrent()
+            assertTrue(viewModel.uiState.value is ProfileEditUiState.Success)
+        }
+
+    @Test
+    fun profile_saveCancelsStaleReadAndResumeDoesNotReloadDuringSave() =
+        runTest(dispatcher) {
+            var reads = 0
+            val stale = CompletableDeferred<User>()
+            val saved = CompletableDeferred<User>()
+            val repository =
+                FakeMyProfileRepository.strict().apply {
+                    onGetMyProfile = { if (++reads == 1) user() else stale.await() }
+                    onUpdateMyProfile = { _, _, _ -> saved.await() }
+                }
+            val viewModel = ProfileEditViewModel(repository, FakePhotoUploadRepository.strict())
+            runCurrent()
+            viewModel.onIntent(ProfileEditIntent.RefreshOnReturn)
+            viewModel.onIntent(ProfileEditIntent.RefreshOnReturn)
+            runCurrent()
+            viewModel.onIntent(ProfileEditIntent.UpdateProfile("작성한 이름", "01012345678"))
+            viewModel.onIntent(ProfileEditIntent.UpdateProfile("중복", "01000000000"))
+            viewModel.onIntent(ProfileEditIntent.RefreshOnReturn)
+            runCurrent()
+            assertEquals(2, reads)
+            assertEquals(1, repository.profileUpdateCalls.size)
+            saved.completeExceptionally(IllegalStateException("save failed"))
+            runCurrent()
+            stale.complete(user().copy(name = "stale"))
+            runCurrent()
+            assertEquals("이름", (viewModel.uiState.value as ProfileEditUiState.Success).name)
+            assertFalse((viewModel.uiState.value as ProfileEditUiState.Success).isUpdating)
+        }
+
+    @Test
+    fun push_firstResumeAndPendingLoadDoNotDuplicateAndRefreshKeepsContent() =
+        runTest(dispatcher) {
+            var calls = 0
+            var response = CompletableDeferred<UserPushSetting>()
+            val repository =
+                FakeSettingNotificationRepository.strict().apply {
+                    onGetMyPushSettings = {
+                        calls++
+                        response.await()
+                    }
+                }
+            val viewModel = pushViewModel(repository)
+            viewModel.onIntent(PushNotificationIntent.RefreshOnReturn)
+            viewModel.onIntent(PushNotificationIntent.RefreshOnReturn)
+            runCurrent()
+            assertEquals(1, calls)
+            response.complete(UserPushSetting(false, false, false))
+            runCurrent()
+            val previous = viewModel.uiState.value
+            response = CompletableDeferred()
+            viewModel.onIntent(PushNotificationIntent.RefreshOnReturn)
+            viewModel.onIntent(PushNotificationIntent.RefreshOnReturn)
+            runCurrent()
+            assertEquals(2, calls)
+            assertEquals(previous, viewModel.uiState.value)
+            response.complete(UserPushSetting(true, true, true))
+            runCurrent()
+            assertTrue(viewModel.uiState.value.isNewsletterOn)
+            assertTrue(viewModel.uiState.value.isMindRecordOn)
+            assertTrue(viewModel.uiState.value.isAfternoteOn)
+            assertFalse(viewModel.uiState.value.isLoading)
+        }
+
+    @Test
+    fun push_failedRefreshPreservesLoadedState() =
+        runTest(dispatcher) {
+            val repository =
+                FakeSettingNotificationRepository.strict().apply {
+                    onGetMyPushSettings = {
+                        UserPushSetting(
+                            true,
+                            true,
+                            true,
+                        )
+                    }
+                }
+            val viewModel = pushViewModel(repository)
+            runCurrent()
+            viewModel.onIntent(PushNotificationIntent.RefreshOnReturn)
+            val previous = viewModel.uiState.value
+            repository.onGetMyPushSettings = { error("offline") }
+            viewModel.onIntent(PushNotificationIntent.RefreshOnReturn)
+            runCurrent()
+            assertEquals(previous, viewModel.uiState.value)
+        }
+
+    @Test
+    fun push_saveCancelsStaleReadAndResumeDoesNotReloadDuringSave() =
+        runTest(dispatcher) {
+            var reads = 0
+            val stale = CompletableDeferred<UserPushSetting>()
+            val saved = CompletableDeferred<UserPushSetting>()
+            val repository =
+                FakeSettingNotificationRepository.strict().apply {
+                    onGetMyPushSettings = { if (++reads == 1) UserPushSetting(false, false, false) else stale.await() }
+                    onUpdateMyPushSettings = { _, _, _ -> saved.await() }
+                }
+            val viewModel = pushViewModel(repository)
+            runCurrent()
+            viewModel.onIntent(PushNotificationIntent.RefreshOnReturn)
+            viewModel.onIntent(PushNotificationIntent.RefreshOnReturn)
+            runCurrent()
+            viewModel.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.NEWSLETTER, true))
+            viewModel.onIntent(PushNotificationIntent.RefreshOnReturn)
+            runCurrent()
+            assertEquals(2, reads)
+            saved.complete(UserPushSetting(true, false, false))
+            runCurrent()
+            stale.complete(UserPushSetting(false, false, false))
+            runCurrent()
+            assertTrue(viewModel.uiState.value.isNewsletterOn)
+        }
+
+    @Test
+    fun profile_refreshPreservesPhotoSelectedWhileRequestIsPending() =
+        runTest(dispatcher) {
+            val pending = CompletableDeferred<User>()
+            val repository = FakeMyProfileRepository.strict().apply { onGetMyProfile = { user() } }
+            val viewModel = ProfileEditViewModel(repository, FakePhotoUploadRepository.strict())
+            runCurrent()
+            viewModel.onIntent(ProfileEditIntent.RefreshOnReturn)
+            repository.onGetMyProfile = { pending.await() }
+            viewModel.onIntent(ProfileEditIntent.RefreshOnReturn)
+            runCurrent()
+            viewModel.onIntent(ProfileEditIntent.SelectPhoto("content://picked"))
+            pending.complete(user().copy(profileImageUrl = "https://example.com/server.jpg"))
+            runCurrent()
+            assertEquals("content://picked", (viewModel.uiState.value as ProfileEditUiState.Success).displayImageUri)
+        }
+
+    @Test
+    fun marketing_firstResumeSkipsReadAndLaterResumeRefreshesServerConsent() =
+        runTest(dispatcher) {
+            val repository = FakeSettingNotificationRepository()
+            val viewModel = PushNotificationViewModel(ApplicationProvider.getApplicationContext(), repository, NoOpErrorReporter)
+            viewModel.onIntent(PushNotificationIntent.RefreshOnReturn)
+            runCurrent()
+            assertEquals(1, repository.getMyMarketingConsentsCalls)
+            repository.marketingConsent = UserMarketingConsent(false, false, true)
+            viewModel.onIntent(PushNotificationIntent.RefreshOnReturn)
+            runCurrent()
+            assertEquals(2, repository.getMyMarketingConsentsCalls)
+            assertFalse(viewModel.uiState.value.isSmsChecked)
+            assertFalse(viewModel.uiState.value.isEmailChecked)
+            assertTrue(viewModel.uiState.value.isPushChecked)
+            val previous = viewModel.uiState.value
+            repository.onGetMyMarketingConsents = { error("offline") }
+            viewModel.onIntent(PushNotificationIntent.RefreshOnReturn)
+            runCurrent()
+            assertEquals(previous, viewModel.uiState.value)
+        }
+
+    @Test
+    fun marketing_writeCancelsStaleLoadAndReentryWaitsForPendingWrite() =
+        runTest(dispatcher) {
+            val stale = CompletableDeferred<UserMarketingConsent>()
+            val saved = CompletableDeferred<UserMarketingConsent>()
+            val repository = FakeSettingNotificationRepository()
+            val viewModel = PushNotificationViewModel(ApplicationProvider.getApplicationContext(), repository, NoOpErrorReporter)
+            viewModel.onIntent(PushNotificationIntent.RefreshOnReturn)
+            runCurrent()
+            repository.onGetMyMarketingConsents = { stale.await() }
+            viewModel.onIntent(PushNotificationIntent.RefreshOnReturn)
+            runCurrent()
+            repository.onUpdateMyMarketingConsents = { _, _, _ -> saved.await() }
+            viewModel.onIntent(PushNotificationIntent.ChangeMarketingConsent(MarketingConsent.SMS, false))
+            viewModel.onIntent(PushNotificationIntent.RefreshOnReturn)
+            runCurrent()
+            assertEquals(2, repository.getMyMarketingConsentsCalls)
+            stale.complete(UserMarketingConsent(true, true, false))
+            saved.complete(UserMarketingConsent(false, true, false))
+            runCurrent()
+            assertFalse(viewModel.uiState.value.isSmsChecked)
+            repository.onGetMyMarketingConsents = { UserMarketingConsent(false, false, true) }
+            viewModel.onIntent(PushNotificationIntent.RefreshOnReturn)
+            runCurrent()
+            assertEquals(3, repository.getMyMarketingConsentsCalls)
+            assertFalse(viewModel.uiState.value.isEmailChecked)
+        }
+
+    private fun deliveryViewModel(repository: FakeUserReceiverRepository) =
+        DeliveryConditionViewModel(
+            SettingRoute.AfterDeliveryRoute(receiverId = 42L),
+            repository,
+            UpdateTimeLetterDeliveryConditionUseCase(repository),
+        )
+
+    private fun pushViewModel(repository: FakeSettingNotificationRepository) =
+        PushNotificationViewModel(
+            ApplicationProvider.getApplicationContext(),
+            repository.apply { onGetMyMarketingConsents = { UserMarketingConsent(true, true, false) } },
+            NoOpErrorReporter,
+        )
+
+    private fun user() = User("이름", "user@example.com", "01012345678", null)
+
+    private fun accounts(google: Boolean = false) = UserConnectedAccount(true, google, false, false, false, null, null, null, null, null)
+
+    private fun delivery(type: DeliveryConditionType = DeliveryConditionType.INACTIVITY) =
+        ReceiverDeliveryConditions(
+            receiverId = 42L,
+            conditions =
+                listOf(
+                    DeliveryConditionItem(
+                        contentType = DeliveryContentType.TIME_LETTER,
+                        conditionType = type,
+                        inactivityPeriod = InactivityPeriod.SIX_MONTHS.takeIf { type == DeliveryConditionType.INACTIVITY },
+                        state = ConditionState.ACTIVE,
+                        fulfilled = false,
+                        gracePeriodStartedAt = null,
+                        fulfilledAt = null,
+                    ),
+                ),
+        )
+}
diff --git a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsMviTest.kt b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsMviTest.kt
new file mode 100644
index 0000000000..c2eb7d27ab
--- /dev/null
+++ b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsMviTest.kt
@@ -0,0 +1,149 @@
+package com.afternote.feature.setting.presentation.account
+
+import com.afternote.core.model.user.UserConnectedAccount
+import com.afternote.feature.setting.domain.testing.FakeSettingAccountRepository
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class ConnectedAccountsMviTest {
+    private val repository = FakeSettingAccountRepository(connectedAccounts = ACCOUNTS)
+
+    @Before
+    fun setUp() {
+        Dispatchers.setMain(UnconfinedTestDispatcher())
+    }
+
+    @After
+    fun tearDown() {
+        Dispatchers.resetMain()
+    }
+
+    @Test
+    fun `토글을 켜면 저장소를 부르지 않고 연결 요청 신호만 올린다`() {
+        val viewModel = ConnectedAccountsViewModel(repository)
+
+        viewModel.onIntent(ConnectedAccountsIntent.Toggle(provider = "google", enabled = true))
+
+        assertEquals("google", viewModel.uiState.value.pendingLinkProvider)
+        assertTrue(repository.connectedLinkCalls.isEmpty())
+        assertTrue(repository.connectedUnlinkCalls.isEmpty())
+    }
+
+    @Test
+    fun `토글을 끄면 신호 없이 바로 해제한다`() {
+        val viewModel = ConnectedAccountsViewModel(repository)
+
+        viewModel.onIntent(ConnectedAccountsIntent.Toggle(provider = "naver", enabled = false))
+
+        assertNull(viewModel.uiState.value.pendingLinkProvider)
+        assertEquals(listOf("naver"), repository.connectedUnlinkCalls)
+        assertFalse(
+            viewModel.uiState.value.accounts
+                .first { it.provider == "naver" }
+                .isConnected,
+        )
+    }
+
+    @Test
+    fun `연결 요청 신호는 소비할 때까지 남고 소비하면 걷힌다`() {
+        val viewModel = ConnectedAccountsViewModel(repository)
+
+        viewModel.onIntent(ConnectedAccountsIntent.Toggle(provider = "kakao", enabled = true))
+        // 다른 작업이 지나가도 신호는 그대로다.
+        viewModel.onIntent(ConnectedAccountsIntent.Toggle(provider = "naver", enabled = false))
+        assertEquals("kakao", viewModel.uiState.value.pendingLinkProvider)
+
+        viewModel.onIntent(ConnectedAccountsIntent.ConsumeLinkRequest("kakao"))
+        assertNull(viewModel.uiState.value.pendingLinkProvider)
+
+        // 소비 뒤 같은 제공자를 다시 켜면 다시 요청한다 (A → null → A).
+        viewModel.onIntent(ConnectedAccountsIntent.Toggle(provider = "kakao", enabled = true))
+        assertEquals("kakao", viewModel.uiState.value.pendingLinkProvider)
+    }
+
+    @Test
+    fun `늦게 도착한 소비가 그사이 올라온 다른 제공자 요청을 지우지 않는다`() {
+        val viewModel = ConnectedAccountsViewModel(repository)
+
+        viewModel.onIntent(ConnectedAccountsIntent.Toggle(provider = "google", enabled = true))
+        viewModel.onIntent(ConnectedAccountsIntent.Toggle(provider = "kakao", enabled = true))
+        viewModel.onIntent(ConnectedAccountsIntent.ConsumeLinkRequest("google"))
+
+        assertEquals("kakao", viewModel.uiState.value.pendingLinkProvider)
+
+        viewModel.onIntent(ConnectedAccountsIntent.ConsumeLinkRequest("kakao"))
+        assertNull(viewModel.uiState.value.pendingLinkProvider)
+    }
+
+    @Test
+    fun `연결이 연달아 실패해도 매번 요청하고 실패 문구를 남긴 뒤 성공하면 계정을 갱신한다`() {
+        var remainingFailures = 2
+        repository.onLinkConnectedAccount = { provider, _ ->
+            if (remainingFailures > 0) {
+                remainingFailures--
+                error("oauth rejected")
+            }
+            ACCOUNTS.copy(google = provider == "google", googleEmail = "linked@afternote.local")
+        }
+        val viewModel = ConnectedAccountsViewModel(repository)
+
+        repeat(2) {
+            viewModel.onIntent(ConnectedAccountsIntent.Link(provider = "google", accessToken = "token-$it"))
+            assertEquals("계정 연결에 실패했습니다.", viewModel.uiState.value.pendingError)
+            assertFalse(
+                viewModel.uiState.value.accounts
+                    .first { it.provider == "google" }
+                    .isConnected,
+            )
+        }
+        viewModel.onIntent(ConnectedAccountsIntent.Link(provider = "google", accessToken = "token-2"))
+
+        assertEquals(
+            List(3) { FakeSettingAccountRepository.ConnectedAccountLinkCall("google", "token-$it") },
+            repository.connectedLinkCalls.toList(),
+        )
+        val google =
+            viewModel.uiState.value.accounts
+                .first { it.provider == "google" }
+        assertTrue(google.isConnected)
+        assertEquals("linked@afternote.local", google.email)
+    }
+
+    @Test
+    fun `조회 실패는 로딩을 끝내고 실패 문구를 남긴다`() {
+        repository.onGetConnectedAccounts = { error("unavailable") }
+
+        val state = ConnectedAccountsViewModel(repository).uiState.value
+
+        assertFalse(state.isLoading)
+        assertTrue(state.accounts.isEmpty())
+        assertEquals("계정 정보를 불러올 수 없습니다.", state.errorMessage)
+    }
+
+    private companion object {
+        val ACCOUNTS =
+            UserConnectedAccount(
+                local = false,
+                naver = true,
+                google = false,
+                kakao = false,
+                apple = false,
+                localEmail = null,
+                naverEmail = "naver@afternote.local",
+                googleEmail = null,
+                kakaoEmail = null,
+                appleEmail = null,
+            )
+    }
+}
diff --git a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsSignalTest.kt b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsSignalTest.kt
new file mode 100644
index 0000000000..5b714026d0
--- /dev/null
+++ b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/account/ConnectedAccountsSignalTest.kt
@@ -0,0 +1,46 @@
+package com.afternote.feature.setting.presentation.account
+
+import androidx.compose.ui.test.junit4.v2.createComposeRule
+import com.afternote.core.ui.theme.AfternoteTheme
+import com.afternote.feature.setting.domain.testing.FakeSettingAccountRepository
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+/**
+ * 연결된 계정 화면이 연결 요청 신호를 받자마자 소비하고, 인증은 신호와 떨어진 화면 코루틴에서
+ * 돌리는지 확인한다 (#1502). 플랫폼 인증은 이 환경에서 토큰을 주지 못하므로 연결 호출까지는 가지 않는다.
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [35])
+class ConnectedAccountsSignalTest {
+    @get:Rule
+    val composeRule = createComposeRule()
+
+    private val repository = FakeSettingAccountRepository()
+    private val viewModel = ConnectedAccountsViewModel(repository)
+
+    @Test
+    fun `화면은 연결 요청 신호를 받으면 곧바로 소비하고 다음 요청도 다시 받는다`() {
+        composeRule.setContent {
+            AfternoteTheme {
+                ConnectedAccountsScreen(onBack = {}, viewModel = viewModel)
+            }
+        }
+        composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) { !viewModel.uiState.value.isLoading }
+
+        repeat(2) {
+            composeRule.runOnIdle { viewModel.onIntent(ConnectedAccountsIntent.Toggle(provider = "google", enabled = true)) }
+            composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) { viewModel.uiState.value.pendingLinkProvider == null }
+        }
+
+        assertTrue(repository.connectedLinkCalls.isEmpty())
+    }
+
+    private companion object {
+        const val TIMEOUT_MILLIS = 5_000L
+    }
+}
diff --git a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/home/SettingProfileAvatarTest.kt b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/home/SettingProfileAvatarTest.kt
new file mode 100644
index 0000000000..128c9f628c
--- /dev/null
+++ b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/home/SettingProfileAvatarTest.kt
@@ -0,0 +1,161 @@
+package com.afternote.feature.setting.presentation.home
+
+import android.app.Application
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Color
+import android.view.View
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.platform.LocalView
+import androidx.compose.ui.test.junit4.v2.createComposeRule
+import androidx.compose.ui.test.onNodeWithContentDescription
+import androidx.test.core.app.ApplicationProvider
+import coil3.ImageLoader
+import coil3.SingletonImageLoader
+import coil3.annotation.DelicateCoilApi
+import coil3.asImage
+import coil3.intercept.Interceptor
+import coil3.request.ErrorResult
+import coil3.request.SuccessResult
+import com.afternote.core.ui.theme.AfternoteTheme
+import com.afternote.feature.setting.presentation.home.component.SettingProfile
+import org.junit.After
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import org.robolectric.annotation.GraphicsMode
+import java.io.IOException
+import java.util.Collections
+import kotlin.math.sqrt
+import com.afternote.core.ui.R as CoreUiR
+
+@OptIn(DelicateCoilApi::class)
+@RunWith(RobolectricTestRunner::class)
+@GraphicsMode(GraphicsMode.Mode.NATIVE)
+@Config(sdk = [35], application = Application::class)
+class SettingProfileAvatarTest {
+    @get:Rule
+    val composeRule = createComposeRule()
+
+    private lateinit var imageLoader: ImageLoader
+    private lateinit var hostView: View
+    private var imageUrl by mutableStateOf<String?>(null)
+    private val requests = Collections.synchronizedList(mutableListOf<Any>())
+    private val context get() = ApplicationProvider.getApplicationContext<Context>()
+
+    @Before
+    fun setUp() {
+        imageLoader =
+            ImageLoader
+                .Builder(context)
+                .components {
+                    add(
+                        Interceptor { chain ->
+                            requests += chain.request.data
+                            if (chain.request.data == BROKEN) {
+                                ErrorResult(null, chain.request, IOException("missing image"))
+                            } else {
+                                val bitmap = Bitmap.createBitmap(60, 60, Bitmap.Config.ARGB_8888)
+                                bitmap.eraseColor(if (chain.request.data == FIRST) Color.RED else Color.GREEN)
+                                SuccessResult(bitmap.asImage(), chain.request)
+                            }
+                        },
+                    )
+                }.build()
+        SingletonImageLoader.setUnsafe(imageLoader)
+        composeRule.setContent {
+            hostView = LocalView.current
+            AfternoteTheme {
+                SettingProfile(
+                    name = "name",
+                    email = "user@example.com",
+                    profileImageUrl = imageUrl,
+                    onInquiryClick = {},
+                    onNoticeClick = {},
+                    onRecipientListClick = {},
+                )
+            }
+        }
+    }
+
+    @After
+    fun tearDown() {
+        SingletonImageLoader.reset()
+        imageLoader.shutdown()
+    }
+
+    @Test
+    fun `등록 사진을 그리고 다른 URL로 바뀌면 새 사진을 그린다`() {
+        show(FIRST)
+        waitForColor(Color.RED)
+        show(SECOND)
+        waitForColor(Color.GREEN)
+        assertEquals(listOf(FIRST, SECOND), requests)
+    }
+
+    @Test
+    fun `사진 삭제와 빈 URL은 기본 이미지로 돌아가고 새 이미지 요청을 하지 않는다`() {
+        val defaultPixels = avatarPixels()
+        show(FIRST)
+        waitForColor(Color.RED)
+
+        show(null)
+        assertArrayEquals(defaultPixels, avatarPixels())
+        show(" ")
+        assertArrayEquals(defaultPixels, avatarPixels())
+        assertEquals(listOf(FIRST), requests)
+    }
+
+    @Test
+    fun `새 사진 로드 실패는 이전 사진 대신 기본 이미지를 그린다`() {
+        val defaultPixels = avatarPixels()
+        show(FIRST)
+        waitForColor(Color.RED)
+
+        show(BROKEN)
+        composeRule.waitUntil(5_000) { requests.contains(BROKEN) }
+        composeRule.waitUntil(5_000) { avatarPixels().contentEquals(defaultPixels) }
+        assertArrayEquals(defaultPixels, avatarPixels())
+    }
+
+    private fun show(url: String?) {
+        composeRule.runOnIdle { imageUrl = url }
+        composeRule.waitForIdle()
+    }
+
+    private fun waitForColor(color: Int) {
+        composeRule.waitUntil(5_000) {
+            val pixels = avatarPixels()
+            val width = sqrt(pixels.size.toDouble()).toInt()
+            pixels[pixels.size / 2 + width / 2] == color
+        }
+    }
+
+    private fun avatarPixels(): IntArray {
+        val description = context.getString(CoreUiR.string.core_ui_content_description_profile_image)
+        val bounds = composeRule.onNodeWithContentDescription(description).fetchSemanticsNode().boundsInRoot
+        return composeRule.runOnIdle {
+            val bitmap = Bitmap.createBitmap(hostView.width, hostView.height, Bitmap.Config.ARGB_8888)
+            hostView.draw(Canvas(bitmap))
+            val width = bounds.width.toInt()
+            val height = bounds.height.toInt()
+            IntArray(width * height).also {
+                bitmap.getPixels(it, 0, width, bounds.left.toInt(), bounds.top.toInt(), width, height)
+            }
+        }
+    }
+
+    private companion object {
+        const val FIRST = "https://images.example/first.jpg"
+        const val SECOND = "https://images.example/second.jpg"
+        const val BROKEN = "https://images.example/missing.jpg"
+    }
+}
diff --git a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/home/SettingProfileImageTest.kt b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/home/SettingProfileImageTest.kt
new file mode 100644
index 0000000000..ec886de0fc
--- /dev/null
+++ b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/home/SettingProfileImageTest.kt
@@ -0,0 +1,87 @@
+package com.afternote.feature.setting.presentation.home
+
+import com.afternote.core.domain.testing.FakeAuthRepository
+import com.afternote.core.domain.testing.FakeMyProfileRepository
+import com.afternote.core.model.user.User
+import com.afternote.feature.setting.domain.testing.FakeSettingAccountRepository
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runCurrent
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Before
+import org.junit.Test
+import java.io.IOException
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class SettingProfileImageTest {
+    private val dispatcher = StandardTestDispatcher()
+    private val repository = FakeMyProfileRepository.strict()
+
+    @Before
+    fun setUp() {
+        Dispatchers.setMain(dispatcher)
+    }
+
+    @After
+    fun tearDown() {
+        Dispatchers.resetMain()
+    }
+
+    @Test
+    fun `프로필 조회와 갱신 결과의 사진 URL을 홈 상태에 전달한다`() =
+        runTest(dispatcher) {
+            var imageUrl = "https://images.example/first.jpg"
+            repository.onGetMyProfile = { User("name", "user@example.com", null, imageUrl) }
+            val viewModel = viewModel()
+            runCurrent()
+            assertEquals(imageUrl, viewModel.profile().profileImageUrl)
+
+            imageUrl = "https://images.example/second.jpg"
+            viewModel.onIntent(SettingIntent.Refresh)
+            runCurrent()
+            assertEquals(imageUrl, viewModel.profile().profileImageUrl)
+        }
+
+    @Test
+    fun `갱신 결과에 사진이 없으면 이전 URL을 남기지 않는다`() =
+        runTest(dispatcher) {
+            var imageUrl: String? = "https://images.example/first.jpg"
+            repository.onGetMyProfile = { User("name", "user@example.com", null, imageUrl) }
+            val viewModel = viewModel()
+            runCurrent()
+            assertEquals(imageUrl, viewModel.profile().profileImageUrl)
+
+            imageUrl = null
+            viewModel.onIntent(SettingIntent.Refresh)
+            runCurrent()
+            assertNull(viewModel.profile().profileImageUrl)
+        }
+
+    @Test
+    fun `프로필 갱신 실패 뒤에는 이전 사진을 담은 성공 상태가 남지 않는다`() =
+        runTest(dispatcher) {
+            repository.onGetMyProfile = { User("name", "user@example.com", null, "https://images.example/first.jpg") }
+            val viewModel = viewModel()
+            runCurrent()
+
+            repository.onGetMyProfile = { throw IOException("offline") }
+            viewModel.onIntent(SettingIntent.Refresh)
+            runCurrent()
+            assertEquals(SettingProfileState.Error, viewModel.uiState.value.profile)
+        }
+
+    private fun viewModel() =
+        SettingViewModel(
+            authRepository = FakeAuthRepository.strict(),
+            myProfileRepository = repository,
+            accountRepository = FakeSettingAccountRepository.strict(),
+        )
+
+    private fun SettingViewModel.profile() = uiState.value.profile as SettingProfileState.Success
+}
diff --git a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/home/SettingViewModelTest.kt b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/home/SettingViewModelTest.kt
index f1582f606a..eee0ea0263 100644
--- a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/home/SettingViewModelTest.kt
+++ b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/home/SettingViewModelTest.kt
@@ -35,11 +35,11 @@ class SettingViewModelTest {
         runTest(dispatcher) {
             val viewModel = viewModel(onDeleteAccount = {})
 
-            viewModel.deleteAccount()
+            viewModel.onIntent(SettingIntent.DeleteAccount)
 
-            assertEquals(WithdrawUiState.Loading, viewModel.withdrawUiState.value)
+            assertEquals(WithdrawUiState.Loading, viewModel.uiState.value.withdraw)
             runCurrent()
-            assertEquals(WithdrawUiState.Success, viewModel.withdrawUiState.value)
+            assertEquals(WithdrawUiState.Success, viewModel.uiState.value.withdraw)
         }
 
     @Test
@@ -47,12 +47,12 @@ class SettingViewModelTest {
         runTest(dispatcher) {
             val viewModel = viewModel(onDeleteAccount = { throw IllegalStateException("failure") })
 
-            viewModel.deleteAccount()
+            viewModel.onIntent(SettingIntent.DeleteAccount)
             runCurrent()
 
-            assertEquals(WithdrawUiState.Error, viewModel.withdrawUiState.value)
-            viewModel.dismissWithdrawError()
-            assertEquals(WithdrawUiState.Idle, viewModel.withdrawUiState.value)
+            assertEquals(WithdrawUiState.Error, viewModel.uiState.value.withdraw)
+            viewModel.onIntent(SettingIntent.DismissWithdrawError)
+            assertEquals(WithdrawUiState.Idle, viewModel.uiState.value.withdraw)
         }
 
     @Test
@@ -61,8 +61,8 @@ class SettingViewModelTest {
             var requestCount = 0
             val viewModel = viewModel(onDeleteAccount = { requestCount++ })
 
-            viewModel.deleteAccount()
-            viewModel.deleteAccount()
+            viewModel.onIntent(SettingIntent.DeleteAccount)
+            viewModel.onIntent(SettingIntent.DeleteAccount)
             runCurrent()
 
             assertEquals(1, requestCount)
diff --git a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/notification/MarketingConsentFailureTest.kt b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/notification/MarketingConsentFailureTest.kt
index 6d88a442f7..b2091e81a1 100644
--- a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/notification/MarketingConsentFailureTest.kt
+++ b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/notification/MarketingConsentFailureTest.kt
@@ -8,7 +8,6 @@ import com.afternote.feature.setting.domain.testing.FakeSettingNotificationRepos
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.launch
 import kotlinx.coroutines.test.StandardTestDispatcher
 import kotlinx.coroutines.test.advanceUntilIdle
 import kotlinx.coroutines.test.resetMain
@@ -17,6 +16,7 @@ import kotlinx.coroutines.test.runTest
 import kotlinx.coroutines.test.setMain
 import org.junit.After
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
 import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Test
@@ -49,23 +49,21 @@ class MarketingConsentFailureTest {
                     onUpdateMyMarketingConsents = { _, _, _ -> error("unavailable") }
                 }
             val viewModel = viewModel(repository, reporter)
-            val events = mutableListOf<PushNotificationEvent>()
-            backgroundScope.launch(dispatcher) { viewModel.events.collect { events += it } }
             advanceUntilIdle()
-            runCurrent()
+            viewModel.onIntent(PushNotificationIntent.MarketingFeedbackStarted)
 
-            viewModel.onSmsChecked(false)
-            advanceUntilIdle()
-            assertTrue(viewModel.uiState.value.isSmsChecked)
-            viewModel.onEmailChecked(false)
-            advanceUntilIdle()
-            assertTrue(viewModel.uiState.value.isEmailChecked)
-            viewModel.onPushChecked(false)
-            advanceUntilIdle()
-            runCurrent()
-            assertTrue(viewModel.uiState.value.isPushChecked)
+            var signals = 0
+            MarketingConsent.entries.forEach { consent ->
+                viewModel.onIntent(PushNotificationIntent.ChangeMarketingConsent(consent, false))
+                assertFalse(viewModel.uiState.value.checked(consent))
+                advanceUntilIdle()
+
+                assertTrue(viewModel.uiState.value.checked(consent))
+                if (viewModel.uiState.value.isMarketingConsentSaveFailed) signals++
+                viewModel.onIntent(PushNotificationIntent.ConsumeMarketingConsentSaveFailure)
+            }
 
-            assertEquals(List(3) { PushNotificationEvent.MarketingConsentSaveFailed }, events)
+            assertEquals(3, signals)
             assertEquals(listOf("sms_consent_update", "email_consent_update", "push_consent_update"), reporter.stages)
             assertEquals(
                 listOf(Triple(false, null, null), Triple(null, false, null), Triple(null, null, false)),
@@ -82,14 +80,12 @@ class MarketingConsentFailureTest {
                     onUpdateMyMarketingConsents = { _, _, _ -> throw CancellationException("screen left") }
                 }
             val viewModel = viewModel(repository, reporter)
-            val events = mutableListOf<PushNotificationEvent>()
-            backgroundScope.launch(dispatcher) { viewModel.events.collect { events += it } }
             advanceUntilIdle()
-            runCurrent()
+            viewModel.onIntent(PushNotificationIntent.MarketingFeedbackStarted)
 
-            viewModel.onSmsChecked(false)
-            viewModel.onEmailChecked(false)
-            viewModel.onPushChecked(false)
+            MarketingConsent.entries.forEach { consent ->
+                viewModel.onIntent(PushNotificationIntent.ChangeMarketingConsent(consent, false))
+            }
             advanceUntilIdle()
             runCurrent()
 
@@ -97,39 +93,83 @@ class MarketingConsentFailureTest {
                 listOf(false, false, false),
                 viewModel.uiState.value.let { listOf(it.isSmsChecked, it.isEmailChecked, it.isPushChecked) },
             )
-            assertTrue(events.isEmpty())
+            assertFalse(viewModel.uiState.value.isMarketingConsentSaveFailed)
             assertTrue(reporter.stages.isEmpty())
         }
 
     @Test
-    fun `구독이 끝난 동안의 실패 안내는 다음 구독에 재생하지 않는다`() =
+    fun `STARTED 밖에서 난 실패 안내는 다음 진입에 재생하지 않는다`() =
+        runTest(dispatcher) {
+            val viewModel = failingViewModel()
+            advanceUntilIdle()
+            viewModel.onIntent(PushNotificationIntent.MarketingFeedbackStarted)
+            viewModel.onIntent(PushNotificationIntent.MarketingFeedbackStopped)
+
+            viewModel.onIntent(PushNotificationIntent.ChangeMarketingConsent(MarketingConsent.SMS, false))
+            advanceUntilIdle()
+            // 값 롤백은 화면 수명과 무관하게 일어난다. 안내만 막힌다.
+            assertTrue(viewModel.uiState.value.isSmsChecked)
+            assertFalse(viewModel.uiState.value.isMarketingConsentSaveFailed)
+
+            viewModel.onIntent(PushNotificationIntent.MarketingFeedbackStarted)
+            assertFalse(viewModel.uiState.value.isMarketingConsentSaveFailed)
+
+            viewModel.onIntent(PushNotificationIntent.ChangeMarketingConsent(MarketingConsent.EMAIL, false))
+            advanceUntilIdle()
+            assertTrue(viewModel.uiState.value.isMarketingConsentSaveFailed)
+        }
+
+    @Test
+    fun `소비하기 전에 화면이 멈추면 남은 안내를 걷어 재진입에 띄우지 않는다`() =
         runTest(dispatcher) {
+            val viewModel = failingViewModel()
+            advanceUntilIdle()
+            viewModel.onIntent(PushNotificationIntent.MarketingFeedbackStarted)
+
+            viewModel.onIntent(PushNotificationIntent.ChangeMarketingConsent(MarketingConsent.PUSH, true))
+            advanceUntilIdle()
+            assertTrue(viewModel.uiState.value.isMarketingConsentSaveFailed)
+
+            viewModel.onIntent(PushNotificationIntent.MarketingFeedbackStopped)
+            viewModel.onIntent(PushNotificationIntent.MarketingFeedbackStarted)
+
+            assertFalse(viewModel.uiState.value.isMarketingConsentSaveFailed)
+        }
+
+    @Test
+    fun `안내는 소비할 때까지 남고 소비 뒤 연속 실패는 다시 안내한다`() =
+        runTest(dispatcher) {
+            val reporter = RecordingReporter()
             val viewModel =
                 viewModel(
-                    repository().apply {
-                        onUpdateMyMarketingConsents = { _, _, _ -> error("unavailable") }
-                    },
-                    RecordingReporter(),
+                    repository().apply { onUpdateMyMarketingConsents = { _, _, _ -> error("unavailable") } },
+                    reporter,
                 )
-            val events = mutableListOf<PushNotificationEvent>()
-            val firstCollector = backgroundScope.launch(dispatcher) { viewModel.events.collect { events += it } }
             advanceUntilIdle()
-            runCurrent()
-            firstCollector.cancel()
-            runCurrent()
+            viewModel.onIntent(PushNotificationIntent.MarketingFeedbackStarted)
 
-            viewModel.onSmsChecked(false)
+            viewModel.onIntent(PushNotificationIntent.ChangeMarketingConsent(MarketingConsent.SMS, false))
             advanceUntilIdle()
-            backgroundScope.launch(dispatcher) { viewModel.events.collect { events += it } }
-            runCurrent()
-            assertTrue(events.isEmpty())
+            // 다른 입력이 지나가도 소비 전까지 신호는 남는다.
+            viewModel.onIntent(PushNotificationIntent.RefreshDeviceAlarmStatus)
+            assertTrue(viewModel.uiState.value.isMarketingConsentSaveFailed)
 
-            viewModel.onEmailChecked(false)
+            viewModel.onIntent(PushNotificationIntent.ConsumeMarketingConsentSaveFailure)
+            assertFalse(viewModel.uiState.value.isMarketingConsentSaveFailed)
+
+            viewModel.onIntent(PushNotificationIntent.ChangeMarketingConsent(MarketingConsent.SMS, false))
             advanceUntilIdle()
-            runCurrent()
-            assertEquals(listOf(PushNotificationEvent.MarketingConsentSaveFailed), events)
+            assertTrue(viewModel.uiState.value.isMarketingConsentSaveFailed)
+            assertTrue(viewModel.uiState.value.isSmsChecked)
+            assertEquals(listOf("sms_consent_update", "sms_consent_update"), reporter.stages)
         }
 
+    private fun failingViewModel() =
+        viewModel(
+            repository().apply { onUpdateMyMarketingConsents = { _, _, _ -> error("unavailable") } },
+            RecordingReporter(),
+        )
+
     private fun repository() =
         FakeSettingNotificationRepository.strict().apply {
             onGetMyPushSettings = { UserPushSetting(false, false, false) }
@@ -141,6 +181,13 @@ class MarketingConsentFailureTest {
         reporter: ErrorReporter,
     ) = PushNotificationViewModel(ApplicationProvider.getApplicationContext(), repository, reporter)
 
+    private fun PushNotificationUiState.checked(consent: MarketingConsent): Boolean =
+        when (consent) {
+            MarketingConsent.SMS -> isSmsChecked
+            MarketingConsent.EMAIL -> isEmailChecked
+            MarketingConsent.PUSH -> isPushChecked
+        }
+
     private class RecordingReporter : ErrorReporter {
         val stages = mutableListOf<String?>()
 
diff --git a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/notification/NotificationSettingSignalTest.kt b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/notification/NotificationSettingSignalTest.kt
new file mode 100644
index 0000000000..69d87b2b6e
--- /dev/null
+++ b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/notification/NotificationSettingSignalTest.kt
@@ -0,0 +1,169 @@
+package com.afternote.feature.setting.presentation.notification
+
+import android.content.Context
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.ui.test.junit4.v2.createComposeRule
+import androidx.compose.ui.test.onAllNodesWithText
+import androidx.compose.ui.test.onNodeWithText
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.LifecycleRegistry
+import androidx.lifecycle.compose.LocalLifecycleOwner
+import androidx.test.core.app.ApplicationProvider
+import com.afternote.core.model.user.UserMarketingConsent
+import com.afternote.core.model.user.UserPushSetting
+import com.afternote.core.ui.theme.AfternoteTheme
+import com.afternote.feature.setting.domain.testing.FakeSettingNotificationRepository
+import com.afternote.feature.setting.presentation.NoOpErrorReporter
+import com.afternote.feature.setting.presentation.R
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+/**
+ * 알림 설정 화면이 마케팅 동의 저장 실패 신호를 받아 안내하고 소비하는지, STARTED 밖의 실패를
+ * 재진입에 재생하지 않는지 화면 배선까지 확인한다 (#1502, #558).
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [35])
+class NotificationSettingSignalTest {
+    @get:Rule
+    val composeRule = createComposeRule()
+
+    private val context: Context = ApplicationProvider.getApplicationContext()
+    private val failedMessage = context.getString(R.string.setting_marketing_consent_save_failed)
+    private val repository =
+        FakeSettingNotificationRepository.strict().apply {
+            onGetMyPushSettings = { UserPushSetting(timeLetter = false, mindRecord = false, afterNote = false) }
+            onGetMyMarketingConsents = { UserMarketingConsent(sms = true, email = true, push = true) }
+            onUpdateMyMarketingConsents = { _, _, _ -> error("unavailable") }
+        }
+    private val viewModel = PushNotificationViewModel(context, repository, NoOpErrorReporter)
+    private val lifecycleOwner = ManualLifecycleOwner()
+
+    @Test
+    fun `저장 실패 신호를 받으면 안내를 띄우고 신호를 소비한다`() {
+        setScreen()
+        composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) { viewModel.uiState.value.isMarketingFeedbackActive }
+
+        composeRule.runOnIdle {
+            viewModel.onIntent(PushNotificationIntent.ChangeMarketingConsent(MarketingConsent.SMS, false))
+        }
+        composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
+            composeRule.onAllNodesWithText(failedMessage).fetchSemanticsNodes().isNotEmpty()
+        }
+
+        composeRule.onNodeWithText(failedMessage).assertExists()
+        assertFalse(viewModel.uiState.value.isMarketingConsentSaveFailed)
+        assertTrue(viewModel.uiState.value.isSmsChecked)
+    }
+
+    @Test
+    fun `STARTED 밖에서 난 저장 실패는 다시 시작해도 안내하지 않는다`() {
+        setScreen()
+        composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) { viewModel.uiState.value.isMarketingFeedbackActive }
+
+        composeRule.runOnIdle { lifecycleOwner.moveTo(Lifecycle.State.CREATED) }
+        composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) { !viewModel.uiState.value.isMarketingFeedbackActive }
+
+        composeRule.runOnIdle {
+            viewModel.onIntent(PushNotificationIntent.ChangeMarketingConsent(MarketingConsent.EMAIL, false))
+        }
+        composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
+            repository.marketingConsentUpdates.size == 1 && viewModel.uiState.value.isEmailChecked
+        }
+        assertFalse(viewModel.uiState.value.isMarketingConsentSaveFailed)
+
+        composeRule.runOnIdle { lifecycleOwner.moveTo(Lifecycle.State.RESUMED) }
+        composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) { viewModel.uiState.value.isMarketingFeedbackActive }
+        composeRule.waitForIdle()
+
+        assertTrue(composeRule.onAllNodesWithText(failedMessage).fetchSemanticsNodes().isEmpty())
+        assertFalse(viewModel.uiState.value.isMarketingConsentSaveFailed)
+    }
+
+    @Test
+    fun `안내 중에 화면이 멈추면 떠 있던 안내와 밀린 안내를 거둬 재진입에 띄우지 않는다`() {
+        setScreen()
+        composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) { viewModel.uiState.value.isMarketingFeedbackActive }
+
+        // 첫 실패의 안내가 떠 있는 동안 둘째 실패가 나서 그 뒤에 줄을 선다.
+        composeRule.runOnIdle {
+            viewModel.onIntent(PushNotificationIntent.ChangeMarketingConsent(MarketingConsent.SMS, false))
+        }
+        composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) { isFailedMessageShown() }
+        composeRule.runOnIdle {
+            viewModel.onIntent(PushNotificationIntent.ChangeMarketingConsent(MarketingConsent.EMAIL, false))
+        }
+        composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
+            repository.marketingConsentUpdates.size == 2 &&
+                viewModel.uiState.value.isEmailChecked &&
+                !viewModel.uiState.value.isMarketingConsentSaveFailed
+        }
+
+        // 안내 시간이 흘러 저절로 닫히지 않게 시계를 세운다. 멈췄다 돌아오는 것만으로 걷히는지 본다.
+        composeRule.mainClock.autoAdvance = false
+        composeRule.runOnIdle { lifecycleOwner.moveTo(Lifecycle.State.CREATED) }
+        composeRule.runOnIdle { lifecycleOwner.moveTo(Lifecycle.State.RESUMED) }
+        composeRule.mainClock.advanceTimeBy(SNACKBAR_EXIT_MILLIS)
+
+        assertFalse(isFailedMessageShown())
+    }
+
+    @Test
+    fun `알림 설정 화면 첫 진입은 중복 조회하지 않고 복귀하면 서버 동의를 갱신한다`() {
+        setScreen()
+        composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) { viewModel.uiState.value.isMarketingFeedbackActive }
+        composeRule.waitForIdle()
+        assertEquals(1, repository.getMyMarketingConsentsCalls)
+        composeRule.runOnIdle {
+            lifecycleOwner.moveTo(Lifecycle.State.CREATED)
+            repository.onGetMyMarketingConsents = { UserMarketingConsent(sms = false, email = false, push = false) }
+        }
+        composeRule.runOnIdle { lifecycleOwner.moveTo(Lifecycle.State.RESUMED) }
+        composeRule.waitUntil(timeoutMillis = TIMEOUT_MILLIS) {
+            repository.getMyMarketingConsentsCalls == 2 && !viewModel.uiState.value.isSmsChecked
+        }
+        assertFalse(viewModel.uiState.value.isEmailChecked)
+        assertFalse(viewModel.uiState.value.isPushChecked)
+    }
+
+    private fun isFailedMessageShown(): Boolean = composeRule.onAllNodesWithText(failedMessage).fetchSemanticsNodes().isNotEmpty()
+
+    private fun setScreen() {
+        composeRule.setContent {
+            CompositionLocalProvider(LocalLifecycleOwner provides lifecycleOwner) {
+                AfternoteTheme {
+                    NotificationSettingScreen(
+                        onBack = {},
+                        onPushNotificationClick = {},
+                        viewModel = viewModel,
+                    )
+                }
+            }
+        }
+    }
+
+    /** 화면이 보는 수명만 따로 움직인다. 호스트 액티비티는 RESUMED 로 둔 채 STARTED 밖을 흉내 낸다. */
+    private class ManualLifecycleOwner : LifecycleOwner {
+        private val registry = LifecycleRegistry.createUnsafe(this).apply { currentState = Lifecycle.State.RESUMED }
+
+        override val lifecycle: Lifecycle get() = registry
+
+        fun moveTo(state: Lifecycle.State) {
+            registry.currentState = state
+        }
+    }
+
+    private companion object {
+        const val TIMEOUT_MILLIS = 5_000L
+
+        /** 스낵바가 사라지는 애니메이션이 끝나기에 넉넉하고, 짧은 안내 시간(4초)보다는 짧다. */
+        const val SNACKBAR_EXIT_MILLIS = 1_000L
+    }
+}
diff --git a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationSaveReportingTest.kt b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationSaveReportingTest.kt
new file mode 100644
index 0000000000..1068f0f479
--- /dev/null
+++ b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationSaveReportingTest.kt
@@ -0,0 +1,218 @@
+package com.afternote.feature.setting.presentation.notification
+
+import androidx.lifecycle.ViewModelStore
+import androidx.test.core.app.ApplicationProvider
+import com.afternote.core.common.reporting.ErrorReporter
+import com.afternote.core.model.user.UserPushSetting
+import com.afternote.feature.setting.domain.testing.FakeSettingNotificationRepository
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runCurrent
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+/**
+ * 서비스 알림 토글 저장 실패가 개발자 진단으로 남는지 검증한다 (#963).
+ *
+ * 저장 실패만 [ErrorReporter] 로 올리고 조회 실패·성공·취소는 올리지 않는다. 기록 속성은 단계와
+ * 토글 이름뿐이고, [ErrorReporter.recordFailure] 가 덧붙이는 예외 타입 외에는 아무것도 싣지 않는다.
+ */
+@OptIn(ExperimentalCoroutinesApi::class)
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [35])
+class PushNotificationSaveReportingTest {
+    private val dispatcher = StandardTestDispatcher()
+
+    @Before
+    fun setUp() {
+        Dispatchers.setMain(dispatcher)
+    }
+
+    @After
+    fun tearDown() {
+        Dispatchers.resetMain()
+    }
+
+    @Test
+    fun `세 토글의 저장 실패는 토글마다 고정 속성으로 한 번씩 기록하고 롤백과 실패 안내는 그대로다`() =
+        runTest(dispatcher) {
+            val reporter = RecordingReporter()
+            val repository =
+                FakeSettingNotificationRepository(pushSetting = ALL_ON).apply {
+                    onUpdateMyPushSettings = { _, _, _ -> error("server") }
+                }
+            val viewModel = viewModel(repository, reporter)
+            runCurrent()
+
+            viewModel.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.NEWSLETTER, false))
+            runCurrent()
+            assertTrue(viewModel.uiState.value.isNewsletterOn)
+            assertEquals(PushNotificationSaveFailure.SERVER, viewModel.uiState.value.saveFailure)
+            viewModel.onIntent(PushNotificationIntent.DismissSaveFailure)
+
+            viewModel.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.MIND_RECORD, false))
+            runCurrent()
+            assertTrue(viewModel.uiState.value.isMindRecordOn)
+            assertEquals(PushNotificationSaveFailure.SERVER, viewModel.uiState.value.saveFailure)
+            viewModel.onIntent(PushNotificationIntent.DismissSaveFailure)
+
+            viewModel.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.AFTERNOTE, false))
+            runCurrent()
+            assertTrue(viewModel.uiState.value.isAfternoteOn)
+            assertFalse(viewModel.uiState.value.isAfternoteUpdating)
+            assertEquals(PushNotificationSaveFailure.SERVER, viewModel.uiState.value.saveFailure)
+
+            assertEquals(
+                listOf(saveFailureOf("newsletter"), saveFailureOf("mind_record"), saveFailureOf("afternote")),
+                reporter.records.map { it.saveContext() },
+            )
+            reporter.records.forEach { attributes ->
+                assertTrue("허용되지 않은 속성: ${attributes.keys}", ALLOWED_KEYS.containsAll(attributes.keys))
+                assertEquals(IllegalStateException::class.java.name, attributes["error_type"])
+            }
+        }
+
+    @Test
+    fun `저장에 성공하면 진단을 남기지 않는다`() =
+        runTest(dispatcher) {
+            val reporter = RecordingReporter()
+            val viewModel = viewModel(FakeSettingNotificationRepository(pushSetting = ALL_ON), reporter)
+            runCurrent()
+
+            viewModel.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.NEWSLETTER, false))
+            viewModel.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.MIND_RECORD, false))
+            viewModel.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.AFTERNOTE, false))
+            runCurrent()
+
+            assertFalse(viewModel.uiState.value.isNewsletterOn)
+            assertFalse(viewModel.uiState.value.isMindRecordOn)
+            assertFalse(viewModel.uiState.value.isAfternoteOn)
+            assertTrue(reporter.records.isEmpty())
+        }
+
+    @Test
+    fun `저장 중 화면을 떠나 취소되면 진단을 남기지 않는다`() =
+        runTest(dispatcher) {
+            val reporter = RecordingReporter()
+            var cancelled = false
+            val repository =
+                FakeSettingNotificationRepository(pushSetting = ALL_ON).apply {
+                    onUpdateMyPushSettings = { _, _, _ ->
+                        suspendCancellableCoroutine { continuation ->
+                            continuation.invokeOnCancellation { cancelled = true }
+                        }
+                    }
+                }
+            val viewModel = viewModel(repository, reporter)
+            val store = ViewModelStore().apply { put(STORE_KEY, viewModel) }
+            runCurrent()
+
+            viewModel.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.MIND_RECORD, false))
+            runCurrent()
+            assertEquals(1, repository.pushUpdateCalls.size)
+
+            store.clear()
+            runCurrent()
+
+            assertTrue(cancelled)
+            assertTrue(reporter.records.isEmpty())
+        }
+
+    @Test
+    fun `서비스 알림과 마케팅 동의 조회 실패는 진단을 남기지 않는다`() =
+        runTest(dispatcher) {
+            val reporter = RecordingReporter()
+            val repository =
+                FakeSettingNotificationRepository().apply {
+                    onGetMyPushSettings = { error("push settings unavailable") }
+                    onGetMyMarketingConsents = { error("marketing consents unavailable") }
+                }
+            val viewModel = viewModel(repository, reporter)
+            runCurrent()
+
+            assertEquals(1, repository.getMyPushSettingsCalls)
+            assertEquals(1, repository.getMyMarketingConsentsCalls)
+            assertFalse(viewModel.uiState.value.isLoading)
+            assertTrue(reporter.records.isEmpty())
+        }
+
+    @Test
+    fun `재시도가 다시 실패하면 실제 실패마다 한 번씩 기록한다`() =
+        runTest(dispatcher) {
+            val reporter = RecordingReporter()
+            var remainingFailures = 2
+            val repository =
+                FakeSettingNotificationRepository(pushSetting = ALL_ON).apply {
+                    onUpdateMyPushSettings = { _, mindRecord, _ ->
+                        if (remainingFailures > 0) {
+                            remainingFailures--
+                            error("server")
+                        }
+                        ALL_ON.copy(mindRecord = mindRecord ?: ALL_ON.mindRecord)
+                    }
+                }
+            val viewModel = viewModel(repository, reporter)
+            runCurrent()
+
+            viewModel.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.MIND_RECORD, false))
+            runCurrent()
+            viewModel.onIntent(PushNotificationIntent.RetrySave)
+            runCurrent()
+            assertEquals(PushNotificationSaveFailure.SERVER, viewModel.uiState.value.saveFailure)
+            viewModel.onIntent(PushNotificationIntent.RetrySave)
+            runCurrent()
+
+            assertFalse(viewModel.uiState.value.isMindRecordOn)
+            assertEquals(3, repository.pushUpdateCalls.size)
+            assertEquals(
+                List(2) { saveFailureOf("mind_record") },
+                reporter.records.map { it.saveContext() },
+            )
+        }
+
+    private fun viewModel(
+        repository: FakeSettingNotificationRepository,
+        reporter: ErrorReporter,
+    ) = PushNotificationViewModel(
+        context = ApplicationProvider.getApplicationContext(),
+        notificationRepository = repository,
+        errorReporter = reporter,
+    )
+
+    /** [ErrorReporter.recordFailure] 가 정책을 적용한 뒤 넘긴 속성을 그대로 모은다. */
+    private class RecordingReporter : ErrorReporter {
+        val records = mutableListOf<Map<String, String>>()
+
+        override fun writeFailure(
+            throwable: Throwable,
+            attributes: Map<String, String>,
+        ) {
+            records += attributes
+        }
+    }
+
+    private fun Map<String, String>.saveContext(): Map<String, String> = filterKeys { it == KEY_STAGE || it == KEY_PUSH_SETTING }
+
+    private fun saveFailureOf(pushSetting: String): Map<String, String> =
+        mapOf(KEY_STAGE to "push_setting_update", KEY_PUSH_SETTING to pushSetting)
+
+    private companion object {
+        const val STORE_KEY = "push-save-reporting"
+        const val KEY_STAGE = "stage"
+        const val KEY_PUSH_SETTING = "push_setting"
+        val ALLOWED_KEYS = setOf(KEY_STAGE, KEY_PUSH_SETTING, "error_type", "error_cause_type")
+        val ALL_ON = UserPushSetting(timeLetter = true, mindRecord = true, afterNote = true)
+    }
+}
diff --git a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationViewModelTest.kt b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationViewModelTest.kt
index 8a3276dbaf..dc8063ec7d 100644
--- a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationViewModelTest.kt
+++ b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/notification/PushNotificationViewModelTest.kt
@@ -47,7 +47,7 @@ class PushNotificationViewModelTest {
             val viewModel = viewModel(calls = calls)
             runCurrent()
 
-            viewModel.onNewsletterToggle(false)
+            viewModel.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.NEWSLETTER, false))
 
             assertFalse(viewModel.uiState.value.isNewsletterOn)
             assertTrue(viewModel.uiState.value.isNewsletterUpdating)
@@ -67,22 +67,22 @@ class PushNotificationViewModelTest {
             val viewModel = viewModel(calls = calls, failUpdateAttempts = Int.MAX_VALUE)
             runCurrent()
 
-            viewModel.onNewsletterToggle(false)
+            viewModel.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.NEWSLETTER, false))
             assertFalse(viewModel.uiState.value.isNewsletterOn)
             runCurrent()
             assertTrue(viewModel.uiState.value.isNewsletterOn)
             assertEquals(PushNotificationSaveFailure.SERVER, viewModel.uiState.value.saveFailure)
-            viewModel.onSaveFailureDismiss()
+            viewModel.onIntent(PushNotificationIntent.DismissSaveFailure)
             assertNull(viewModel.uiState.value.saveFailure)
 
-            viewModel.onMindRecordToggle(false)
+            viewModel.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.MIND_RECORD, false))
             assertFalse(viewModel.uiState.value.isMindRecordOn)
             runCurrent()
             assertTrue(viewModel.uiState.value.isMindRecordOn)
             assertEquals(PushNotificationSaveFailure.SERVER, viewModel.uiState.value.saveFailure)
-            viewModel.onSaveFailureDismiss()
+            viewModel.onIntent(PushNotificationIntent.DismissSaveFailure)
 
-            viewModel.onAfternoteToggle(false)
+            viewModel.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.AFTERNOTE, false))
             assertFalse(viewModel.uiState.value.isAfternoteOn)
             runCurrent()
             assertTrue(viewModel.uiState.value.isAfternoteOn)
@@ -105,13 +105,13 @@ class PushNotificationViewModelTest {
             val viewModel = viewModel(calls = calls, failUpdateAttempts = 1)
             runCurrent()
 
-            viewModel.onMindRecordToggle(false)
+            viewModel.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.MIND_RECORD, false))
             runCurrent()
 
             assertTrue(viewModel.uiState.value.isMindRecordOn)
             assertEquals(PushNotificationSaveFailure.SERVER, viewModel.uiState.value.saveFailure)
 
-            viewModel.onSaveFailureRetry()
+            viewModel.onIntent(PushNotificationIntent.RetrySave)
 
             assertNull(viewModel.uiState.value.saveFailure)
             assertFalse(viewModel.uiState.value.isMindRecordOn)
@@ -139,7 +139,7 @@ class PushNotificationViewModelTest {
                 )
             runCurrent()
 
-            viewModel.onAfternoteToggle(false)
+            viewModel.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.AFTERNOTE, false))
             runCurrent()
 
             assertEquals(PushNotificationSaveFailure.NETWORK, viewModel.uiState.value.saveFailure)
@@ -154,8 +154,8 @@ class PushNotificationViewModelTest {
             val viewModel = viewModel(calls = calls)
             runCurrent()
 
-            viewModel.onNewsletterToggle(false)
-            viewModel.onNewsletterToggle(true)
+            viewModel.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.NEWSLETTER, false))
+            viewModel.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.NEWSLETTER, true))
 
             assertFalse(viewModel.uiState.value.isNewsletterOn)
             assertTrue(viewModel.uiState.value.isNewsletterUpdating)
@@ -167,6 +167,76 @@ class PushNotificationViewModelTest {
             assertFalse(viewModel.uiState.value.isNewsletterUpdating)
         }
 
+    @Test
+    fun `재시도를 연달아 보내도 실패한 변경을 한 번만 다시 저장한다`() =
+        runTest(dispatcher) {
+            val calls = mutableListOf<PushUpdateCall>()
+            val viewModel = viewModel(calls = calls, failUpdateAttempts = 1)
+            runCurrent()
+
+            viewModel.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.AFTERNOTE, false))
+            runCurrent()
+            assertEquals(PushNotificationSaveFailure.SERVER, viewModel.uiState.value.saveFailure)
+
+            viewModel.onIntent(PushNotificationIntent.RetrySave)
+            viewModel.onIntent(PushNotificationIntent.RetrySave)
+            assertTrue(viewModel.uiState.value.isAfternoteUpdating)
+            runCurrent()
+
+            assertEquals(
+                List(2) { PushUpdateCall(timeLetter = null, mindRecord = null, afterNote = false) },
+                calls,
+            )
+            assertFalse(viewModel.uiState.value.isAfternoteOn)
+            assertFalse(viewModel.uiState.value.isAfternoteUpdating)
+            assertNull(viewModel.uiState.value.failedUpdate)
+        }
+
+    @Test
+    fun `실패 안내를 닫으면 재시도 대상도 비워 이후 재시도가 요청을 보내지 않는다`() =
+        runTest(dispatcher) {
+            val calls = mutableListOf<PushUpdateCall>()
+            val viewModel = viewModel(calls = calls, failUpdateAttempts = 1)
+            runCurrent()
+
+            viewModel.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.NEWSLETTER, false))
+            runCurrent()
+            viewModel.onIntent(PushNotificationIntent.DismissSaveFailure)
+
+            assertNull(viewModel.uiState.value.saveFailure)
+            assertNull(viewModel.uiState.value.failedUpdate)
+
+            viewModel.onIntent(PushNotificationIntent.RetrySave)
+            runCurrent()
+
+            assertEquals(listOf(PushUpdateCall(timeLetter = false, mindRecord = null, afterNote = null)), calls)
+            assertTrue(viewModel.uiState.value.isNewsletterOn)
+        }
+
+    @Test
+    fun `서로 다른 토글이 연달아 실패하면 재시도 대상은 마지막 실패만 남는다`() =
+        runTest(dispatcher) {
+            val calls = mutableListOf<PushUpdateCall>()
+            val viewModel = viewModel(calls = calls, failUpdateAttempts = 2)
+            runCurrent()
+
+            viewModel.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.NEWSLETTER, false))
+            viewModel.onIntent(PushNotificationIntent.TogglePushSetting(PushSetting.MIND_RECORD, false))
+            runCurrent()
+
+            assertTrue(viewModel.uiState.value.isNewsletterOn)
+            assertTrue(viewModel.uiState.value.isMindRecordOn)
+            assertEquals(PushNotificationSaveFailure.SERVER, viewModel.uiState.value.saveFailure)
+
+            viewModel.onIntent(PushNotificationIntent.RetrySave)
+            runCurrent()
+
+            assertEquals(PushUpdateCall(timeLetter = null, mindRecord = false, afterNote = null), calls.last())
+            assertEquals(3, calls.size)
+            assertTrue(viewModel.uiState.value.isNewsletterOn)
+            assertFalse(viewModel.uiState.value.isMindRecordOn)
+        }
+
     private fun viewModel(
         calls: MutableList<PushUpdateCall>,
         failUpdateAttempts: Int = 0,
diff --git a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyMakingApi29Test.kt b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyMakingApi29Test.kt
new file mode 100644
index 0000000000..013ea9a8ef
--- /dev/null
+++ b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyMakingApi29Test.kt
@@ -0,0 +1,425 @@
+package com.afternote.feature.setting.presentation.passkey
+
+import android.app.KeyguardManager
+import android.content.pm.PackageManager
+import android.os.Build
+import android.os.CancellationSignal
+import android.os.Handler
+import android.os.Looper
+import androidx.biometric.BiometricManager
+import androidx.biometric.BiometricManager.Authenticators.BIOMETRIC_STRONG
+import androidx.biometric.BiometricManager.Authenticators.DEVICE_CREDENTIAL
+import androidx.biometric.BiometricPrompt
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.assertIsEnabled
+import androidx.compose.ui.test.junit4.v2.createComposeRule
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import androidx.fragment.app.DialogFragment
+import androidx.fragment.app.FragmentActivity
+import androidx.lifecycle.ViewModelProvider
+import com.afternote.core.common.biometric.BiometricAuthResult
+import com.afternote.core.common.biometric.BiometricMessages
+import com.afternote.core.common.biometric.authenticateBiometric
+import com.afternote.core.common.reporting.ErrorReporter
+import com.afternote.core.domain.push.DevicePushTargetProvider
+import com.afternote.core.domain.repository.UserProfileCacheRepository
+import com.afternote.core.ui.theme.AfternoteTheme
+import com.afternote.feature.setting.domain.Passkey
+import com.afternote.feature.setting.domain.PasskeyRepository
+import com.afternote.feature.setting.domain.SettingAccountRepository
+import com.afternote.feature.setting.domain.SettingNotificationRepository
+import com.afternote.feature.setting.domain.testing.FakeSettingAccountRepository
+import com.afternote.feature.setting.domain.testing.FakeSettingNotificationRepository
+import dagger.hilt.android.AndroidEntryPoint
+import dagger.hilt.android.testing.BindValue
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import dagger.hilt.android.testing.HiltTestApplication
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.Robolectric
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.Shadows.shadowOf
+import org.robolectric.android.controller.ActivityController
+import org.robolectric.annotation.ClassName
+import org.robolectric.annotation.Config
+import org.robolectric.annotation.Implementation
+import org.robolectric.annotation.Implements
+import org.robolectric.shadow.api.Shadow
+import org.robolectric.shadows.ShadowBiometricManager
+import org.robolectric.shadows.ShadowBuild
+import org.robolectric.shadows.ShadowFingerprintManager
+import org.robolectric.util.ReflectionHelpers
+import org.robolectric.util.ReflectionHelpers.ClassParameter
+import java.util.concurrent.Executor
+import javax.crypto.Cipher
+import javax.crypto.spec.SecretKeySpec
+import javax.inject.Inject
+
+/** AndroidX의 실제 사전 검사와 프롬프트 구성을 통과한 뒤 framework 콜백을 전달한다. */
+@RunWith(RobolectricTestRunner::class)
+@HiltAndroidTest
+@Config(
+    sdk = [29],
+    application = HiltTestApplication::class,
+    shadows = [RecordingBiometricPrompt::class, RecordingFingerprintManager::class],
+)
+class PassKeyMakingApi29Test {
+    @get:Rule(order = 0)
+    val hiltRule = HiltAndroidRule(this)
+
+    @get:Rule(order = 1)
+    val composeRule = createComposeRule()
+
+    @BindValue
+    val passkeyRepository: PasskeyRepository =
+        object : PasskeyRepository {
+            override suspend fun getPasskeys(): List<Passkey> = error("생체 인증 오류 경로는 목록을 조회하지 않는다")
+
+            override suspend fun getRegistrationOptions(): String = error("생체 인증 오류 경로는 등록 옵션을 조회하지 않는다")
+
+            override suspend fun registerPasskey(credentialJson: String): Passkey = error("생체 인증 오류 경로는 등록하지 않는다")
+        }
+
+    @BindValue
+    val accountRepository: SettingAccountRepository = FakeSettingAccountRepository.strict()
+
+    @BindValue
+    val notificationRepository: SettingNotificationRepository = FakeSettingNotificationRepository.strict()
+
+    @BindValue
+    val pushTargetProvider: DevicePushTargetProvider =
+        object : DevicePushTargetProvider {
+            override suspend fun currentTargetId(): String? = error("생체 인증 오류 경로는 푸시 대상을 조회하지 않는다")
+
+            override suspend fun existingTargetId(): String? = error("생체 인증 오류 경로는 푸시 대상을 조회하지 않는다")
+        }
+
+    @BindValue
+    val errorReporter: ErrorReporter =
+        object : ErrorReporter {
+            override fun writeFailure(
+                throwable: Throwable,
+                attributes: Map<String, String>,
+            ) {
+                error("생체 인증 오류 경로에서 예상하지 않은 오류 보고")
+            }
+        }
+
+    @Inject
+    lateinit var profileCache: UserProfileCacheRepository
+
+    private var activityController: ActivityController<BiometricTestActivity>? = null
+
+    @Before
+    fun setUp() {
+        RecordedBiometricSession.reset()
+        hiltRule.inject()
+        runBlocking { profileCache.savePasskeyRegistered(false) }
+    }
+
+    @After
+    fun tearDown() {
+        activityController?.pause()?.stop()?.destroy()
+    }
+
+    @Test
+    fun `기존 패스키 프롬프트 허용자 조합은 API29에서 예외를 던진다`() {
+        val failure =
+            assertThrows(IllegalArgumentException::class.java) {
+                BiometricPrompt.PromptInfo
+                    .Builder()
+                    .setTitle("패스키 인증")
+                    .setSubtitle("본인 인증")
+                    .setAllowedAuthenticators(BIOMETRIC_STRONG or DEVICE_CREDENTIAL)
+                    .build()
+            }
+
+        assertTrue(failure.message.orEmpty().contains("unsupported on API 29"))
+    }
+
+    @Test
+    @Config(sdk = [26, 27, 28, 29, 30, 35])
+    fun `공용 래퍼는 지원되는 강도와 취소 정책으로 프롬프트를 열고 사용자 취소를 전달한다`() {
+        val activity = secureBiometricActivity()
+        val messages =
+            BiometricMessages(
+                initFailed = "init failed",
+                noHardware = "no hardware",
+                noneEnrolled = "none enrolled",
+                hwUnavailable = "hardware unavailable",
+                notAvailable = "unsupported authenticators",
+                verificationFailed = "verification failed",
+            )
+        lateinit var result: Deferred<BiometricAuthResult>
+
+        composeRule.runOnIdle {
+            result =
+                CoroutineScope(Dispatchers.Main.immediate).async(start = CoroutineStart.UNDISPATCHED) {
+                    activity.authenticateBiometric("패스키 인증", "본인 인증", messages)
+                }
+        }
+        composeRule.waitUntil { RecordedBiometricSession.authenticationStarts == 1 }
+        composeRule.runOnIdle {
+            val fragment = activity.supportFragmentManager.fragments.single { it.javaClass.simpleName == "BiometricFragment" }
+            val biometricViewModel = ReflectionHelpers.getField<Any>(fragment, "mViewModel")
+            // AndroidX가 실제로 받아 보관한 PromptInfo를 읽는다. 앱 선언의 공개 범위는 바꾸지 않는다.
+            val promptInfo = ReflectionHelpers.getField<BiometricPrompt.PromptInfo>(biometricViewModel, "mPromptInfo")
+            val biometricOnly = Build.VERSION.SDK_INT in 28..29
+            assertEquals(
+                if (biometricOnly) BIOMETRIC_STRONG else BIOMETRIC_STRONG or DEVICE_CREDENTIAL,
+                promptInfo.allowedAuthenticators,
+            )
+            assertEquals(
+                if (biometricOnly) activity.getString(android.R.string.cancel) else "",
+                promptInfo.negativeButtonText.toString(),
+            )
+            assertFalse(result.isCompleted)
+            RecordedBiometricSession.error(BiometricPrompt.ERROR_USER_CANCELED, "user canceled")
+        }
+        shadowOf(Looper.getMainLooper()).idle()
+        composeRule.waitForIdle()
+        composeRule.waitUntil { result.isCompleted }
+        assertEquals(BiometricAuthResult.Canceled, runBlocking { result.await() })
+        assertEquals(false, runBlocking { profileCache.isPasskeyRegisteredFlow().first() })
+    }
+
+    @Test
+    @Config(sdk = [28])
+    fun `API28 Samsung crypto 인증은 AppCompat 지문 대화상자를 열고 취소할 수 있다`() {
+        val activity = secureBiometricActivity()
+        ShadowBuild.setManufacturer("samsung")
+        ShadowBuild.setModel("SM-G960F")
+        // Robolectric의 AndroidKeyStore 대신 일반 cipher로 실제 AndroidX crypto 경로를 연다.
+        val cipher =
+            Cipher.getInstance("AES/CBC/PKCS5Padding").apply {
+                init(Cipher.ENCRYPT_MODE, SecretKeySpec(ByteArray(16), "AES"))
+            }
+        var errorCode: Int? = null
+        composeRule.runOnIdle {
+            val prompt =
+                BiometricPrompt(
+                    activity,
+                    Executor { it.run() },
+                    object : BiometricPrompt.AuthenticationCallback() {
+                        override fun onAuthenticationError(
+                            code: Int,
+                            errString: CharSequence,
+                        ) {
+                            errorCode = code
+                        }
+                    },
+                )
+            val promptInfo =
+                BiometricPrompt.PromptInfo
+                    .Builder()
+                    .setTitle("패스키 인증")
+                    .setAllowedAuthenticators(BIOMETRIC_STRONG)
+                    .setNegativeButtonText(activity.getString(android.R.string.cancel))
+                    .build()
+            prompt.authenticate(promptInfo, BiometricPrompt.CryptoObject(cipher))
+        }
+        composeRule.waitUntil { RecordedBiometricSession.authenticationStarts == 1 }
+        composeRule.runOnIdle {
+            val dialog =
+                activity.supportFragmentManager.fragments.single { it.javaClass.simpleName == "FingerprintDialogFragment" }
+                    as DialogFragment
+            assertTrue(dialog.requireDialog().isShowing)
+            RecordedBiometricSession.error(BiometricPrompt.ERROR_USER_CANCELED, "user canceled")
+        }
+        shadowOf(Looper.getMainLooper()).idle()
+        composeRule.waitForIdle()
+        assertEquals(BiometricPrompt.ERROR_USER_CANCELED, errorCode)
+        assertEquals(false, runBlocking { profileCache.isPasskeyRegisteredFlow().first() })
+    }
+
+    @Test
+    fun `API29 지문 불일치와 사용자 취소는 패스키 저장이나 화면 이동을 하지 않는다`() {
+        val activity = secureBiometricActivity()
+        val viewModel = showPasskeyScreen(activity)
+        composeRule.onNodeWithText("지문 인증하기").assertIsEnabled().performClick()
+        composeRule.waitUntil { RecordedBiometricSession.authenticationStarts == 1 }
+
+        composeRule.runOnIdle { RecordedBiometricSession.failure() }
+        assertNotRegistered(viewModel)
+        composeRule.runOnIdle { RecordedBiometricSession.error(BiometricPrompt.ERROR_USER_CANCELED, "user canceled") }
+        composeRule.onNodeWithText("지문 인증하기").assertIsEnabled()
+        composeRule.onNodeWithText("user canceled").assertDoesNotExist()
+        assertNotRegistered(viewModel)
+    }
+
+    @Test
+    fun `API29 실제 프롬프트의 오류를 닫고 재시도해도 실패는 패스키를 등록하지 않는다`() {
+        val activity = secureBiometricActivity()
+        val viewModel = showPasskeyScreen(activity)
+        val errorMessage = "sensor unavailable"
+        composeRule.onNodeWithText("지문 인증하기").assertIsEnabled().performClick()
+        composeRule.waitUntil { RecordedBiometricSession.authenticationStarts == 1 }
+        composeRule.runOnIdle { RecordedBiometricSession.error(BiometricPrompt.ERROR_HW_UNAVAILABLE, errorMessage) }
+
+        composeRule.onNodeWithText(errorMessage).assertIsDisplayed()
+        assertNotRegistered(viewModel)
+        composeRule.onNodeWithText("확인").performClick()
+        composeRule.onNodeWithText(errorMessage).assertDoesNotExist()
+        composeRule.onNodeWithText("지문 인증하기").assertIsEnabled().performClick()
+        composeRule.waitUntil { RecordedBiometricSession.authenticationStarts == 2 }
+        composeRule.runOnIdle { RecordedBiometricSession.error(BiometricPrompt.ERROR_HW_UNAVAILABLE, errorMessage) }
+        composeRule.onNodeWithText(errorMessage).assertIsDisplayed()
+        assertNotRegistered(viewModel)
+    }
+
+    private var backCalls = 0
+    private var passwordCalls = 0
+
+    private fun showPasskeyScreen(activity: FragmentActivity): PassKeyViewModel {
+        val viewModel = ViewModelProvider(activity)[PassKeyViewModel::class.java]
+        composeRule.setContent {
+            CompositionLocalProvider(LocalContext provides activity) {
+                AfternoteTheme {
+                    PassKeyMakingScreen(
+                        onBackClick = { backCalls++ },
+                        onPasswordAuthClick = { passwordCalls++ },
+                        viewModel = viewModel,
+                    )
+                }
+            }
+        }
+        return viewModel
+    }
+
+    private fun assertNotRegistered(viewModel: PassKeyViewModel) {
+        composeRule.onNodeWithText("패스키 생성이 완료되었습니다").assertDoesNotExist()
+        composeRule.runOnIdle {
+            assertEquals(null, viewModel.uiState.value.result)
+            assertFalse(viewModel.uiState.value.isRegistering)
+            assertEquals(0, backCalls)
+            assertEquals(0, passwordCalls)
+        }
+        assertEquals(false, runBlocking { profileCache.isPasskeyRegisteredFlow().first() })
+    }
+
+    private fun secureBiometricActivity(): FragmentActivity {
+        val activity =
+            Robolectric
+                .buildActivity(BiometricTestActivity::class.java)
+                .also { it.get().setTheme(androidx.appcompat.R.style.Theme_AppCompat) }
+                .setup()
+                .also { activityController = it }
+                .get()
+        shadowOf(activity.getSystemService(KeyguardManager::class.java)).apply {
+            setIsKeyguardSecure(true)
+            setIsDeviceSecure(true)
+        }
+        // 모델 허용 목록에 기대지 않고 등록된 지문이 있는 일반 기기를 구성한다.
+        ShadowBuild.setModel("generic")
+        shadowOf(activity.packageManager).setSystemFeature(PackageManager.FEATURE_FINGERPRINT, true)
+        Shadow.extract<ShadowFingerprintManager>(activity.getSystemService("fingerprint")).apply {
+            setIsHardwareDetected(true)
+            setDefaultFingerprints(1)
+        }
+        if (Build.VERSION.SDK_INT >= 29) {
+            Shadow
+                .extract<ShadowBiometricManager>(
+                    activity.getSystemService(android.hardware.biometrics.BiometricManager::class.java),
+                ).setCanAuthenticate(true)
+        }
+
+        // AndroidX 결과를 대역으로 바꾸지 않고 실제 라이브러리 사전 검사를 통과해야 한다.
+        assertEquals(BiometricManager.BIOMETRIC_SUCCESS, BiometricManager.from(activity).canAuthenticate(BIOMETRIC_STRONG))
+        if (Build.VERSION.SDK_INT in 28..29) {
+            assertEquals(
+                BiometricManager.BIOMETRIC_ERROR_UNSUPPORTED,
+                BiometricManager.from(activity).canAuthenticate(BIOMETRIC_STRONG or DEVICE_CREDENTIAL),
+            )
+        }
+        return activity
+    }
+}
+
+@AndroidEntryPoint
+class BiometricTestActivity : FragmentActivity()
+
+/** 실제 AndroidX 프롬프트가 호출하는 Android framework 경계만 기록한다. */
+private object RecordedBiometricSession {
+    var authenticationStarts = 0
+    lateinit var error: (Int, String) -> Unit
+    lateinit var failure: () -> Unit
+
+    fun reset() {
+        authenticationStarts = 0
+        error = { _, _ -> error("인증이 시작되지 않았다") }
+        failure = { error("인증이 시작되지 않았다") }
+    }
+}
+
+@Implements(value = android.hardware.biometrics.BiometricPrompt::class, minSdk = 28)
+class RecordingBiometricPrompt {
+    @Implementation
+    fun authenticate(
+        cancel: CancellationSignal,
+        executor: Executor,
+        callback: android.hardware.biometrics.BiometricPrompt.AuthenticationCallback,
+    ) {
+        RecordedBiometricSession.authenticationStarts++
+        RecordedBiometricSession.error = { code, message -> executor.execute { callback.onAuthenticationError(code, message) } }
+        RecordedBiometricSession.failure = { executor.execute { callback.onAuthenticationFailed() } }
+        cancel.setOnCancelListener {
+            executor.execute { callback.onAuthenticationError(BiometricPrompt.ERROR_CANCELED, "canceled") }
+        }
+    }
+
+    @Implementation
+    fun authenticate(
+        crypto: android.hardware.biometrics.BiometricPrompt.CryptoObject,
+        cancel: CancellationSignal,
+        executor: Executor,
+        callback: android.hardware.biometrics.BiometricPrompt.AuthenticationCallback,
+    ) {
+        authenticate(cancel, executor, callback)
+    }
+}
+
+// compileSdk 37은 삭제 예정 framework FingerprintManager를 공개 stub에서 제외한다.
+// Robolectric의 API 26~29 framework 경계는 클래스 이름으로 지정한다.
+@Implements(className = "android.hardware.fingerprint.FingerprintManager")
+class RecordingFingerprintManager : ShadowFingerprintManager() {
+    @Implementation
+    fun authenticate(
+        @ClassName("android.hardware.fingerprint.FingerprintManager\$CryptoObject") crypto: Any?,
+        cancel: CancellationSignal?,
+        flags: Int,
+        @ClassName("android.hardware.fingerprint.FingerprintManager\$AuthenticationCallback") callback: Any,
+        handler: Handler?,
+    ) {
+        RecordedBiometricSession.authenticationStarts++
+        RecordedBiometricSession.error = { code, message ->
+            ReflectionHelpers.callInstanceMethod<Any?>(
+                callback,
+                "onAuthenticationError",
+                ClassParameter.from(Int::class.javaPrimitiveType, code),
+                ClassParameter.from(CharSequence::class.java, message),
+            )
+        }
+        RecordedBiometricSession.failure = {
+            ReflectionHelpers.callInstanceMethod<Any?>(callback, "onAuthenticationFailed")
+        }
+        cancel?.setOnCancelListener { RecordedBiometricSession.error(BiometricPrompt.ERROR_CANCELED, "canceled") }
+    }
+}
diff --git a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/passkey/PasskeyViewModelTest.kt b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/passkey/PasskeyViewModelTest.kt
new file mode 100644
index 0000000000..f85582caec
--- /dev/null
+++ b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/passkey/PasskeyViewModelTest.kt
@@ -0,0 +1,362 @@
+package com.afternote.feature.setting.presentation.passkey
+
+import androidx.credentials.exceptions.CreateCredentialCancellationException
+import com.afternote.core.common.reporting.ErrorReporter
+import com.afternote.core.domain.testing.FakeUserProfileCacheRepository
+import com.afternote.core.ui.UiText
+import com.afternote.feature.setting.domain.Passkey
+import com.afternote.feature.setting.domain.PasskeyRepository
+import com.afternote.feature.setting.presentation.R
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.NonCancellable
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.TestScope
+import kotlinx.coroutines.test.advanceUntilIdle
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runCurrent
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
+import kotlinx.coroutines.withContext
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertSame
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import java.io.IOException
+import kotlin.coroutines.cancellation.CancellationException
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class PasskeyViewModelTest {
+    private val dispatcher = StandardTestDispatcher()
+    private val repository = PasskeyScenario()
+    private val cache = FakeUserProfileCacheRepository()
+    private val reporter = PasskeyFailureRecorder()
+
+    @Before
+    fun setUp() {
+        Dispatchers.setMain(dispatcher)
+    }
+
+    @After
+    fun tearDown() {
+        Dispatchers.resetMain()
+    }
+
+    @Test
+    fun registration_waitsForServerBeforeUpdatingCacheOrReturningSuccess() =
+        runTest(dispatcher) {
+            val server = CompletableDeferred<Passkey>()
+            repository.register = { credential ->
+                assertEquals("platform-credential", credential)
+                server.await()
+            }
+            val viewModel = PassKeyViewModel(cache, repository, reporter)
+            viewModel.onIntent(
+                PassKeyIntent.Register { options ->
+                    assertEquals("server-options", options)
+                    "platform-credential"
+                },
+            )
+            runCurrent()
+            assertTrue(viewModel.uiState.value.isRegistering)
+            assertEquals(null, viewModel.uiState.value.result)
+            assertTrue(cache.savedPasskeyValues.isEmpty())
+            server.complete(PASSKEY)
+            runCurrent()
+            assertSame(PasskeyRegistrationResult.Success, viewModel.uiState.value.result)
+            assertEquals(listOf(true), cache.savedPasskeyValues)
+            assertTrue(reporter.stages.isEmpty())
+        }
+
+    @Test
+    fun registration_optionsFailureDoesNotLaunchCredentialManagerOrSaveCache() =
+        runTest(dispatcher) {
+            repository.options = { throw IOException("private server response") }
+            val result =
+                register(PassKeyViewModel(cache, repository, reporter)) {
+                    error("Credential Manager must not run after options failure")
+                }
+            assertEquals(
+                PasskeyRegistrationResult.Error(UiText.Resource(R.string.setting_passkey_options_error)),
+                result,
+            )
+            assertEquals(listOf("passkey_registration_options"), reporter.stages)
+            assertTrue(cache.savedPasskeyValues.isEmpty())
+            assertTrue(repository.credentials.isEmpty())
+        }
+
+    @Test
+    fun registration_unexpectedCredentialResponseIsReportedWithoutRegistering() =
+        runTest(dispatcher) {
+            val result =
+                register(PassKeyViewModel(cache, repository, reporter)) {
+                    error("Unexpected credential response")
+                }
+            assertEquals(
+                PasskeyRegistrationResult.Error(UiText.Resource(R.string.setting_passkey_registration_error)),
+                result,
+            )
+            assertEquals(listOf("passkey_create_credential"), reporter.stages)
+            assertTrue(repository.credentials.isEmpty())
+            assertTrue(cache.savedPasskeyValues.isEmpty())
+        }
+
+    @Test
+    fun registration_nativeCancellationIsQuietAndDoesNotRegister() =
+        runTest(dispatcher) {
+            val result =
+                register(PassKeyViewModel(cache, repository, reporter)) {
+                    throw CreateCredentialCancellationException()
+                }
+            assertSame(PasskeyRegistrationResult.Canceled, result)
+            assertTrue(reporter.stages.isEmpty())
+            assertTrue(repository.credentials.isEmpty())
+            assertTrue(cache.savedPasskeyValues.isEmpty())
+        }
+
+    @Test
+    fun registration_coroutineCancellationPropagatesWithoutReporting() =
+        runTest(dispatcher) {
+            val cancellation = CancellationException("screen left")
+            repository.options = { throw cancellation }
+            val viewModel = PassKeyViewModel(cache, repository, reporter)
+            viewModel.onIntent(PassKeyIntent.Register { "unused" })
+            runCurrent()
+            assertFalse(viewModel.uiState.value.isRegistering)
+            assertEquals(null, viewModel.uiState.value.result)
+            assertTrue(reporter.stages.isEmpty())
+            assertTrue(cache.savedPasskeyValues.isEmpty())
+        }
+
+    @Test
+    fun registration_serverFailureIsReportedWithoutSavingSuccess() =
+        runTest(dispatcher) {
+            repository.register = { throw IOException("server rejected credential") }
+            val result = register(PassKeyViewModel(cache, repository, reporter)) { "credential" }
+            assertTrue(result is PasskeyRegistrationResult.Error)
+            assertEquals(listOf("passkey_register"), reporter.stages)
+            assertTrue(cache.savedPasskeyValues.isEmpty())
+        }
+
+    @Test
+    fun registration_cacheFailureKeepsServerSuccessAndReportsOnlyCacheStage() =
+        runTest(dispatcher) {
+            cache.onSavePasskeyRegistered = { throw IOException("disk") }
+            val result = register(PassKeyViewModel(cache, repository, reporter)) { "credential" }
+            assertSame(PasskeyRegistrationResult.Success, result)
+            assertEquals(listOf("credential"), repository.credentials)
+            assertEquals(listOf("passkey_registration_cache"), reporter.stages)
+        }
+
+    @Test
+    fun list_failureIsDistinctFromEmptyAndRetryCanRecover() =
+        runTest(dispatcher) {
+            repository.list = { throw IOException("offline") }
+            val viewModel = PassKeyListViewModel(repository, cache, reporter)
+            viewModel.onIntent(PassKeyListIntent.Refresh)
+            advanceUntilIdle()
+            assertFalse(viewModel.uiState.value.isLoading)
+            assertEquals(UiText.Resource(R.string.setting_passkey_list_error), viewModel.uiState.value.errorMessage)
+            assertEquals(listOf("passkey_list"), reporter.stages)
+
+            repository.list = { emptyList() }
+            viewModel.onIntent(PassKeyListIntent.Refresh)
+            advanceUntilIdle()
+            assertEquals(PassKeyListUiState(), viewModel.uiState.value)
+
+            assertTrue(cache.savedPasskeyValues.isEmpty())
+
+            repository.list = { listOf(PASSKEY) }
+            viewModel.onIntent(PassKeyListIntent.Refresh)
+            advanceUntilIdle()
+            assertEquals(listOf(PASSKEY), viewModel.uiState.value.passkeys)
+            assertTrue(cache.passkeyRegisteredState.value)
+        }
+
+    @Test
+    fun list_resumeRefreshSupersedesARequestStartedBeforeRegistration() =
+        runTest(dispatcher) {
+            val oldList = CompletableDeferred<List<Passkey>>()
+            var calls = 0
+            repository.list = {
+                calls++
+                if (calls == 1) withContext(NonCancellable) { oldList.await() } else listOf(PASSKEY)
+            }
+            val viewModel = PassKeyListViewModel(repository, cache, reporter)
+            viewModel.onIntent(PassKeyListIntent.Refresh)
+            runCurrent()
+            viewModel.onIntent(PassKeyListIntent.Refresh)
+            runCurrent()
+            assertEquals(2, calls)
+            assertEquals(listOf(PASSKEY), viewModel.uiState.value.passkeys)
+            oldList.complete(emptyList())
+            runCurrent()
+            assertEquals(listOf(PASSKEY), viewModel.uiState.value.passkeys)
+            assertFalse(viewModel.uiState.value.isLoading)
+        }
+
+    @Test
+    fun registration_cancelThenRetryIgnoresPreviousCompletionAndBlocksDuplicateSubmission() =
+        runTest(dispatcher) {
+            val first = CompletableDeferred<String>()
+            val second = CompletableDeferred<String>()
+            val viewModel = PassKeyViewModel(cache, repository, reporter)
+            viewModel.onIntent(PassKeyIntent.Register { first.await() })
+            runCurrent()
+            viewModel.onIntent(PassKeyIntent.CancelRegistration)
+            viewModel.onIntent(PassKeyIntent.Register { second.await() })
+            viewModel.onIntent(PassKeyIntent.Register { error("duplicate platform request") })
+            runCurrent()
+            assertTrue(viewModel.uiState.value.isRegistering)
+            first.complete("stale")
+            runCurrent()
+            assertTrue(repository.credentials.isEmpty())
+            second.complete("new")
+            runCurrent()
+            assertEquals(listOf("new"), repository.credentials)
+            assertSame(PasskeyRegistrationResult.Success, viewModel.uiState.value.result)
+            viewModel.onIntent(PassKeyIntent.Register { error("success must be consumed first") })
+            runCurrent()
+            assertEquals(listOf("new"), repository.credentials)
+            viewModel.onIntent(PassKeyIntent.ConsumeResult(viewModel.uiState.value.registrationId, PasskeyRegistrationResult.Success))
+            assertEquals(null, viewModel.uiState.value.result)
+            viewModel.onIntent(PassKeyIntent.Register { "again" })
+            runCurrent()
+            assertSame(PasskeyRegistrationResult.Success, viewModel.uiState.value.result)
+            assertEquals(listOf("new", "again"), repository.credentials)
+        }
+
+    @Test
+    fun registration_serverSuccessIsVisibleBeforeCacheCompletesAndCacheCancellationKeepsIt() =
+        runTest(dispatcher) {
+            val cacheWrite = CompletableDeferred<Unit>()
+            cache.onSavePasskeyRegistered = { cacheWrite.await() }
+            val viewModel = PassKeyViewModel(cache, repository, reporter)
+            viewModel.onIntent(PassKeyIntent.Register { "credential" })
+            runCurrent()
+            assertSame(PasskeyRegistrationResult.Success, viewModel.uiState.value.result)
+            assertFalse(viewModel.uiState.value.isRegistering)
+            cacheWrite.cancel()
+            runCurrent()
+            assertSame(PasskeyRegistrationResult.Success, viewModel.uiState.value.result)
+            assertEquals(listOf("credential"), repository.credentials)
+            assertTrue(reporter.stages.isEmpty())
+        }
+
+    @Test
+    fun registration_leavingScreenAfterServerSuccessStillSavesCache() =
+        runTest(dispatcher) {
+            val cacheWrite = CompletableDeferred<Unit>()
+            cache.onSavePasskeyRegistered = { registered ->
+                cacheWrite.await()
+                cache.passkeyRegisteredState.value = registered
+            }
+            val viewModel = PassKeyViewModel(cache, repository, reporter)
+            viewModel.onIntent(PassKeyIntent.Register { "credential" })
+            runCurrent()
+            assertSame(PasskeyRegistrationResult.Success, viewModel.uiState.value.result)
+            viewModel.onIntent(PassKeyIntent.CancelRegistration)
+            runCurrent()
+            cacheWrite.complete(Unit)
+            runCurrent()
+            assertTrue(cache.passkeyRegisteredState.value)
+            assertTrue(reporter.stages.isEmpty())
+        }
+
+    @Test
+    fun registration_canceledPlatformReturningLateCannotSubmitCredential() =
+        runTest(dispatcher) {
+            val oldCredential = CompletableDeferred<String>()
+            val newCredential = CompletableDeferred<String>()
+            val viewModel = PassKeyViewModel(cache, repository, reporter)
+            viewModel.onIntent(PassKeyIntent.Register { withContext(NonCancellable) { oldCredential.await() } })
+            runCurrent()
+            viewModel.onIntent(PassKeyIntent.CancelRegistration)
+            viewModel.onIntent(PassKeyIntent.Register { newCredential.await() })
+            runCurrent()
+            oldCredential.complete("stale")
+            runCurrent()
+            assertTrue(repository.credentials.isEmpty())
+            assertTrue(viewModel.uiState.value.isRegistering)
+            newCredential.complete("fresh")
+            runCurrent()
+            assertEquals(listOf("fresh"), repository.credentials)
+        }
+
+    @Test
+    fun registration_staleConsumptionCannotClearNextSuccessfulRegistration() =
+        runTest(dispatcher) {
+            val viewModel = PassKeyViewModel(cache, repository, reporter)
+            register(viewModel) { "first" }
+            val firstId = viewModel.uiState.value.registrationId
+            viewModel.onIntent(PassKeyIntent.ConsumeResult(firstId, PasskeyRegistrationResult.Success))
+            register(viewModel) { "second" }
+            viewModel.onIntent(PassKeyIntent.ConsumeResult(firstId, PasskeyRegistrationResult.Success))
+            assertSame(PasskeyRegistrationResult.Success, viewModel.uiState.value.result)
+            assertEquals(listOf("first", "second"), repository.credentials)
+        }
+
+    @Test
+    fun registration_canceledServerReturningLateCannotOverwriteNextRequest() =
+        runTest(dispatcher) {
+            val server = CompletableDeferred<Passkey>()
+            val nextCredential = CompletableDeferred<String>()
+            repository.register = { withContext(NonCancellable) { server.await() } }
+            val viewModel = PassKeyViewModel(cache, repository, reporter)
+            viewModel.onIntent(PassKeyIntent.Register { "first" })
+            runCurrent()
+            viewModel.onIntent(PassKeyIntent.CancelRegistration)
+            viewModel.onIntent(PassKeyIntent.Register { nextCredential.await() })
+            runCurrent()
+            server.complete(PASSKEY)
+            runCurrent()
+            assertTrue(viewModel.uiState.value.isRegistering)
+            assertEquals(null, viewModel.uiState.value.result)
+            // 화면 상태는 덮어쓰지 않지만, 서버에 패스키가 생겼으므로 지문 관문 캐시는 켠다.
+            assertEquals(listOf(true), cache.savedPasskeyValues)
+            viewModel.onIntent(PassKeyIntent.CancelRegistration)
+        }
+
+    private fun TestScope.register(
+        viewModel: PassKeyViewModel,
+        createCredential: suspend (String) -> String,
+    ): PasskeyRegistrationResult? {
+        viewModel.onIntent(PassKeyIntent.Register(createCredential))
+        runCurrent()
+        return viewModel.uiState.value.result
+    }
+}
+
+private class PasskeyScenario : PasskeyRepository {
+    var list: suspend () -> List<Passkey> = { emptyList() }
+    var options: suspend () -> String = { "server-options" }
+    var register: suspend (String) -> Passkey = { PASSKEY }
+    val credentials = mutableListOf<String>()
+
+    override suspend fun getPasskeys(): List<Passkey> = list()
+
+    override suspend fun getRegistrationOptions(): String = options()
+
+    override suspend fun registerPasskey(credentialJson: String): Passkey {
+        credentials += credentialJson
+        return register(credentialJson)
+    }
+}
+
+private class PasskeyFailureRecorder : ErrorReporter {
+    val stages = mutableListOf<String>()
+
+    override fun writeFailure(
+        throwable: Throwable,
+        attributes: Map<String, String>,
+    ) {
+        stages += requireNotNull(attributes["stage"])
+        assertFalse(throwable.message.orEmpty().contains("private server response"))
+    }
+}
+
+private val PASSKEY = Passkey(id = 7L, displayName = "Test passkey", createdAt = "2026-09-06T10:00:00")
diff --git a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/password/PasswordChangeViewModelTest.kt b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/password/PasswordChangeViewModelTest.kt
index 569e0b0345..341b552141 100644
--- a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/password/PasswordChangeViewModelTest.kt
+++ b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/password/PasswordChangeViewModelTest.kt
@@ -170,33 +170,6 @@ class PasswordChangeViewModelTest {
         assertNull(viewModel.uiState.value.errorMessage)
     }
 
-    /**
-     * 유니코드 숫자는 **허용 목록 밖 문자라서** 거절된다 — 서버와 같은 판정이다.
-     *
-     * `[0-9]` 를 `\d` 로 되돌리는 변이는 이 단언으로 잡히지 않는다(실측). 허용 목록
-     * `[A-Za-z0-9@$!%*#?&]` 이 이미 그 문자들을 닫고 있어 두 정규식의 판정이 갈리는 입력 자체가
-     * 없고, JVM 유닛 테스트는 호스트 정규식 엔진이라 Android 의 유니코드 문자 클래스도 재현하지
-     * 못한다. `\d` 를 쓰지 않는 이유는 허용 목록이 넓어지는 날 갈리기 때문이고, 그 근거는
-     * [SettingPasswordRule] KDoc 이 갖는다.
-     */
-    @Test
-    fun `규칙은 서버와 같다 - 유니코드 숫자를 숫자로 받지 않는다`() {
-        assertFalse(SettingPasswordRule.isSatisfied("Abcdefg１!"))
-        assertFalse(SettingPasswordRule.isSatisfied("Abcdefg١!"))
-        assertTrue(SettingPasswordRule.isSatisfied("Abcdefg1!"))
-    }
-
-    @Test
-    fun `규칙은 서버와 같다 - 허용 목록 밖 문자와 길이를 막는다`() {
-        assertFalse(SettingPasswordRule.isSatisfied("Abcde1!"))
-        assertFalse(SettingPasswordRule.isSatisfied("Abcdefghijklmn1!"))
-        assertFalse(SettingPasswordRule.isSatisfied("Abcdefg1_"))
-        assertFalse(SettingPasswordRule.isSatisfied("Abcdefg1 !"))
-        assertFalse(SettingPasswordRule.isSatisfied("Abcdefgh!"))
-        assertFalse(SettingPasswordRule.isSatisfied("Abcdefg12"))
-        assertTrue(SettingPasswordRule.isSatisfied("Abcdefghijklm1!"))
-    }
-
     private fun submit(viewModel: PasswordChangeViewModel) {
         viewModel.onIntent(PasswordChangeIntent.UpdateCurrentPassword(CURRENT_PASSWORD))
         viewModel.onIntent(PasswordChangeIntent.UpdateNewPassword(NEW_PASSWORD))
diff --git a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditActivityRestorationTest.kt b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditActivityRestorationTest.kt
new file mode 100644
index 0000000000..4a16576706
--- /dev/null
+++ b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditActivityRestorationTest.kt
@@ -0,0 +1,182 @@
+package com.afternote.feature.setting.presentation.profile
+
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.os.Bundle
+import android.os.Parcel
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.compose.ui.test.junit4.createEmptyComposeRule
+import androidx.compose.ui.test.onNodeWithContentDescription
+import androidx.compose.ui.test.performClick
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.ViewModelProvider
+import androidx.test.core.app.ApplicationProvider
+import com.afternote.core.domain.testing.FakeMyProfileRepository
+import com.afternote.core.domain.testing.FakePhotoUploadRepository
+import com.afternote.core.model.user.User
+import com.afternote.core.ui.theme.AfternoteTheme
+import kotlinx.coroutines.CompletableDeferred
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotSame
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.Robolectric
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.Shadows.shadowOf
+import org.robolectric.android.controller.ActivityController
+import org.robolectric.annotation.Config
+import com.afternote.core.ui.R as CoreUiR
+
+/** 실제 Activity와 ActivityResultRegistry를 저장/복원한다. 피커 UI와 OS 프로세스 종료는 실행하지 않는다. */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [35])
+class ProfileEditActivityRestorationTest {
+    @get:Rule
+    val composeRule = createEmptyComposeRule()
+
+    private var controller: ActivityController<ProfilePickerRestorationActivity>? = null
+
+    @After
+    fun tearDown() {
+        controller?.pause()?.stop()?.destroy()
+        controller = null
+        ProfilePickerRestorationActivity.profileRepository = null
+    }
+
+    @Test
+    fun `새 Activity에 복원된 피커 결과는 조회 완료까지 보관하고 두번째 복원 후에도 선택을 유지한다`() {
+        val initialRepository = FakeMyProfileRepository(profile = SAVED)
+        ProfilePickerRestorationActivity.profileRepository = initialRepository
+        val first = launch()
+        waitForSelection(first, null)
+        val badge =
+            ApplicationProvider
+                .getApplicationContext<Context>()
+                .getString(CoreUiR.string.core_ui_content_description_profile_edit)
+        composeRule.onNodeWithContentDescription(badge).performClick()
+        val request = checkNotNull(shadowOf(first).nextStartedActivityForResult)
+        val firstState = destroyAndSave()
+
+        // NonConfigurationInstances/VM을 넘기지 않고 새 Activity와 새 저장소를 만든다.
+        val load = CompletableDeferred<User>()
+        val restoredRepository = FakeMyProfileRepository.strict().apply { onGetMyProfile = { load.await() } }
+        ProfilePickerRestorationActivity.profileRepository = restoredRepository
+        val secondController = Robolectric.buildActivity(ProfilePickerRestorationActivity::class.java).create(firstState)
+        controller = secondController
+        val second = secondController.get()
+        assertNotSame(first, second)
+        assertNotSame(first.profileViewModel, second.profileViewModel)
+        assertEquals(ProfileEditUiState.Loading, second.profileViewModel.uiState.value)
+
+        // 아직 compose launcher가 재등록되기 전 raw ActivityResult를 실제 registry에 넣는다.
+        assertTrue(
+            second.activityResultRegistry.dispatchResult(request.requestCode, Activity.RESULT_OK, Intent().setData(Uri.parse(PICKED))),
+        )
+        secondController.start().resume().visible()
+        composeRule.waitForIdle()
+        assertEquals(ProfileEditUiState.Loading, second.profileViewModel.uiState.value)
+
+        // 결과가 조회 대기 중 rememberSaveable에 들어간 뒤 다시 저장/복원한다.
+        val secondState = destroyAndSave()
+        val finalLoad = CompletableDeferred<User>()
+        val finalRepository = FakeMyProfileRepository.strict().apply { onGetMyProfile = { finalLoad.await() } }
+        ProfilePickerRestorationActivity.profileRepository = finalRepository
+        val third = launch(secondState)
+        composeRule.waitForIdle()
+        assertNotSame(second.profileViewModel, third.profileViewModel)
+        assertEquals(ProfileEditUiState.Loading, third.profileViewModel.uiState.value)
+        finalLoad.complete(SAVED)
+        waitForSelection(third, PICKED)
+
+        composeRule.runOnIdle {
+            assertEquals(PICKED, (third.profileViewModel.uiState.value as ProfileEditUiState.Success).displayImageUri)
+            assertEquals(1, finalRepository.getProfileCalls)
+            assertTrue(finalRepository.profileUpdateCalls.isEmpty())
+            assertNull((first.profileViewModel.uiState.value as ProfileEditUiState.Success).selectedImageUri)
+        }
+    }
+
+    private fun launch(state: Bundle? = null): ProfilePickerRestorationActivity {
+        val next =
+            Robolectric
+                .buildActivity(ProfilePickerRestorationActivity::class.java)
+                .create(state)
+                .start()
+                .resume()
+                .visible()
+        controller = next
+        return next.get()
+    }
+
+    private fun waitForSelection(
+        activity: ProfilePickerRestorationActivity,
+        uri: String?,
+    ) {
+        composeRule.waitUntil(5_000) {
+            val state = activity.profileViewModel.uiState.value
+            state is ProfileEditUiState.Success && state.selectedImageUri == uri
+        }
+        composeRule.waitForIdle()
+    }
+
+    private fun destroyAndSave(): Bundle {
+        val active = checkNotNull(controller)
+        val state = Bundle()
+        active
+            .pause()
+            .saveInstanceState(state)
+            .stop()
+            .destroy()
+        controller = null
+        // Parcel round trip은 원 Activity/registry의 메모리 객체 공유를 피한다.
+        val parcel = Parcel.obtain()
+        return try {
+            parcel.writeBundle(state)
+            parcel.setDataPosition(0)
+            checkNotNull(parcel.readBundle(ProfilePickerRestorationActivity::class.java.classLoader))
+        } finally {
+            parcel.recycle()
+        }
+    }
+
+    private companion object {
+        const val PICKED = "content://media/picker/0/profile/1438"
+        val SAVED = User(name = "QA", email = "qa@example.test", phone = null, profileImageUrl = null)
+    }
+}
+
+/** 외부 서버와 DI만 대체한다. Activity의 registry와 saved-state 처리는 그대로 실행한다. */
+class ProfilePickerRestorationActivity : ComponentActivity() {
+    internal lateinit var profileViewModel: ProfileEditViewModel
+        private set
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        val repository = checkNotNull(profileRepository)
+        profileViewModel =
+            ViewModelProvider(
+                this,
+                object : ViewModelProvider.Factory {
+                    @Suppress("UNCHECKED_CAST")
+                    override fun <T : ViewModel> create(modelClass: Class<T>): T =
+                        ProfileEditViewModel(repository, FakePhotoUploadRepository.strict()) as T
+                },
+            )[ProfileEditViewModel::class.java]
+        setContent {
+            AfternoteTheme {
+                ProfileEditScreen(onBackClick = {}, onWithdrawGuideClick = {}, viewModel = profileViewModel)
+            }
+        }
+    }
+
+    companion object {
+        internal var profileRepository: FakeMyProfileRepository? = null
+    }
+}
diff --git a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditMviTest.kt b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditMviTest.kt
new file mode 100644
index 0000000000..c72aed92d9
--- /dev/null
+++ b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditMviTest.kt
@@ -0,0 +1,128 @@
+package com.afternote.feature.setting.presentation.profile
+
+import com.afternote.core.domain.testing.FakeMyProfileRepository
+import com.afternote.core.domain.testing.FakePhotoUploadRepository
+import com.afternote.core.model.user.User
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import kotlin.coroutines.cancellation.CancellationException
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class ProfileEditMviTest {
+    private val updateGates = ArrayDeque<CompletableDeferred<Result<User>>>()
+
+    private val repository =
+        FakeMyProfileRepository(
+            profile = PROFILE,
+            onUpdateMyProfile = { _, _, _ -> updateGates.removeFirst().await().getOrThrow() },
+        )
+
+    @Before
+    fun setUp() {
+        Dispatchers.setMain(UnconfinedTestDispatcher())
+    }
+
+    @After
+    fun tearDown() {
+        Dispatchers.resetMain()
+    }
+
+    @Test
+    fun `load fills form and load failure becomes error`() {
+        assertEquals(
+            ProfileEditUiState.Success(name = "홍길동", phone = "", email = "hong@afternote.local"),
+            ProfileEditViewModel(repository, FakePhotoUploadRepository.strict()).uiState.value,
+        )
+
+        val failing = FakeMyProfileRepository(onGetMyProfile = { error("load failed") })
+        assertEquals(ProfileEditUiState.Error, ProfileEditViewModel(failing, FakePhotoUploadRepository.strict()).uiState.value)
+    }
+
+    @Test
+    fun `update while in flight or after success does not submit again`() {
+        val gate = enqueueUpdate()
+        val viewModel = ProfileEditViewModel(repository, FakePhotoUploadRepository.strict())
+
+        viewModel.onIntent(ProfileEditIntent.UpdateProfile(name = "새 이름", phone = ""))
+        viewModel.onIntent(ProfileEditIntent.UpdateProfile(name = "또 이름", phone = ""))
+
+        assertTrue(viewModel.success().isUpdating)
+        assertEquals(
+            listOf(FakeMyProfileRepository.ProfileUpdateCall(name = "새 이름", phone = null, profileImageUrl = null)),
+            repository.profileUpdateCalls,
+        )
+
+        gate.complete(Result.success(PROFILE))
+        viewModel.onIntent(ProfileEditIntent.UpdateProfile(name = "또 이름", phone = ""))
+
+        assertEquals(ProfileEditEvent.UpdateSuccess, viewModel.success().pendingEvent)
+        assertEquals(1, repository.profileUpdateCalls.size)
+    }
+
+    @Test
+    fun `success signal stays until consumed and consuming clears it once`() {
+        enqueueUpdate().complete(Result.success(PROFILE))
+        val viewModel = ProfileEditViewModel(repository, FakePhotoUploadRepository.strict())
+
+        viewModel.onIntent(ProfileEditIntent.UpdateProfile(name = "새 이름", phone = "01012345678"))
+
+        assertEquals(ProfileEditEvent.UpdateSuccess, viewModel.success().pendingEvent)
+
+        viewModel.onIntent(ProfileEditIntent.ConsumeEvent(ProfileEditEvent.UpdateFailure))
+
+        assertEquals(ProfileEditEvent.UpdateSuccess, viewModel.success().pendingEvent)
+
+        viewModel.onIntent(ProfileEditIntent.ConsumeEvent(ProfileEditEvent.UpdateSuccess))
+
+        assertNull(viewModel.success().pendingEvent)
+        assertFalse(viewModel.success().isUpdating)
+        assertTrue(viewModel.success().isUpdated)
+    }
+
+    @Test
+    fun `failure allows retry and a late consume does not clear the newer signal`() {
+        enqueueUpdate().complete(Result.failure(IllegalStateException("update failed")))
+        val viewModel = ProfileEditViewModel(repository, FakePhotoUploadRepository.strict())
+
+        viewModel.onIntent(ProfileEditIntent.UpdateProfile(name = "새 이름", phone = ""))
+
+        assertEquals(ProfileEditEvent.UpdateFailure, viewModel.success().pendingEvent)
+        assertFalse(viewModel.success().isUpdating)
+
+        enqueueUpdate().complete(Result.success(PROFILE))
+        viewModel.onIntent(ProfileEditIntent.UpdateProfile(name = "새 이름", phone = ""))
+        viewModel.onIntent(ProfileEditIntent.ConsumeEvent(ProfileEditEvent.UpdateFailure))
+
+        assertEquals(2, repository.profileUpdateCalls.size)
+        assertEquals(ProfileEditEvent.UpdateSuccess, viewModel.success().pendingEvent)
+    }
+
+    @Test
+    fun `cancelled update is not reported as failure`() {
+        enqueueUpdate().completeExceptionally(CancellationException("cancelled"))
+        val viewModel = ProfileEditViewModel(repository, FakePhotoUploadRepository.strict())
+
+        viewModel.onIntent(ProfileEditIntent.UpdateProfile(name = "새 이름", phone = ""))
+
+        assertNull(viewModel.success().pendingEvent)
+    }
+
+    private fun enqueueUpdate(): CompletableDeferred<Result<User>> = CompletableDeferred<Result<User>>().also(updateGates::addLast)
+
+    private fun ProfileEditViewModel.success(): ProfileEditUiState.Success = uiState.value as ProfileEditUiState.Success
+
+    private companion object {
+        val PROFILE = User("홍길동", "hong@afternote.local", null, null)
+    }
+}
diff --git a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditPhoneTest.kt b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditPhoneTest.kt
new file mode 100644
index 0000000000..89dcd7b157
--- /dev/null
+++ b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditPhoneTest.kt
@@ -0,0 +1,147 @@
+package com.afternote.feature.setting.presentation.profile
+
+import android.text.InputType
+import android.view.inputmethod.EditorInfo
+import androidx.compose.ui.ExperimentalComposeUiApi
+import androidx.compose.ui.platform.InterceptPlatformTextInput
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.assertIsEnabled
+import androidx.compose.ui.test.assertIsNotEnabled
+import androidx.compose.ui.test.hasScrollToNodeAction
+import androidx.compose.ui.test.hasSetTextAction
+import androidx.compose.ui.test.hasText
+import androidx.compose.ui.test.junit4.v2.createComposeRule
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import androidx.compose.ui.test.performScrollTo
+import androidx.compose.ui.test.performScrollToNode
+import androidx.compose.ui.test.performTextReplacement
+import com.afternote.core.domain.testing.FakeMyProfileRepository
+import com.afternote.core.domain.testing.FakePhotoUploadRepository
+import com.afternote.core.model.user.User
+import com.afternote.core.ui.theme.AfternoteTheme
+import kotlinx.coroutines.awaitCancellation
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+@OptIn(ExperimentalComposeUiApi::class)
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [35])
+class ProfileEditPhoneTest {
+    @get:Rule
+    val composeRule = createComposeRule()
+
+    @Test
+    fun `연락처를 누르면 전화번호 키보드를 요청한다`() {
+        val viewModel = viewModel(FakeMyProfileRepository(profile = PROFILE))
+        var inputType: Int? = null
+        composeRule.setContent {
+            AfternoteTheme {
+                InterceptPlatformTextInput(
+                    interceptor = { request, _ ->
+                        val editorInfo = EditorInfo()
+                        request.createInputConnection(editorInfo)
+                        inputType = editorInfo.inputType
+                        awaitCancellation()
+                    },
+                ) {
+                    ProfileEditScreen(onBackClick = {}, onWithdrawGuideClick = {}, viewModel = viewModel)
+                }
+            }
+        }
+        awaitSuccess(viewModel)
+
+        phoneField(PHONE).performScrollTo().performClick()
+
+        composeRule.waitUntil(TIMEOUT_MILLIS) { inputType != null }
+        composeRule.runOnIdle { assertEquals(InputType.TYPE_CLASS_PHONE, inputType!! and InputType.TYPE_MASK_CLASS) }
+    }
+
+    @Test
+    fun `서버의 잘못된 연락처에도 오류가 보이고 저장이 막힌다`() {
+        val repository = FakeMyProfileRepository(profile = PROFILE.copy(phone = INVALID_PHONE))
+        val viewModel = viewModel(repository)
+        setContent(viewModel)
+        awaitSuccess(viewModel)
+
+        scrollToText(PHONE_ERROR)
+        composeRule.onNodeWithText(PHONE_ERROR).assertIsDisplayed()
+        scrollToText("수정하기")
+        composeRule
+            .onNodeWithText("수정하기")
+            .assertIsNotEnabled()
+            .performClick()
+
+        composeRule.runOnIdle { assertTrue(repository.profileUpdateCalls.isEmpty()) }
+    }
+
+    @Test
+    fun `붙여넣은 잘못된 연락처를 고치면 오류가 해제되고 저장된다`() {
+        val repository = FakeMyProfileRepository(profile = PROFILE)
+        val viewModel = viewModel(repository)
+        var navigatedBack = 0
+        setContent(viewModel) { navigatedBack++ }
+        awaitSuccess(viewModel)
+
+        phoneField(PHONE).performScrollTo().performTextReplacement(INVALID_PHONE)
+        scrollToText(PHONE_ERROR)
+        composeRule.onNodeWithText(PHONE_ERROR).assertIsDisplayed()
+        scrollToText("수정하기")
+        composeRule.onNodeWithText("수정하기").assertIsNotEnabled()
+        composeRule.runOnIdle { assertTrue(repository.profileUpdateCalls.isEmpty()) }
+
+        scrollToText(INVALID_PHONE)
+        phoneField(INVALID_PHONE).performTextReplacement("010-5555-6666")
+        composeRule.onNodeWithText(PHONE_ERROR).assertDoesNotExist()
+        scrollToText("수정하기")
+        composeRule
+            .onNodeWithText("수정하기")
+            .assertIsEnabled()
+            .performClick()
+
+        composeRule.waitUntil(TIMEOUT_MILLIS) { navigatedBack == 1 }
+        composeRule.runOnIdle {
+            assertEquals(
+                listOf(FakeMyProfileRepository.ProfileUpdateCall("기존 이름", "010-5555-6666", null)),
+                repository.profileUpdateCalls,
+            )
+        }
+    }
+
+    private fun scrollToText(value: String) {
+        composeRule.onNode(hasScrollToNodeAction()).performScrollToNode(hasText(value))
+    }
+
+    private fun phoneField(value: String) = composeRule.onNode(hasSetTextAction() and hasText(value))
+
+    private fun setContent(
+        viewModel: ProfileEditViewModel,
+        onBackClick: () -> Unit = {},
+    ) {
+        composeRule.setContent {
+            AfternoteTheme {
+                ProfileEditScreen(onBackClick = onBackClick, onWithdrawGuideClick = {}, viewModel = viewModel)
+            }
+        }
+    }
+
+    private fun viewModel(repository: FakeMyProfileRepository) = ProfileEditViewModel(repository, FakePhotoUploadRepository.strict())
+
+    private fun awaitSuccess(viewModel: ProfileEditViewModel) {
+        composeRule.waitUntil(TIMEOUT_MILLIS) { viewModel.uiState.value is ProfileEditUiState.Success }
+        composeRule.waitForIdle()
+    }
+
+    private companion object {
+        const val TIMEOUT_MILLIS = 5_000L
+        const val PHONE = "01012345678"
+        const val INVALID_PHONE = "01055556666ggyyy"
+        const val PHONE_ERROR = "올바른 연락처를 입력해주세요."
+        val PROFILE = User("기존 이름", "qa@afternote.local", PHONE, null)
+    }
+}
diff --git a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditPhotoPickerTest.kt b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditPhotoPickerTest.kt
new file mode 100644
index 0000000000..ad82860bf0
--- /dev/null
+++ b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditPhotoPickerTest.kt
@@ -0,0 +1,205 @@
+package com.afternote.feature.setting.presentation.profile
+
+import android.content.Context
+import android.net.Uri
+import androidx.activity.compose.LocalActivityResultRegistryOwner
+import androidx.activity.result.ActivityResultRegistry
+import androidx.activity.result.ActivityResultRegistryOwner
+import androidx.activity.result.PickVisualMediaRequest
+import androidx.activity.result.contract.ActivityResultContract
+import androidx.activity.result.contract.ActivityResultContracts.PickVisualMedia
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.test.junit4.v2.createComposeRule
+import androidx.compose.ui.test.onNodeWithContentDescription
+import androidx.compose.ui.test.performClick
+import androidx.core.app.ActivityOptionsCompat
+import androidx.test.core.app.ApplicationProvider
+import com.afternote.core.domain.testing.FakeMyProfileRepository
+import com.afternote.core.domain.testing.FakePhotoUploadRepository
+import com.afternote.core.model.user.User
+import com.afternote.core.ui.theme.AfternoteTheme
+import kotlinx.coroutines.CompletableDeferred
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import java.io.IOException
+import com.afternote.core.ui.R as CoreUiR
+
+/**
+ * 프로필 편집 화면의 사진 배지 → 갤러리 선택 결과 처리 (#1438).
+ *
+ * 피커 자체는 띄우지 않는다. [LocalActivityResultRegistryOwner] 를 결과를 정해 둔 레지스트리로 갈아
+ * 끼우고 화면의 공개 계약(배지 탭 → 피커 요청 → ViewModel 의 선택)만 본다. 온보딩의
+ * `OnboardingProfilePickerResultTest` 와 같은 관용구다.
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [35])
+class ProfileEditPhotoPickerTest {
+    @get:Rule
+    val composeRule = createComposeRule()
+
+    private val pickBadge =
+        ApplicationProvider
+            .getApplicationContext<Context>()
+            .getString(CoreUiR.string.core_ui_content_description_profile_edit)
+
+    @Test
+    fun `배지는 갤러리 이미지 선택만 요청하고 취소는 기존 사진을 지우지 않는다`() {
+        val registry = GalleryResultRegistry(result = null)
+        val viewModel = loadedViewModel()
+        setContent(registry) { viewModel }
+        awaitSuccess(viewModel)
+
+        composeRule.onNodeWithContentDescription(pickBadge).performClick()
+
+        composeRule.runOnIdle {
+            assertEquals(listOf(PickVisualMedia.ImageOnly), registry.requestedMediaTypes)
+            assertNull(viewModel.success().selectedImageUri)
+            assertEquals(SERVER_IMAGE_URL, viewModel.success().displayImageUri)
+        }
+    }
+
+    @Test
+    fun `갤러리에서 고른 사진은 저장 전 선택으로 아바타에 실린다`() {
+        val registry = GalleryResultRegistry(result = Uri.parse(PICKED_PHOTO))
+        val viewModel = loadedViewModel()
+        setContent(registry) { viewModel }
+        awaitSuccess(viewModel)
+
+        composeRule.onNodeWithContentDescription(pickBadge).performClick()
+
+        composeRule.waitUntil(TIMEOUT_MILLIS) { viewModel.success().selectedImageUri == PICKED_PHOTO }
+        composeRule.runOnIdle { assertEquals(PICKED_PHOTO, viewModel.success().displayImageUri) }
+    }
+
+    @Test
+    fun `프로필 조회가 끝나기 전에 돌아온 사진은 보관했다가 조회가 끝나면 넘긴다`() {
+        // 갤러리에 다녀오는 사이 프로세스가 회수된 경우를 흉내 낸다. 화면은 그대로 복원되고 ViewModel 만
+        // 새로 생겨 조회 중일 때 피커 결과가 먼저 도착한다.
+        val registry = GalleryResultRegistry(result = null, deferResult = true)
+        val firstViewModel = loadedViewModel()
+        val pendingProfile = CompletableDeferred<User>()
+        val restoredViewModel =
+            ProfileEditViewModel(
+                FakeMyProfileRepository.strict().apply { onGetMyProfile = { pendingProfile.await() } },
+                FakePhotoUploadRepository.strict(),
+            )
+        var current by mutableStateOf(firstViewModel)
+        setContent(registry) { current }
+        awaitSuccess(firstViewModel)
+        composeRule.onNodeWithContentDescription(pickBadge).performClick()
+
+        composeRule.runOnIdle { current = restoredViewModel }
+        composeRule.waitForIdle()
+        composeRule.runOnIdle { registry.deliver(Uri.parse(PICKED_PHOTO)) }
+        composeRule.waitForIdle()
+        composeRule.runOnIdle { assertEquals(ProfileEditUiState.Loading, restoredViewModel.uiState.value) }
+
+        pendingProfile.complete(SAVED)
+
+        composeRule.waitUntil(TIMEOUT_MILLIS) {
+            (restoredViewModel.uiState.value as? ProfileEditUiState.Success)?.selectedImageUri == PICKED_PHOTO
+        }
+        composeRule.runOnIdle { assertNull(firstViewModel.success().selectedImageUri) }
+    }
+
+    @Test
+    fun `저장 중에 돌아온 사진은 보관했다가 저장이 실패한 뒤에 넘긴다`() {
+        val registry = GalleryResultRegistry(result = null, deferResult = true)
+        val pendingUpdate = CompletableDeferred<User>()
+        val viewModel =
+            ProfileEditViewModel(
+                FakeMyProfileRepository(profile = SAVED).apply {
+                    onUpdateMyProfile = { _, _, _ -> pendingUpdate.await() }
+                },
+                FakePhotoUploadRepository.strict(),
+            )
+        setContent(registry) { viewModel }
+        awaitSuccess(viewModel)
+        composeRule.onNodeWithContentDescription(pickBadge).performClick()
+
+        composeRule.runOnIdle { viewModel.onIntent(ProfileEditIntent.UpdateProfile(name = "새 이름", phone = "01011112222")) }
+        composeRule.waitUntil(TIMEOUT_MILLIS) { viewModel.success().isUpdating }
+        composeRule.runOnIdle { registry.deliver(Uri.parse(PICKED_PHOTO)) }
+        composeRule.waitForIdle()
+        composeRule.runOnIdle { assertNull(viewModel.success().selectedImageUri) }
+
+        pendingUpdate.completeExceptionally(IOException("offline"))
+
+        composeRule.waitUntil(TIMEOUT_MILLIS) { viewModel.success().selectedImageUri == PICKED_PHOTO }
+    }
+
+    private fun setContent(
+        registry: GalleryResultRegistry,
+        viewModel: () -> ProfileEditViewModel,
+    ) {
+        val registryOwner =
+            object : ActivityResultRegistryOwner {
+                override val activityResultRegistry = registry
+            }
+        composeRule.setContent {
+            AfternoteTheme {
+                CompositionLocalProvider(LocalActivityResultRegistryOwner provides registryOwner) {
+                    ProfileEditScreen(onBackClick = {}, onWithdrawGuideClick = {}, viewModel = viewModel())
+                }
+            }
+        }
+    }
+
+    private fun awaitSuccess(viewModel: ProfileEditViewModel) {
+        composeRule.waitUntil(TIMEOUT_MILLIS) { viewModel.uiState.value is ProfileEditUiState.Success }
+        composeRule.waitForIdle()
+    }
+
+    private fun loadedViewModel() =
+        ProfileEditViewModel(
+            FakeMyProfileRepository.strict().apply { onGetMyProfile = { SAVED } },
+            FakePhotoUploadRepository.strict(),
+        )
+
+    private fun ProfileEditViewModel.success(): ProfileEditUiState.Success = uiState.value as ProfileEditUiState.Success
+
+    private companion object {
+        const val TIMEOUT_MILLIS = 5_000L
+        const val SERVER_IMAGE_URL = "https://cdn.test/profiles/saved.jpg"
+        const val PICKED_PHOTO = "content://media/picker/0/profile/1"
+        val SAVED = User(name = "기존 이름", email = "user@afternote.local", phone = "01000000000", profileImageUrl = SERVER_IMAGE_URL)
+    }
+}
+
+/** 갤러리 피커 요청을 기록하고, 정해 둔 결과를 즉시 또는 [deliver] 때 돌려주는 레지스트리. */
+private class GalleryResultRegistry(
+    private val result: Uri?,
+    private val deferResult: Boolean = false,
+) : ActivityResultRegistry() {
+    val requestedMediaTypes = mutableListOf<PickVisualMedia.VisualMediaType>()
+    private var pendingRequestCode: Int? = null
+
+    fun deliver(uri: Uri?) {
+        val requestCode = checkNotNull(pendingRequestCode) { "피커 요청이 없다" }
+        pendingRequestCode = null
+        dispatchResult(requestCode, uri)
+    }
+
+    override fun <I, O> onLaunch(
+        requestCode: Int,
+        contract: ActivityResultContract<I, O>,
+        input: I,
+        options: ActivityOptionsCompat?,
+    ) {
+        requestedMediaTypes += (input as PickVisualMediaRequest).mediaType
+        if (deferResult) {
+            pendingRequestCode = requestCode
+        } else {
+            @Suppress("UNCHECKED_CAST")
+            dispatchResult(requestCode, result as O)
+        }
+    }
+}
diff --git a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditViewModelTest.kt b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditViewModelTest.kt
new file mode 100644
index 0000000000..7e4b4f6685
--- /dev/null
+++ b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/profile/ProfileEditViewModelTest.kt
@@ -0,0 +1,249 @@
+package com.afternote.feature.setting.presentation.profile
+
+import com.afternote.core.domain.model.UploadedFile
+import com.afternote.core.domain.testing.FakeMyProfileRepository
+import com.afternote.core.domain.testing.FakeMyProfileRepository.ProfileUpdateCall
+import com.afternote.core.domain.testing.FakePhotoUploadRepository
+import com.afternote.core.model.user.User
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runCurrent
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import java.io.IOException
+
+/**
+ * 프로필 사진 변경의 저장 계약 (#1438).
+ *
+ * 고른 사진은 `profiles` 로 올린 뒤 받은 파일 키로 `PATCH users/me` 를 보낸다. 업로드가 실패하면
+ * 수정 요청을 보내지 않고, 선택하지 않았으면 사진 칸을 널로 보내 서버 사진을 그대로 둔다.
+ */
+@OptIn(ExperimentalCoroutinesApi::class)
+class ProfileEditViewModelTest {
+    private val dispatcher = StandardTestDispatcher()
+
+    @Before
+    fun setUp() {
+        Dispatchers.setMain(dispatcher)
+    }
+
+    @After
+    fun tearDown() {
+        Dispatchers.resetMain()
+    }
+
+    @Test
+    fun `잘못된 연락처는 사진 업로드와 프로필 수정 전에 차단한다`() =
+        runTest(dispatcher) {
+            for (phone in listOf("01055556666ggyyy", "0101234567", "02012345678", "010--1234-5678")) {
+                val profileRepository = FakeMyProfileRepository(profile = SAVED.copy(phone = phone))
+                val uploadRepository = FakePhotoUploadRepository.strict()
+                val viewModel = ProfileEditViewModel(profileRepository, uploadRepository)
+                runCurrent()
+                viewModel.onIntent(ProfileEditIntent.SelectPhoto(PICKED_PHOTO))
+
+                viewModel.onIntent(ProfileEditIntent.UpdateProfile(name = "새 이름", phone = phone))
+                runCurrent()
+
+                assertTrue(profileRepository.profileUpdateCalls.isEmpty())
+                assertTrue(uploadRepository.uploads.isEmpty())
+                assertFalse(viewModel.success().isUpdating)
+                assertNull(viewModel.success().pendingEvent)
+                assertEquals(PICKED_PHOTO, viewModel.success().selectedImageUri)
+            }
+        }
+
+    @Test
+    fun `빈 연락처와 유효한 휴대폰의 기존 저장 값을 보존한다`() =
+        runTest(dispatcher) {
+            for (phone in listOf("", "   ", "01012345678", "010-1234-5678", "011-123-4567")) {
+                val profileRepository = FakeMyProfileRepository(profile = SAVED)
+                val viewModel = ProfileEditViewModel(profileRepository, FakePhotoUploadRepository.strict())
+                runCurrent()
+
+                viewModel.onIntent(ProfileEditIntent.UpdateProfile(name = "새 이름", phone = phone))
+                runCurrent()
+
+                assertEquals(
+                    listOf(ProfileUpdateCall(name = "새 이름", phone = phone.takeIf { it.isNotBlank() }, profileImageUrl = null)),
+                    profileRepository.profileUpdateCalls,
+                )
+                assertEquals(ProfileEditEvent.UpdateSuccess, viewModel.success().pendingEvent)
+            }
+        }
+
+    @Test
+    fun `잘못된 연락처를 고치면 보관한 사진과 함께 저장할 수 있다`() =
+        runTest(dispatcher) {
+            val profileRepository = FakeMyProfileRepository(profile = SAVED.copy(phone = "01055556666ggyyy"))
+            val uploadRepository = FakePhotoUploadRepository(uploadedKey = UPLOADED_KEY)
+            val viewModel = ProfileEditViewModel(profileRepository, uploadRepository)
+            runCurrent()
+            viewModel.onIntent(ProfileEditIntent.SelectPhoto(PICKED_PHOTO))
+            viewModel.onIntent(ProfileEditIntent.UpdateProfile(name = "새 이름", phone = "01055556666ggyyy"))
+            runCurrent()
+
+            viewModel.onIntent(ProfileEditIntent.UpdateProfile(name = "새 이름", phone = "01055556666"))
+            runCurrent()
+
+            assertEquals(listOf(PICKED_PHOTO to "profiles"), uploadRepository.uploads)
+            assertEquals(
+                listOf(ProfileUpdateCall(name = "새 이름", phone = "01055556666", profileImageUrl = UPLOADED_KEY)),
+                profileRepository.profileUpdateCalls,
+            )
+            assertEquals(ProfileEditEvent.UpdateSuccess, viewModel.success().pendingEvent)
+        }
+
+    @Test
+    fun `서버 프로필 사진을 싣고 고른 사진은 저장 전까지 그 위에만 보인다`() =
+        runTest(dispatcher) {
+            val viewModel = ProfileEditViewModel(FakeMyProfileRepository(profile = SAVED), FakePhotoUploadRepository.strict())
+            runCurrent()
+
+            assertEquals(SERVER_IMAGE_URL, viewModel.success().profileImageUrl)
+            assertEquals(SERVER_IMAGE_URL, viewModel.success().displayImageUri)
+
+            viewModel.onIntent(ProfileEditIntent.SelectPhoto(PICKED_PHOTO))
+
+            assertEquals(PICKED_PHOTO, viewModel.success().selectedImageUri)
+            assertEquals(PICKED_PHOTO, viewModel.success().displayImageUri)
+            assertEquals(SERVER_IMAGE_URL, viewModel.success().profileImageUrl)
+        }
+
+    @Test
+    fun `고른 사진은 profiles 로 올린 뒤 받은 파일 키로 수정 요청을 보낸다`() =
+        runTest(dispatcher) {
+            val order = mutableListOf<String>()
+            val uploadRepository =
+                FakePhotoUploadRepository(
+                    onUpload = { _, _ ->
+                        order += "upload"
+                        Result.success(UploadedFile(fileUrl = UPLOADED_URL, fileKey = UPLOADED_KEY))
+                    },
+                )
+            val profileRepository =
+                FakeMyProfileRepository(profile = SAVED).apply {
+                    onUpdateMyProfile = { _, _, _ ->
+                        order += "patch"
+                        SAVED
+                    }
+                }
+            val viewModel = ProfileEditViewModel(profileRepository, uploadRepository)
+            runCurrent()
+
+            viewModel.onIntent(ProfileEditIntent.SelectPhoto(PICKED_PHOTO))
+            viewModel.onIntent(ProfileEditIntent.UpdateProfile(name = "새 이름", phone = "01011112222"))
+            runCurrent()
+
+            assertEquals(listOf("upload", "patch"), order)
+            assertEquals(listOf(PICKED_PHOTO to "profiles"), uploadRepository.uploads)
+            assertEquals(
+                listOf(ProfileUpdateCall(name = "새 이름", phone = "01011112222", profileImageUrl = UPLOADED_KEY)),
+                profileRepository.profileUpdateCalls,
+            )
+            assertEquals(ProfileEditEvent.UpdateSuccess, viewModel.success().pendingEvent)
+        }
+
+    @Test
+    fun `사진을 고르지 않으면 업로드 없이 사진 칸을 비워 보내 기존 사진을 유지한다`() =
+        runTest(dispatcher) {
+            val profileRepository = FakeMyProfileRepository(profile = SAVED)
+            val viewModel = ProfileEditViewModel(profileRepository, FakePhotoUploadRepository.strict())
+            runCurrent()
+
+            viewModel.onIntent(ProfileEditIntent.UpdateProfile(name = "새 이름", phone = ""))
+            runCurrent()
+
+            assertEquals(
+                listOf(ProfileUpdateCall(name = "새 이름", phone = null, profileImageUrl = null)),
+                profileRepository.profileUpdateCalls,
+            )
+            assertEquals(ProfileEditEvent.UpdateSuccess, viewModel.success().pendingEvent)
+        }
+
+    @Test
+    fun `업로드가 실패하면 수정 요청을 보내지 않고 고른 사진을 그대로 둔다`() =
+        runTest(dispatcher) {
+            val uploadRepository = FakePhotoUploadRepository(onUpload = { _, _ -> Result.failure(IOException("upload failed")) })
+            val profileRepository = FakeMyProfileRepository.strict().apply { onGetMyProfile = { SAVED } }
+            val viewModel = ProfileEditViewModel(profileRepository, uploadRepository)
+            runCurrent()
+
+            viewModel.onIntent(ProfileEditIntent.SelectPhoto(PICKED_PHOTO))
+            viewModel.onIntent(ProfileEditIntent.UpdateProfile(name = "새 이름", phone = "01011112222"))
+            runCurrent()
+
+            assertEquals(1, uploadRepository.uploads.size)
+            assertTrue(profileRepository.profileUpdateCalls.isEmpty())
+            assertEquals(PICKED_PHOTO, viewModel.success().selectedImageUri)
+            assertEquals(SERVER_IMAGE_URL, viewModel.success().profileImageUrl)
+            assertFalse(viewModel.success().isUpdating)
+            assertEquals(ProfileEditEvent.UpdateFailure, viewModel.success().pendingEvent)
+        }
+
+    @Test
+    fun `수정 요청이 실패해도 고른 사진은 남아 다시 저장할 수 있다`() =
+        runTest(dispatcher) {
+            val uploadRepository = FakePhotoUploadRepository(uploadedKey = UPLOADED_KEY)
+            val profileRepository =
+                FakeMyProfileRepository(profile = SAVED).apply {
+                    onUpdateMyProfile = { _, _, _ -> throw IOException("offline") }
+                }
+            val viewModel = ProfileEditViewModel(profileRepository, uploadRepository)
+            runCurrent()
+
+            viewModel.onIntent(ProfileEditIntent.SelectPhoto(PICKED_PHOTO))
+            viewModel.onIntent(ProfileEditIntent.UpdateProfile(name = "새 이름", phone = "01011112222"))
+            runCurrent()
+
+            assertEquals(PICKED_PHOTO, viewModel.success().selectedImageUri)
+            assertFalse(viewModel.success().isUpdating)
+            assertEquals(ProfileEditEvent.UpdateFailure, viewModel.success().pendingEvent)
+        }
+
+    @Test
+    fun `저장 중에 고른 사진은 받지 않아 올라가는 사진과 보이는 사진이 갈리지 않는다`() =
+        runTest(dispatcher) {
+            val pendingUpdate = CompletableDeferred<User>()
+            val uploadRepository = FakePhotoUploadRepository(uploadedKey = UPLOADED_KEY)
+            val profileRepository =
+                FakeMyProfileRepository(profile = SAVED).apply {
+                    onUpdateMyProfile = { _, _, _ -> pendingUpdate.await() }
+                }
+            val viewModel = ProfileEditViewModel(profileRepository, uploadRepository)
+            runCurrent()
+
+            viewModel.onIntent(ProfileEditIntent.SelectPhoto(PICKED_PHOTO))
+            viewModel.onIntent(ProfileEditIntent.UpdateProfile(name = "새 이름", phone = "01011112222"))
+            runCurrent()
+            assertTrue(viewModel.success().isUpdating)
+
+            viewModel.onIntent(ProfileEditIntent.SelectPhoto(OTHER_PHOTO))
+
+            assertEquals(PICKED_PHOTO, viewModel.success().selectedImageUri)
+            assertEquals(listOf(PICKED_PHOTO to "profiles"), uploadRepository.uploads)
+            pendingUpdate.complete(SAVED)
+            runCurrent()
+        }
+
+    private fun ProfileEditViewModel.success(): ProfileEditUiState.Success = uiState.value as ProfileEditUiState.Success
+
+    private companion object {
+        const val SERVER_IMAGE_URL = "https://cdn.test/profiles/saved.jpg?signature=abc"
+        const val PICKED_PHOTO = "content://media/picker/0/profile/1"
+        const val OTHER_PHOTO = "content://media/picker/0/profile/2"
+        const val UPLOADED_URL = "https://cdn.test/profiles/new.jpg"
+        const val UPLOADED_KEY = "profiles/tmp/new.jpg"
+        val SAVED = User(name = "기존 이름", email = "user@afternote.local", phone = "01000000000", profileImageUrl = SERVER_IMAGE_URL)
+    }
+}
diff --git a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverInviteViewModelTest.kt b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverInviteViewModelTest.kt
new file mode 100644
index 0000000000..7acfb8f152
--- /dev/null
+++ b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverInviteViewModelTest.kt
@@ -0,0 +1,180 @@
+package com.afternote.feature.setting.presentation.receiver
+
+import androidx.lifecycle.SavedStateHandle
+import com.afternote.core.domain.error.ReceiverInvitationFailure
+import com.afternote.core.domain.testing.FakeMyProfileRepository
+import com.afternote.core.domain.testing.FakeReceiverInvitationRepository
+import com.afternote.core.domain.testing.FakeUserProfileCacheRepository
+import com.afternote.core.model.user.User
+import com.afternote.core.ui.UiText
+import com.afternote.feature.setting.presentation.NoOpErrorReporter
+import com.afternote.feature.setting.presentation.R
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.advanceUntilIdle
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Before
+import org.junit.Test
+import java.io.IOException
+
+/** 수신자 등록 화면의 초대 발급 — 내 이름 확보와 실패 안내 (#944). */
+@OptIn(ExperimentalCoroutinesApi::class)
+class ReceiverInviteViewModelTest {
+    private val dispatcher = StandardTestDispatcher()
+
+    @Before
+    fun setUp() {
+        Dispatchers.setMain(dispatcher)
+    }
+
+    @After
+    fun tearDown() {
+        Dispatchers.resetMain()
+    }
+
+    @Test
+    fun `시트를 열고 보내면 캐시된 내 이름과 토큰으로 공유 요청을 낸다`() =
+        runTest(dispatcher) {
+            val fixture = Fixture(cachedName = "홍발신")
+            val viewModel = fixture.viewModel()
+
+            viewModel.onIntent(ReceiverInviteIntent.OpenSheet("김민서"))
+            viewModel.onIntent(ReceiverInviteIntent.SendInvite)
+            advanceUntilIdle()
+
+            assertEquals(
+                ReceiverInviteShareRequest(
+                    token = FakeReceiverInvitationRepository.DEFAULT_TOKEN,
+                    senderName = "홍발신",
+                    receiverName = "김민서",
+                ),
+                viewModel.uiState.value.shareRequest,
+            )
+            assertEquals(1, fixture.invitations.createCalls)
+            assertEquals(0, fixture.profile.getProfileCalls)
+        }
+
+    @Test
+    fun `캐시에 이름이 없으면 서버 프로필에서 읽는다`() =
+        runTest(dispatcher) {
+            val fixture = Fixture(cachedName = null)
+            fixture.profile.profile = User(name = "서버이름", email = "a@b.c", phone = null, profileImageUrl = null)
+            val viewModel = fixture.viewModel()
+
+            viewModel.onIntent(ReceiverInviteIntent.OpenSheet("김민서"))
+            viewModel.onIntent(ReceiverInviteIntent.SendInvite)
+            advanceUntilIdle()
+
+            assertEquals(
+                "서버이름",
+                viewModel.uiState.value.shareRequest
+                    ?.senderName,
+            )
+        }
+
+    @Test
+    fun `내 이름을 어디서도 못 읽으면 초대를 만들지 않고 실패로 알린다`() =
+        runTest(dispatcher) {
+            val fixture = Fixture(cachedName = null)
+            fixture.profile.onGetMyProfile = { throw IOException("offline") }
+            val viewModel = fixture.viewModel()
+
+            viewModel.onIntent(ReceiverInviteIntent.OpenSheet("김민서"))
+            viewModel.onIntent(ReceiverInviteIntent.SendInvite)
+            advanceUntilIdle()
+
+            assertNull(viewModel.uiState.value.shareRequest)
+            assertEquals(UiText.Resource(R.string.setting_receiver_invite_sender_name_unavailable), viewModel.uiState.value.errorMessage)
+            assertEquals(0, fixture.invitations.createCalls)
+            assertEquals("김민서", viewModel.uiState.value.sheetReceiverName)
+        }
+
+    @Test
+    fun `발급 실패는 시트를 유지한 채 안내하고 미인증은 로그인 안내다`() =
+        runTest(dispatcher) {
+            val fixture = Fixture(cachedName = "홍발신")
+            fixture.invitations.onCreate = { Result.failure(ReceiverInvitationFailure.Unauthenticated(IllegalStateException())) }
+            val viewModel = fixture.viewModel()
+
+            viewModel.onIntent(ReceiverInviteIntent.OpenSheet("김민서"))
+            viewModel.onIntent(ReceiverInviteIntent.SendInvite)
+            advanceUntilIdle()
+
+            assertEquals(UiText.Resource(R.string.setting_receiver_invite_create_unauthenticated), viewModel.uiState.value.errorMessage)
+            assertEquals("김민서", viewModel.uiState.value.sheetReceiverName)
+        }
+
+    @Test
+    fun `공유가 뜨면 보냈어요 phase 로 가고 다시 보내기는 새 발급 없이 같은 토큰을 다시 올린다`() =
+        runTest(dispatcher) {
+            val fixture = Fixture(cachedName = "홍발신")
+            val viewModel = fixture.viewModel()
+            viewModel.onIntent(ReceiverInviteIntent.OpenSheet("김민서"))
+            viewModel.onIntent(ReceiverInviteIntent.SendInvite)
+            advanceUntilIdle()
+            val request = requireNotNull(viewModel.uiState.value.shareRequest)
+            viewModel.onIntent(ReceiverInviteIntent.ConsumeShareRequest)
+
+            viewModel.onIntent(ReceiverInviteIntent.ShareLaunched)
+
+            assertEquals(request, viewModel.uiState.value.sentInvitation)
+            assertNull(viewModel.uiState.value.sheetReceiverName)
+
+            viewModel.onIntent(ReceiverInviteIntent.Resend)
+            assertEquals(request, viewModel.uiState.value.shareRequest)
+            assertEquals(1, fixture.invitations.createCalls)
+        }
+
+    @Test
+    fun `보냈어요 phase 는 SavedState 로 재생성 뒤에도 남는다`() =
+        runTest(dispatcher) {
+            val savedStateHandle = SavedStateHandle()
+            val fixture = Fixture(cachedName = "홍발신", savedStateHandle = savedStateHandle)
+            val viewModel = fixture.viewModel()
+            viewModel.onIntent(ReceiverInviteIntent.OpenSheet("김민서"))
+            viewModel.onIntent(ReceiverInviteIntent.SendInvite)
+            advanceUntilIdle()
+            viewModel.onIntent(ReceiverInviteIntent.ShareLaunched)
+
+            val restoredValues = savedStateHandle.keys().associateWith { key -> savedStateHandle.get<Any?>(key) }
+            val restored = Fixture(cachedName = "홍발신", savedStateHandle = SavedStateHandle(restoredValues)).viewModel()
+
+            assertEquals(viewModel.uiState.value.sentInvitation, restored.uiState.value.sentInvitation)
+        }
+
+    @Test
+    fun `시트가 닫혀 있으면 보내기는 무시된다`() =
+        runTest(dispatcher) {
+            val fixture = Fixture(cachedName = "홍발신")
+            val viewModel = fixture.viewModel()
+
+            viewModel.onIntent(ReceiverInviteIntent.SendInvite)
+            advanceUntilIdle()
+
+            assertEquals(0, fixture.invitations.createCalls)
+        }
+
+    private class Fixture(
+        cachedName: String?,
+        val savedStateHandle: SavedStateHandle = SavedStateHandle(),
+    ) {
+        val invitations = FakeReceiverInvitationRepository()
+        val cache = FakeUserProfileCacheRepository(cachedUserName = cachedName)
+        val profile = FakeMyProfileRepository()
+
+        fun viewModel() =
+            ReceiverInviteViewModel(
+                invitationRepository = invitations,
+                profileCacheRepository = cache,
+                myProfileRepository = profile,
+                errorReporter = NoOpErrorReporter,
+                savedStateHandle = savedStateHandle,
+            )
+    }
+}
diff --git a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverRegisterViewModelTest.kt b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverRegisterViewModelTest.kt
index 9c1037bc2f..77a8312b76 100644
--- a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverRegisterViewModelTest.kt
+++ b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/receiver/ReceiverRegisterViewModelTest.kt
@@ -37,7 +37,7 @@ class ReceiverRegisterViewModelTest {
     fun `invalid email is rejected before repository call`() {
         val viewModel = ReceiverRegisterViewModel(repository())
 
-        viewModel.register("홍길동", "딸", "01012345678", "invalid", null)
+        viewModel.onIntent(ReceiverRegisterIntent.Register("홍길동", "딸", "01012345678", "invalid", null))
 
         assertEquals(UiText.Resource(R.string.setting_receiver_email_invalid), viewModel.uiState.value.errorMessage)
         assertEquals(0, createCalls.get())
@@ -48,7 +48,7 @@ class ReceiverRegisterViewModelTest {
     fun `blank email is rejected as required before repository call`() {
         val viewModel = ReceiverRegisterViewModel(repository())
 
-        viewModel.register("홍길동", "딸", null, "", null)
+        viewModel.onIntent(ReceiverRegisterIntent.Register("홍길동", "딸", null, "", null))
 
         assertEquals(UiText.Resource(R.string.setting_receiver_email_required), viewModel.uiState.value.errorMessage)
         assertEquals(0, createCalls.get())
@@ -59,7 +59,7 @@ class ReceiverRegisterViewModelTest {
     fun `blank phone is rejected as required before repository call`() {
         val viewModel = ReceiverRegisterViewModel(repository())
 
-        viewModel.register("홍길동", "딸", null, "receiver@example.com", null)
+        viewModel.onIntent(ReceiverRegisterIntent.Register("홍길동", "딸", null, "receiver@example.com", null))
 
         assertEquals(UiText.Resource(R.string.setting_receiver_phone_required), viewModel.uiState.value.errorMessage)
         assertEquals(0, createCalls.get())
@@ -70,7 +70,7 @@ class ReceiverRegisterViewModelTest {
     fun `invalid phone is rejected before repository call`() {
         val viewModel = ReceiverRegisterViewModel(repository())
 
-        viewModel.register("홍길동", "딸", "123", "receiver@example.com", null)
+        viewModel.onIntent(ReceiverRegisterIntent.Register("홍길동", "딸", "123", "receiver@example.com", null))
 
         assertEquals(UiText.Resource(R.string.setting_receiver_phone_invalid), viewModel.uiState.value.errorMessage)
         assertEquals(0, createCalls.get())
@@ -92,12 +92,23 @@ class ReceiverRegisterViewModelTest {
     fun `unexpected failure uses safe resource message`() {
         val viewModel = ReceiverRegisterViewModel(repository(failure = Exception("internal details")))
 
-        viewModel.register("홍길동", "딸", "01012345678", "receiver@example.com", null)
+        viewModel.onIntent(ReceiverRegisterIntent.Register("홍길동", "딸", "01012345678", "receiver@example.com", null))
 
         assertEquals(UiText.Resource(R.string.setting_receiver_register_failed), viewModel.uiState.value.errorMessage)
         assertFalse(viewModel.uiState.value.isLoading)
     }
 
+    @Test
+    fun `register success is a state signal and consumes only the same signal`() {
+        val viewModel = ReceiverRegisterViewModel(repository())
+
+        viewModel.onIntent(ReceiverRegisterIntent.Register("홍길동", "딸", "01012345678", "receiver@example.com", null))
+
+        assertEquals(ReceiverRegisterEvent.RegisterSuccess, viewModel.uiState.value.pendingEvent)
+        viewModel.onIntent(ReceiverRegisterIntent.ConsumeEvent(ReceiverRegisterEvent.RegisterSuccess))
+        assertEquals(null, viewModel.uiState.value.pendingEvent)
+    }
+
     private fun repository(failure: Throwable? = null): UserReceiverRepository =
         Proxy.newProxyInstance(
             UserReceiverRepository::class.java.classLoader,
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index c270032fe7..f658f2fcbd 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -1,6 +1,7 @@
 [versions]
 agp = "9.3.2"
-biometric = "1.1.0"
+# Core 1.19의 FingerprintManagerCompat는 no-op이므로 내부 호환 구현이 있는 Biometric이 필요하다.
+biometric = "1.4.0-alpha07"
 exifinterface = "1.4.2"
 coreKtx = "1.19.0"
 fragmentKtx = "1.8.9"
@@ -13,9 +14,9 @@ robolectric = "4.15.1"
 espressoCore = "3.7.0"
 lifecycleRuntimeKtx = "2.11.0"
 activityCompose = "1.13.0"
-kotlin = "2.4.10"
+kotlin = "2.4.20"
 composeBom = "2026.06.01"
-jetbrainsKotlinJvm = "2.4.10"
+jetbrainsKotlinJvm = "2.4.20"
 hilt = "2.60.1"
 hiltNavigation = "1.4.0"
 ksp = "2.3.10"
@@ -57,6 +58,9 @@ profileInstaller = "1.4.1"
 # 루트 build.gradle.kts 의 buildscript 블록은 카탈로그 accessor 를 못 써 같은 값을 리터럴로 둔다.
 bouncycastle = "1.85"
 netty = "4.1.137.Final"
+guavaAndroid = "32.0.1-android"
+jsoup = "1.23.2"
+wire = "6.4.5"
 commonsLang3 = "3.18.0"
 jose4j = "0.9.6"
 jdom2 = "2.0.6.1"
@@ -64,6 +68,10 @@ httpclient = "4.5.14"
 logback = "1.5.34"
 testcontainers = "2.0.5"
 protobufJavalite = "3.25.9"
+# 빌드 클래스패스 전용 보안 하한 — GHSA-27j2-h3m2-8237(critical)이 2.3.35 에서 패치(#2204). kover 0.9.9 가
+# kover-features-jvm → intellij-coverage-reporter → coverage-report 1.0.25 경유로 2.3.32 를 고정하고, kover·
+# coverage-report 최신판도 같은 값이라 상류 업그레이드로는 못 푼다. build-logic 의 constraint 가 쓴다.
+freemarker = "2.3.35"
 
 [libraries]
 androidx-biometric = { module = "androidx.biometric:biometric", version.ref = "biometric" }
@@ -111,6 +119,7 @@ ktlint-gradle = { group = "org.jlleitschuh.gradle", name = "ktlint-gradle", vers
 androidx-datastore-preferences = { group = "androidx.datastore", name = "datastore-preferences", version.ref = "datastorePreferences" }
 kakao-sdk-user = { group = "com.kakao.sdk", name = "v2-user", version.ref = "kakaoSdk" }
 kakao-sdk-auth = { group = "com.kakao.sdk", name = "v2-auth", version.ref = "kakaoSdk" }
+kakao-sdk-share = { group = "com.kakao.sdk", name = "v2-share", version.ref = "kakaoSdk" }
 androidx-credentials = { group = "androidx.credentials", name = "credentials", version.ref = "credentials" }
 androidx-credentials-play-services-auth = { group = "androidx.credentials", name = "credentials-play-services-auth", version.ref = "credentials" }
 googleid = { group = "com.google.android.libraries.identity.googleid", name = "googleid", version.ref = "googleid" }
diff --git a/konsist/src/test/kotlin/com/afternote/konsist/ExplicitApiModulePolicyKonsistTest.kt b/konsist/src/test/kotlin/com/afternote/konsist/ExplicitApiModulePolicyKonsistTest.kt
index e8d19492ad..369aa02d67 100644
--- a/konsist/src/test/kotlin/com/afternote/konsist/ExplicitApiModulePolicyKonsistTest.kt
+++ b/konsist/src/test/kotlin/com/afternote/konsist/ExplicitApiModulePolicyKonsistTest.kt
@@ -197,7 +197,6 @@ class ExplicitApiModulePolicyKonsistTest {
                 "afternote.android.data",
                 "afternote.android.datastore",
                 "afternote.android.domain",
-                "afternote.android.feature",
                 "afternote.android.library",
                 "afternote.android.library.compose",
                 "afternote.jvm.domain",
diff --git a/konsist/src/test/kotlin/com/afternote/konsist/MviContractKonsistTest.kt b/konsist/src/test/kotlin/com/afternote/konsist/MviContractKonsistTest.kt
index 88993df1b6..c8560a4192 100644
--- a/konsist/src/test/kotlin/com/afternote/konsist/MviContractKonsistTest.kt
+++ b/konsist/src/test/kotlin/com/afternote/konsist/MviContractKonsistTest.kt
@@ -17,15 +17,19 @@ import java.io.File
  * 정착했는데 그 아래 전이 경로는 화면마다 갈렸고, 진입점을 하나로 모은 화면은 51개 중
  * 1개뿐이었다. 규약을 문서로만 두면 같은 일이 반복된다.
  *
- * 규칙은 셋이다.
+ * 규칙은 넷이다.
  * - **A.** `MviViewModel` 상속체는 `MutableStateFlow`·`MutableSharedFlow`·`Channel` 을 직접
  *   선언하지 않는다. 별도 상태 홀더를 두면 전이가 `reduce` 밖으로 새고 베이스를 도입한 의미가
  *   사라진다. `Channel` 금지는 #1502 가 세우려는 규칙과 같은 방향이라 **두 규칙을 하나로 합친다** —
  *   따로 두면 나중에 서로를 덮는다.
- * - **B.** `feature/…/presentation` 의 ViewModel 은 `MviViewModel` 을 상속한다. 전환 전
- *   49개는 [PENDING_MVI_MIGRATION] 예외로 두고, 모듈 전환 이슈가 닫힐 때마다 뺀다.
+ * - **B.** `feature/…/presentation` 의 ViewModel 은 `MviViewModel` 을 상속한다. 아직 전환하지 않은
+ *   것은 [PENDING_MVI_MIGRATION] 예외로 두고(가드 도입 시점 49개), 전환할 때마다 뺀다.
  * - **C.** `MviIntent`·`ReducerEvent` 를 직접 구현하는 화면 계약 타입은 `sealed interface` 다.
  *   열려 있으면 `when` 이 전수 분기를 보장하지 못해 진입점 단일화의 이득이 사라진다.
+ * - **D.** 아직 전환하지 않은 `feature/…/presentation` ViewModel 도 이벤트용 `Channel`·`MutableSharedFlow` 를
+ *   새로 들이지 않는다 (#1502). 규칙 A 는 전환한 ViewModel 만 보므로, 이 규칙이 없으면 [PENDING_MVI_MIGRATION]
+ *   예외에 든 ViewModel 이 전환 전까지 이벤트 스트림을 늘릴 수 있다. 가드 도입 시점에 이미 있던 선언은
+ *   [LEGACY_EVENT_STREAMS] 기준선으로 인정한다. `MutableStateFlow` 는 전환 전 상태 홀더라 대상이 아니다.
  *
  * 기준 문서는 `docs/convention/mvi.md` 다.
  *
@@ -84,7 +88,7 @@ class MviContractKonsistTest {
         println(
             buildString {
                 appendLine("[경고] PENDING_MVI_MIGRATION 에 지금 소스에 없는 항목이 남아 있다 (${stale.size}건).")
-                appendLine("전환이 끝났거나(그러면 지운다), 아직 도착하지 않은 선등재다(PENDING_ARRIVAL_*).")
+                appendLine("전환이 끝났으면 지우고, 클래스가 옮겨졌으면 새 FQN 으로 고친다.")
                 appendLine("목록에서 지워야 다음 미전환 ViewModel 이 이 자리에 숨지 않는다.")
                 appendLine("목록이 비면 규칙 B 의 예외 자체를 지운다.")
                 appendLine()
@@ -93,6 +97,38 @@ class MviContractKonsistTest {
         )
     }
 
+    @Test
+    fun `미전환 ViewModel 도 이벤트 스트림을 새로 들이지 않는다`() {
+        val violations = legacyEventStreams(AfternoteKonsistScope.productionFiles) - LEGACY_EVENT_STREAMS
+
+        check(violations.isEmpty()) {
+            buildString {
+                appendLine("MVI 미전환 ViewModel 이 이벤트용 Channel·MutableSharedFlow 를 새로 선언한다 (${violations.size}건).")
+                appendLine("producer 가 consumer 보다 오래 살면 Channel·SharedFlow 는 전달을 보장하지 못한다 (#228).")
+                appendLine()
+                violations.sorted().forEach { appendLine("  $it") }
+                appendLine()
+                appendLine("일회성 신호는 UiState 의 nullable 필드로 흡수하고 소비는 Intent 로 받는다 (#1502).")
+                appendLine("기존 선언을 옮긴 것이면 ViewModel 을 MviViewModel 로 전환한다. 기준: docs/convention/mvi.md")
+            }
+        }
+    }
+
+    @Test
+    fun `해소된 이벤트 스트림 기준선은 경고로 알린다`() {
+        val stale = LEGACY_EVENT_STREAMS - legacyEventStreams(AfternoteKonsistScope.productionFiles)
+        if (stale.isEmpty()) return
+
+        println(
+            buildString {
+                appendLine("[경고] LEGACY_EVENT_STREAMS 에 지금 소스에 없는 항목이 남아 있다 (${stale.size}건).")
+                appendLine("전환이 끝났으면 지운다 — 남겨 두면 같은 이름으로 다시 들인 스트림이 기준선에 숨는다.")
+                appendLine()
+                stale.sorted().forEach { appendLine("  $it") }
+            },
+        )
+    }
+
     @Test
     fun `Intent 와 ReducerEvent 는 sealed interface 다`() {
         val violations = openContractTypes(AfternoteKonsistScope.productionFiles)
@@ -182,7 +218,7 @@ class MviContractKonsistTest {
 
         val violations = unmigratedViewModels(fixtureFiles(root))
 
-        // app 은 규칙 B 의 대상이 아니고(#1809 몫), 추상 베이스와 전환된 것도 위반이 아니다.
+        // app 은 규칙 B 의 범위 밖이고, 추상 베이스와 전환된 것도 위반이 아니다.
         assertEquals(setOf("sample.LegacyViewModel"), violations)
     }
 
@@ -219,6 +255,60 @@ class MviContractKonsistTest {
         check(violations.any { it.endsWith("object Dismiss") }) { violations.toString() }
     }
 
+    @Test
+    fun `규칙 D - 미전환 ViewModel 의 Channel·MutableSharedFlow 만 잡는다`() {
+        val root = fixture.newFolder("rule-d")
+        root.writeKotlin(
+            "feature/sample/presentation/src/main/kotlin/sample/LegacyViewModel.kt",
+            """
+            package sample
+
+            class LegacyViewModel : ViewModel() {
+                private val _uiState = MutableStateFlow(SampleUiState())
+                private val _events = Channel<SampleEvent>(Channel.BUFFERED)
+                private val signals = MutableSharedFlow<SampleEvent>(replay = 0)
+                private val plain = 0
+            }
+            """,
+        )
+        root.writeKotlin(
+            "feature/sample/presentation/src/main/kotlin/sample/MigratedViewModel.kt",
+            """
+            package sample
+
+            class MigratedViewModel : MviViewModel<SampleIntent, SampleUiState, SampleEvent>(SampleUiState()) {
+                private val signals = Channel<String>()
+            }
+            """,
+        )
+        root.writeKotlin(
+            "feature/sample/presentation/src/main/kotlin/sample/SnackbarRelay.kt",
+            """
+            package sample
+
+            class SnackbarRelay {
+                private val messages = Channel<String>()
+            }
+            """,
+        )
+        root.writeKotlin(
+            "app/src/main/kotlin/app/AppViewModel.kt",
+            """
+            package app
+
+            class AppViewModel : ViewModel() {
+                private val _events = Channel<String>()
+            }
+            """,
+        )
+
+        val violations = legacyEventStreams(fixtureFiles(root))
+
+        // 상태 홀더(MutableStateFlow)는 전환 전 ViewModel 의 정상 구조다. 전환한 ViewModel 은 규칙 A,
+        // ViewModel 이 아닌 타입과 app 은 이 규칙 밖이다(app 은 #1809 몫).
+        assertEquals(setOf("sample.LegacyViewModel._events", "sample.LegacyViewModel.signals"), violations)
+    }
+
     @Test
     fun `규칙 A·B - 중간 추상 베이스를 낀 상속도 MviViewModel 로 본다`() {
         val root = fixture.newFolder("indirect-parents")
@@ -267,6 +357,25 @@ class MviContractKonsistTest {
             }.toSet()
     }
 
+    /** 규칙 D 위반 후보 — `feature/…/presentation` main 소스의 미전환 ViewModel 이 든 이벤트 스트림(`FQN.프로퍼티`). */
+    private fun legacyEventStreams(files: List<KoFileDeclaration>): Set<String> {
+        val extendsMvi = mviViewModelSubclassTest(files)
+        return files
+            .filter { FEATURE_PRESENTATION_MAIN.containsMatchIn(it.normalizedProjectPath()) }
+            .flatMap { file ->
+                file
+                    .classes()
+                    .filter { it.name.endsWith(VIEW_MODEL_SUFFIX) }
+                    .filterNot(extendsMvi)
+                    .flatMap { declaration ->
+                        declaration
+                            .properties()
+                            .filter { property -> EVENT_STREAM.containsMatchIn(property.text) }
+                            .map { property -> "${file.packagee?.name}.${declaration.name}.${property.name}" }
+                    }
+            }.toSet()
+    }
+
     /** 규칙 A 위반 — 베이스를 상속한 ViewModel 이 직접 든 상태 홀더. */
     private fun stateHolderDeclarations(files: List<KoFileDeclaration>): List<String> {
         val extendsMvi = mviViewModelSubclassTest(files)
@@ -363,19 +472,15 @@ class MviContractKonsistTest {
          */
         val STATE_HOLDER = Regex("""\b(MutableStateFlow|MutableSharedFlow|Channel)\s*[(<]""")
 
-        /** #1804 가 뺀다. */
-        private val ISSUE_1804_AFTERNOTE =
-            setOf(
-                "com.afternote.feature.afternote.presentation.AfternoteHostViewModel",
-                "com.afternote.feature.afternote.presentation.detail.AfternoteDetailViewModel",
-                "com.afternote.feature.afternote.presentation.editor.AfternoteEditorViewModel",
-                "com.afternote.feature.afternote.presentation.editor.memorial.AddSongViewModel",
-                "com.afternote.feature.afternote.presentation.editor.receiver.SelectReceiverViewModel",
-                "com.afternote.feature.afternote.presentation.home.AfternoteHomeViewModel",
-                "com.afternote.feature.afternote.presentation.receiver.afternotelist.ReceiverAfternoteHomeViewModel",
-                "com.afternote.feature.afternote.presentation.receiver.detail.ReceivedAfternoteDetailViewModel",
-                "com.afternote.feature.afternote.presentation.receiver.playlist.ReceiverMemorialPlaylistViewModel",
-            )
+        /** 규칙 D 의 이벤트 스트림 선언. [STATE_HOLDER] 에서 전환 전 상태 홀더인 `MutableStateFlow` 만 뺐다. */
+        val EVENT_STREAM = Regex("""\b(MutableSharedFlow|Channel)\s*[(<]""")
+
+        /**
+         * 규칙 D 의 기준선 — 가드 도입(#1502) 때 이미 있던 미전환 ViewModel 의 이벤트 스트림.
+         *
+         * 새 항목은 넣지 않는다. 해당 ViewModel 이 전환되거나 지워지면 여기서도 뺀다(남으면 경고).
+         */
+        val LEGACY_EVENT_STREAMS = emptySet<String>()
 
         /** #1808 이 뺀다. */
         private val ISSUE_1808_HOME =
@@ -401,44 +506,34 @@ class MviContractKonsistTest {
             )
 
         /**
-         * 아직 develop 에 없다. #457(PR #1624, 승인 완료)이 들여오는 네 번째 onboarding ViewModel 이라,
-         * 이 가드가 먼저 머지되면 규칙이 생기기 전에 쓰인 그 PR 이 규칙 B 로 빨개진다. 머지 순서가
-         * 어느 쪽이든 develop 이 red 가 되지 않도록 미리 등재한다 — 그때까지는 「해소된 항목」 경고로만
-         * 남는다. 전환은 #1802 후속 몫이다.
+         * #457(PR #1624)이 #1802 파일럿 뒤에 들인 onboarding ViewModel 이다. 미전환이고 빼는 담당
+         * 이슈는 없다.
          */
-        private val PENDING_ARRIVAL_ONBOARDING =
+        private val UNASSIGNED_ONBOARDING =
             setOf(
                 "com.afternote.feature.onboarding.presentation.findaccount.FindPasswordViewModel",
             )
 
-        /** #1803 이 뺀다. */
-        private val ISSUE_1803_RECEIVER =
+        /**
+         * #1803 이 NOT_PLANNED 로 닫혀 빼는 담당 이슈가 없다. 철회된 구 수신자 흐름이지만 소스에 남아
+         * 있어 유지한다.
+         */
+        private val UNASSIGNED_RECEIVER =
             setOf(
                 "com.afternote.feature.receiver.presentation.deliveryverification.DeliveryVerificationFlowViewModel",
                 "com.afternote.feature.receiver.presentation.deliveryverification.DocumentUploadViewModel",
                 "com.afternote.feature.receiver.presentation.deliveryverification.IdentityVerificationViewModel",
                 "com.afternote.feature.receiver.presentation.deliveryverification.MasterKeyViewModel",
-                // 이 스택의 base 에는 아직 여기 있다. develop 은 #1666 으로 feature/home 으로 옮겼고
-                // 그쪽 FQN 은 ISSUE_1808_HOME 에 있다 — 스택이 develop 을 들이면 이 줄을 지운다.
-                "com.afternote.feature.receiver.presentation.home.ReceiverHomeViewModel",
                 "com.afternote.feature.receiver.presentation.recordsbox.ReceivedRecordsViewModel",
                 "com.afternote.feature.receiver.presentation.recordsbox.SenderRegistrationViewModel",
                 "com.afternote.feature.receiver.presentation.senderdetail.SenderDetailViewModel",
             )
 
-        /** #1805 가 뺀다. `Channel` 5곳 흡수(#1502)가 선행이다. */
-        private val ISSUE_1805_SETTING =
-            setOf(
-                "com.afternote.feature.setting.presentation.account.ConnectedAccountsViewModel",
-                "com.afternote.feature.setting.presentation.applock.AppLockSetupViewModel",
-                "com.afternote.feature.setting.presentation.delivery.DeliveryConditionViewModel",
-                "com.afternote.feature.setting.presentation.home.SettingViewModel",
-                "com.afternote.feature.setting.presentation.notification.PushNotificationViewModel",
-                "com.afternote.feature.setting.presentation.passkey.PassKeyViewModel",
-                "com.afternote.feature.setting.presentation.profile.ProfileEditViewModel",
-                "com.afternote.feature.setting.presentation.receiver.ReceiverEditViewModel",
-                "com.afternote.feature.setting.presentation.receiver.ReceiverRegisterViewModel",
-            )
+        /**
+         * #1805 가 뺀다. 이벤트 스트림을 쓰던 ConnectedAccounts·PushNotification 은 #1502 가 전환했다.
+         * ReceiverRegisterViewModel 은 #944 가 카카오 초대로 교체하며 뺀다([LEGACY_EVENT_STREAMS]).
+         */
+        private val ISSUE_1805_SETTING = emptySet<String>()
 
         /** #1806 이 뺀다. */
         private val ISSUE_1806_TIMELETTER =
@@ -453,15 +548,13 @@ class MviContractKonsistTest {
             )
 
         /**
-         * 전환 전 46개 — onboarding 3개는 #1802 파일럿이 전환해 빠졌다. `app` 의 ViewModel 2개는 이 규칙의 대상이 아니라 목록에도 없다 —
-         * 규칙 B 가 `feature/…/presentation` 만 보기 때문이고, 그 2개는 #1809 가 처리한다.
+         * `app` 의 ViewModel 은 규칙 B 가 `feature/…/presentation` 만 보기 때문에 범위 밖이라 목록에 없다.
          *
          * 목록이 비면 규칙 B 의 예외(`- PENDING_MVI_MIGRATION`)도 함께 지운다.
          */
         val PENDING_MVI_MIGRATION =
-            PENDING_ARRIVAL_ONBOARDING +
-                ISSUE_1803_RECEIVER +
-                ISSUE_1804_AFTERNOTE +
+            UNASSIGNED_ONBOARDING +
+                UNASSIGNED_RECEIVER +
                 ISSUE_1805_SETTING +
                 ISSUE_1806_TIMELETTER +
                 ISSUE_1807_MINDRECORD +
diff --git a/konsist/src/test/kotlin/com/afternote/konsist/PresentationLayerDependencyKonsistTest.kt b/konsist/src/test/kotlin/com/afternote/konsist/PresentationLayerDependencyKonsistTest.kt
index 46f6c5b65e..f8ce71958f 100644
--- a/konsist/src/test/kotlin/com/afternote/konsist/PresentationLayerDependencyKonsistTest.kt
+++ b/konsist/src/test/kotlin/com/afternote/konsist/PresentationLayerDependencyKonsistTest.kt
@@ -129,13 +129,7 @@ class PresentationLayerDependencyKonsistTest {
         val FORBIDDEN_DATA_IMPORT =
             Regex("""^com\.afternote\.core\.datastore\..*$|^com\.afternote\.core\.data\.repoimpl\..*$""")
 
-        /**
-         * #635 (setting 4건 중 3번) 이 수복한다. `PassKeyViewModel` 이 `UserProfileCacheRepository`
-         * 를 건너뛰고 `UserProfileDataSource` 를 직접 주입받는다. setting 은 다른 담당이라
-         * 이 PR 에서 고치지 않는다.
-         */
-        val KNOWN_LAYER_BYPASSES =
-            setOf("PassKeyViewModel: com.afternote.core.datastore.UserProfileDataSource")
+        val KNOWN_LAYER_BYPASSES = emptySet<String>()
 
         /** 구현이 사는 모듈 — 이 모듈들의 테스트는 자기 구현을 조립하는 것이 맞다. */
         val DATA_LAYER_MODULE_PREFIXES = listOf("core/data/", "core/datastore/")
diff --git a/konsist/src/test/kotlin/com/afternote/konsist/ProductionVisibilityKonsistTest.kt b/konsist/src/test/kotlin/com/afternote/konsist/ProductionVisibilityKonsistTest.kt
index ad93465dcf..c88c00190a 100644
--- a/konsist/src/test/kotlin/com/afternote/konsist/ProductionVisibilityKonsistTest.kt
+++ b/konsist/src/test/kotlin/com/afternote/konsist/ProductionVisibilityKonsistTest.kt
@@ -296,19 +296,6 @@ class ProductionVisibilityKonsistTest {
                 "core/ui/src/main/kotlin/com/afternote/core/ui/topbar/HomeTopBar.kt::property PROFILE_ICON_TEST_TAG [implicit-public]",
             )
 
-        /**
-         * 남은 항목은 MVI 전환(#1804)이 다시 열 화면 seam 이라 #1817 이 그 뒤에 판정한다.
-         * #1673 의 나머지(mapper·test tag·Saver·목록 매퍼)는 해소돼 목록에서 빠졌다.
-         */
-        val ISSUE_1673_AFTERNOTE =
-            setOf(
-                "feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/detail/AfternoteDetailRoute.kt::function DeleteInProgressOverlay [internal]",
-                "feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorContent.kt::function EditorContent [internal]",
-                "feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorScreen.kt::function editorContentSignature [internal]",
-                "feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/AfternoteEditorViewModel.kt::function toAfternoteEditorError [internal]",
-                "feature/afternote/presentation/src/main/kotlin/com/afternote/feature/afternote/presentation/editor/selection/EditorServiceSelectionSheet.kt::function EditorServiceSelectionSheetContent [internal]",
-            )
-
         /**
          * 남은 항목은 MVI 전환(#1807)이 다시 열 Content seam 이라 #1818 이 그 뒤에 판정한다.
          * #1674 의 나머지(매퍼 2건·화면 helper 3건·요약 helper 2건·주간 날짜 복원)는 해소돼
@@ -360,7 +347,6 @@ class ProductionVisibilityKonsistTest {
         val LEGACY_TEST_DRIVEN_VISIBILITY =
             ISSUE_1671_PLATFORM +
                 ISSUE_1672_CORE +
-                ISSUE_1673_AFTERNOTE +
                 ISSUE_1674_MINDRECORD +
                 ISSUE_1675_ONBOARDING +
                 ISSUE_1676_RECEIVER +
diff --git a/konsist/src/test/kotlin/com/afternote/konsist/RefreshOnReturnWiringKonsistTest.kt b/konsist/src/test/kotlin/com/afternote/konsist/RefreshOnReturnWiringKonsistTest.kt
index a7d1feec94..ae3f506db9 100644
--- a/konsist/src/test/kotlin/com/afternote/konsist/RefreshOnReturnWiringKonsistTest.kt
+++ b/konsist/src/test/kotlin/com/afternote/konsist/RefreshOnReturnWiringKonsistTest.kt
@@ -1,6 +1,8 @@
 package com.afternote.konsist
 
 import com.lemonappdev.konsist.api.declaration.KoFileDeclaration
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
 import org.junit.Test
 
 /**
@@ -19,7 +21,7 @@ import org.junit.Test
  *
  * ### 규칙
  * main 소스셋의 어느 클래스가 `refreshOnReturn` 을 선언하면, **자기 파일이 아닌** main 소스셋
- * 파일 중 `Lifecycle.Event.ON_RESUME` 과 `refreshOnReturn(` 을 함께 갖고 그 클래스 이름을
+ * 파일 중 `Lifecycle.Event.ON_RESUME`과 직접 갱신 호출 또는 해당 ViewModel의 RefreshOnReturn Intent를 갖고 클래스 이름을
  * 참조하는 파일이 최소 하나 있어야 한다.
  *
  * 모듈을 가로지르는 결선(홈 탭은 `feature:home:presentation` 의 ViewModel 을 app 모듈
@@ -35,7 +37,7 @@ class RefreshOnReturnWiringKonsistTest {
     @Test
     fun `refreshOnReturn 을 선언한 ViewModel 은 ON_RESUME 결선을 갖는다`() {
         val mainFiles = mainSourceFiles()
-        val wiringSites = mainFiles.filter { ON_RESUME in it.text && REFRESH_CALL in it.text }
+        val wiringSites = mainFiles.filter { ON_RESUME in it.text }
 
         val unwired =
             mainFiles
@@ -46,7 +48,7 @@ class RefreshOnReturnWiringKonsistTest {
                         .map { declaration -> file to declaration.name }
                 }.filter { (declaringFile, className) ->
                     wiringSites.none { site ->
-                        site.projectPath != declaringFile.projectPath && site.references(className)
+                        site.projectPath != declaringFile.projectPath && site.references(className) && hasRefreshCall(site.text, className)
                     }
                 }.map { (declaringFile, className) -> "${declaringFile.normalizedProjectPath()} — $className" }
 
@@ -64,6 +66,40 @@ class RefreshOnReturnWiringKonsistTest {
         }
     }
 
+    @Test
+    fun `설정 재진입 갱신은 마케팅 동의를 포함한 모든 소비 화면에 결선된다`() {
+        val expected =
+            mapOf(
+                "ConnectedAccountsScreen.kt" to "ConnectedAccountsIntent",
+                "DeliveryConditionScreen.kt" to "DeliveryConditionIntent",
+                "ProfileEditScreen.kt" to "ProfileEditIntent",
+                "PushNotificationScreen.kt" to "PushNotificationIntent",
+                "NotificationSettingScreen.kt" to "PushNotificationIntent",
+            )
+        val settingFiles = mainSourceFiles().filter { "/feature/setting/" in "/${it.normalizedProjectPath()}" }
+        expected.forEach { (fileName, intent) ->
+            val source = settingFiles.single { it.normalizedProjectPath().endsWith("/$fileName") }.text
+            check(ON_RESUME in source && "$intent.RefreshOnReturn" in source) { "$fileName 재진입 갱신 결선 누락" }
+        }
+    }
+
+    @Test
+    fun `MVI 전환 뒤에도 해당 ViewModel의 resume Intent 결선을 요구한다`() {
+        assertTrue(hasRefreshCall("viewModel.onIntent(ExampleIntent.RefreshOnReturn)", "ExampleViewModel"))
+        assertTrue(hasRefreshCall("viewModel.refreshOnReturn()", "ExampleViewModel"))
+        assertFalse(hasRefreshCall("viewModel.onIntent(OtherIntent.RefreshOnReturn)", "ExampleViewModel"))
+        assertFalse(hasRefreshCall("viewModel.onIntent(ExampleIntent.Retry)", "ExampleViewModel"))
+    }
+
+    private fun hasRefreshCall(
+        text: String,
+        className: String,
+    ): Boolean {
+        val intentName = className.removeSuffix("ViewModel") + "Intent"
+        val intentCall = Regex("""\bonIntent\s*\(\s*${Regex.escape(intentName)}\.RefreshOnReturn\s*\)""")
+        return REFRESH_CALL in text || intentCall.containsMatchIn(text)
+    }
+
     private fun mainSourceFiles(): List<KoFileDeclaration> =
         AfternoteKonsistScope.files.filter { "/src/main/" in it.normalizedProjectPath() }
 
diff --git a/konsist/src/test/kotlin/com/afternote/konsist/RootNavHostPredictiveBackKonsistTest.kt b/konsist/src/test/kotlin/com/afternote/konsist/RootNavHostPredictiveBackKonsistTest.kt
index d8d0885bee..f633af643b 100644
--- a/konsist/src/test/kotlin/com/afternote/konsist/RootNavHostPredictiveBackKonsistTest.kt
+++ b/konsist/src/test/kotlin/com/afternote/konsist/RootNavHostPredictiveBackKonsistTest.kt
@@ -4,20 +4,18 @@ import com.lemonappdev.konsist.api.declaration.KoFileDeclaration
 import org.junit.Test
 
 /**
- * 루트 `NavHost` 의 predictive back pop 전환 결선 가드 (#1869).
+ * 루트 `FeatureNavDisplay` 의 predictive back pop 전환 결선 가드 (#1869, #1702).
  *
- * 이 저장소는 네비게이션 엔진을 둘 쓴다. Nav3 로컬 스택은 `predictivePopTransitionSpec` 을 안 넘겨도
- * 라이브러리 기본값이 앞 화면을 줄여 주지만, **Nav2 루트 `NavHost` 의 pop 기본값은 fade 라 앞 화면이
- * 제자리에서 흐려지기만 한다** — 그래서 진행 중 두 화면이 같은 크기로 겹쳐 보였다(#1869 실기기 재현).
+ * Navigation 3 기본값과 #1869 공용 전환은 같은 모양이지만, 루트도 공용 전환을 명시적으로 전달해
+ * 로컬 스택과 단일 출처를 유지한다.
  *
  * 어긋난 축이 「화면이 어떻게 보이는가」 하나라서 기존 자동 검사가 전부 지나간다.
  * `PredictiveBackNavigationTest`(5건)는 백스택 상태만 보고, Robolectric 은 프레임을 돌리지 않는다.
- * `popEnterTransition`·`popExitTransition` 두 인자는 **기본값이 있어 지워도 컴파일이 통과하고**,
- * 그대로 #1869 이전 상태로 되돌아간다. 그 되돌림을 소스에서 본다.
+ * `predictivePopTransitionSpec` 은 기본값이 있어 지워도 컴파일이 통과한다. 그 되돌림을 소스에서 본다.
  *
  * ### 이 가드가 잡는 것과 못 잡는 것
  *
- * 잡는 것 — 두 인자 중 하나라도 사라지는 것, 다른 값으로 갈아 끼우는 것, core/ui 의 공용 상수를
+ * 잡는 것 — 공용 전환 둘 중 하나라도 사라지는 것, 다른 값으로 갈아 끼우는 것, core/ui 의 공용 상수를
  * 두고 app 안에서 따로 정의한 값을 넘기는 것(import 까지 본다), 그리고 core/ui 쪽 상수가
  * 이름을 바꾸거나 사라지는 것.
  *
@@ -29,47 +27,40 @@ import org.junit.Test
  */
 class RootNavHostPredictiveBackKonsistTest {
     @Test
-    fun `루트 NavHost 는 core ui 의 predictive back pop 전환을 넘긴다`() {
+    fun `루트 FeatureNavDisplay 는 core ui 의 predictive back pop 전환을 넘긴다`() {
         // 공유 진입점을 쓴다 — 워크트리 사본이 섞이면 남의 브랜치 소스로 헛짚는다 (#1659, ScanScopeKonsistTest).
         val source = singleFile(APP_NAVIGATION_PATH).text
-        val arguments = rootNavHostArguments(source)
+        val arguments = rootNavDisplayArguments(source)
 
         check(arguments != null) {
-            "$APP_NAVIGATION_PATH 에서 루트 «NavHost(» 호출을 찾지 못했다 — 루트가 NavDisplay 로 바뀌었다면(#1702) " +
-                "이 가드를 predictivePopTransitionSpec 기준으로 옮긴다."
+            "$APP_NAVIGATION_PATH 에서 루트 «FeatureNavDisplay(» 호출을 찾지 못했다."
         }
 
-        EXPECTED_BINDINGS.forEach { (parameter, constant) ->
-            val binding =
-                Regex("""$parameter\s*=\s*([^,\n]+)""")
-                    .find(arguments)
-                    ?.groupValues
-                    ?.get(1)
-                    ?.trim()
-
-            check(binding != null) {
-                "루트 NavHost 에 $parameter 인자가 없다 (#1869).\n" +
-                    "기본값은 fade 라, 지우면 predictive back 진행 중 앞 화면이 줄지 않고 뒤 화면과 겹쳐 그려진다.\n" +
-                    "  $parameter = { $constant },"
-            }
+        val binding = Regex("""(?s)predictivePopTransitionSpec\s*=\s*(\{[^}]*})""").find(arguments)?.groupValues?.get(1)
+        check(binding != null) { "루트 FeatureNavDisplay 에 predictivePopTransitionSpec 인자가 없다 (#1869)." }
+        EXPECTED_BINDINGS.forEach { constant ->
             check(binding.references(constant)) {
-                "루트 NavHost 의 $parameter 가 «$constant» 이 아니라 «$binding» 을 넘긴다 (#1869)."
+                "루트 FeatureNavDisplay 의 predictivePopTransitionSpec 에 «$constant» 가 없다 (#1869)."
             }
             // 같은 이름을 app 안에서 새로 정의해도 위 단언은 통과한다 — 출처가 core/ui 인지 import 로 본다.
             check(source.contains("import $CONSTANT_PACKAGE.$constant")) {
                 "$APP_NAVIGATION_PATH 가 $CONSTANT_PACKAGE.$constant 을 import 하지 않는다 — " +
-                    "두 엔진이 같은 값을 쓰도록 상수는 core/ui 한 곳에 둔다 (#1869)."
+                    "루트와 로컬이 같은 값을 쓰도록 상수는 core/ui 한 곳에 둔다 (#1869)."
             }
         }
+        val featureDisplay = singleFile(FEATURE_NAV_DISPLAY_PATH).text
+        check(Regex("""predictivePopTransitionSpec\s*=\s*predictivePopTransitionSpec""").containsMatchIn(featureDisplay)) {
+            "FeatureNavDisplay 가 predictivePopTransitionSpec 을 NavDisplay 에 전달하지 않는다 (#1869)."
+        }
     }
 
     @Test
     fun `predictive back pop 전환은 core ui 가 소유한다`() {
         val declared = singleFile(TRANSITIONS_PATH).properties().map { it.name }.toSet()
-        val missing = EXPECTED_BINDINGS.values.filterNot(declared::contains)
+        val missing = EXPECTED_BINDINGS.filterNot(declared::contains)
 
         check(missing.isEmpty()) {
-            "$TRANSITIONS_PATH 에 ${missing.joinToString()} 이 없다 — 루트 NavHost 와 #1702 의 NavDisplay 가 " +
+            "$TRANSITIONS_PATH 에 ${missing.joinToString()} 이 없다 — 루트와 로컬 NavDisplay 가 " +
                 "같은 값을 넘기려면 이 파일이 단일 출처여야 한다 (#1869)."
         }
     }
@@ -91,7 +82,7 @@ class RootNavHostPredictiveBackKonsistTest {
      * 이름은 식별자 경계로 찾는다 — 같은 파일에 `AfternoteNavHost(`·`ReceiverNavHost(` 처럼 끝이
      * 겹치는 호출이 여럿이라, 단순 `indexOf` 는 그중 무엇이 먼저 오느냐에 결과가 달라진다.
      */
-    private fun rootNavHostArguments(source: String): String? {
+    private fun rootNavDisplayArguments(source: String): String? {
         val open = NAV_HOST_CALL.find(source)?.range?.last ?: return null
         var depth = 0
         for (index in open until source.length) {
@@ -120,16 +111,13 @@ class RootNavHostPredictiveBackKonsistTest {
         const val APP_NAVIGATION_PATH = "app/src/main/java/com/afternote/afternote_fe/navigation/AppNavigation.kt"
         const val TRANSITIONS_PATH =
             "core/ui/src/main/kotlin/com/afternote/core/ui/navigation/PredictiveBackTransitions.kt"
+        const val FEATURE_NAV_DISPLAY_PATH = "core/ui/src/main/kotlin/com/afternote/core/ui/navigation/FeatureNavDisplay.kt"
         const val CONSTANT_PACKAGE = "com.afternote.core.ui.navigation"
 
-        /** 루트 `NavHost(` — `AfternoteNavHost(` 처럼 끝만 겹치는 호출을 배제한다. */
-        val NAV_HOST_CALL = Regex("""(?<![A-Za-z0-9_])NavHost\(""")
+        /** 루트 `FeatureNavDisplay(` — `AfternoteNavHost(` 처럼 이름 끝만 겹치는 호출을 배제한다. */
+        val NAV_HOST_CALL = Regex("""(?<![A-Za-z0-9_])FeatureNavDisplay\(""")
 
-        /** 루트 `NavHost` 인자 → 넘어가야 하는 core/ui 상수. */
-        val EXPECTED_BINDINGS =
-            mapOf(
-                "popEnterTransition" to "PredictiveBackPopEnter",
-                "popExitTransition" to "PredictiveBackPopExit",
-            )
+        /** 루트 `FeatureNavDisplay` 가 넘기는 core/ui 상수. */
+        val EXPECTED_BINDINGS = listOf("PredictiveBackPopEnter", "PredictiveBackPopExit")
     }
 }