diff --git a/.claude/rules/logging.md b/.claude/rules/logging.md
index 6e3a4e7..b4baea0 100644
--- a/.claude/rules/logging.md
+++ b/.claude/rules/logging.md
@@ -33,7 +33,8 @@
 - 비밀번호, 토큰(JWT·리프레시·API 키), 쿠키, `Authorization` 헤더
 - 주민등록번호·카드번호·계좌번호 등 개인 식별/금융 정보
 - 요청 본문 전체 덤프 (`JSON.stringify(req.body)` 금지 — 필요한 필드만 선택해 남긴다)
-- 사용자가 친 검색어(쿼리의 `q` — 메일 검색 · 받는 사람 추천) — 요청 URL 을 남길 때는 `shared/utils/mask.ts` 의 `maskUrlForLog()` 를 거친다(`q` · `cursor` 는 길이만 — 목록 커서에는 검색어의 지문이 들어 있어 후보 낱말을 대입해 볼 수 있다).
+- DB 쿼리 로그(매개변수) — **개발 환경도** 남기지 않는다. 메일 글 · 제목 · 주소가 DB 에 있다(14단계 검색 색인). TypeORM `logging` 은 개발에서 오류 · 경고 · 마이그레이션만, 운영 · 시험은 끈다 (`shared/config/database.config.ts` 의 `databaseLogging`)
+- 사용자가 친 검색어(쿼리의 `q` — 메일 검색 · 받는 사람 추천) — 요청 URL 을 남길 때는 `shared/utils/mask.ts` 의 `maskUrlForLog()` 를 거친다(`q` · 조건 검색의 `from` · `to` · `subject` · `body`(14단계) · `cursor` 는 길이만 — 목록 커서에는 검색어의 지문이 들어 있어 후보 낱말을 대입해 볼 수 있다).
   앞단 nginx 도 접근 로그에 쿼리를 남기지 않는다 — `/api` 와 화면 요청 모두(메일 검색은 화면 주소 `/mail/search?q=…` 에도 검색어가 들어간다, [[docker]]).
   **예외**: nginx 오류 로그(413 · 502 · 504 등)는 장애 원인 줄을 잃지 않게 요청 줄 · referrer 를 쿼리째 남긴다 — 오류 로그를 볼 수 있는 사람을 운영 담당으로 한정한다
 
diff --git a/.claude/skills/docker/SKILL.md b/.claude/skills/docker/SKILL.md
index 2ca0983..2f5ff5d 100644
--- a/.claude/skills/docker/SKILL.md
+++ b/.claude/skills/docker/SKILL.md
@@ -180,7 +180,7 @@ sudo docker compose --env-file .env.production logs -f backend
     `X-Forwarded-For` 를 꾸며 IP 를 바꿀 수 있다. 외부 프록시 IP 는 frontend 가 보는 주소(proxy 네트워크 안)이며 고정해 둔다(`ipv4_address` 등).
     **프록시가 다른 서버에 있으면** 주소 목록 `<EDGE_NETWORK_SUBNET>,<프록시 서버의 사설 IP>` 다(같은 VPC 의 다른 서버가 8080 에 바로 붙어 꾸미는 것을 막는다 — 프록시 서버 위의 다른 컨테이너는 같은 IP 로 나가 가를 수 없다).
   - **요청 수 한도 `THROTTLE_LIMIT`** (운영 확인 항목 — 기본 1분 100회, `THROTTLE_TTL_MS`): 백엔드는 **경로마다 · 클라이언트 IP 마다** 센다 — 사무실이 NAT 하나로 나가면 모든 직원이 경로마다 한 칸을 나눠 쓴다.
-    "직원 수 × 한 사람의 평소 분당 요청(가장 많이 부르는 경로 기준 — 예: 주소록 목록 `GET /api/contacts`)"보다 넉넉히 정한다. 넘으면 그 경로가 429 `REQ_001` 이다.
+    "직원 수 × 한 사람의 평소 분당 요청(가장 많이 부르는 경로 기준 — 예: 주소록 목록 `GET /api/contacts`, 메일을 열 때마다 부르는 같은 대화 `GET /api/messages/{id}/conversation` — 14단계)"보다 넉넉히 정한다. 넘으면 그 경로가 429 `REQ_001` 이다.
     외부 이미지 중계 `GET /api/mail-images/{token}`(9단계)만은 라우트에서 IP 마다 1분 600회로 따로 정했다(뉴스레터 한 통에 이미지가 수십 개).
   - **백엔드의 바깥 연결**(운영 확인 항목, 9단계): 외부 이미지 중계는 backend 컨테이너가 바깥 80 · 443 으로 나가 이미지를 받아 온다 — 호스트 방화벽 · 사내 프록시가 막으면
     이미지 자리가 비어 보인다(다른 기능은 영향 없음). 사설 · 내부 주소로는 백엔드가 스스로 나가지 않는다(SSRF 막기 — 계약 2절 "외부 이미지 보기").
@@ -484,7 +484,7 @@ node --env-file=.env.development mail/scripts/setup.mjs
 - **백업**(restic → Object Storage, 보존 일 7 · 주 4 · 월 6, 일요일 prune · check 5%): 메일 볼륨은 켜 둔 채 미리 올리고(warm — restic 종료 3 은 받아들임) → 엔진을 잠깐 멈춰(9초 안팎) 바뀐 것만(final — 상한 `BACKUP_FINAL_TIMEOUT` 15분) → 다시 띄운다.
   DB `pg_dump -Fc`(+ `pg_restore -l` 확인) · 업로드 볼륨 · env 둘. 어떻게 끝나도 엔진을 다시 띄운다(EXIT trap + `ExecStopPost`, 멈추는 중 신호면 멈춤을 끝낸 뒤). 비밀 사본(env · 덤프)은 끝날 때 지운다.
   **매일 03:30 에 웹메일이 10초 안팎 `MAIL_001`** 이다(엔진 멈춤). 백업과 복원 연습은 같은 잠금 — 잠긴 동안 손으로 부른 엔진 띄우기는 건너뛴다(final 도중 띄우면 일관되지 않은 스냅숏이 final 이 된다).
-- **복원**(`arasystem-restore.sh` — snapshots · check · drill · files · volumes · db): final 태그 스냅숏만, 쓰는 컨테이너가 있거나 볼륨이 비지 않았으면 멈춘다(운영 볼륨을 덮지 않게), 새 서버는 `.env.production` 없이 ops.env 의 `PROJECT_NAME` 으로 files 부터. 분기마다 `drill`.
+- **복원**(`arasystem-restore.sh` — snapshots · check · drill · files · volumes · db): final 태그 스냅숏만, 쓰는 컨테이너가 있거나 볼륨이 비지 않았으면 멈춘다(운영 볼륨을 덮지 않게), 새 서버는 `.env.production` 없이 ops.env 의 `PROJECT_NAME` 으로 files 부터. 한 달에 한 번 `drill`(mail/README "백업 › 복원" 이 기준).
 - **15분 점검**: 디스크 두 곳 · 컨테이너 health · 백엔드 health · 메일 대기열 · 인증서 셋 · 백업 나이(26시간 이상) · ClamAV 서명 · Spamhaus 키 → Healthchecks.io(정상 · 실패 + 까닭 한 줄). 바깥은 UptimeRobot(포털 HTTPS · mx1:993 · mx1:25) — 알림은 우리 메일 서버가 아닌 주소로.
 - **비-root 예외**: restic 보조 컨테이너는 root 로 돌되 `--cap-drop ALL` + 필요한 권한만(읽기 `DAC_READ_SEARCH`, 복원은 `DAC_OVERRIDE` · `CHOWN` · `FOWNER`) · `no-new-privileges` ([[security]]). 연습 엔진(Stalwart)을 `no-new-privileges` 로 띄우려면 `NET_BIND_SERVICE` 가 든다.
 - 비밀은 명령줄에 싣지 않는다 — `docker exec -e 이름` · 표준 입력 · 읽기 전용 마운트, Healthchecks 주소도 `curl -K -`.
@@ -569,6 +569,9 @@ node --env-file=.env.development mail/scripts/setup.mjs
   `nest-cli.json` 의 `deleteOutDir` 는 마운트 지점을 지우려다 EBUSY 로 죽으므로, dev `command` 는 기동 때 볼륨 내용만 비우고
   `deleteOutDir` 만 끈 설정 사본으로 `start:dev` 를 돌린다 (`-V` 로 재생성하면 이미지의 산출물로 다시 채워진다).
 - **dev backend 메모리 한도는 2g** — watch 컴파일과 타입 검사가 함께 돌아 base 의 1g 에서 OOM 으로 죽었다 (운영은 1g 그대로).
+- **db 메모리 한도는 1g · 공유 버퍼(`shared_buffers`) 256MB** (14단계 — 메일 검색 색인의 찾기는 표 · 색인이 메모리에 있어야 1초 안이다, 캐시가 비면 3~8배).
+  공유 버퍼는 compose 의 db `command`(`postgres -c …` — 명령줄 값이 데이터 폴더의 설정보다 이긴다)이고 개발도 같은 값이다(dev 오버라이드가 덮어쓰지 않는다).
+  8GB 서버의 한도 합 · 운영에 올리는 차례는 mail/README.md "메모리 예산".
 - **dev backend 는 컨테이너를 기동할 때 한 번 `migration:run` 을 한다** (`dc down -v` 등으로 DB 를 새로 만든 뒤에도 바로 뜨게).
   watch 재시작은 이 단계를 다시 돌지 않는다 — 그래서 생성만 하고 검토 전인 마이그레이션이 파일을 저장할 때마다 적용되지는 않는다.
   ⚠️ 다만 **컨테이너를 다시 띄우면** 그때 있는 마이그레이션이 적용된다. 마이그레이션을 고치는 중(revert → 수정 → run)에는
diff --git a/.claude/skills/nestjs/SKILL.md b/.claude/skills/nestjs/SKILL.md
index 1a05a9a..e734265 100644
--- a/.claude/skills/nestjs/SKILL.md
+++ b/.claude/skills/nestjs/SKILL.md
@@ -43,6 +43,7 @@ description: NestJS 백엔드(backend/) 개발 규칙 — 컨트롤러/서비스
 | 공개 링크 · 내려받기 (11단계) | `modules/file-sharing` · `modules/mail/mail-large-files.service.ts` · `large-file-block.ts` · `share-link.controller.ts` | 메일 한 통에 링크 하나(토큰 256비트 — DB 에는 SHA-256 만). 보낼 때 서버가 정화 · 지문 · 중복 확인 뒤 본문에 덩이를 넣는다(`large-file-block.ts` — 표시 `<!--ara-large-files:v1-->` · `data-ara-large-files` 는 서버만 넣고 두 정화기가 사용자 HTML 에서 지운다, 경계 `bodyQuoteStart`). 링크는 "확실한 실패"(`SendNotStartedException` — 형식으로 가른다)에서만 거둔다. 임시 저장은 머리글 `X-Ara-Large-Files`(보내는 메일에는 없다). 공개 경로 `/api/public-links/{token}`(로그인 없음) — 공개 호스트 미들웨어 `public-host.ts`(공개 호스트에서는 이 경로만 · 포털에서는 닫음, Host 를 스스로 정규화. 경로는 원문 · 라우터의 `req.path` · WHATWG URL · 퍼센트를 푼 원문 네 모양을 모두 본다 — 공개 호스트는 모두 공개 경로일 때만, 포털은 하나라도 공개 경로면 닫고, 읽지 못한 모양이 있으면 둘 다 닫는다. 라우터가 읽는 모양을 빼면 절대 주소 꼴 · `\` 요청이 막기를 지난다 — 2026-10-30), 파일 응답 `serveFile`(octet-stream · attachment · nosniff · CSP sandbox · no-store · Range `shared/utils/http-range.ts`), 받은 수는 조건부 UPDATE 한 문장, 종료 때 진행 중 응답을 `BeforeApplicationShutdown` 에서 끊는다. 읽기 화면의 `largeFiles` 는 표시 · 우리 출처 토큰 · 링크 주인 == From 이 모두 맞을 때만. 기간은 `shared/utils/kst-date.ts`(보낸 날부터 30일째 23:59:59 KST). 계약 4절 |
 | 계정 보안 (12단계) | `modules/account-security` · `modules/auth` 의 세션 부분 · `modules/mail/jmap/jmap-account-security.provider.ts` | 2단계 인증(엔진 TOTP — 계약 5절): 등록 `two-factor-enrollments.ts`(비밀 160비트 · 메모리 10분 · 직원마다 하나) · 켜기 · 끄기 `two-factor.service.ts`(엔진이 기준 — `enabledAt` 만 표 `two_factor_settings`) · **코드 가드 `two-factor-code-guard.ts`** — 실패 차지 · 다시 쓴 코드 확인 · (주소, 코드) "확인 중" 차지를 await 없이 한 번에 하고(같은 코드의 동시 요청이 둘 다 지나가지 않게), 받으면 그 자리에서 2분 기억한다. 결과는 받음 · 거절 · 쓰지 않음(`unused` — 새 비밀번호 거절처럼 코드와 상관없는 실패는 세지도 기억하지도 않는다). 코드 실패 카운터는 `login-attempt.service.ts`(같은 주소 15분 5 · 24시간 20 + IP 의 로그인 실패 한도). TOTP · base32 는 `shared/utils/totp.ts`(RFC 6238 — 새 의존성 없음, ±1 단계 상수 시간 비교). 잠금 `two-factor-locks.ts`(같은 직원의 2단계 바꾸기는 한 번에 하나). 로그인 2단계는 `auth.service.ts` — 앱 비밀번호 모양 거절 → 실패 차지 → 본인 Basic → **402 면 대리 접근 프로필로 정식 주소**(막는 계정의 별칭은 `AUTH_004`) → 코드는 엔진 `POST /api/auth`(mfaToken). 앱 비밀번호 `app-passwords.*`(엔진 `x:AppPassword` — 권한 `Replace` 셋, 직원마다 만들기는 한 번에 하나, 마지막 사용은 표 `app_password_usages` — 번호 · createdAt 이 같을 때만 잇는다, 비밀번호를 바꾸면 모두 지운다). 로그인된 브라우저 `modules/auth/auth-sessions.*`(경로 `/api/auth/sessions` — 지금 세션은 `AuthService.requestSessionId`: 웹은 리프레시 쿠키 · 앱은 액세스 토큰의 sid) · **끊은 세션 기억 `revoked-sessions.ts`**(액세스 토큰의 `sid` — 1시간, 기동 때 DB 에서 채운다, 끊는 모든 길이 `revokeWhere` 한 곳을 지난다 — 가드가 막고 실시간 알림은 다음 ping 때 닫는다). User-Agent → 짧은 이름 `shared/utils/user-agent.ts`(앱 이름 `ARA SYSTEM 앱` 은 세션의 `client` · 로그인 기록의 `method` 가 app 일 때만 `describeAppUserAgent` 로 — 웹 세션이 앱 꼴 UA 를 보내면 브라우저 null. 운영체제는 앱 UA `ARASYSTEM-App/<판> (Android <판>; <기종>)` 의 첫 괄호 칸 — 짝: flutter `kUserAgentProduct`). 세션 목록 항목에 `client`(web · app). 로그인 기록 `login-events.*`(표 `login_events` — 방식 webmail · app · imap · smtp, 90일 정리 cron `login-events.cleanup.ts`, 위치 커서 `login-event-cursor.ts`). 엔진 웹훅 `mail-engine-events.*` — 본문을 받기 전에 소켓 주소(`APP_NETWORK_SUBNET` — `shared/utils/cidr.ts`)와 키 유무를 보고, 원문 HMAC 을 상수 시간으로, 이 경로만 JSON 한도를 따로(4MB · 배열 10,000 · 값 200,000), 겹침은 내용 지문(`dedupe_key` 유일 인덱스 — 엔진은 다시 보낼 때 id 를 새로 붙인다), 1,000행씩 `ON CONFLICT DO NOTHING`, DB 실패는 5xx(엔진이 다시 보낸다), 빈 묶음 200(setup 의 받는 곳 확인). 마이그레이션 `AddAccountSecurity` |
 | 전환 준비 (13단계) | `common/decorators/allow-restricted-session.decorator.ts` · `JwtAuthGuard` · `modules/account-security/two-factor-policy.service.ts` · `modules/system-settings` · `modules/system-mail` · `src/cli/ops.ts` + `modules/ops` · `modules/mail/jmap/jmap-ops-engine.ts` · `jmap-system-mailbox.ts` | **제한된 세션**(계약 6절): 세션 표의 `restriction`(`passwordChange` · `twoFactorSetup`)을 액세스 토큰(`rst`)에도 싣고, `JwtAuthGuard`(Reflector)가 `@AllowRestrictedSession()` 을 단 핸들러(`/api/auth/*` · 2단계 켜기 셋)만 지나게 한다 — 그 밖은 403 `AUTH_010`. 제한이 실린 토큰만 요청마다 세션 표의 지금 값을 읽는다(PK 한 번). 푸는 요청은 그 세션(`sid`)만 다음 제한으로 바꾸고(`replaceRestriction` — 조건부 UPDATE), 2단계를 켜면 그 직원의 다른 `twoFactorSetup` 세션은 끊는다(`revokeRestrictedOf` — 사유 `two-factor-not-verified`, 갱신에서도). **비밀번호 만료 알아채기**: 게이트웨이 대리 접근 세션에 메일 계정이 없고 `/api/account` 권한이 다섯 안이면 `PasswordExpiredException`(`jmap.client.ts` 의 `isPasswordExpiredPermissions` — 로그인 · 갱신 때 엔진 기준, 풀렸으면 지움). **2단계 필수 정책 · 문의 연락처**: 표 `system_settings`(한 줄 — 프로세스마다 10초 기억), `GET /api/support-contact`(로그인 없음 · `{ text }`), `twoFactorDeadline` 은 유예 중이고 아직 안 켠 직원만. **받은편지함 알림 메일**: 대리 접근 `Email/import`(안 읽음 · 필터 · 스팸 안 거침), 보낸 사람 `ARA SYSTEM <postmaster@도메인>`, 글은 디자인 README 13단계(링크 없음 · 이름 · 파일 이름 · 연락처 이스케이프 · 보내는 정화 통과), 실패는 warn(원래 일은 성공), 위험 파일은 처음 판정 때 한 번(`markInfected`). **운영 도구**(`sudo docker exec -it <PROJECT_NAME>-backend node dist/cli/ops.js`): Nest 앱 컨텍스트(ScheduleModule 없음 · `FILE_SCANNER` null · `migrationsRun` false), 한국어 메뉴 → 바뀔 것 → y/N → 실행 → `ops_audit_log`. **메일 이전**(2026-11-02 — 전환의 imapsync): 「입사」의 이전용 비밀번호는 엔진 비밀번호 만료를 30일 뒤로 건다(그때까지 IMAP 정상 — 임시 비밀번호의 지난 만료는 IMAP 이 끊긴다), 이전 중 = 만료가 미래(31일 안)이고 실행 기록(`ops_audit_log`)의 마지막 판정 기록이 이전용(`hire-migration` · `migration-password` — 이전용 명령은 failure 도 센다) — 판정은 `modules/ops/migration-state.ts` 하나(엔진 만료만으로는 기본 만료의 찌꺼기와 가를 수 없다), 「메일 이전」(`modules/ops/migration-commands.ts`)의 이전 마치기가 직원용 임시 비밀번호로 바꾼다. 이전용 비밀번호는 실행 한 번 안에서 같은 값 — `migration-password.ts` 의 `MigrationPasswordSession`(싱글턴 · 메모리에만 · `OpsCli.run()` 의 finally 에서 지움), 약함 거절의 다시 만들기는 `temp-password.ts` 의 `applyFreshPassword`. 관리자 비밀번호는 TTY 에서만 · 입력 기록 0(`historySize: 0`) — 자동 시험만 `OPS_ALLOW_NO_TTY=1`. 관리자 Basic 은 `x:Account` · `x:MailingList` 에만, 직원 메일함 · Sieve · 앱 비밀번호는 게이트웨이 대리 접근(관리자에 impersonate 가 없다). 명령 열한 개와 차례는 계약 6절(재설정: 앱 비밀번호 → 세션 끊기 → 알림 → 만료 → 세션 한 번 더 / 잠금: Sieve → authenticate 빼기 → 세션 / 이전 마치기: 앱 비밀번호 → 세션 → 로그인 기록 → 임시 비밀번호 + 만료 → 세션 한 번 더(알림 없음) / 퇴사 마무리: 엔진 계정 → 주소 키 표 한 트랜잭션(세션 행은 남김) · 예외 목록 · MailingList 구성원 → 디스크). 끊은 세션 기억은 15초마다 DB 에서 채운다(`revoked-sessions.ts` — 운영 도구는 다른 프로세스). 마이그레이션 `AddCutoverPrep`(`auth_sessions.restriction` · `system_settings` · `ops_audit_log`). Swagger 는 가드를 건 컨트롤러에 `@ApiSessionErrors()`(AUTH_001 + AUTH_010) |
+| 메일 검색 색인 (14단계 1차 — 색인 바탕 · 2차 — 검색 · 강조 · 3차 — 대화) | `modules/mail-search` · `modules/mail/jmap/jmap-index-source.ts` · `shared/utils/search-text.ts` · `subject-base.ts` | 표 둘(마이그레이션 `AddMailSearchIndex`): `mail_search_messages`(직원 주소 + 엔진 메일 id 마다 한 줄 — 원문(NFC) · 접기 글 `fold_*` · 글자 두 개 묶음 `grams` · 메일함 · 답장 관계(GIN 둘 — 직원 주소(lower 식) · 묶음 · 메일함을 한 색인에 담은 찾기 GIN `IDX_mail_search_messages_user_grams_mailboxes` 와 refs GIN. 마이그레이션이 손으로 만들고 엔티티에는 `synchronize: false` 로 이름만)) · `mail_search_states`(직원마다 한 줄 — building · ready, 엔진 Email state, 채우기 자리, 멈춘 까닭, 실패 수). 포트 `MAIL_INDEX_SOURCE`(`mail-index-source.ts` — 엔진 교체는 `mail-search.module.ts` 의 useClass 만): 어댑터는 textBody 의 글자 부분만 읽는다(첨부 안의 글은 읽지 않는다) — 본문 값은 부분 256KiB · 한 통 1MiB, 한 요청의 메일 전체 크기 합 32MiB · 16MiB 넘는 메일은 혼자. 접기 `foldText`(NFC 뒤 코드 포인트 하나씩 — 전각 → 반각 · 소문자, 원문과 위치가 같다) · 묶음 `gramsOf` · 맞은 곳 `matchRanges` · 말머리 떼기 `subjectBase` — **짝: frontend `shared/utils/search-match.ts`**, 같은 표본 표 `backend/test/search-text-samples.ts`(한쪽을 고치면 둘 다). 상태 줄은 로그인(`AuthService`) · 비밀번호 바꾸기 · `GET /api/search-index` 가 만들고 멈춤을 푼다(로그인한 적 없는 계정은 색인하지 않는다). 맞추기 `mail-search-sync.service.ts`(Email/changes — 실시간 state 소식 300ms 모음 · 5분 cron · 검색 바로 전 1.5초, 직원마다 하나(`MailSearchRuns`) · 서버 전체 4(`ConcurrencyGate`), cannotCalculate → 전체 대조), 채우기 `mail-search-build.service.ts`(밤 창 KST 22:00~02:45 · 05:00~07:30 — 1분 cron, 최신부터 50통씩 anchor, 다 읽으면 새 차례의 처음에 따라잡기 → 전체 대조 → ready). **시간 끝은 실패가 아니다** — `IndexDeadlineError`(이어 하기 — 실패 수 · 경고 없음). 색인 쓰기는 상태 줄을 `FOR UPDATE` 로 잠근 한 트랜잭션 — 퇴사 마무리(`ops-data.service.ts`)는 상태 줄 → 색인 줄 차례로 지운다. 맞추고 채우는 직원은 사내 도메인(`MAIL_DOMAIN`) 주소뿐이다(같은 DB 의 e2e 줄은 건드리지 않는다). cron 은 `timeZone: 'Asia/Seoul'`. 묶음 크기 · 시간 한도는 `mail-search.constants.ts` 한 곳(잰 뒤 바꾼다). 로그는 코드 · 사유 · 가린 주소만(메일 글 · 제목 · 엔진 설명 문장 없음), 조건 검색 쿼리(`from` · `to` · `subject` · `body`)는 `maskUrlForLog` 가 길이만, 개발의 DB 쿼리 로그도 끈다(`database.config.ts`). **2차(검색 · 강조)**: `GET /api/messages` 의 조건 `from` · `to`(참조 포함) · `subject` · `body`(검색어와 같은 검사 — `dto/search-query-fields.ts` 의 `SearchTextField`) · `after` · `before`(UTC) · `hasAttachment=true`. 목록 · 검색은 `modules/mail/message-list.service.ts` — 색인이 준비됐으면(ready · 지금 판 `INDEX_FORMAT` — 판이 다르면 서버가 뜰 때 building 으로 되돌려 밤에 다시 채운다) 색인, 아니면 엔진(조건은 `jmap/search-terms.ts` 의 `searchFieldConditions`), 쪽을 넘기는 중에는 커서의 방식대로(`mail-search/search-cursor.ts` — 색인 커서 2판 `{v:2,m:'i'}`, 엔진 커서는 1판). 첫 쪽의 색인 찾기가 DB 장애면 엔진으로 찾는다. 색인 찾기: 계획 `search-plan.ts`(낱말 · 칸 · 한 글자 낱말 `SINGLE_CHAR_TERMS_SKIP_BODY` · 두 글자 낱말뿐이면 묶음만으로 `exactByGrams`) → SQL `search-sql.ts` → `mail-search-query.service.ts`. **후보는 찾기 GIN 하나에서만 거른다** — `IDX_mail_search_messages_user_grams_mailboxes`(마이그레이션 `SearchIndexUserGramsMailboxes`, 2026-11-06 실사용 시험)가 직원 · 묶음 · 메일함을 한 번에 맞춰 맞은 줄만 읽는다. 주소는 `lower("user_email")` 식(그대로면 btree 로 그 직원 줄을 다 읽고 묶음 배열(TOAST)을 풀었다 — 260~700ms → 10ms), 메일함은 `"mailbox_ids" @> $n` 그대로(`= ANY` 면 그 직원의 묶음 줄을 모두 읽는다). **메일함만 담은 GIN 을 다시 만들지 않는다** — 메일함 id 가 계정마다 같은 꼴이라 posting 이 회사 전체인데, 계획기가 그것만으로 메일함 줄을 다 읽고 묶음 배열을 줄마다(다른 직원 줄까지) 풀었다(1만 통 메일함 1.1초 · 남의 큰 메일함과 id 가 같은 빈 메일함 1초 — 고친 뒤 15ms · 1ms). e2e 가 EXPLAIN(그 색인 하나 · 색인 조건에 메일함)과 GIN 목록을 본다. 확인(strpos — 접은 본문을 풀어 한 줄 0.15~0.3ms)은 후보 id 의 줄만, 후보가 많으면 100줄부터 4배씩 쪽이 찰 때까지 · 한 요청 3,000줄까지(넘으면 이어 찾기 커서 — 쪽이 limit 보다 적어도 hasNext), total 은 첫 쪽에서 1,000까지(넘거나 다 세지 못하면 null). 상수는 `mail-search.constants.ts`. 강조: 목록 `search-highlight.ts`(제목 · 본문에서 맞은 곳 둘레의 미리 보기 — 색인 방식에서만. 미리 보기는 인용 줄(`>`) 밖의 맞은 곳 먼저 → 인용 안에서만 맞고 검색어 낱말이 모두 색인의 다른 칸(접은 칸 넷 — `highlightTextsSql`)에도 있으면 인용 밖 첫 글 → 아니면 `>` 를 뗀 인용 조각. 본문 강조는 두 글자 이상 낱말만 — `search-plan.ts` 의 `bodyHighlightOf`, 읽기 화면 `highlightTermsOf` 도 같은 계획에서 꺼낸다), 읽기 화면 `modules/mail/message-highlight.ts` + **정화한 뒤** HTML 의 글 조각에 `<mark>` 를 넣는 `html/html-mark.ts`(태그 · 속성 · 주석 · style 안은 그대로, 길이에 비례 · 1,000개까지). 위치는 NFC 글의 UTF-16 [시작, 끝) — 강조가 있으면 제목 · 첨부 이름 · textBody 를 NFC 로 싣는다. **3차(대화)**: 대화 키 — 색인 쓰기(`mail-search-index.repository.ts` 의 `linkThreads`)가 넣은 메일 M 의 refs 가 가리키는 메일 · M 을 가리키는 메일 가운데 말머리를 뗀 제목(`subject_base`)이 같은 것의 키를 가장 작은 키로 합친다(쌍 읽기 한 쿼리 + UPDATE 한 문장 · 합치기 `thread-keys.ts`, Message-ID 가 없으면 혼자, 넣기는 이미 있는 줄의 대화 키를 덮지 않는다). 같은 대화 `GET /api/messages/{id}/conversation` · 묶은 목록 `GET /api/conversations?mailboxId=` — `modules/mail/conversation.controller.ts` · `conversation.service.ts`(색인이 준비됐으면 색인 · 아니면 엔진의 스레드 — 응답의 `basis`, 커서가 방식을 잇는다 `mail-search/conversation-cursor.ts` — `m` 이 색인 방식이면 **입구에서 decode**: 꾸민 커서는 맞추기 · 엔진 · DB 전에 400). 색인 쿼리 `mail-search/conversation-sql.ts` · `mail-conversation-query.service.ts` — **늘 그 직원 주소의 btree 로 먼저 좁힌다**(메일함은 `$n = ANY("mailbox_ids")` 꼴 — 메일함 posting 은 회사 전체라 그 직원의 줄에서 거른다. 메일함 칸을 담은 GIN 은 검색의 찾기 GIN 하나뿐이고 대화 쿼리는 쓰지 않는다), 같은 대화는 그 메일의 키와 쪽을 한 문장(LEFT JOIN LATERAL — 색인에 없음과 빈 쪽을 가른다). 묶은 목록 줄: messageIds 최신부터 `CONVERSATION_MESSAGE_IDS_MAX`(500)까지 · 참여자는 **첫 보낸 사람 칸**(`from_email` · `from_name` — 마이그레이션 `AddMailSearchSender`, 색인 판 4. 보낸 사람 글을 다시 해석하지 않는다 — 이름 안의 `<주소>` 는 주소가 아니다)에서 주소마다 한 번 · 10명까지 DB 가 고른다(대화마다 LATERAL `DISTINCT ON`), `pendingSendIds`(messageIds 가운데 붙잡힌 메일 — 기다리는 제출은 쪽마다 한 번: 색인은 `getSummariesWithHeld`, 엔진은 목록 요청 안). 10명 흉내(10만 줄)에서 큰 메일함 첫 쪽 15~80ms · 자세히 · 참여자 1~2ms. 엔진 쪽은 `jmap/jmap-conversations.ts`(Thread/get · collapseThreads) — **거르기는 값싼 속성 · 요약 속성은 내보낼 메일만**, 상한 · 시간은 `mail-search.constants.ts` 의 `CONVERSATION_ENGINE_*`(같은 대화 한 요청 1,000통 — 그 이하 스레드만 total, 넘으면 커서 자리부터 · total null / 묶은 목록 스레드마다 최신 500 · 한 요청 2,000(`shareScan`) — 상한에 걸린 줄은 읽지 못한 메일을 거르지 않고 통 수에 더하고 나머지는 읽은 최신 쪽으로 / 한 요청 15초 — 훑는 호출은 마지막 요약 읽기 몫 3초를 뺀 제한 시간, 마지막 읽기만 남은 시간을 다, 남은 3초면 더 훑지 않고 시간에 끊긴 훑기는 읽은 데까지로 답한다. 참여자 이름은 색인과 같은 `participantName`(100 코드 포인트)). 엔진의 Thread/get emailIds 는 받은 시각 오래된 차례다(2026-11-06 개발 엔진 200 스레드 확인). 휴지통 · 스팸메일함 역할과 내부 발송 키워드는 `jmap/mail-scope.ts` 한 곳, 보이기 경로의 기다리는 제출 상한 경고는 `pending-send.ts` 의 `warnIfHeldQueryFull`. 설정 `groupByConversation`(`modules/mail-user-settings` — 처음 끔, 서버는 화면이 부르면 묶을 뿐 설정을 보지 않는다) |
 | Rate Limiting | `app.module.ts` 의 `ClientIpThrottlerGuard`(APP_GUARD, `common/guards/client-ip-throttler.guard.ts`) | 초과 시 429 → `REQ_001`. 루트 `.env` 의 `THROTTLE_*` 로 조정. `ThrottlerGuard` 를 상속해 tracker 만 바꿨다 — IP 는 `shared/utils/client-ip.ts` 의 `clientIpKey()`(IPv6 는 /64 로 묶음, 로그인 실패 카운터와 같은 함수) |
 | 로깅 | `shared/logger/winston.config.ts` | `console.log` 대신 사용 ([[logging]]) |
 | env 검증 | `shared/config/env.validation.ts` | 잘못된 설정이면 **기동 실패**(fail-fast) ([[env-structure]]) |
@@ -260,6 +261,7 @@ SwaggerModule.setup('api-docs', app, document);
   > 코드 실패 카운터(`login-attempt.service.ts` 의 codeFailures · dailyCodeFailures), 2단계 바꾸기 잠금(`two-factor-locks.ts`) · 앱 비밀번호 만들기 차례(`AppPasswordsService.creating`) —
   > 그대로면 인스턴스마다 따로 세고 기억해 같은 코드를 다른 인스턴스에서 다시 쓸 수 있다 → 공유 저장소(`SET NX PX` · 카운터). 끊은 세션 기억(`revoked-sessions.ts` — 1시간, 기동 때 DB 에서 채움) —
   > 13단계부터 15초마다 DB 에서 채우므로 인스턴스 사이도 15초 안에 맞는다(운영 도구가 끊은 세션도 같은 길). 2단계 필수 정책 · 문의 연락처의 10초 기억(`system-settings`)도 인스턴스마다 따로지만 10초 안에 맞는다. 검사가 겹치면 위험 파일 알림 메일도 겹칠 수 있다(조건부 UPDATE 로 줄였다). 로그인 기록 정리 cron · 웹훅 거절 로그 묶음은 인스턴스마다 돌아도 무해하다.
+  > 검색 색인(14단계)의 직원마다 차례(`mail-search-runs.ts` 의 `MailSearchRuns`) · 맞추기의 소식 모음 · 기다리는 맞추기 · 5분 차례 겹침 막기(`mail-search-sync.service.ts` 의 debounces · queued · syncingAll) · 서버 전체 맞추기 수(`ConcurrencyGate` — 4) · 1분 채우기 겹침 막기(`mail-search-build.service.ts` 의 running) — 그대로면 인스턴스마다 따로 돌아, **두 인스턴스의 1분 차례가 같은 직원을 함께 채우고**(쓰기는 상태 줄 잠금으로 차례가 되지만 같은 묶음을 두 번 읽는다) 같은 직원을 함께 맞추며, 엔진에 가는 맞추기 수가 인스턴스 수만큼 는다 → 직원마다 잠금(`SET NX PX` · `pg_advisory_lock`) · 공유 셈. 표 쓰기 자체는 DB 라 그대로 맞다.
   > 대용량 첨부(11단계)의 같은 조각 게이트 · 조각 동시 수(`file-storage.service.ts` 의 `ChunkGate` — 그대로면 두 인스턴스가 같은 조각을 함께 쓴다 → 잠금), 검사 차례(`file-scan.service.ts` — 행 잠금이 없어
   > 두 인스턴스가 같은 파일을 두 번 검사한다 → `FOR UPDATE SKIP LOCKED`), 정리 cron 둘(인스턴스마다 돈다), 파일 바이트(로컬 볼륨 → 같은 저장 포트 `FILE_BLOB_STORE` 의 공유 저장 어댑터(S3 호환)) —
   > 만들기 잠금(`pg_advisory_xact_lock`) · 받은 수 셈(조건부 UPDATE)은 DB 라 그대로 맞다:
diff --git a/.claude/skills/vue3/SKILL.md b/.claude/skills/vue3/SKILL.md
index 0311d30..6435519 100644
--- a/.claude/skills/vue3/SKILL.md
+++ b/.claude/skills/vue3/SKILL.md
@@ -37,7 +37,7 @@ description: Vue 3 프론트엔드(frontend/) 개발 규칙 — Composition API
 | 외부 HTML 격리 렌더링 | `src/components/mail/MailBodyFrame.vue` · `src/shared/utils/mail-html.ts` | 메일 본문 등 외부 HTML 은 이 컴포넌트로만 그린다 (sandbox·내부 CSP 근거는 파일 머리말). 보여 줄 HTML 고르기는 `displayedHtmlBody()` 하나다 — null 이거나 공백뿐이면 textBody (읽기 화면·인용 공용, 서버의 `isBodyTruncated` 와 같은 규칙) |
 | 메일 모듈 | `src/pages/mail/*` · `src/components/mail/*` | API 계약 `docs/mail/api-contract.md`, 디자인 원본 `docs/design/webmail/` |
 | 콘텐츠 열 토큰 | `src/styles/tokens.css` 의 `--content-*` · `--content-toolbar-start` | 읽기·쓰기 화면이 같은 최대 폭·여백·32px 시작선을 쓴다 (새 화면도 이 토큰으로) |
-| 밀도 예외 크기 | `src/styles/tokens.css` 의 `--size-compact-control` · `--size-segment-item` · `--size-segment-item-lg` · `--size-editor-tool` · `--size-editor-menu-item` · `--size-editor-swatch-cell` · `--size-editor-table-cell` · `--table-col-check` · `--size-row-check` · `--size-search-clear-width`/`-height` · `--size-notice-bar` · `--size-mailbox-more` · `--size-notice-action` · `--size-filter-control` · `--size-filter-remove` (주석에 "밀도 예외") | 클릭 영역 44px 기준의 의도된 예외(목록 표의 별·보기 전환, 설정 화면의 미리 보기 전환 36(`.segmented`)·서명 그림 크기 줄 36(작게·보통·원본·그림 빼기), 편집기 툴바 버튼 40×44·메뉴 항목 40·색 견본 40·표 고르기 칸 22, 3단계의 목록 표 고르기 칸 32·분할 행 고르기 칸 폭 36·검색 칸 ✕ 40×38·새 메일 알림 줄 40·검색 범위 전환 36·이동 메뉴 항목 40, 4단계의 메일함 행 ⋯ 32×40 · ⋯ 메뉴 항목 40, 5단계의 목록 위 알림 권하기 줄 40 · 줄 안의 단추 36, 6단계의 필터 조건 칸 40 · 조건 ✕ 36 · 필터 행 ▲▼ 32×40 · 켜기 스위치 누르는 곳 40×44 · 고치기 창 안 [다시 불러오기] 36, 8단계의 패널 그룹 줄 ⋯ 32×40 · 연락처 창의 줄 · 칸 40 · 줄 ✕ 36×40 · 구성원 넣기 창 전환 36 · 찾기 칸 40 — 새 토큰 없이 위 것을 다시 쓴다, 9단계의 읽기 화면 안내 줄 단추([이미지 보기] · [차단 풀기] · [고치기] · [예약 취소]) · 차단한 주소 줄의 [차단 풀기] 36(`--size-notice-action`) — 역시 새 토큰 없음, tokens.css 주석)에만 쓴다 — 사용자 확정(캔버스). 그 밖의 `--size-editor-*`(툴바 높이·글꼴 단추·본문 최소 높이 등)는 예외가 아니라 보통 크기다 |
+| 밀도 예외 크기 | `src/styles/tokens.css` 의 `--size-compact-control` · `--size-segment-item` · `--size-segment-item-lg` · `--size-editor-tool` · `--size-editor-menu-item` · `--size-editor-swatch-cell` · `--size-editor-table-cell` · `--table-col-check` · `--size-row-check` · `--size-search-clear-width`/`-height` · `--size-notice-bar` · `--size-mailbox-more` · `--size-notice-action` · `--size-filter-control` · `--size-filter-remove` (주석에 "밀도 예외") | 클릭 영역 44px 기준의 의도된 예외(목록 표의 별·보기 전환, 설정 화면의 미리 보기 전환 36(`.segmented`)·서명 그림 크기 줄 36(작게·보통·원본·그림 빼기), 편집기 툴바 버튼 40×44·메뉴 항목 40·색 견본 40·표 고르기 칸 22, 3단계의 목록 표 고르기 칸 32·분할 행 고르기 칸 폭 36·검색 칸 ✕ 40×38·새 메일 알림 줄 40·검색 범위 전환 36·이동 메뉴 항목 40, 4단계의 메일함 행 ⋯ 32×40 · ⋯ 메뉴 항목 40, 5단계의 목록 위 알림 권하기 줄 40 · 줄 안의 단추 36, 6단계의 필터 조건 칸 40 · 조건 ✕ 36 · 필터 행 ▲▼ 32×40 · 켜기 스위치 누르는 곳 40×44 · 고치기 창 안 [다시 불러오기] 36, 8단계의 패널 그룹 줄 ⋯ 32×40 · 연락처 창의 줄 · 칸 40 · 줄 ✕ 36×40 · 구성원 넣기 창 전환 36 · 찾기 칸 40 — 새 토큰 없이 위 것을 다시 쓴다, 9단계의 읽기 화면 안내 줄 단추([이미지 보기] · [차단 풀기] · [고치기] · [예약 취소]) · 차단한 주소 줄의 [차단 풀기] 36(`--size-notice-action`) — 역시 새 토큰 없음, 14단계의 검색 칸 [조건] 32(`--size-compact-control`) · 조건 패널의 칸 · 단추 40(`--size-filter-control`) · 조건 줄 40 · 줄 안 [조건 지우기] 36 · 같은 대화 펼친 줄의 [답장] · [이 메일만 열기] 36 · 목록 머리 [대화로 묶기] 36(`--size-notice-action`) — 역시 새 토큰 없음, tokens.css 주석)에만 쓴다 — 사용자 확정(캔버스). 그 밖의 `--size-editor-*`(툴바 높이·글꼴 단추·본문 최소 높이 등)는 예외가 아니라 보통 크기다 |
 | 사용자별 화면 설정 | `src/stores/mail-view.store.ts` | localStorage(키에 사용자 email, try/catch, 실패 시 기본값). 서버 설정 API 가 생기면 교체 |
 | 화면 이동 규칙 | `src/composables/useMailNavigation.ts` | 이전/다음은 replace, "목록으로"는 뒤로 가기 또는 replace (기록이 쌓이지 않게) |
 | 발송 키 규칙 | `src/shared/utils/idempotency-key.ts` 의 `shouldRenewSendKey()` | `Idempotency-Key` 는 성공과 `MAIL_005` 때만 바꾼다 — 그 밖의 실패 뒤 다시 보내기는 같은 키 (계약 2절 "발송 본문"). UUID 만들기는 `shared/utils/uuid.ts` 하나(필터 id 와 공용 — `crypto.randomUUID` 가 없으면 대체 경로) |
@@ -46,13 +46,16 @@ description: Vue 3 프론트엔드(frontend/) 개발 규칙 — Composition API
 | 임시 저장 | `src/composables/useDraftSaving.ts` · `components/mail/ComposeDraftStatus.vue` · `composables/useComposeDraftLink.ts`(주소 맞추기 · 옛 id 기록 · 보내지 못한 메일을 저장본으로) · `composables/useDraftTrash.ts`(휴지통 · 되돌리기) | 3초 멈춤 · 쉬지 않고 쓰면 30초 · 10초 간격 · 한 번에 하나(계약 2절 "임시 저장", 상수 `shared/constants/mail.ts` 의 `DRAFT_*`). `MAIL_008`·PUT 404 는 막지 않고 POST 로 새로. 찾지 못한 첨부가 남았거나 본문이 한도를 넘는 동안은 저장하지 않고, 실을 수 없는 첨부가 든 남의 저장본은 첫 저장을 POST 로(원본 보존). 보내기·버리기 전에는 `suspend`+`settle` — 보내기는 settle 뒤 첨부 상태를 다시 본다. 저장할 때마다 주소를 `?draft=<새 id>` 로 맞추고(떠나기 전 저장 제외), 옛 id 로 돌아오면 `mail.store` 의 `latestDraftId()` 로 마지막 저장본을 연다. 쓰기 화면 휴지통은 DELETE 가 아니라 PATCH(휴지통으로 이동) — 이미 휴지통인 메일은 DELETE 가 영구 삭제한다 |
 | 받는 사람 자동 완성 | `src/composables/useRecipientSuggestions.ts` · `shared/utils/recipient-match.ts` · `components/mail/RecipientField.vue` · `RecipientSuggestionList.vue` | 검색어는 input · compositionupdate 의 `target.value`(한글 조합 중 글자 포함)로 따로 두고, 칩 확정은 v-model. Enter 등의 조합 판정은 `shared/utils/keyboard-shortcut.ts` 의 `isImeComposing()`(`isComposing` 또는 keyCode 229 — Safari · macOS) — 새 입력 칸의 Enter 처리도 이것을 쓴다. 쓰기 화면을 열 때 `limit=100` 한 번, 모자랄 때만 250ms 뒤 `q` 로(8단계부터 초성 · 조합 중 글자도 묻는다 — 서버의 q 가 같은 맞추기다: 짝 backend `modules/mail/recipient-match.ts`, 같은 표본 표 `test-utils/recipient-match-samples.ts` — 한쪽을 고치면 둘 다. 늦은 응답은 버린다). 초성 검색·맞은 글자 강조는 `recipient-match.ts`(강조는 `<strong>` 조각 — v-html 없음). combobox 접근성(aria-activedescendant · listbox · 조합 중 Enter 무시), 완전한 주소면 미리 고르지 않는다 |
 | 메일 서명 | `src/stores/mail-signature.store.ts` · `components/mail/editor/signature/` · `shared/utils/mail-signature.ts` · `pages/settings/` | 서명은 메일 화면에 들어올 때 받아 두고 쓰기 화면이 넣는다(새 메일은 끝, 답장·전달은 인용 위 — 이어 쓰기는 다시 넣지 않는다). 설정 화면(`SettingsLayout.vue` 왼쪽 메뉴 — 묶음 · 항목은 `shared/constants/settings-menu.ts` + `MailSignaturePage.vue`)은 들어올 때마다 새로 받는다. 미리 보기는 편집기 스키마의 `DOMSerializer` 로 그린다. 그림 3장은 서명 칸 안의 그림 수로(서버 보관 상한 10장은 서버가 센다) |
-| 메일 스토어 구성 | `src/stores/mail.store.ts`(조립 · 공개 API) + `src/stores/mail/` — `mailboxes.ts` · `list.ts` · `selection.ts` · `message.ts` · `bulk.ts` · `mailbox-admin.ts`(4단계 메일함 관리) | Pinia 스토어는 `useMailStore` 하나이고 기능별 setup 모듈을 조립한다(스토어를 여러 개로 나누지 않는다 — 서로 부르는 고리가 생긴다). 목록 출처는 `shared/utils/mail-list-source.ts`(메일함 · 검색). **늦게 온 응답 버리기**: 목록 맞추기는 이 탭의 목록 변경 세대(`localGeneration` — 읽음 · 중요 · 빼기 · 옮기기마다 오른다)가 그사이 바뀌었으면 응답을 버리고 한 번 더 맞춘다. 여러 통 처리 · 한 통 삭제는 시작할 때의 출처 순번(`sourceSeq`)과 다르면 목록을 건드리지 않고 개수만 맞춘다 |
+| 메일 스토어 구성 | `src/stores/mail.store.ts`(조립 · 공개 API) + `src/stores/mail/` — `mailboxes.ts` · `list.ts` · `selection.ts` · `message.ts` · `bulk.ts` · `mailbox-admin.ts`(4단계 메일함 관리) · `conversation.ts`(14단계 같은 대화 칸) | Pinia 스토어는 `useMailStore` 하나이고 기능별 setup 모듈을 조립한다(스토어를 여러 개로 나누지 않는다 — 서로 부르는 고리가 생긴다). 목록 출처는 `shared/utils/mail-list-source.ts`(메일함 · 검색 · 대화로 묶은 메일함 `conversations` — 14단계). **목록에 든 메일인지 볼 때는 `messages` 대신 줄 기준 도우미**(`rowCount` · `rowIndexOfMessage` · `rowMessageIdAt` · `isListedMessage` · `listedSummaries`)를 쓴다 — 대화 목록에서는 `messages` 가 비어 있다. 목록 요청은 출처가 바뀌면 `listAbort`(AbortController)로 끊는다(끊긴 요청은 알리지 않는다). **늦게 온 응답 버리기**: 목록 맞추기는 이 탭의 목록 변경 세대(`localGeneration` — 읽음 · 중요 · 빼기 · 옮기기마다 오른다)가 그사이 바뀌었으면 응답을 버리고 한 번 더 맞춘다. 여러 통 처리 · 한 통 삭제는 시작할 때의 출처 순번(`sourceSeq`)과 다르면 목록을 건드리지 않고 개수만 맞춘다 |
 | 새 메일 확인 · 탭 제목 | `src/composables/useMailStatePolling.ts`(메일 화면 `MailLayout` 이 시작) · `useListArrivalNotice.ts` + `components/mail/MailNewNotice.vue` · `useMailTabTitle.ts` + `shared/utils/document-title.ts` | 화면이 보이는 동안 60초마다 `GET /mail-state`, 탭으로 돌아오면 10초 지났을 때 바로, 한 번에 하나, 실패는 `silent`. 바뀌면 `syncCounts()` + 보이는 목록 맞추기(불러온 만큼 · 최대 100통, 검색 결과는 건너뜀). 목록을 내려 본 채면 "새 메일 N통 · 맨 위로" 줄. 받은편지함 안 읽음이 있으면 탭 제목 앞 `(N) ` (메일 라우트에서만) — 계약 2절 "새 메일 확인" |
 | 실시간 새 메일 (5단계) | `src/composables/useMailRealtime.ts`(`App.vue` 가 시작 — 로그인한 동안 앱 전체) · `stores/mail-realtime.store.ts` · `shared/utils/sse-parser.ts` · `mail-events.ts` · `mail-realtime.ts` · `browser-support.ts` | **브라우저마다 연결 하나** — Web Locks 잠금(이름에 사용자 주소)을 받은 탭만 `GET /api/mail-events` 를 읽고 BroadcastChannel 로 나눈다(메시지에 사용자 주소, 다른 계정 것은 버린다). `fetch` 로 읽는다 — `EventSource` 는 401 을 몰라 쓰지 않는다. 75초 무소식 감시는 요청 시작부터, 401 → 세션 갱신 한 번(그 바로 뒤의 시도만 "갱신 직후"), 다시 잇기 2 · 5 · 15 · 30 · 60초(±20%) — 간격은 연결이 **자리 잡은 뒤**(정상 ping 또는 20초)에만 처음부터 다시 세고, 자리 잡기 전의 `end` 는 실패처럼 기다린다(열리자마자 끝나는 연결에서 갱신 폭주를 막는다). 메일 화면(`useMailStatePolling`)은 이 소식을 받아 연결이 살아 있는 동안 1분 확인을 멈추고, `state` 가 바뀌면 보이는 탭은 맞추기(1초 모아서 — `MAIL_REALTIME_SYNC_DELAY_MS`) · 숨은 탭은 `inboxUnread` 로 탭 제목만(`setInboxUnread`) — 계약 2절 "실시간 알림" |
 | 바탕화면 알림 (5단계) | `src/composables/useNewMailNotifier.ts` · `useDesktopNotification.ts` · `stores/mail-notify.store.ts`(브라우저 · 사용자마다 localStorage) · `shared/utils/desktop-notify.ts` · 목록 위 권하기 `components/mail/MailNotifyOffer.vue` · 설정 `pages/settings/MailNotifyPage.vue`(+ `components/settings/NotifySettingsForm.vue` · `RealtimeLinkStatus.vue`) · 아이콘 `assets/brand/notification-icon.png` · 문구 `shared/constants/mail-notify.ts` | 연결한 탭이 `new-mail` 을 받고 설정이 켜져 있고 허락됐고 **웹메일을 보고 있는 탭이 없을 때만**(보이고 초점이 있음 — `visibilityState === 'visible' && document.hasFocus()`, 다른 탭에 짧게 묻는다) 띄운다 — tag 하나로 앞 알림을 바꿔 쓰고, 사용자가 돌아오면 닫는다. 허락을 묻는 동안 단추는 `disabled` 가 아니라 `aria-disabled`(초점을 잃지 않게). 허락은 사용자가 누른 뒤에만(`Notification.requestPermission()`). 누르면 그 메일로(`useMailNavigation` 의 `openFromNotification` — 세션이 바뀌었으면 이동하지 않는다) |
 | 실시간 테스트 도구 | `src/test-utils/event-stream.ts`(가짜 SSE 서버) · `notification.ts`(가짜 Notification) · `web-locks.ts`(가짜 `navigator.locks` · BroadcastChannel) | 실시간 · 알림 테스트는 이것들과 손으로 돌리는 시계(`manual-clock.ts`)로 — 진짜 타이머 · 고정 대기 없이 |
 | 메일 검색 | `src/components/mail/MailSearchBox.vue`(상단 바의 search 슬롯) · `composables/useMailSearchNavigation.ts` · `MailSearchHeader.vue` · `MailSearchScope.vue` · `MailSearchEmpty.vue` · 라우트 `/mail/search` · `/mail/search/:messageId` | Enter 로만 찾는다(`isImeComposing()` 이면 무시), ✕ · Esc 는 검색을 시작한 메일함으로. 주소 `?q=…&in=<메일함 id \| all>` — 검색 화면 안의 다시 찾기 · 범위 바꾸기는 replace. 서버와 같은 한도(200자 · 낱말 8개)를 먼저 본다. 조사 처리 · 한계는 서버 몫(계약 2절 "검색") |
-| 여러 통 처리 · 삭제 | `src/components/mail/MailCheckbox.vue` · `MailSelectionToolbar.vue`(+ `MailBulkButton` · `MailBulkMoveButton`) · `MailPurgeDialog.vue` · `MessageDeleteButton.vue` · `composables/useBulkMailActions.ts` · `useMessageRemoval.ts` · `useMailMoveFeedback.ts` · `shared/utils/mail-selection.ts` · `mail-bulk.ts` | 100통씩 차례로. 읽음 · 중요는 먼저 바꾸고 `failedIds` 만 되돌리고, 이동 · 삭제는 응답의 id 만 뺀다. **웹은 `DELETE /api/messages/{id}` 를 쓰지 않는다** — 휴지통 밖 삭제는 `PATCH` 이동(+ 되돌리기), 휴지통에서는 확인 대화상자(처음 초점 「취소」) 뒤 `POST /message-deletions`. 읽기 화면도 그 메일의 `mailboxIds` 로 같은 규칙을 탄다. 도구 줄은 role="toolbar" 로빙 tabindex(바쁜 · 꺼진 단추는 건너뛴다) — 계약 2절 "여러 통 한꺼번에" |
+| 메일 검색 — 14단계 (조건 · 강조 · 준비 중) | `src/components/mail/MailSearchConditions.vue`(조건 패널 — 칸 `MailSearchConditionFields.vue` · 기간 `MailSearchPeriodField.vue` · [조건] `MailSearchConditionsToggle.vue`, 고치는 값 `composables/useSearchConditionsDraft.ts` · 열고 닫기 `useSearchConditionsPopup.ts`) · `MailSearchConditionLine.vue`(조건 줄) · `MailSearchNotices.vue`(준비 중 · 한 글자 안내) · `MailSearchMore.vue`([더 찾기]) · `HighlightedText.vue` · `shared/utils/mail-search.ts`(조건 ↔ 주소 ↔ API · 기간 · 조건 줄 글) · `search-highlight.ts` · `search-match.ts` · `shared/constants/mail-search.ts` | 조건 이름 · 화면 주소(`since` · `until` 은 브라우저 시간대 날짜 · 양 끝 포함, 첨부 `attachment=1`) · 이어 찾기(`MAIL_SEARCH_FILL_MAX_REQUESTS` 5번)는 계약 2절 "검색 — 14단계"의 클라이언트 줄. **`search-match.ts` 는 backend `shared/utils/search-query.ts` · `search-text.ts` · `subject-base.ts` 와 짝** — 같은 표본 표 `test-utils/search-text-samples.ts`(backend `test/search-text-samples.ts` 와 행 · 차례까지 같다, 보이지 않는 글자는 `\u` 로 적는다 — 한쪽을 고치면 둘 다). 맞은 말은 `HighlightedText` 가 글 조각 + `<mark>` 로 그린다(v-html 없음 — 위치가 글 밖 · 거꾸로 · 정수가 아니면 버리고, 서로게이트 쌍을 가르지 않는다). **강조가 든 응답은 보이기만 한다** — `openMessage(id, highlight)` 는 강조 쿼리가 다르면 다시 받고, 답장 · 전달 · 인쇄 · 예약 · 대용량 첨부 다시 받기는 강조 쿼리 없이 받는다. 손으로 고친 주소도 패널과 같은 검사(8낱말 넘으면 묻지 않고 "찾을 말이 너무 많습니다"). 강조 노랑은 `--color-search-mark` — 본문 틀(`mail-html.ts`)의 같은 값과 짝. 미리 보기 줄(회색 글) 안의 강조만 글자를 `--color-text-secondary` 로 진하게(노랑 위 대비 — `MessageListItem.vue`). 패널의 [조건 지우기]는 칸만 비운다 — 패널은 열린 채 · 찾지 않음, 걸린 조건은 [찾기] · 조건 줄의 [조건 지우기]가 뺀다(2026-11-07) |
+| 같은 대화 (14단계) | `src/components/mail/MessageConversation.vue`(읽기 화면 첨부 아래 칸) · `ConversationMessageRow.vue`(줄) · `ConversationMessagePanel.vue`(펼친 안) · `stores/mail/conversation.ts` · `composables/useConversationSync.ts`(언제 받을지 — 시계 주입) · `shared/utils/mail-conversation.ts`(이름 자리 · 쪽 맞추기 · 갈 곳) · `shared/constants/mail-conversation.ts` · `shared/utils/format.ts` 의 `formatConversationTime` | 받기 · 다시 받기는 계약 2절 "대화 — 14단계"의 클라이언트 줄(100통 · 이어 묻기 5번 · [더 보기], 실패는 칸 안 안내 — 404 면 칸 없음). **다시 받기 판정은 `mail.store` 의 `mailboxTotalsKey`**(메일함마다 `id:totalCount` — 바뀔 때만 `requestConversationRefresh()`, MailLayout 의 바뀜 소식에서는 부르지 않는다 — 읽음 · 중요 표시만 바뀐 소식으로 대화를 다시 받지 않게 — 칸의 안 읽은 줄은 목록처럼 굵게 그리고, 이 탭이 바꾼 읽음은 `list.ts` 의 `watchLocalReads` 로 바로 적는다: 받는 동안 바꾼 것은 `conversation.ts` 의 `withLocalReads` 가 받은 값보다 앞세우고, 다른 탭의 읽음은 다음 받기 때 — 2026-11-07), 간격은 받기가 끝난 때(`conversationBusy` 가 꺼질 때)부터 10초. 펼친 본문은 `MailBodyFrame` · 강조 쿼리 없이, 안 읽은 메일은 `markRead`(`Promise<boolean>` — 같은 목록의 `pendingFlags` 에 같은 읽음이 있으면 건너뛴다)로. `closeMessage` 가 칸도 비운다. 초점은 누른 단추가 사라지면 줄의 펼침 단추 → 새 [다시 시도] → 칸 h3(`tabindex="-1"`) → 칸이 없어지면 읽기 화면에 `settled`. 상태 영역은 늘 두고 글만 바꾼다(다시 실패해도 읽게). [이 메일만 열기]는 분할 보기 push · 목록 보기 replace(layout prop). 줄 차례는 `orderHeldLast`(붙잡힌 메일은 끝 — 보낼 시각 차례), 미리 보기는 `previewWithoutOwnQuote`(우리 원문 인용 머리부터 잘라 냄 — `mail-conversation.ts`), 펼친 줄의 첨부 수 안내는 `ConversationMessagePanel` |
+| 대화로 묶어 보기 (14단계) | `src/components/mail/MailConversationToggle.vue`(목록 머리 [대화로 묶기]) · `ConversationListItem.vue`(분할 보기 줄) · `ConversationTableRow.vue`(목록 보기 표 줄) · `composables/useConversationRows.ts` · `shared/utils/mail-conversation-list.ts`(응답 맞추기 · 할 일 id · 참여자 · 머리 글 · 표시 적용 · 맞추기 병합 · 삭제 뒤 갈 곳) · `stores/mail/list.ts`(출처 `conversations`) · 설정 `stores/mail-settings.store.ts` 의 `groupByConversation`(+ 설정 › 보내기 · 읽기 한 줄) · 글 `shared/constants/mail-conversation.ts` 의 `MAIL_CONVERSATION_LIST_TEXT` | 받기 · 맞추기 · 줄에 하는 일은 계약 2절 "대화 — 14단계"의 클라이언트 줄(20줄 · 맞추기는 불러온 줄 수만큼 최대 100줄 `silent` · 할 일 = `messageIds` − 붙잡힌 메일 · 줄 전체 표시는 모두 바꿨을 때만 · 옮기기 · 삭제 뒤 한 번 다시 받기). **첫 진입 짐작**은 localStorage `groupByConversationHintKey(주소)` — 설정을 받기 전 · 받지 못했으면 이 값, 받으면 서버 값, 읽기 · 쓰기가 던져도 끔. 로그아웃 · 세션 만료에 설정 스토어를 비워도 화면이 보는 값은 그대로 둔다(뒤집히면 watcher 가 떠나는 화면의 목록을 다시 부른다 — 2026-11-06 리뷰). **목록을 부르는 watcher 는 `authStore.canUseApp` 이 false 면 부르지 않는다**(소스에도 넣는다). 붙잡힌 메일이 든 줄은 고르기 칸 · 별이 `aria-disabled` + 까닭(`SEND_LATER_TEXT.heldNotSelectable`). 목록 줄의 화면 낭독 글("안 읽음, " · "중요 표시" · "첨부 있음")은 `shared/constants/mail.ts` 의 `MAIL_LIST_ROW_TEXT` — 메일 줄은 아직 직접 적은 글이라 함께 고친다. 읽기 화면 [이전] · [다음] · 위치는 대화 단위(`ListReadNav.vue`), 한 통 삭제 뒤 갈 곳은 `conversationNeighborAfterRemoval`. 분할 보기 머리의 줄인 개수 글 `listHeadShortCountText`(전체 글은 title · 숨긴 글) · 도구 줄 `selectedShort`(숨긴 글 "대화 N개 선택됨") · 표 머리 "참여자"(`participantsColumn`) · 줄 알림 `announceMove(…, { from })` → `MAIL_BULK_TEXT.movedFrom`("{메일함}에 있는 메일 N통을 …"). 영구 삭제는 `MailPurgeDialog` 의 `from` + `announcePurge(…, { from })` → `purgeTitleFrom` · `purgedFrom`(값은 `useBulkMailActions` 의 `conversationFrom` — 묶지 않은 목록 · 읽기 화면은 null). **설정 다시 받기** `composables/useMailSettingsRefresh.ts`(MailLayout — 탭이 보일 때 60초 `MAIL_SETTINGS_REFRESH_AFTER_MS` · `canUseApp`) + 스토어 `refresh()`(silent · 받는 동안 loading 으로 바꾸지 않음 · 저장 중이면 하지 않음 · 받는 사이 고른 것(`choiceSeq`) · 다시 받기(`loadSeq`) · 세션이 바뀌면 버림) · `fetchSeq` — 디자인 README "14단계 구현하며 정한 보완 — 목록 대화로 묶어 보기" |
+| 여러 통 처리 · 삭제 | `src/components/mail/MailCheckbox.vue` · `MailSelectionToolbar.vue`(+ `MailBulkButton` · `MailBulkMoveButton`) · `MailPurgeDialog.vue` · `MessageDeleteButton.vue` · `composables/useBulkMailActions.ts` · `useMessageRemoval.ts` · `useMailMoveFeedback.ts` · `shared/utils/mail-selection.ts` · `mail-bulk.ts` | 100통씩 차례로. 읽음 · 중요는 먼저 바꾸고 `failedIds` 만 되돌리고, 이동 · 삭제는 응답의 id 만 뺀다. **웹은 `DELETE /api/messages/{id}` 를 쓰지 않는다** — 휴지통 밖 삭제는 `PATCH` 이동(+ 되돌리기), 휴지통에서는 확인 대화상자(처음 초점 「취소」) 뒤 `POST /message-deletions`. 읽기 화면도 그 메일의 `mailboxIds` 로 같은 규칙을 탄다. 도구 줄은 role="toolbar" 로빙 tabindex(바쁜 · 꺼진 단추는 건너뛴다). [되돌리기] 뒤 알림은 한 메일함이면 그 이름(`restoredMessageText(…, mailboxName)` — "메일 N통을 받은편지함으로 되돌렸습니다.") — 계약 2절 "여러 통 한꺼번에" |
 | 설정 › 비밀번호 · 부재중 (4단계) | `src/pages/settings/AccountPasswordPage.vue` · `MailVacationPage.vue` · `components/settings/`(`SettingsPageFrame` 공용 틀 — 머리 오른쪽 단추는 `actions` 슬롯 · `PasswordChangeForm` · `PasswordField` · `Vacation*`) · `stores/mail-vacation.store.ts` · `shared/utils/password-change.ts` · `mail-vacation.ts` · 메뉴 `shared/constants/settings-menu.ts` | 메뉴는 묶음(계정 › 비밀번호 / 메일 › 서명 · 부재중 자동 응답 · 필터(6단계) · 알림(5단계)), 라우트 이름은 `SETTINGS_ROUTES` 하나. 비밀번호는 서버와 같은 규칙을 먼저 보고, 서버 거절(`AUTH_005` · `VAL_001`)은 칸 아래에만(알림 없음) — 성공하면 세 칸을 비운다. 부재중은 날짜만 고르고 브라우저 시간대의 시작일 0시 · 끝나는 날 다음 날 0시를 UTC 로 보낸다(변환은 `mail-vacation.ts` 한 곳 — 되읽을 때는 1ms 앞 날짜). 켤 때만 검사하고 꺼 둔 채로는 빈 값도 저장한다(길이 150 · 600 도 켤 때만 — 꺼 둔 채로는 4단계 한도까지, 끄기는 늘 저장되게). 부재중 상태는 메일 화면에 들어올 때 받고, 패널 안내 `components/mail/MailVacationNotice.vue` 가 1분마다 다시 계산한다(`useClock` · `VACATION_NOTICE_REFRESH_MS`). 저장 응답은 세션 세대(`authStore.generation`)가 바뀌었으면 쓰지 않는다. 저장한 값이 켜짐인데 엔진에서 규칙이 꺼져 있으면(응답의 `isActive: false` — 7단계) 머리 아래 노란 줄(`MailFilterNotice` 를 단추 없이 — `actionLabel` 을 주지 않는다). 칸을 고친 값이 아니라 저장한 값으로 보고, `isActive` 는 PUT 본문에 넣지 않는다(`useMail().saveVacation` 이 다섯 칸만) — 계약 1절 · 2절 "부재중 자동 응답" |
 | 메일함 관리 · 오래 걸리는 처리 (4단계) | `src/components/mail/MailboxTree.vue` · `MailboxPanelRow.vue` · `MailboxMoreButton.vue`(⋯ 메뉴) · `MailboxDialogs.vue`(+ `Mailbox*Dialog.vue`) · `MailboxEmptyButton.vue`(목록 머리 「비우기」) · `composables/useMailboxActions.ts` · `stores/mail/mailbox-admin.ts` · `shared/utils/mailbox-operation.ts` · 상수 `shared/constants/mailbox-manage.ts` | 만들기 · 이름 바꾸기는 칸 안 실패(`MAIL_009` · `VAL_001`)를 알림 없이 칸 아래에. 모두 읽음 · 비우기 · 지우기는 남은 수가 0(지우기는 `deleted: true`)이 될 때까지 다시 보내며 진행 알림을 고친다 — 진행은 응답의 `processed`, 세션이 바뀌면 멈춘다(`epoch` — 늦게 온 만들기 · 이름 바꾸기 응답도 버린다), 같은 메일함의 같은 처리는 하나, **휴지통 비우기와 메일함 지우기는 함께 돌리지 않는다**(비우기는 그사이 휴지통에 들어온 메일도 지운다 — 판정은 스토어의 `isMailboxOperationBlocked` 하나, 메뉴 · 단추 · 대화상자 확인이 모두 이것을 본다). 끝난 뒤 누른 단추가 사라져 초점을 잃었으면 패널의 지금 메일함 항목으로 옮긴다. ⋯ 메뉴는 보이는 영역 안에 다 들게 연다(`shared/utils/popup-placement.ts` — 아래가 모자라면 위로). 되돌릴 수 없는 일은 확인 대화상자(처음 초점 「취소」) 뒤에, 확인한 그 메일함만 — 계약 2절 "메일함 관리" |
 | 스팸 · 원문 (4단계) | `src/components/mail/MessageSpamButton.vue`(읽기 화면) · 도구 줄의 스팸 단추(`MailSelectionToolbar.vue`) · `MessageMoreMenu.vue`(⋯ › 원문 내려받기) | 스팸 신고 · 스팸 아님은 이동과 `isJunk` 를 한 요청에 보내고(`mailStore.moveMessages(…, { isJunk })`), [되돌리기]는 원래 메일함으로 반대 값을 보낸다. 원문(.eml)은 `useMail().downloadMessageSource()` — 첨부처럼 `confirmSession()` 을 먼저 거친다 — 계약 2절 "스팸 · 원문" |
diff --git a/backend/src/migrations/1793873715423-AddMailSearchIndex.ts b/backend/src/migrations/1793873715423-AddMailSearchIndex.ts
new file mode 100644
index 0000000..1213c58
--- /dev/null
+++ b/backend/src/migrations/1793873715423-AddMailSearchIndex.ts
@@ -0,0 +1,79 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * 메일 검색 색인 표 (14단계 — 자체 검색 색인 · 대화 묶기의 바탕, 설계 A).
+ * - mail_search_messages: 직원 주소 + 엔진 메일 id 마다 한 줄 — 메일함 · 키워드 · 받은 시각 · 답장 관계 · 원문 글(NFC) · 접기 글(fold_*) ·
+ *   글자 두 개 묶음(grams) · 대화 키. 색인: PK, (직원, 받은 시각, id) · (직원, Message-ID) · (직원, 대화 키),
+ *   GIN 셋(grams · mailbox_ids · refs — TypeORM 이 GIN 을 적지 못해 엔티티에는 synchronize: false 로 이름만 있다)
+ * - mail_search_states: 직원마다 한 줄 — 상태(building · ready) · 엔진 Email state · 채우기 자리 · 멈춘 까닭 · 실패 수
+ * - mail_settings.group_by_conversation: 목록을 대화로 묶어 보기(기본 끔 — API 는 14단계 3차)
+ * 기존 표의 칸 · 행은 지우지 않는다 — 표를 새로 만들고 칸 하나를 더하기만 한다.
+ * (자동 생성: npm run migration:generate — GIN 색인 셋만 손으로 더했다. 엔티티는 modules/mail-search/*.entity.ts ·
+ *  modules/mail-user-settings/mail-user-settings.entity.ts)
+ */
+export class AddMailSearchIndex1793873715423 implements MigrationInterface {
+  name = 'AddMailSearchIndex1793873715423';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "mail_search_messages" ("user_email" character varying(254) NOT NULL, "email_id" character varying(64) NOT NULL, "mailbox_ids" text array NOT NULL, "keywords" text array NOT NULL, "received_at" TIMESTAMP WITH TIME ZONE NOT NULL, "size" integer NOT NULL, "message_id" text, "refs" text array NOT NULL, "subject" text NOT NULL, "subject_base" text NOT NULL, "from_text" text NOT NULL, "to_text" text NOT NULL, "cc_text" text NOT NULL, "attachment_names" text NOT NULL, "has_attachment" boolean NOT NULL, "preview" text NOT NULL, "body_text" text NOT NULL, "fold_from" text NOT NULL, "fold_to" text NOT NULL, "fold_subject" text NOT NULL, "fold_attachment" text NOT NULL, "fold_body" text NOT NULL, "grams" text array NOT NULL, "thread_key" character varying(64) NOT NULL, "engine_thread_id" character varying(64), "indexed_at" TIMESTAMP WITH TIME ZONE NOT NULL, CONSTRAINT "PK_bdeada2a9bbda7dece469d81b6f" PRIMARY KEY ("user_email", "email_id"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_mail_search_messages_thread_key" ON "mail_search_messages" ("user_email", "thread_key") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_mail_search_messages_message_id" ON "mail_search_messages" ("user_email", "message_id") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_mail_search_messages_received" ON "mail_search_messages" ("user_email", "received_at", "email_id") `,
+    );
+    // GIN — 찾는 말의 글자 두 개 묶음이 모두 든 줄(grams @> …) · 메일함 범위(mailbox_ids && …) · 늦게 온 원본이 자식을 찾기(refs @> …)
+    await queryRunner.query(
+      `CREATE INDEX "IDX_mail_search_messages_grams" ON "mail_search_messages" USING GIN ("grams")`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_mail_search_messages_mailbox_ids" ON "mail_search_messages" USING GIN ("mailbox_ids")`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_mail_search_messages_refs" ON "mail_search_messages" USING GIN ("refs")`,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "mail_search_states" ("user_email" character varying(254) NOT NULL, "status" character varying(32) NOT NULL, "email_state" text, "build_anchor" character varying(64), "build_done" integer NOT NULL DEFAULT '0', "build_total" integer, "build_started_at" TIMESTAMP WITH TIME ZONE, "ready_at" TIMESTAMP WITH TIME ZONE, "last_synced_at" TIMESTAMP WITH TIME ZONE, "paused_reason" character varying(32), "failure_count" integer NOT NULL DEFAULT '0', "created_at" TIMESTAMP WITH TIME ZONE NOT NULL, "updated_at" TIMESTAMP WITH TIME ZONE NOT NULL, CONSTRAINT "PK_e8aa94c380c49ff05919e5177ab" PRIMARY KEY ("user_email"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_mail_search_states_status" ON "mail_search_states" ("status") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "mail_settings" ADD "group_by_conversation" boolean NOT NULL DEFAULT false`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "mail_settings" DROP COLUMN "group_by_conversation"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_mail_search_states_status"`,
+    );
+    await queryRunner.query(`DROP TABLE "mail_search_states"`);
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_mail_search_messages_refs"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_mail_search_messages_mailbox_ids"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_mail_search_messages_grams"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_mail_search_messages_received"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_mail_search_messages_message_id"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_mail_search_messages_thread_key"`,
+    );
+    await queryRunner.query(`DROP TABLE "mail_search_messages"`);
+  }
+}
diff --git a/backend/src/migrations/1793882273224-SearchIndexUserGrams.ts b/backend/src/migrations/1793882273224-SearchIndexUserGrams.ts
new file mode 100644
index 0000000..b4af38e
--- /dev/null
+++ b/backend/src/migrations/1793882273224-SearchIndexUserGrams.ts
@@ -0,0 +1,41 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * 메일 검색 색인 2차 (14단계 설계 G — 1만 통 측정 뒤).
+ * - 글자 두 개 묶음 GIN 을 직원 주소와 함께로 바꾼다(btree_gin). 주소 칸은 **`lower("user_email")` 식**으로 넣는다 —
+ *   후보를 찾는 쿼리가 같은 식으로만 직원을 거르면 이 색인 말고 쓸 수 있는 색인이 없다. 주소 그대로(`"user_email"`)면 계획기가 흔한 묶음에서
+ *   주소의 btree 로 그 직원의 줄을 모두 읽고 묶음을 줄마다 풀어(TOAST) 보는 길을 골랐다(1만 통에 260~700ms — 이 색인이면 10ms 안팎, 2026-11-05 측정).
+ *   표의 주소는 늘 소문자다(서비스가 맞춘다) — 식은 값을 바꾸지 않는다.
+ *   `btree_gin` 은 PostgreSQL 13 부터 trusted 확장이라 DB 주인 계정이 만든다(이미 있으면 그대로)
+ * - 상태 줄에 색인 판(index_format)을 더한다 — 지금까지 만든 줄은 1(이 칸의 처음 값). 서버가 판이 다른 줄을 building 으로 돌려 다시 채운다
+ * 기존 표의 칸 · 행은 지우지 않는다. 내릴 때 확장은 남긴다(다른 곳이 쓸 수 있다).
+ * (자동 생성: npm run migration:generate — GIN 두 개 · 확장은 손으로 적었다. 엔티티는 modules/mail-search/*.entity.ts)
+ */
+export class SearchIndexUserGrams1793882273224 implements MigrationInterface {
+  name = 'SearchIndexUserGrams1793882273224';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`CREATE EXTENSION IF NOT EXISTS btree_gin`);
+    await queryRunner.query(
+      `CREATE INDEX "IDX_mail_search_messages_user_grams" ON "mail_search_messages" USING GIN (lower("user_email"), "grams")`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_mail_search_messages_grams"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "mail_search_states" ADD "index_format" smallint NOT NULL DEFAULT '1'`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "mail_search_states" DROP COLUMN "index_format"`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_mail_search_messages_grams" ON "mail_search_messages" USING GIN ("grams")`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_mail_search_messages_user_grams"`,
+    );
+  }
+}
diff --git a/backend/src/migrations/1793898213073-AddMailSearchSender.ts b/backend/src/migrations/1793898213073-AddMailSearchSender.ts
new file mode 100644
index 0000000..c57769a
--- /dev/null
+++ b/backend/src/migrations/1793898213073-AddMailSearchSender.ts
@@ -0,0 +1,30 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * 메일 검색 색인 3차 리뷰 L3 (14단계 — 대화로 묶은 목록의 참여자).
+ * - 색인 줄에 첫 보낸 사람의 주소(`from_email` — 254) · 이름(`from_name` — 100 코드 포인트)을 따로 둔다. 참여자는 이 칸만 읽는다 —
+ *   보낸 사람 글(`from_text` — "이름 <주소>")을 다시 해석하면 주소 없이 이름만 `대표 <ceo@…>` 꼴인 보낸 사람이 그 주소로 보이고, 400자에서 잘린 줄은 빠졌다
+ * - 둘 다 null 을 받는다(주소가 없는 보낸 사람 · 지금 있는 줄). 지금 있는 줄은 색인 판 4(INDEX_FORMAT)로 다시 채우며 채운다
+ * 기존 칸 · 행은 지우지 않는다. (자동 생성: npm run migration:generate — 엔티티는 modules/mail-search/mail-search-message.entity.ts)
+ */
+export class AddMailSearchSender1793898213073 implements MigrationInterface {
+  name = 'AddMailSearchSender1793898213073';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "mail_search_messages" ADD "from_email" character varying(254)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "mail_search_messages" ADD "from_name" character varying(100)`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "mail_search_messages" DROP COLUMN "from_name"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "mail_search_messages" DROP COLUMN "from_email"`,
+    );
+  }
+}
diff --git a/backend/src/migrations/1793979304483-SearchIndexUserGramsMailboxes.ts b/backend/src/migrations/1793979304483-SearchIndexUserGramsMailboxes.ts
new file mode 100644
index 0000000..914095d
--- /dev/null
+++ b/backend/src/migrations/1793979304483-SearchIndexUserGramsMailboxes.ts
@@ -0,0 +1,44 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * 메일 검색 색인 — 메일함 범위 찾기 (14단계 실사용 시험, 2026-11-06).
+ * - 글자 두 개 묶음 GIN 에 메일함 칸을 더한다: GIN 하나 (lower("user_email"), "grams", "mailbox_ids") 가 직원 · 묶음 · 메일함을 한 번에 맞춘다.
+ *   주소 · 묶음 GIN(`IDX_mail_search_messages_user_grams`)과 메일함만 담은 GIN(`IDX_mail_search_messages_mailbox_ids`)은 지운다.
+ * - 까닭: 메일함 범위의 후보 쿼리(`"mailbox_ids" @> $n` — search-sql.ts 의 candidatesSql)에서 계획기가 메일함 GIN 만으로 그 메일함의 줄을 모두 읽고
+ *   묶음 배열(TOAST)을 줄마다 풀어 보는 길을 골랐다. 메일함 id 는 계정마다 같은 꼴(a · b …)이라 그 posting 은 회사 전체이고, 묶음 확인이
+ *   주소 확인보다 먼저 돌아 다른 직원의 줄까지 풀었다 — 1만 통 메일함 안 1.1초, 그 메일함 id 가 남의 큰 메일함과 같은 직원은 빈 메일함에도 1.6초.
+ *   계획기는 TOAST 를 푸는 값을 모르고, 묶음 GIN 의 대기 목록(fastupdate)이 쌓이면 그 GIN 을 더 비싸게 보아 이 길로 넘어간다 —
+ *   그래서 고를 길을 하나만 남긴다(이 색인 말고 `lower("user_email")` · 묶음 · 메일함 조건을 받는 색인이 없다. 메일함만 담은 색인을 다시 만들지 않는다).
+ * - 같은 표의 흉내(10명 · 10만 줄 — 메일함 id 가 겹친다)에서 큰 메일함 29ms · 작은 메일함 1~7ms · 전체 13ms
+ *   (전에는 큰 메일함 43~125ms · 작은 메일함 5~88ms — 메일함 GIN 과 함께 쓸 때와 쓰지 않을 때). 그 표의 몫(직원 주소 · 메일함 칸)은 묶음보다 훨씬 작다.
+ * 쓰기 비용은 지금과 같다 — 메일함이 바뀐 줄은 지금도 두 GIN 에 새로 들어간다(색인된 칸이라 HOT 이 아니다). 표의 칸 · 행은 그대로다.
+ * btree_gin 확장은 SearchIndexUserGrams 가 만들었다. 내릴 때는 두 색인을 다시 만든다.
+ * (손으로 적었다 — TypeORM 이 GIN 을 적지 못한다. 엔티티는 modules/mail-search/mail-search-message.entity.ts 에 synchronize: false 로 이름만)
+ */
+export class SearchIndexUserGramsMailboxes1793979304483 implements MigrationInterface {
+  name = 'SearchIndexUserGramsMailboxes1793979304483';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE INDEX "IDX_mail_search_messages_user_grams_mailboxes" ON "mail_search_messages" USING GIN (lower("user_email"), "grams", "mailbox_ids")`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_mail_search_messages_user_grams"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_mail_search_messages_mailbox_ids"`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE INDEX "IDX_mail_search_messages_mailbox_ids" ON "mail_search_messages" USING GIN ("mailbox_ids")`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_mail_search_messages_user_grams" ON "mail_search_messages" USING GIN (lower("user_email"), "grams")`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_mail_search_messages_user_grams_mailboxes"`,
+    );
+  }
+}
diff --git a/backend/src/modules/auth/auth.module.ts b/backend/src/modules/auth/auth.module.ts
index d1bd871..f1b7267 100644
--- a/backend/src/modules/auth/auth.module.ts
+++ b/backend/src/modules/auth/auth.module.ts
@@ -6,6 +6,7 @@ import { PassportModule } from '@nestjs/passport';
 import { AccountSecurityModule } from '@/modules/account-security/account-security.module';
 import { MailModule } from '@/modules/mail/mail.module';
 import { MailDirectoryModule } from '@/modules/mail-directory/mail-directory.module';
+import { MailSearchModule } from '@/modules/mail-search/mail-search.module';
 import { AppAuthController } from './app-auth.controller';
 import { AuthSessionCleanup } from './auth-session.cleanup';
 import { AuthSessionModule } from './auth-session.module';
@@ -40,6 +41,8 @@ import { LoginAttemptModule } from './login-attempt.module';
     MailDirectoryModule,
     // 2단계 인증 코드의 한도 · 다시 쓰기 막기 · 바꾸기 잠금, 로그인 기록, 비밀번호를 바꾸면 앱 비밀번호 지우기
     AccountSecurityModule,
+    // 로그인한 직원의 검색 색인 상태 줄 (14단계 — 처음 로그인하면 building, 멈춰 있으면 푼다)
+    MailSearchModule,
   ],
   controllers: [AuthController, AppAuthController, AuthSessionsController],
   providers: [
diff --git a/backend/src/modules/auth/auth.service.spec.ts b/backend/src/modules/auth/auth.service.spec.ts
index 44ff825..f3ce85c 100644
--- a/backend/src/modules/auth/auth.service.spec.ts
+++ b/backend/src/modules/auth/auth.service.spec.ts
@@ -15,6 +15,7 @@ import {
 import type { CredentialCheck } from '@/modules/mail/mail.types';
 import type { MailSettings } from '@/modules/mail/mail.settings';
 import type { MailDirectoryService } from '@/modules/mail-directory/mail-directory.service';
+import type { MailSearchIndexService } from '@/modules/mail-search/mail-search-index.service';
 import type { AuthSessionEntity } from './auth-session.entity';
 import { hashRefreshToken } from './auth-session.policy';
 import type {
@@ -260,6 +261,8 @@ describe('AuthService', () => {
     sessionState: jest.Mock;
     isEnabledInEngine: jest.Mock;
   };
+  /** 검색 색인 대역 (14단계) — 로그인한 직원의 상태 줄 */
+  let searchIndex: { enrollAfterLogin: jest.Mock };
   let jwt: JwtService;
   let service: AuthService;
   let logs: string[];
@@ -278,6 +281,7 @@ describe('AuthService', () => {
       loginEvents as unknown as LoginEventsService,
       appPasswords as unknown as AppPasswordsService,
       twoFactorPolicy as unknown as TwoFactorPolicyService,
+      searchIndex as unknown as MailSearchIndexService,
     );
 
   const decode = (token: string) =>
@@ -330,6 +334,7 @@ describe('AuthService', () => {
         .mockResolvedValue({ restriction: null, deadline: null }),
       isEnabledInEngine: jest.fn().mockResolvedValue(false),
     };
+    searchIndex = { enrollAfterLogin: jest.fn().mockResolvedValue(undefined) };
     jwt = new JwtService({});
     service = build();
 
@@ -396,6 +401,22 @@ describe('AuthService', () => {
       expect(directory.recordLogin).not.toHaveBeenCalled();
     });
 
+    it('로그인에 성공한 직원의 검색 색인 상태 줄을 만든다 (14단계) — 실패한 로그인 · 코드를 기다리는 로그인은 만들지 않는다', async () => {
+      await service.login(ARA, PASSWORD, CLIENT_IP);
+      expect(searchIndex.enrollAfterLogin).toHaveBeenCalledWith(ARA);
+
+      searchIndex.enrollAfterLogin.mockClear();
+      mail.verifyCredentials.mockResolvedValue(INVALID);
+      expect(
+        (await failureOf(service.login(ARA, 'wrong', CLIENT_IP)))?.code,
+      ).toBe('AUTH_004');
+      mail.verifyCredentials.mockResolvedValue(TWO_FACTOR);
+      expect((await service.login(ARA, PASSWORD, CLIENT_IP)).status).toBe(
+        'twoFactorRequired',
+      );
+      expect(searchIndex.enrollAfterLogin).not.toHaveBeenCalled();
+    });
+
     it('사내 목록 기록에 실패해도 로그인은 성공한다 — 경고만 남긴다 (주소는 가려서)', async () => {
       directory.recordLogin.mockRejectedValue(new Error('db down'));
 
@@ -915,6 +936,20 @@ describe('AuthService', () => {
       await expect(rotateFrom(colleague)).resolves.toEqual(expect.any(String));
     });
 
+    it('비밀번호가 바뀌면 검색 색인의 멈춤을 풀고 줄을 만든다 (14단계 — 만료로 멈춘 색인) · 바뀌지 않았으면 하지 않는다', async () => {
+      const current = await loginToken();
+      searchIndex.enrollAfterLogin.mockClear();
+
+      mail.changePassword.mockResolvedValueOnce('new-password-rejected');
+      expect((await failureOf(change(PASSWORD, current)))?.code).toBe(
+        'VAL_001',
+      );
+      expect(searchIndex.enrollAfterLogin).not.toHaveBeenCalled();
+
+      await expect(change(PASSWORD, current)).resolves.toBeUndefined();
+      expect(searchIndex.enrollAfterLogin).toHaveBeenCalledWith(ARA);
+    });
+
     it('리프레시 쿠키가 없거나 · 위조거나 · 다른 직원의 것이면 이 세션을 알 수 없어 그 직원의 세션을 모두 끊는다', async () => {
       const colleague = (await service.login(DOYUN, PASSWORD, CLIENT_IP))
         .tokens!.refreshToken;
@@ -1806,6 +1841,8 @@ describe('AuthService', () => {
       expect(decode(result.tokens.accessToken).rst).toBe('passwordChange');
       // 만료된 계정의 이름(@ 앞)으로 사내 목록을 덮지 않는다
       expect(directory.recordLogin).not.toHaveBeenCalled();
+      // 대리 접근이 막혀 있다 — 검색 색인의 멈춤을 풀지 않는다 (14단계)
+      expect(searchIndex.enrollAfterLogin).not.toHaveBeenCalled();
       // 성공한 로그인이다 — 실패로 세지 않고 기록에 성공으로 남는다
       expect(loginEvents.recordSignIn).toHaveBeenCalledWith(
         expect.objectContaining({ email: ARA, isSuccess: true }),
diff --git a/backend/src/modules/auth/auth.service.ts b/backend/src/modules/auth/auth.service.ts
index ca8092f..69ad584 100644
--- a/backend/src/modules/auth/auth.service.ts
+++ b/backend/src/modules/auth/auth.service.ts
@@ -33,6 +33,7 @@ import type {
   PasswordChangeOutcome,
 } from '@/modules/mail/mail.types';
 import { MailDirectoryService } from '@/modules/mail-directory/mail-directory.service';
+import { MailSearchIndexService } from '@/modules/mail-search/mail-search-index.service';
 import { traceTag } from '@/shared/logger/request-context';
 import { maskEmail } from '@/shared/utils/mask';
 import { truncateUserAgent } from '@/shared/utils/user-agent';
@@ -208,6 +209,8 @@ export class AuthService {
     private readonly appPasswords: AppPasswordsService,
     /** 13단계 — 2단계 인증 필수 정책 (제한 twoFactorSetup · 유예의 시작 시각) */
     private readonly twoFactorPolicy: TwoFactorPolicyService,
+    /** 14단계 — 로그인한 직원의 검색 색인 상태 줄 (처음이면 만들고, 멈춰 있으면 푼다 — 던지지 않는다) */
+    private readonly searchIndex: MailSearchIndexService,
   ) {}
 
   /**
@@ -329,6 +332,9 @@ export class AuthService {
     const tokens = await this.startSession(profile, client, state);
     // 만료된 계정의 이름은 주소의 @ 앞뿐이다 — 사내 목록의 이름을 덮지 않는다 (바꾼 뒤의 로그인이 진짜 이름으로 남긴다)
     if (!passwordExpired) await this.recordInDirectory(profile);
+    // 검색 색인(14단계) — 만료된 계정은 대리 접근이 막혀 있어 멈춤을 풀지 않는다 (비밀번호를 바꾸면 changePassword 가 푼다)
+    if (!passwordExpired)
+      await this.searchIndex.enrollAfterLogin(profile.email);
     await this.loginEvents.recordSignIn({
       method: signInMethodOf(client),
       email: profile.email,
@@ -585,6 +591,8 @@ export class AuthService {
         refreshToken,
         twoFactorEnabled,
       );
+      // 검색 색인(14단계) — 비밀번호가 바뀌었으니(만료도 풀렸다) 대리 접근이 다시 된다: 멈춘 줄을 풀고, 없던 줄은 만든다 (던지지 않는다)
+      await this.searchIndex.enrollAfterLogin(address);
     } finally {
       releaseLock?.();
     }
diff --git a/backend/src/modules/mail-search/conversation-cursor.spec.ts b/backend/src/modules/mail-search/conversation-cursor.spec.ts
new file mode 100644
index 0000000..8b39a5a
--- /dev/null
+++ b/backend/src/modules/mail-search/conversation-cursor.spec.ts
@@ -0,0 +1,107 @@
+import { BusinessException } from '@/common/errors/business.exception';
+import { encodeCursor } from '@/modules/mail/jmap/jmap-cursor';
+import {
+  conversationCursorMethod,
+  decodeConversationCursor,
+  encodeConversationCursor,
+} from './conversation-cursor';
+import { encodeIndexCursor } from './search-cursor';
+
+function codeOf(run: () => unknown): string | null {
+  try {
+    run();
+    return null;
+  } catch (error) {
+    return error instanceof BusinessException ? error.code : 'NOT_BUSINESS';
+  }
+}
+
+describe('대화 커서 (conversation-cursor — 14단계 C3 · C4)', () => {
+  const position = { at: new Date('2026-11-02T01:23:45.678Z'), key: 'm9x' };
+
+  it('자리를 그대로 되돌린다 — 같은 대화는 그 메일, 묶은 목록은 그 메일함 범위에서만', () => {
+    const thread = encodeConversationCursor('thread', position, 'e1');
+    const list = encodeConversationCursor('list', position, 'inbox');
+    expect(thread).toMatch(/^[A-Za-z0-9_-]+$/);
+    expect(decodeConversationCursor('thread', thread, 'e1')).toEqual(position);
+    expect(decodeConversationCursor('list', list, 'inbox')).toEqual(position);
+
+    // 다른 메일 · 다른 메일함 · 다른 종류의 커서는 VAL_001
+    expect(codeOf(() => decodeConversationCursor('thread', thread, 'e2'))).toBe(
+      'VAL_001',
+    );
+    expect(codeOf(() => decodeConversationCursor('list', list, 'sent'))).toBe(
+      'VAL_001',
+    );
+    expect(codeOf(() => decodeConversationCursor('list', thread, 'e1'))).toBe(
+      'VAL_001',
+    );
+  });
+
+  it('방식을 커서로 안다 — 그 종류의 색인 커서만 index, 엔진 · 검색 커서 · 알 수 없는 값은 engine', () => {
+    expect(
+      conversationCursorMethod(
+        encodeConversationCursor('thread', position, 'e1'),
+        'thread',
+      ),
+    ).toBe('index');
+    expect(
+      conversationCursorMethod(
+        encodeConversationCursor('list', position, 'inbox'),
+        'thread',
+      ),
+    ).toBe('engine');
+    expect(
+      conversationCursorMethod(
+        encodeCursor(
+          { anchor: 'm1', position: 3 },
+          { conditions: ['conversation', 'e1'] },
+        ),
+        'thread',
+      ),
+    ).toBe('engine');
+    expect(
+      conversationCursorMethod(
+        encodeIndexCursor({ receivedAt: position.at, emailId: 'm1' }, 'scope'),
+        'list',
+      ),
+    ).toBe('engine');
+    for (const cursor of ['', 'not-a-cursor', 'a'.repeat(600)]) {
+      expect(conversationCursorMethod(cursor, 'list')).toBe('engine');
+    }
+
+    // `m` 만 맞은 꾸민 커서는 색인 커서로 본다 — 나머지 모양은 decode 가 VAL_001 로 (서비스 입구 — 리뷰 L1)
+    const onlyMethod = Buffer.from(JSON.stringify({ m: 'ti' })).toString(
+      'base64url',
+    );
+    expect(conversationCursorMethod(onlyMethod, 'thread')).toBe('index');
+    expect(
+      codeOf(() => decodeConversationCursor('thread', onlyMethod, 'e1')),
+    ).toBe('VAL_001');
+    expect(conversationCursorMethod(onlyMethod, 'list')).toBe('engine');
+  });
+
+  it('모양이 틀린 커서는 VAL_001 — 시각이 날짜가 아님 · 이상한 키 · 너무 긴 값', () => {
+    const real = JSON.parse(
+      Buffer.from(
+        encodeConversationCursor('list', position, 'inbox'),
+        'base64url',
+      ).toString('utf8'),
+    ) as Record<string, unknown>;
+    const forge = (patch: Record<string, unknown>) =>
+      Buffer.from(JSON.stringify({ ...real, ...patch })).toString('base64url');
+    for (const cursor of [
+      forge({ t: 9e15 }),
+      forge({ t: -1 }),
+      forge({ k: '../x' }),
+      forge({ k: 'k'.repeat(65) }),
+      forge({ v: 2 }),
+      'not-json',
+      'a'.repeat(600),
+    ]) {
+      expect(
+        codeOf(() => decodeConversationCursor('list', cursor, 'inbox')),
+      ).toBe('VAL_001');
+    }
+  });
+});
diff --git a/backend/src/modules/mail-search/conversation-cursor.ts b/backend/src/modules/mail-search/conversation-cursor.ts
new file mode 100644
index 0000000..ed95100
--- /dev/null
+++ b/backend/src/modules/mail-search/conversation-cursor.ts
@@ -0,0 +1,122 @@
+import { createHash } from 'crypto';
+
+import { BusinessException } from '@/common/errors/business.exception';
+import { MAIL_ID_PATTERN } from '@/modules/mail/mail.constants';
+import { SEARCH_ID_COLUMN_LENGTH } from './mail-search.constants';
+
+/**
+ * 색인으로 본 대화의 커서 (14단계 설계 C3 · C4 — 클라이언트에게는 불투명 문자열).
+ * - 같은 대화(`m: 'ti'`): `{ v: 1, m, t: 받은 시각(ms), k: 메일 id, s }` — 그 줄 다음(오래된 차례 — 받은 시각 · id 가 더 큰 쪽)부터
+ * - 묶은 목록(`m: 'li'`): `{ v: 1, m, t: 그 메일함 안 마지막 받은 시각(ms), k: 대화 키, s }` — 그 대화 다음(최신 차례 — 더 작은 쪽)부터
+ * 방식(m)이 커서에 실려 쪽을 넘기는 중에 색인이 준비되거나 다시 채우기에 들어가도 처음 방식대로 이어 간다 — 엔진 방식의 커서(jmap-cursor.ts — `m` 이 없다)는 엔진으로.
+ * `m` 이 그 종류의 방식이면 색인 커서로 보고 나머지 모양은 서비스 입구에서 decode 로 본다(엔진 · DB 에 묻기 전에 VAL_001 — 3차 리뷰 L1).
+ * 범위 지문(s)에는 그 메일 id(같은 대화) · 메일함 id(묶은 목록)가 든다 — 다른 대화 · 메일함의 커서를 섞어 쓰면 VAL_001
+ */
+const CURSOR_VERSION = 1;
+const MAX_CURSOR_LENGTH = 512;
+const SCOPE_HASH_LENGTH = 16;
+/** 대화 키 · 메일 id 의 최대 길이 — 표의 열(thread_key · email_id) */
+const MAX_KEY_LENGTH = SEARCH_ID_COLUMN_LENGTH;
+
+/** 커서의 종류 */
+export type ConversationCursorKind = 'thread' | 'list';
+
+const METHOD: Readonly<Record<ConversationCursorKind, string>> = {
+  thread: 'ti',
+  list: 'li',
+};
+
+/** 이어 갈 자리 — 받은 시각과 그 줄(같은 대화는 메일 id, 묶은 목록은 대화 키) */
+export interface ConversationPosition {
+  readonly at: Date;
+  readonly key: string;
+}
+
+interface EncodedCursor {
+  v: number;
+  m: string;
+  t: number;
+  k: string;
+  s: string;
+}
+
+function scopeHash(kind: ConversationCursorKind, scope: string): string {
+  return createHash('sha256')
+    .update(JSON.stringify([kind, scope]))
+    .digest('base64url')
+    .slice(0, SCOPE_HASH_LENGTH);
+}
+
+function invalidCursor(reason: string): BusinessException {
+  return new BusinessException('VAL_001', {
+    context: { reason: `invalid-cursor:${reason}` },
+  });
+}
+
+/**
+ * 방식 — `m` 이 그 종류의 색인 방식이면 'index'(판 · 시각 · 키 · 지문은 decodeConversationCursor 가 본다 — 틀리면 VAL_001),
+ * 아니면 'engine'(엔진 쪽 커서 — 모양이 틀리면 엔진 쪽 decode 가 VAL_001)
+ */
+export function conversationCursorMethod(
+  cursor: string,
+  kind: ConversationCursorKind,
+): 'index' | 'engine' {
+  if (cursor.length > MAX_CURSOR_LENGTH) return 'engine';
+  try {
+    const parsed = JSON.parse(
+      Buffer.from(cursor, 'base64url').toString('utf8'),
+    ) as unknown;
+    return typeof parsed === 'object' &&
+      parsed !== null &&
+      (parsed as Partial<EncodedCursor>).m === METHOD[kind]
+      ? 'index'
+      : 'engine';
+  } catch {
+    return 'engine';
+  }
+}
+
+export function encodeConversationCursor(
+  kind: ConversationCursorKind,
+  position: ConversationPosition,
+  scope: string,
+): string {
+  const payload: EncodedCursor = {
+    v: CURSOR_VERSION,
+    m: METHOD[kind],
+    t: position.at.getTime(),
+    k: position.key,
+    s: scopeHash(kind, scope),
+  };
+  return Buffer.from(JSON.stringify(payload)).toString('base64url');
+}
+
+/** 커서를 읽는다 — 모양이 틀리거나 다른 대화 · 메일함의 커서면 VAL_001 */
+export function decodeConversationCursor(
+  kind: ConversationCursorKind,
+  cursor: string,
+  scope: string,
+): ConversationPosition {
+  if (cursor.length > MAX_CURSOR_LENGTH) throw invalidCursor('too-long');
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'));
+  } catch {
+    throw invalidCursor('not-json');
+  }
+  const { v, m, t, k, s } = (parsed ?? {}) as Partial<EncodedCursor>;
+  const valid =
+    v === CURSOR_VERSION &&
+    m === METHOD[kind] &&
+    typeof t === 'number' &&
+    Number.isSafeInteger(t) &&
+    t >= 0 &&
+    Number.isFinite(new Date(t).getTime()) &&
+    typeof k === 'string' &&
+    k.length <= MAX_KEY_LENGTH &&
+    MAIL_ID_PATTERN.test(k) &&
+    typeof s === 'string';
+  if (!valid) throw invalidCursor('shape');
+  if (s !== scopeHash(kind, scope)) throw invalidCursor('other-list');
+  return { at: new Date(t), key: k };
+}
diff --git a/backend/src/modules/mail-search/conversation-sql.spec.ts b/backend/src/modules/mail-search/conversation-sql.spec.ts
new file mode 100644
index 0000000..5eb9645
--- /dev/null
+++ b/backend/src/modules/mail-search/conversation-sql.spec.ts
@@ -0,0 +1,154 @@
+import {
+  conversationDetailsSql,
+  conversationPageSql,
+  conversationParticipantsSql,
+  mailboxConversationsSql,
+} from './conversation-sql';
+
+const USER = 'ara.kim@arasystem.test';
+const EXCLUSIONS = {
+  excludedMailboxIds: ['b', 'c'],
+  excludedKeywords: ['$ara-sending'],
+};
+
+const flat = (sql: string) => sql.replace(/\s+/g, ' ');
+
+describe('대화의 SQL (conversation-sql — 14단계 C3 · C4)', () => {
+  it('같은 대화 한 쪽 — 그 메일의 대화 키를 같은 문장에서 읽고(리뷰 L2), 오래된 차례 · 빼는 메일함에만 든 메일 · 내부 발송 초안은 빼되 지금 메일은 넣고, 이어 갈 자리 다음부터', () => {
+    const after = { at: new Date('2026-11-01T00:00:00Z'), key: 'm3' };
+    const query = conversationPageSql(USER, 'm5', EXCLUSIONS, after, 101);
+
+    expect(flat(query.sql)).toBe(
+      'SELECT "page"."email_id", "page"."received_at", "page"."total" ' +
+        'FROM (SELECT "thread_key" FROM "mail_search_messages" WHERE "user_email" = $1 AND "email_id" = $2) AS "current" ' +
+        'LEFT JOIN LATERAL (SELECT "email_id", "received_at", count(*) OVER ()::int AS "total" FROM "mail_search_messages" ' +
+        'WHERE "user_email" = $1 AND "thread_key" = "current"."thread_key" ' +
+        'AND ((NOT ("mailbox_ids" <@ $3::text[]) AND NOT ("keywords" && $4::text[])) OR "email_id" = $2) ' +
+        'AND ("received_at", "email_id") > ($5::timestamptz, $6) ' +
+        'ORDER BY "received_at" ASC, "email_id" ASC LIMIT $7) AS "page" ON TRUE ' +
+        'ORDER BY "page"."received_at" ASC, "page"."email_id" ASC',
+    );
+    expect(query.params).toEqual([
+      USER,
+      'm5',
+      ['b', 'c'],
+      ['$ara-sending'],
+      after.at,
+      'm3',
+      101,
+    ]);
+
+    // 빼는 키워드만 있어도 지금 메일은 넣는다
+    const keywordOnly = conversationPageSql(
+      USER,
+      'm5',
+      { excludedMailboxIds: [], excludedKeywords: ['$ara-sending'] },
+      null,
+      10,
+    );
+    expect(flat(keywordOnly.sql)).toContain(
+      'AND ((NOT ("keywords" && $3::text[])) OR "email_id" = $2) ORDER BY',
+    );
+  });
+
+  it('묶은 목록 한 쪽 — 그 직원의 줄(주소 btree)에서 메일함은 GIN 을 못 쓰는 꼴(= ANY)로 거른 뒤 대화 키로 묶는다', () => {
+    const query = mailboxConversationsSql(USER, 'a', EXCLUSIONS, null, 21);
+
+    expect(flat(query.sql)).toBe(
+      'SELECT "thread_key", max("received_at") AS "latest_at", count(*) OVER ()::int AS "total" FROM "mail_search_messages" ' +
+        'WHERE "user_email" = $1 AND $2 = ANY("mailbox_ids") AND NOT ("keywords" && $3::text[]) ' +
+        'GROUP BY "thread_key" ORDER BY "latest_at" DESC, "thread_key" DESC LIMIT $4',
+    );
+    expect(query.params).toEqual([USER, 'a', ['$ara-sending'], 21]);
+    expect(query.sql).not.toContain('"mailbox_ids" @>');
+
+    const next = mailboxConversationsSql(
+      USER,
+      'a',
+      EXCLUSIONS,
+      { at: new Date('2026-11-01T00:00:00Z'), key: 'k9' },
+      21,
+    );
+    expect(flat(next.sql)).toContain(
+      'GROUP BY "thread_key" HAVING (max("received_at"), "thread_key") < ($4::timestamptz, $5) ORDER BY',
+    );
+  });
+
+  it('묶은 목록의 자세히 — 그 쪽의 대화 키만, 통 수는 대화 전체(빼는 메일함에만 든 메일 빼고 — 그 메일함 것은 넣고), 그 메일함 안 id 는 최신부터 상한까지(리뷰 L4) · 보낸 사람 글은 끌어오지 않는다', () => {
+    const query = conversationDetailsSql(
+      USER,
+      'a',
+      ['k1', 'k2'],
+      EXCLUSIONS,
+      500,
+    );
+    const sql = flat(query.sql);
+
+    expect(sql).toContain(
+      'WHERE "user_email" = $1 AND "thread_key" = ANY($2::text[]) AND NOT ("keywords" && $8::text[]) GROUP BY "thread_key"',
+    );
+    expect(sql).toContain(
+      'count(*) FILTER (WHERE (NOT ("mailbox_ids" <@ $4::text[]) OR $3 = ANY("mailbox_ids")))::int AS "message_count"',
+    );
+    expect(sql).toContain(
+      '(array_agg("email_id" ORDER BY "received_at" DESC, "email_id" DESC) FILTER (WHERE $3 = ANY("mailbox_ids")))[1:$7::int] AS "mailbox_message_ids"',
+    );
+    expect(sql).not.toContain('from_text');
+    expect(query.params).toEqual([
+      USER,
+      ['k1', 'k2'],
+      'a',
+      ['b', 'c'],
+      '$seen',
+      '$flagged',
+      500,
+      ['$ara-sending'],
+    ]);
+  });
+
+  it('묶은 목록의 참여자 — 첫 보낸 사람 칸에서 주소(소문자)마다 처음 보낸 메일 하나, 그 차례로 상한까지 · 대화마다 (리뷰 L3 · L4)', () => {
+    const query = conversationParticipantsSql(
+      USER,
+      'a',
+      ['k1', 'k2'],
+      EXCLUSIONS,
+      10,
+    );
+    const sql = flat(query.sql);
+
+    expect(sql).toContain('FROM unnest($2::text[]) AS "keys"("thread_key")');
+    expect(sql).toContain(
+      'SELECT DISTINCT ON (lower("from_email")) "from_email", "from_name", "received_at", "email_id" FROM "mail_search_messages" ' +
+        'WHERE "user_email" = $1 AND "thread_key" = "keys"."thread_key" AND "from_email" IS NOT NULL ' +
+        'AND (NOT ("mailbox_ids" <@ $4::text[]) OR $3 = ANY("mailbox_ids")) AND NOT ("keywords" && $5::text[]) ' +
+        'ORDER BY lower("from_email"), "received_at" ASC, "email_id" ASC',
+    );
+    expect(sql).toContain(
+      'ORDER BY "senders"."received_at" ASC, "senders"."email_id" ASC LIMIT $6) AS "first"',
+    );
+    expect(sql).not.toContain('from_text');
+    expect(query.params).toEqual([
+      USER,
+      ['k1', 'k2'],
+      'a',
+      ['b', 'c'],
+      ['$ara-sending'],
+      10,
+    ]);
+  });
+
+  it('빼는 것이 없으면 조건도 없다 (지금 메일의 예외도 없다)', () => {
+    const none = { excludedMailboxIds: [], excludedKeywords: [] };
+    const page = conversationPageSql(USER, 'm5', none, null, 10);
+    expect(flat(page.sql)).toContain(
+      'WHERE "user_email" = $1 AND "thread_key" = "current"."thread_key" ORDER BY',
+    );
+    expect(page.params).toEqual([USER, 'm5', 10]);
+
+    const details = conversationDetailsSql(USER, 'a', ['k1'], none, 500);
+    expect(flat(details.sql)).toContain(
+      'count(*) FILTER (WHERE TRUE)::int AS "message_count"',
+    );
+    expect(flat(details.sql)).toContain('AND TRUE GROUP BY "thread_key"');
+  });
+});
diff --git a/backend/src/modules/mail-search/conversation-sql.ts b/backend/src/modules/mail-search/conversation-sql.ts
new file mode 100644
index 0000000..0dfb4b8
--- /dev/null
+++ b/backend/src/modules/mail-search/conversation-sql.ts
@@ -0,0 +1,207 @@
+import {
+  FLAGGED_KEYWORD,
+  SEARCH_MESSAGES_TABLE,
+  SEEN_KEYWORD,
+} from './mail-search.constants';
+import type { ConversationPosition } from './conversation-cursor';
+import type { SqlQuery } from './search-sql';
+
+/**
+ * 대화의 SQL (순수 함수 — 14단계 설계 C3 · C4). 값은 모두 매개변수다.
+ * 언제나 그 직원 주소(`"user_email" = $1` — btree)로 먼저 좁힌다. 메일함 조건은 `$n = ANY("mailbox_ids")` 로 적는다 —
+ * 메일함의 posting 은 회사 전체라(메일함 id 가 계정마다 같은 꼴) GIN 으로 거르지 않고 그 직원의 줄에서만 거른다(리뷰).
+ * 메일함 칸을 담은 GIN 은 찾기 GIN(lower 식 · 묶음 · 메일함) 하나뿐이고 이 쿼리들은 그것을 쓰지 않는다
+ */
+
+const TABLE = `"${SEARCH_MESSAGES_TABLE}"`;
+
+/** 대화에서 빼는 것 — 빼는 메일함에만 든 메일 · 빼는 키워드(내부 발송 초안) */
+export interface ConversationExclusions {
+  readonly excludedMailboxIds: readonly string[];
+  readonly excludedKeywords: readonly string[];
+}
+
+/** 매개변수를 차례로 쌓는다 */
+class Params {
+  readonly values: unknown[] = [];
+
+  add(value: unknown): string {
+    this.values.push(value);
+    return `$${this.values.length}`;
+  }
+}
+
+/** 빼는 키워드 — 없으면 늘 참 */
+function keywordCondition(
+  params: Params,
+  exclusions: ConversationExclusions,
+): string {
+  return exclusions.excludedKeywords.length > 0
+    ? `NOT ("keywords" && ${params.add([...exclusions.excludedKeywords])}::text[])`
+    : 'TRUE';
+}
+
+/** 빼는 메일함에만 든 메일이 아니다 — 없으면 늘 참 */
+function mailboxCondition(
+  params: Params,
+  exclusions: ConversationExclusions,
+): string {
+  return exclusions.excludedMailboxIds.length > 0
+    ? `NOT ("mailbox_ids" <@ ${params.add([...exclusions.excludedMailboxIds])}::text[])`
+    : 'TRUE';
+}
+
+/**
+ * 같은 대화 한 쪽 — 지금 보는 메일(`emailId`)의 대화 키를 같은 문장에서 읽어(3차 리뷰 L2 — 키를 읽은 뒤 그 키가 합쳐져 빈 쪽이 나오지 않게 · 왕복 하나)
+ * 그 키의 줄을 오래된 차례(받은 시각 · id)로, `after` 다음부터 `limit` 줄. 빼는 메일함에만 든 메일 · 빼는 키워드의 메일(내부 발송 초안)은 빼되
+ * 지금 보는 메일은 넣는다(엔진 방식 `jmap-conversations.ts` 의 inConversation 과 같다).
+ * - 그 메일이 색인에 없으면 줄이 없다. 있는데 쪽이 비면 `email_id` 가 null 인 줄 하나다(LEFT JOIN LATERAL) — 둘을 가른다
+ * - `total` 은 이 쪽의 조건(이어 갈 자리 빼고)에 맞는 줄 수 — 첫 쪽에서만 쓴다
+ */
+export function conversationPageSql(
+  user: string,
+  emailId: string,
+  exclusions: ConversationExclusions,
+  after: ConversationPosition | null,
+  limit: number,
+): SqlQuery {
+  const params = new Params();
+  const user$ = params.add(user);
+  const email$ = params.add(emailId);
+  const where = [
+    `"user_email" = ${user$}`,
+    `"thread_key" = "current"."thread_key"`,
+  ];
+  const kept = [
+    mailboxCondition(params, exclusions),
+    keywordCondition(params, exclusions),
+  ].filter((condition) => condition !== 'TRUE');
+  if (kept.length > 0) {
+    where.push(`((${kept.join(' AND ')}) OR "email_id" = ${email$})`);
+  }
+  if (after !== null) {
+    where.push(
+      `("received_at", "email_id") > (${params.add(after.at)}::timestamptz, ${params.add(after.key)})`,
+    );
+  }
+  return {
+    sql:
+      `SELECT "page"."email_id", "page"."received_at", "page"."total"` +
+      ` FROM (SELECT "thread_key" FROM ${TABLE} WHERE "user_email" = ${user$} AND "email_id" = ${email$}) AS "current"` +
+      ` LEFT JOIN LATERAL (SELECT "email_id", "received_at", count(*) OVER ()::int AS "total" FROM ${TABLE}` +
+      ` WHERE ${where.join(' AND ')} ORDER BY "received_at" ASC, "email_id" ASC LIMIT ${params.add(limit)}) AS "page" ON TRUE` +
+      ` ORDER BY "page"."received_at" ASC, "page"."email_id" ASC`,
+    params: params.values,
+  };
+}
+
+/**
+ * 묶은 목록 한 쪽 — 그 메일함 안의 대화(대화 키)마다 그 메일함 안 마지막 받은 시각, 최신부터 `limit` 개.
+ * 그 직원의 줄(주소 btree)에서만 메일함 · 키워드로 거른 뒤 대화 키로 묶는다. `after` 면 그 대화 다음부터(받은 시각 · 키가 더 작은 쪽).
+ * `total` 은 묶은 대화 수(이어 갈 자리 다음의 것) — 첫 쪽에서만 쓴다
+ */
+export function mailboxConversationsSql(
+  user: string,
+  mailboxId: string,
+  exclusions: ConversationExclusions,
+  after: ConversationPosition | null,
+  limit: number,
+): SqlQuery {
+  const params = new Params();
+  const where = [
+    `"user_email" = ${params.add(user)}`,
+    `${params.add(mailboxId)} = ANY("mailbox_ids")`,
+    keywordCondition(params, exclusions),
+  ];
+  const having =
+    after === null
+      ? ''
+      : ` HAVING (max("received_at"), "thread_key") < (${params.add(after.at)}::timestamptz, ${params.add(after.key)})`;
+  return {
+    sql: `SELECT "thread_key", max("received_at") AS "latest_at", count(*) OVER ()::int AS "total" FROM ${TABLE} WHERE ${where.join(' AND ')} GROUP BY "thread_key"${having} ORDER BY "latest_at" DESC, "thread_key" DESC LIMIT ${params.add(limit)}`,
+    params: params.values,
+  };
+}
+
+/**
+ * 묶은 목록의 대화마다 자세히 — 그 쪽의 대화 키만(주소 + 대화 키 btree).
+ * - 대화 전체(빼는 메일함에만 든 메일은 빼되 그 메일함의 메일은 넣는다): 통 수
+ * - 그 메일함 안: 메일 id(최신부터 `maxIds` 통까지 — 첫째가 마지막 메일, 3차 리뷰 L4) · 모두 읽음 · 하나라도 중요 · 하나라도 첨부
+ * 참여자는 conversationParticipantsSql 이 따로 읽는다(주소마다 한 번 · 상한까지 — 대화 전체의 보낸 사람 글을 끌어오지 않는다)
+ */
+export function conversationDetailsSql(
+  user: string,
+  mailboxId: string,
+  threadKeys: readonly string[],
+  exclusions: ConversationExclusions,
+  maxIds: number,
+): SqlQuery {
+  const params = new Params();
+  const user$ = params.add(user);
+  const keys$ = params.add([...threadKeys]);
+  const mailbox$ = params.add(mailboxId);
+  const inMailbox = `${mailbox$} = ANY("mailbox_ids")`;
+  const kept = keptInConversation(params, exclusions, inMailbox);
+  const seen$ = params.add(SEEN_KEYWORD);
+  const flagged$ = params.add(FLAGGED_KEYWORD);
+  const maxIds$ = params.add(maxIds);
+  const keywords = keywordCondition(params, exclusions);
+  return {
+    sql:
+      `SELECT "thread_key",` +
+      ` count(*) FILTER (WHERE ${kept})::int AS "message_count",` +
+      ` (array_agg("email_id" ORDER BY "received_at" DESC, "email_id" DESC) FILTER (WHERE ${inMailbox}))[1:${maxIds$}::int] AS "mailbox_message_ids",` +
+      ` coalesce(bool_and(${seen$} = ANY("keywords")) FILTER (WHERE ${inMailbox}), true) AS "is_read",` +
+      ` coalesce(bool_or(${flagged$} = ANY("keywords")) FILTER (WHERE ${inMailbox}), false) AS "is_flagged",` +
+      ` coalesce(bool_or("has_attachment") FILTER (WHERE ${inMailbox}), false) AS "has_attachment"` +
+      ` FROM ${TABLE} WHERE "user_email" = ${user$} AND "thread_key" = ANY(${keys$}::text[]) AND ${keywords} GROUP BY "thread_key"`,
+    params: params.values,
+  };
+}
+
+/**
+ * 묶은 목록의 대화마다 참여자 — 첫 보낸 사람 칸(from_email · from_name — 3차 리뷰 L3)에서 주소(소문자)마다 처음 보낸 메일 하나,
+ * 그 차례(받은 시각 · id)로 `max` 명까지(대화마다 LATERAL — 주소 + 대화 키 btree). 대화의 범위는 자세히(통 수)와 같다
+ */
+export function conversationParticipantsSql(
+  user: string,
+  mailboxId: string,
+  threadKeys: readonly string[],
+  exclusions: ConversationExclusions,
+  max: number,
+): SqlQuery {
+  const params = new Params();
+  const user$ = params.add(user);
+  const keys$ = params.add([...threadKeys]);
+  const mailbox$ = params.add(mailboxId);
+  const kept = keptInConversation(
+    params,
+    exclusions,
+    `${mailbox$} = ANY("mailbox_ids")`,
+  );
+  const keywords = keywordCondition(params, exclusions);
+  const max$ = params.add(max);
+  return {
+    sql:
+      `SELECT "keys"."thread_key", "first"."from_email", "first"."from_name"` +
+      ` FROM unnest(${keys$}::text[]) AS "keys"("thread_key")` +
+      ` CROSS JOIN LATERAL (SELECT "senders"."from_email", "senders"."from_name", "senders"."received_at", "senders"."email_id" FROM (` +
+      `SELECT DISTINCT ON (lower("from_email")) "from_email", "from_name", "received_at", "email_id" FROM ${TABLE}` +
+      ` WHERE "user_email" = ${user$} AND "thread_key" = "keys"."thread_key" AND "from_email" IS NOT NULL AND ${kept} AND ${keywords}` +
+      ` ORDER BY lower("from_email"), "received_at" ASC, "email_id" ASC) AS "senders"` +
+      ` ORDER BY "senders"."received_at" ASC, "senders"."email_id" ASC LIMIT ${max$}) AS "first"` +
+      ` ORDER BY "keys"."thread_key", "first"."received_at" ASC, "first"."email_id" ASC`,
+    params: params.values,
+  };
+}
+
+/** 대화에 드는 줄 — 빼는 메일함에만 든 메일이 아니거나 `orCondition`(그 메일함의 메일) */
+function keptInConversation(
+  params: Params,
+  exclusions: ConversationExclusions,
+  orCondition: string,
+): string {
+  return exclusions.excludedMailboxIds.length > 0
+    ? `(NOT ("mailbox_ids" <@ ${params.add([...exclusions.excludedMailboxIds])}::text[]) OR ${orCondition})`
+    : 'TRUE';
+}
diff --git a/backend/src/modules/mail-search/dto/search-index-status.dto.ts b/backend/src/modules/mail-search/dto/search-index-status.dto.ts
new file mode 100644
index 0000000..a370f54
--- /dev/null
+++ b/backend/src/modules/mail-search/dto/search-index-status.dto.ts
@@ -0,0 +1,32 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+import type {
+  SearchIndexStatus,
+  SearchIndexStatusView,
+} from '@/modules/mail-search/mail-search.types';
+
+/** GET /api/search-index 의 응답 (14단계 — 화면의 "검색 준비 중" 줄) */
+export class SearchIndexStatusDto implements SearchIndexStatusView {
+  @ApiProperty({
+    description:
+      '색인 상태 — building: 지난 메일을 채우는 중(그동안 검색은 엔진 방식 — 낱말이 통째로 같은 메일만) · ready: 다 만들었음',
+    enum: ['building', 'ready'],
+    example: 'building',
+  })
+  status!: SearchIndexStatus;
+
+  @ApiProperty({
+    description: '채운 메일 수 — 다 만들었으면 그때 색인에 든 수',
+    example: 1200,
+  })
+  done!: number;
+
+  @ApiProperty({
+    description:
+      '채울 메일 수(채우기를 시작할 때의 메일 수) — 아직 시작하지 않았으면 null. 다 만들었으면 done 과 같다',
+    type: Number,
+    nullable: true,
+    example: 4800,
+  })
+  total!: number | null;
+}
diff --git a/backend/src/modules/mail-search/index-document.spec.ts b/backend/src/modules/mail-search/index-document.spec.ts
new file mode 100644
index 0000000..6bba378
--- /dev/null
+++ b/backend/src/modules/mail-search/index-document.spec.ts
@@ -0,0 +1,232 @@
+import { startCpuTimer } from '@/../test/cpu-time';
+import {
+  firstSender,
+  isIndexableId,
+  referencesOf,
+  storableText,
+  takeCodePoints,
+  toIndexRow,
+} from './index-document';
+import type { IndexDocument } from './mail-index-source';
+import {
+  INDEX_ADDRESSES_MAX,
+  INDEX_BODY_MAX_CHARS,
+  INDEX_FROM_NAME_MAX_CHARS,
+  INDEX_REFS_MAX,
+  INDEX_SUBJECT_MAX_CHARS,
+  SEARCH_EMAIL_COLUMN_LENGTH,
+} from './mail-search.constants';
+
+function documentOf(overrides: Partial<IndexDocument> = {}): IndexDocument {
+  return {
+    id: 'e1',
+    threadId: 't1',
+    mailboxIds: ['inbox'],
+    keywords: ['$seen'],
+    receivedAt: '2026-11-05T01:02:03Z',
+    size: 1234,
+    messageIds: ['m1@example.com'],
+    inReplyTo: [],
+    references: [],
+    subject: 'Re: [공지] 11월 계약서',
+    from: [{ name: '이도윤', email: 'doyun.lee@arasystem.test' }],
+    to: [{ name: null, email: 'ara.kim@arasystem.test' }],
+    cc: [{ name: 'Partner', email: 'partner@example.com' }],
+    attachmentNames: ['계약서.PDF'],
+    hasAttachment: true,
+    preview: '계약서를 보내 드립니다',
+    bodyText: '안녕하세요.\n계약서를 보내 드립니다.',
+    ...overrides,
+  };
+}
+
+describe('toIndexRow (엔진의 메일 한 통 → 색인 한 줄)', () => {
+  it('원문은 NFC 그대로, 접기 칸은 소문자 · 반각 — 받는 사람 칸은 받는 사람과 참조를 함께', () => {
+    const row = toIndexRow(documentOf());
+    expect(row).toMatchObject({
+      emailId: 'e1',
+      mailboxIds: ['inbox'],
+      keywords: ['$seen'],
+      receivedAt: new Date('2026-11-05T01:02:03Z'),
+      size: 1234,
+      messageId: 'm1@example.com',
+      refs: [],
+      subject: 'Re: [공지] 11월 계약서',
+      subjectBase: '11월 계약서',
+      fromText: '이도윤 <doyun.lee@arasystem.test>',
+      toText: 'ara.kim@arasystem.test',
+      ccText: 'Partner <partner@example.com>',
+      attachmentNames: '계약서.PDF',
+      hasAttachment: true,
+      preview: '계약서를 보내 드립니다',
+      bodyText: '안녕하세요.\n계약서를 보내 드립니다.',
+      foldFrom: '이도윤 <doyun.lee@arasystem.test>',
+      // 공백류(줄바꿈 · 탭 등)는 띄어쓰기 하나로 접는다 — 1:1 이라 위치는 그대로 (색인 판 2)
+      foldTo: 'ara.kim@arasystem.test partner <partner@example.com>',
+      foldSubject: 're: [공지] 11월 계약서',
+      foldAttachment: '계약서.pdf',
+      foldBody: '안녕하세요. 계약서를 보내 드립니다.',
+      threadKey: 'e1',
+      engineThreadId: 't1',
+    });
+    // 묶음은 다섯 칸에서 — 칸 경계를 넘지 않는다 (보낸 사람 끝 + 받는 사람 처음 같은 묶음이 없다)
+    expect(row.grams).toEqual(
+      expect.arrayContaining(['계약', '약서', 're', '공지']),
+    );
+    expect(row.grams).not.toContain('>a');
+    expect(new Set(row.grams).size).toBe(row.grams.length);
+  });
+
+  it('PostgreSQL 에 넣을 수 없는 글자(NUL · 짝 없는 서로게이트)는 U+FFFD — 위치는 그대로', () => {
+    const row = toIndexRow(
+      documentOf({ subject: 'a\u0000b\ud800c', bodyText: '\udc00본문' }),
+    );
+    expect(row.subject).toBe('a\ufffdb\ufffdc');
+    expect(row.bodyText).toBe('\ufffd본문');
+    expect(row.foldSubject.length).toBe(row.subject.length);
+  });
+
+  it('풀어 쓴 한글(NFD)은 NFC 로 모은 원문을 담는다', () => {
+    const row = toIndexRow(
+      documentOf({ subject: '\u1112\u1161\u11ab\u1100\u1173\u11af 메일' }),
+    );
+    expect(row.subject).toBe('한글 메일');
+  });
+
+  it('본문은 앞 INDEX_BODY_MAX_CHARS 코드 포인트 · 제목도 상한까지 · 주소는 INDEX_ADDRESSES_MAX 개까지', () => {
+    const row = toIndexRow(
+      documentOf({
+        bodyText: '가'.repeat(INDEX_BODY_MAX_CHARS + 500),
+        subject: 'S'.repeat(INDEX_SUBJECT_MAX_CHARS * 2),
+        to: Array.from({ length: INDEX_ADDRESSES_MAX + 50 }, (_, index) => ({
+          name: null,
+          email: `p${index}@example.com`,
+        })),
+      }),
+    );
+    expect(row.bodyText).toHaveLength(INDEX_BODY_MAX_CHARS);
+    expect(row.subject).toHaveLength(INDEX_SUBJECT_MAX_CHARS);
+    expect(row.toText.split('\n')).toHaveLength(INDEX_ADDRESSES_MAX);
+  });
+
+  it('주소의 이름 · 주소 가운데 있는 것만 · 빈 첨부 이름은 뺀다 · 키워드 · 메일함은 겹치지 않게', () => {
+    const row = toIndexRow(
+      documentOf({
+        from: [
+          { name: '  ', email: 'a@example.com' },
+          { name: '이름만', email: null },
+          { name: null, email: null },
+        ],
+        attachmentNames: ['', '  보고서.hwp  '],
+        keywords: ['$seen', '$seen', '$flagged'],
+        mailboxIds: ['inbox', 'inbox'],
+      }),
+    );
+    expect(row.fromText).toBe('a@example.com\n이름만');
+    expect(row.attachmentNames).toBe('보고서.hwp');
+    expect(row.keywords).toEqual(['$seen', '$flagged']);
+    expect(row.mailboxIds).toEqual(['inbox']);
+  });
+
+  it('첫 보낸 사람 칸(참여자 — 리뷰 L3) — 주소 · 이름을 따로, 이름 안의 `<주소>` 꼴은 주소가 되지 않는다', () => {
+    // 주소 없이 이름만 `대표 <ceo@…>` — 보낸 사람 글(조건 검색)에는 남지만 참여자 칸은 비운다
+    const nameOnly = toIndexRow(
+      documentOf({ from: [{ name: '대표 <ceo@example.com>', email: null }] }),
+    );
+    expect(nameOnly.fromText).toBe('대표 <ceo@example.com>');
+    expect(nameOnly.fromEmail).toBeNull();
+    expect(nameOnly.fromName).toBeNull();
+
+    // 이름이 `<다른 주소>` 를 품어도 칸의 주소는 엔진이 준 주소다
+    const disguised = toIndexRow(
+      documentOf({
+        from: [
+          { name: ' 대표 <ceo@example.com> ', email: ' real@example.net ' },
+          { name: '둘째', email: 'second@example.com' },
+        ],
+      }),
+    );
+    expect(disguised.fromEmail).toBe('real@example.net');
+    expect(disguised.fromName).toBe('대표 <ceo@example.com>');
+
+    expect(toIndexRow(documentOf({ from: [] })).fromEmail).toBeNull();
+  });
+
+  it('첫 보낸 사람 — 이름은 앞 INDEX_FROM_NAME_MAX_CHARS 코드 포인트(서로게이트 쌍을 가르지 않는다) · 주소가 열보다 길면 담지 않는다', () => {
+    const long = firstSender([
+      {
+        name: `${'가'.repeat(INDEX_FROM_NAME_MAX_CHARS - 1)}😀😀`,
+        email: 'a@example.com',
+      },
+    ]);
+    expect([...(long.name ?? '')]).toHaveLength(INDEX_FROM_NAME_MAX_CHARS);
+    expect(long.name?.endsWith('😀')).toBe(true);
+
+    const tooLong = `${'a'.repeat(SEARCH_EMAIL_COLUMN_LENGTH)}@example.com`;
+    expect(firstSender([{ name: '긴 주소', email: tooLong }])).toEqual({
+      email: null,
+      name: null,
+    });
+    expect(firstSender([{ name: '  ', email: 'a@example.com' }])).toEqual({
+      email: 'a@example.com',
+      name: null,
+    });
+  });
+
+  it('받은 시각이 날짜가 아니면 1970-01-01 · 크기는 32비트 정수 안 · Message-ID 가 없으면 null · 긴 대화 id 는 null', () => {
+    const row = toIndexRow(
+      documentOf({
+        receivedAt: 'not-a-date',
+        size: Number.MAX_SAFE_INTEGER,
+        messageIds: [],
+        threadId: 'x'.repeat(100),
+      }),
+    );
+    expect(row.receivedAt.getTime()).toBe(0);
+    expect(row.size).toBe(2_147_483_647);
+    expect(row.messageId).toBeNull();
+    expect(row.engineThreadId).toBeNull();
+  });
+
+  it('1MiB 본문도 길이에 비례해 담는다 (자르기 전에 통째로 NFC 하지 않는다)', () => {
+    const body = '계약서를 보내 드립니다. Project plan '.repeat(40_000);
+    const cpu = startCpuTimer();
+    const row = toIndexRow(documentOf({ bodyText: body }));
+    expect(row.bodyText).toHaveLength(INDEX_BODY_MAX_CHARS);
+    expect(cpu()).toBeLessThan(3_000);
+  });
+});
+
+describe('referencesOf (답장 관계)', () => {
+  it('In-Reply-To 다음 References 를 가까운 것부터, 겹치지 않게', () => {
+    expect(referencesOf(['c@x'], ['a@x', 'b@x', 'c@x'])).toEqual([
+      'c@x',
+      'b@x',
+      'a@x',
+    ]);
+  });
+
+  it('앞 INDEX_REFS_MAX 개 · 빈 것 · 너무 긴 id 는 뺀다', () => {
+    const many = Array.from({ length: 80 }, (_, index) => `r${index}@x`);
+    const refs = referencesOf([], many);
+    expect(refs).toHaveLength(INDEX_REFS_MAX);
+    expect(refs[0]).toBe('r79@x');
+    expect(referencesOf(['', '  ', 'x'.repeat(300)], ['ok@x'])).toEqual([
+      'ok@x',
+    ]);
+  });
+});
+
+describe('takeCodePoints · storableText · isIndexableId', () => {
+  it('서로게이트 쌍을 가르지 않는다', () => {
+    expect(takeCodePoints('😀😀😀', 2)).toBe('😀😀');
+    expect(takeCodePoints('ab', 5)).toBe('ab');
+    expect(storableText('😀😀😀', 1)).toBe('😀');
+  });
+
+  it('엔진 id 는 비지 않고 열 길이 안이어야 한다', () => {
+    expect(isIndexableId('abc')).toBe(true);
+    expect(isIndexableId('')).toBe(false);
+    expect(isIndexableId('x'.repeat(65))).toBe(false);
+  });
+});
diff --git a/backend/src/modules/mail-search/index-document.ts b/backend/src/modules/mail-search/index-document.ts
new file mode 100644
index 0000000..167a6ae
--- /dev/null
+++ b/backend/src/modules/mail-search/index-document.ts
@@ -0,0 +1,247 @@
+import { foldText, gramsOf } from '@/shared/utils/search-text';
+import { subjectBase } from '@/shared/utils/subject-base';
+import type { IndexAddress, IndexDocument } from './mail-index-source';
+import {
+  INDEX_ADDRESSES_MAX,
+  INDEX_ADDRESS_LINE_MAX_CHARS,
+  INDEX_ATTACHMENT_NAMES_MAX,
+  INDEX_ATTACHMENT_NAME_MAX_CHARS,
+  INDEX_BODY_MAX_CHARS,
+  INDEX_FROM_NAME_MAX_CHARS,
+  INDEX_MESSAGE_ID_MAX_LENGTH,
+  INDEX_PREVIEW_MAX_CHARS,
+  INDEX_REFS_MAX,
+  INDEX_SUBJECT_MAX_CHARS,
+  SEARCH_EMAIL_COLUMN_LENGTH,
+  SEARCH_ID_COLUMN_LENGTH,
+} from './mail-search.constants';
+
+/**
+ * 엔진의 메일 한 통 → 색인 한 줄의 값 (순수 함수 — 14단계 설계 A1 · B1).
+ * - 글 칸은 원문(NFC — 맞은 곳의 위치를 그 위에 그린다)으로 두고, 칸마다 길이 상한(mail-search.constants.ts)에서 자른다 — 코드 포인트로 세고 서로게이트 쌍을 가르지 않는다
+ * - PostgreSQL 의 text 는 NUL(U+0000)을 받지 않고 짝이 없는 서로게이트는 UTF-8 로 보낼 때 U+FFFD 가 된다 — 둘 다 먼저 U+FFFD 로 바꾼다
+ *   (한 단위를 한 단위로 — 위치가 바뀌지 않는다. 접은 글 · 묶음이 저장된 원문과 같아지게)
+ * - 접기 글(fold_*)은 foldText — 원문과 위치가 같다. 받는 사람 칸은 받는 사람과 참조를 줄바꿈으로 이어 접는다
+ * - 묶음(grams)은 다섯 접기 칸에서 따로 뽑아 합친다(칸 경계를 넘지 않는다, 겹치지 않게)
+ * - 답장 관계(refs): In-Reply-To 다음 References 를 가까운 것(뒤)부터, 겹치지 않게 앞 INDEX_REFS_MAX 개. 너무 긴 id 는 뺀다
+ * - 첫 보낸 사람은 주소 · 이름을 따로도 둔다(from_email · from_name — 묶은 목록의 참여자, 3차 리뷰 L3). 주소가 없으면 null — 이름 안의 `<주소>` 꼴은 주소로 읽지 않는다
+ * - 대화 키는 넣을 때 그 메일 id 다 — 색인에 쓸 때 이어진 메일의 키와 합친다(3차 — 설계 B4, mail-search-index.repository.ts 의 linkThreads)
+ */
+
+/** 색인 한 줄의 값 — 표의 칸과 같다 (user_email · indexed_at 은 쓰는 쪽이 붙인다) */
+export interface IndexRowValues {
+  readonly emailId: string;
+  readonly mailboxIds: string[];
+  readonly keywords: string[];
+  readonly receivedAt: Date;
+  readonly size: number;
+  readonly messageId: string | null;
+  readonly refs: string[];
+  readonly subject: string;
+  readonly subjectBase: string;
+  readonly fromText: string;
+  readonly fromEmail: string | null;
+  readonly fromName: string | null;
+  readonly toText: string;
+  readonly ccText: string;
+  readonly attachmentNames: string;
+  readonly hasAttachment: boolean;
+  readonly preview: string;
+  readonly bodyText: string;
+  readonly foldFrom: string;
+  readonly foldTo: string;
+  readonly foldSubject: string;
+  readonly foldAttachment: string;
+  readonly foldBody: string;
+  readonly grams: string[];
+  readonly threadKey: string;
+  readonly engineThreadId: string | null;
+}
+
+/** NUL · 짝이 없는 서로게이트 — PostgreSQL text 에 그대로 넣을 수 없는 글자 */
+const UNSTORABLE =
+  // eslint-disable-next-line no-control-regex
+  /\u0000|[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/g;
+const REPLACEMENT_CHARACTER = '\ufffd';
+
+/** 자르기 전에 볼 원문의 길이 — 풀어 쓴 한글(NFD)은 NFC 로 모으면 셋이 하나가 되므로 넉넉히 */
+const NFC_SLACK = 4;
+
+/** 32비트 정수 열(size)의 상한 */
+const MAX_INT32 = 2_147_483_647;
+
+/** 앞에서 코드 포인트 `max` 개까지 (서로게이트 쌍을 가르지 않는다) */
+export function takeCodePoints(text: string, max: number): string {
+  if (text.length <= max) return text;
+  let units = 0;
+  let points = 0;
+  while (units < text.length && points < max) {
+    const code = text.charCodeAt(units);
+    units +=
+      code >= 0xd800 &&
+      code <= 0xdbff &&
+      units + 1 < text.length &&
+      (text.charCodeAt(units + 1) & 0xfc00) === 0xdc00
+        ? 2
+        : 1;
+    points += 1;
+  }
+  return text.slice(0, units);
+}
+
+/** 저장할 원문 — 넣을 수 없는 글자를 바꾸고, NFC 로 모으고, 코드 포인트 `max` 개까지 */
+export function storableText(text: string, max: number): string {
+  // 아주 긴 글(본문 1MiB 등)을 통째로 NFC 하지 않게 먼저 넉넉히 자른다
+  const head =
+    text.length > max * NFC_SLACK ? text.slice(0, max * NFC_SLACK) : text;
+  return takeCodePoints(
+    head.replace(UNSTORABLE, REPLACEMENT_CHARACTER).normalize('NFC'),
+    max,
+  );
+}
+
+/** "이름 <주소>" — 이름이 없으면 주소, 주소가 없으면 이름 */
+function addressLine(address: IndexAddress): string {
+  const name = (address.name ?? '').trim();
+  const email = (address.email ?? '').trim();
+  const line = name && email ? `${name} <${email}>` : name || email;
+  return storableText(line, INDEX_ADDRESS_LINE_MAX_CHARS);
+}
+
+/**
+ * 참여자 이름 — 앞뒤 공백을 지운 NFC, 앞 INDEX_FROM_NAME_MAX_CHARS 코드 포인트(서로게이트 쌍을 가르지 않는다), 비면 null.
+ * 색인의 첫 보낸 사람 칸(firstSender)과 엔진 방식 대화의 참여자(modules/mail/jmap/jmap-conversations.ts)가 같은 자르기를 쓴다
+ */
+export function participantName(
+  name: string | null | undefined,
+): string | null {
+  const trimmed = storableText(
+    (name ?? '').trim(),
+    INDEX_FROM_NAME_MAX_CHARS,
+  ).trim();
+  return trimmed === '' ? null : trimmed;
+}
+
+/**
+ * 첫 보낸 사람 — 주소(앞뒤 공백을 지운 NFC, SEARCH_EMAIL_COLUMN_LENGTH 를 넘거나 없으면 null)와 이름(participantName).
+ * 목록 요약(jmap.mapper.ts 의 toAddress — `from[0]`)과 같은 사람이다. 주소가 없으면 이름도 두지 않는다(참여자는 주소로 센다)
+ */
+export function firstSender(addresses: readonly IndexAddress[]): {
+  readonly email: string | null;
+  readonly name: string | null;
+} {
+  const first = addresses[0];
+  const email = storableText(
+    (first?.email ?? '').trim(),
+    SEARCH_EMAIL_COLUMN_LENGTH + 1,
+  );
+  if (email === '' || email.length > SEARCH_EMAIL_COLUMN_LENGTH) {
+    return { email: null, name: null };
+  }
+  return { email, name: participantName(first?.name) };
+}
+
+function addressText(addresses: readonly IndexAddress[]): string {
+  return addresses
+    .slice(0, INDEX_ADDRESSES_MAX)
+    .map(addressLine)
+    .filter((line) => line !== '')
+    .join('\n');
+}
+
+/** 답장 관계 — In-Reply-To 다음 References 를 가까운 것부터, 겹치지 않게 앞 INDEX_REFS_MAX 개 */
+export function referencesOf(
+  inReplyTo: readonly string[],
+  references: readonly string[],
+): string[] {
+  const refs: string[] = [];
+  const seen = new Set<string>();
+  for (const raw of [...inReplyTo, ...[...references].reverse()]) {
+    const ref = storableText(raw.trim(), INDEX_MESSAGE_ID_MAX_LENGTH + 1);
+    if (ref === '' || ref.length > INDEX_MESSAGE_ID_MAX_LENGTH) continue;
+    if (seen.has(ref)) continue;
+    seen.add(ref);
+    refs.push(ref);
+    if (refs.length >= INDEX_REFS_MAX) break;
+  }
+  return refs;
+}
+
+/** 첫 Message-ID — 없거나 너무 길면 null */
+function firstMessageId(messageIds: readonly string[]): string | null {
+  const first = storableText(
+    (messageIds[0] ?? '').trim(),
+    INDEX_MESSAGE_ID_MAX_LENGTH + 1,
+  );
+  return first === '' || first.length > INDEX_MESSAGE_ID_MAX_LENGTH
+    ? null
+    : first;
+}
+
+/** 열 길이 안의 엔진 id 인가 */
+export function isIndexableId(id: string): boolean {
+  return id !== '' && id.length <= SEARCH_ID_COLUMN_LENGTH;
+}
+
+/** 엔진의 메일 한 통 → 색인 한 줄의 값. 받은 시각이 날짜가 아니면 1970-01-01 (목록과 같다) */
+export function toIndexRow(document: IndexDocument): IndexRowValues {
+  const subject = storableText(document.subject, INDEX_SUBJECT_MAX_CHARS);
+  const fromText = addressText(document.from);
+  const sender = firstSender(document.from);
+  const toText = addressText(document.to);
+  const ccText = addressText(document.cc);
+  const attachmentNames = document.attachmentNames
+    .slice(0, INDEX_ATTACHMENT_NAMES_MAX)
+    .map((name) => storableText(name.trim(), INDEX_ATTACHMENT_NAME_MAX_CHARS))
+    .filter((name) => name !== '')
+    .join('\n');
+  const bodyText = storableText(document.bodyText, INDEX_BODY_MAX_CHARS);
+
+  const foldFrom = foldText(fromText);
+  const foldTo = foldText([toText, ccText].filter(Boolean).join('\n'));
+  const foldSubject = foldText(subject);
+  const foldAttachment = foldText(attachmentNames);
+  const foldBody = foldText(bodyText);
+  const grams = new Set<string>();
+  for (const fold of [
+    foldFrom,
+    foldTo,
+    foldSubject,
+    foldAttachment,
+    foldBody,
+  ]) {
+    gramsOf(fold, grams);
+  }
+
+  const receivedAt = Date.parse(document.receivedAt);
+  const threadId = document.threadId ?? '';
+  return {
+    emailId: document.id,
+    mailboxIds: [...new Set(document.mailboxIds)],
+    keywords: [...new Set(document.keywords)],
+    receivedAt: new Date(Number.isNaN(receivedAt) ? 0 : receivedAt),
+    size: Math.min(MAX_INT32, Math.max(0, Math.trunc(document.size) || 0)),
+    messageId: firstMessageId(document.messageIds),
+    refs: referencesOf(document.inReplyTo, document.references),
+    subject,
+    subjectBase: subjectBase(subject),
+    fromText,
+    fromEmail: sender.email,
+    fromName: sender.name,
+    toText,
+    ccText,
+    attachmentNames,
+    hasAttachment: document.hasAttachment,
+    preview: storableText(document.preview, INDEX_PREVIEW_MAX_CHARS),
+    bodyText,
+    foldFrom,
+    foldTo,
+    foldSubject,
+    foldAttachment,
+    foldBody,
+    grams: [...grams],
+    // 처음 키는 그 메일 id — 색인에 쓸 때 이어진 메일의 키와 합친다(mail-search-index.repository.ts 의 linkThreads)
+    threadKey: document.id,
+    engineThreadId: isIndexableId(threadId) ? threadId : null,
+  };
+}
diff --git a/backend/src/modules/mail-search/mail-conversation-query.service.ts b/backend/src/modules/mail-search/mail-conversation-query.service.ts
new file mode 100644
index 0000000..3ddba32
--- /dev/null
+++ b/backend/src/modules/mail-search/mail-conversation-query.service.ts
@@ -0,0 +1,248 @@
+import { Injectable } from '@nestjs/common';
+import { InjectDataSource } from '@nestjs/typeorm';
+import type { DataSource } from 'typeorm';
+
+import {
+  encodeConversationCursor,
+  type ConversationPosition,
+} from './conversation-cursor';
+import {
+  conversationDetailsSql,
+  conversationPageSql,
+  conversationParticipantsSql,
+  mailboxConversationsSql,
+  type ConversationExclusions,
+} from './conversation-sql';
+import {
+  CONVERSATION_MESSAGE_IDS_MAX,
+  CONVERSATION_PARTICIPANTS_MAX,
+} from './mail-search.constants';
+import type { ConversationParticipant } from './mail-search.types';
+
+/** 같은 대화 한 쪽 — 메일 id 만(요약은 부르는 쪽이 엔진에서 읽는다) */
+export interface IndexConversationPage {
+  readonly ids: readonly string[];
+  readonly hasNext: boolean;
+  readonly nextCursor: string | null;
+  /** 첫 쪽에서만 — 다음 쪽은 null */
+  readonly total: number | null;
+}
+
+/** 묶은 목록의 대화 하나 (색인) — 마지막 메일의 요약은 부르는 쪽이 엔진에서 읽는다 */
+export interface IndexConversation {
+  readonly key: string;
+  /** 그 메일함 안 마지막 메일 */
+  readonly latestId: string;
+  /** 그 메일함 안 메일 — 최신부터 CONVERSATION_MESSAGE_IDS_MAX 통까지 */
+  readonly mailboxMessageIds: readonly string[];
+  readonly messageCount: number;
+  readonly participants: readonly ConversationParticipant[];
+  readonly isRead: boolean;
+  readonly isFlagged: boolean;
+  readonly hasAttachment: boolean;
+}
+
+export interface IndexConversationList {
+  readonly items: readonly IndexConversation[];
+  readonly hasNext: boolean;
+  readonly nextCursor: string | null;
+  readonly total: number | null;
+}
+
+/** 쪽을 읽는 자리 — 커서는 서비스 입구에서 읽어(VAL_001 — 엔진 · DB 에 묻기 전) 자리로 넘긴다 (3차 리뷰 L1) */
+export interface ConversationPageRequest {
+  readonly limit: number;
+  readonly after: ConversationPosition | null;
+}
+
+interface PageRow {
+  /** 그 메일은 색인에 있는데 쪽이 비었으면 null (LEFT JOIN LATERAL) */
+  readonly email_id: string | null;
+  readonly received_at: Date | string | null;
+  readonly total: number | null;
+}
+
+interface ListRow {
+  readonly thread_key: string;
+  readonly latest_at: Date | string;
+  readonly total: number;
+}
+
+interface DetailRow {
+  readonly thread_key: string;
+  readonly message_count: number;
+  readonly mailbox_message_ids: string[] | null;
+  readonly is_read: boolean;
+  readonly is_flagged: boolean;
+  readonly has_attachment: boolean;
+}
+
+interface ParticipantRow {
+  readonly thread_key: string;
+  readonly from_email: string;
+  readonly from_name: string | null;
+}
+
+function dateOf(value: Date | string): Date {
+  return value instanceof Date ? value : new Date(value);
+}
+
+/** 표의 직원 주소 — 늘 소문자다 (MailSearchIndexService 와 같은 맞춤) */
+function normalize(user: string): string {
+  return user.trim().toLowerCase();
+}
+
+/**
+ * 색인으로 본 대화 (14단계 설계 C3 · C4) — 대화 키(B4)로 묶는다. 엔진을 모른다(빼는 메일함 · 키워드는 부르는 쪽이 엔진에서 받아 준다).
+ * - 같은 대화: 그 메일의 키와 그 키의 줄을 한 문장으로(3차 리뷰 L2), 오래된 차례 · 커서(conversation-cursor.ts 의 thread)
+ * - 묶은 목록: 그 메일함 안의 줄을 대화 키로 묶어 마지막 받은 시각 최신부터 · 커서(list), 그 쪽의 대화만 자세히(통 수 · 그 메일함 안 id(최신부터
+ *   CONVERSATION_MESSAGE_IDS_MAX 통까지) · 읽음 …)와 참여자(첫 보낸 사람 칸 — 주소마다 한 번, CONVERSATION_PARTICIPANTS_MAX 명까지)
+ * 모든 쿼리는 그 직원 주소(btree)로 먼저 좁히고 메일함은 그 줄에서 거른다 — 메일함의 GIN posting(회사 전체)을 쓰지 않는다(conversation-sql.ts)
+ */
+@Injectable()
+export class MailConversationQueryService {
+  constructor(@InjectDataSource() private readonly dataSource: DataSource) {}
+
+  /**
+   * 같은 대화 한 쪽 — 오래된 차례. 지금 보는 메일(`emailId`)은 빼는 메일함에 있어도 넣는다.
+   * 그 메일이 색인에 없으면 null (부르는 쪽이 첫 쪽이면 엔진으로, 이어 가는 쪽이면 RES_001)
+   */
+  async conversation(
+    user: string,
+    emailId: string,
+    exclusions: ConversationExclusions,
+    page: ConversationPageRequest,
+  ): Promise<IndexConversationPage | null> {
+    const query = conversationPageSql(
+      normalize(user),
+      emailId,
+      exclusions,
+      page.after,
+      page.limit + 1,
+    );
+    const rows = await this.dataSource.query<PageRow[]>(
+      query.sql,
+      query.params,
+    );
+    if (rows.length === 0) return null;
+    const found = rows.flatMap((row) =>
+      row.email_id !== null && row.received_at !== null
+        ? [
+            {
+              id: row.email_id,
+              at: dateOf(row.received_at),
+              total: row.total,
+            },
+          ]
+        : [],
+    );
+    const shown = found.slice(0, page.limit);
+    const hasNext = found.length > page.limit;
+    const last = shown[shown.length - 1];
+    return {
+      ids: shown.map((row) => row.id),
+      hasNext,
+      nextCursor:
+        hasNext && last
+          ? encodeConversationCursor(
+              'thread',
+              { at: last.at, key: last.id },
+              emailId,
+            )
+          : null,
+      total: page.after === null ? Number(found[0]?.total ?? 0) : null,
+    };
+  }
+
+  /** 묶은 목록 한 쪽 — 그 메일함 안 마지막 받은 시각 최신부터 */
+  async mailboxConversations(
+    user: string,
+    mailboxId: string,
+    exclusions: ConversationExclusions,
+    page: ConversationPageRequest,
+  ): Promise<IndexConversationList> {
+    const key = normalize(user);
+    const { after } = page;
+    // 쪽 · 자세히 · 참여자는 같은 스냅숏에서 — 그사이 온 메일로 대화 키가 합쳐져도 한 쪽 안에서는 어긋나지 않게
+    return this.dataSource.transaction('REPEATABLE READ', async (manager) => {
+      const listQuery = mailboxConversationsSql(
+        key,
+        mailboxId,
+        exclusions,
+        after,
+        page.limit + 1,
+      );
+      const rows = await manager.query<ListRow[]>(
+        listQuery.sql,
+        listQuery.params,
+      );
+      const shown = rows.slice(0, page.limit);
+      const hasNext = rows.length > page.limit;
+      const keys = shown.map((row) => row.thread_key);
+      let detailRows: DetailRow[] = [];
+      let participantRows: ParticipantRow[] = [];
+      if (keys.length > 0) {
+        const detailQuery = conversationDetailsSql(
+          key,
+          mailboxId,
+          keys,
+          exclusions,
+          CONVERSATION_MESSAGE_IDS_MAX,
+        );
+        detailRows = await manager.query<DetailRow[]>(
+          detailQuery.sql,
+          detailQuery.params,
+        );
+        const participantQuery = conversationParticipantsSql(
+          key,
+          mailboxId,
+          keys,
+          exclusions,
+          CONVERSATION_PARTICIPANTS_MAX,
+        );
+        participantRows = await manager.query<ParticipantRow[]>(
+          participantQuery.sql,
+          participantQuery.params,
+        );
+      }
+      const details = new Map(detailRows.map((row) => [row.thread_key, row]));
+      const participants = new Map<string, ConversationParticipant[]>();
+      for (const row of participantRows) {
+        const list = participants.get(row.thread_key) ?? [];
+        list.push({ name: row.from_name, email: row.from_email });
+        participants.set(row.thread_key, list);
+      }
+      const items = shown.flatMap((row): IndexConversation[] => {
+        const detail = details.get(row.thread_key);
+        const ids = detail?.mailbox_message_ids ?? [];
+        if (!detail || ids.length === 0) return [];
+        return [
+          {
+            key: row.thread_key,
+            latestId: ids[0],
+            mailboxMessageIds: ids,
+            messageCount: Math.max(Number(detail.message_count), 1),
+            participants: participants.get(row.thread_key) ?? [],
+            isRead: detail.is_read,
+            isFlagged: detail.is_flagged,
+            hasAttachment: detail.has_attachment,
+          },
+        ];
+      });
+      const last = shown[shown.length - 1];
+      return {
+        items,
+        hasNext,
+        nextCursor:
+          hasNext && last
+            ? encodeConversationCursor(
+                'list',
+                { at: dateOf(last.latest_at), key: last.thread_key },
+                mailboxId,
+              )
+            : null,
+        total: after === null ? Number(rows[0]?.total ?? 0) : null,
+      };
+    });
+  }
+}
diff --git a/backend/src/modules/mail-search/mail-index-source.ts b/backend/src/modules/mail-search/mail-index-source.ts
new file mode 100644
index 0000000..75e5960
--- /dev/null
+++ b/backend/src/modules/mail-search/mail-index-source.ts
@@ -0,0 +1,132 @@
+/**
+ * 메일 검색 색인이 메일 엔진에서 읽는 것 — 포트 (14단계 설계 B2). 엔진을 모르는 쪽(맞추기 · 채우기)은 이것만 안다.
+ * 지금 구현은 Stalwart(JMAP) — `modules/mail/jmap/jmap-index-source.ts`. 엔진을 바꿀 때는 mail-search.module.ts 의 useClass 만 바꾼다.
+ *
+ * 실패는 BusinessException 으로 던진다 — 대리 접근이 막힌 계정은 메일 포트와 같은 예외(PasswordExpiredException · AccountLoginDisabledException ·
+ * AUTH_001), 엔진 장애 MAIL_001, 엔진 한도 REQ_001.
+ */
+export const MAIL_INDEX_SOURCE = Symbol('MAIL_INDEX_SOURCE');
+
+/** 한 번의 엔진 읽기의 끝 시각(epoch ms) — 넘으면 엔진 호출을 그만둔다 (호출마다 남은 시간만큼만 기다린다) */
+export interface IndexReadOptions {
+  readonly deadline: number;
+}
+
+/**
+ * 차례의 끝 시각에 닿았다 — 남은 시간이 INDEX_CALL_MIN_MS 보다 적어 엔진 읽기를 시작하지 않았거나, 남은 시간으로 줄인 기다림이 끝나 끊었다.
+ * **실패가 아니다** — 맞추기 · 채우기는 쓴 데까지를 두고 다음 차례에 이어 한다(실패 수 · 경고 없음). 응답으로 나가지 않는다(배경 일에서만 쓴다)
+ */
+export class IndexDeadlineError extends Error {
+  constructor() {
+    super('검색 색인 차례의 끝 시각');
+    this.name = 'IndexDeadlineError';
+  }
+}
+
+/** 주소 하나 — 이름이 없으면 null */
+export interface IndexAddress {
+  readonly name: string | null;
+  readonly email: string | null;
+}
+
+/** 색인에 넣을 메일 한 통 — 엔진이 준 그대로(자르기 · 접기는 index-document.ts 가 한다) */
+export interface IndexDocument {
+  readonly id: string;
+  /** 엔진의 대화(threadId) — 없으면 null */
+  readonly threadId: string | null;
+  readonly mailboxIds: readonly string[];
+  /** 켜진 키워드 */
+  readonly keywords: readonly string[];
+  /** 받은 시각 (ISO 8601) */
+  readonly receivedAt: string;
+  readonly size: number;
+  /** 머리글 Message-ID 들 (꺾쇠 없이) */
+  readonly messageIds: readonly string[];
+  readonly inReplyTo: readonly string[];
+  readonly references: readonly string[];
+  readonly subject: string;
+  readonly from: readonly IndexAddress[];
+  readonly to: readonly IndexAddress[];
+  readonly cc: readonly IndexAddress[];
+  /** 진짜 첨부(본문 그림이 아닌 것)의 이름 — 이름이 없는 첨부는 빠진다 */
+  readonly attachmentNames: readonly string[];
+  /** 목록과 같은 첨부 판정 */
+  readonly hasAttachment: boolean;
+  readonly preview: string;
+  /** 본문 글 — HTML 본문이면 글자만, 부분은 줄바꿈으로 잇는다. 엔진이 부분마다 앞쪽만 줄 수 있다 */
+  readonly bodyText: string;
+}
+
+/** 바뀔 수 있는 칸만 (JMAP 에서 메일의 글은 바뀌지 않는다 — 메일함 · 키워드뿐) */
+export interface IndexMutable {
+  readonly id: string;
+  readonly mailboxIds: readonly string[];
+  readonly keywords: readonly string[];
+}
+
+/** 엔진 Email state 부터의 변화 — 만들어진 · 바뀐 · 없어진 메일 id */
+export type IndexChanges =
+  | {
+      readonly kind: 'changes';
+      readonly created: readonly string[];
+      readonly updated: readonly string[];
+      readonly destroyed: readonly string[];
+      readonly newState: string;
+      /** 한 번에 다 주지 못했다 — newState 부터 다시 묻는다 */
+      readonly hasMore: boolean;
+    }
+  /** 엔진이 그 state 부터의 변화를 셀 수 없다 — 전체 대조로 */
+  | { readonly kind: 'cannotCalculate' };
+
+/** 받은 차례(최신부터) 메일 id 의 한 쪽 */
+export interface IndexIdPage {
+  readonly ids: readonly string[];
+  /** 이 쪽의 첫 메일 자리 (0 부터) */
+  readonly position: number;
+  /** 엔진이 센 모든 메일 수 — 세지 않았으면 null */
+  readonly total: number | null;
+}
+
+/** 엔진의 모든 메일 id 와 그것을 읽기 바로 전의 Email state (전체 대조) */
+export interface IndexAllIds {
+  readonly state: string;
+  readonly ids: readonly string[];
+}
+
+export interface MailIndexSource {
+  /** 지금 Email state 와 모든 메일 수 (채우기를 시작할 때 — 싼 읽기) */
+  snapshot(
+    user: string,
+    options: IndexReadOptions,
+  ): Promise<{ readonly state: string; readonly total: number | null }>;
+  /** sinceState 부터의 변화 — 한 번에 maxChanges 개까지 */
+  changes(
+    user: string,
+    sinceState: string,
+    maxChanges: number,
+    options: IndexReadOptions,
+  ): Promise<IndexChanges>;
+  /** 메일 글 — 그사이 없어진 메일은 빠진다 (차례는 ids 를 따르지 않아도 된다) */
+  documents(
+    user: string,
+    ids: readonly string[],
+    options: IndexReadOptions,
+  ): Promise<IndexDocument[]>;
+  /** 메일함 · 키워드만 — 그사이 없어진 메일은 빠진다 */
+  mutable(
+    user: string,
+    ids: readonly string[],
+    options: IndexReadOptions,
+  ): Promise<IndexMutable[]>;
+  /**
+   * 받은 차례(최신부터) 한 쪽 — anchor(지난 쪽의 마지막 메일) 다음부터. anchor 가 없거나 그사이 지워졌으면 `position` 부터
+   */
+  pageIds(
+    user: string,
+    from: { readonly anchor: string | null; readonly position: number },
+    limit: number,
+    options: IndexReadOptions,
+  ): Promise<IndexIdPage>;
+  /** 모든 메일 id — 전체 대조 (그 바로 전의 state 와 함께) */
+  allIds(user: string, options: IndexReadOptions): Promise<IndexAllIds>;
+}
diff --git a/backend/src/modules/mail-search/mail-search-build.service.ts b/backend/src/modules/mail-search/mail-search-build.service.ts
new file mode 100644
index 0000000..71d01fa
--- /dev/null
+++ b/backend/src/modules/mail-search/mail-search-build.service.ts
@@ -0,0 +1,280 @@
+import {
+  Inject,
+  Injectable,
+  Logger,
+  type OnApplicationBootstrap,
+  Optional,
+} from '@nestjs/common';
+import { Cron } from '@nestjs/schedule';
+
+import { maskEmail } from '@/shared/utils/mask';
+import { isIndexableId } from './index-document';
+import {
+  IndexDeadlineError,
+  MAIL_INDEX_SOURCE,
+  type MailIndexSource,
+} from './mail-index-source';
+import { MailSearchIndexRepository } from './mail-search-index.repository';
+import { MailSearchRuns } from './mail-search-runs';
+import { MailSearchSyncService } from './mail-search-sync.service';
+import {
+  MAIL_SEARCH_TIMING,
+  SYSTEM_SEARCH_TIMING,
+  type MailSearchTiming,
+} from './mail-search-timing';
+import {
+  BUILD_BATCH_PAUSE_MS,
+  BUILD_BATCH_SIZE,
+  BUILD_RUN_BUDGET_MS,
+  FINISH_MIN_REMAINING_MS,
+  INDEX_FORMAT,
+  SEARCH_CRON_TIME_ZONE,
+  STEP_MIN_REMAINING_MS,
+} from './mail-search.constants';
+import { isBuildWindow, isDueAfterFailures } from './search-index-schedule';
+
+/** 밤 채우기 차례에서 한 번에 읽어 볼 직원 수 — 실패가 이어진 직원 · 다른 도메인 줄을 건너뛰고 고를 만큼 */
+const BUILD_CANDIDATES_LIMIT = 20;
+const MS_PER_MINUTE = 60_000;
+
+/**
+ * 한 직원의 채우기 결과 — 다 만들었음 · 이어 하기(끝 시각 · 창이 닫힘 · 마무리를 새 차례로 넘김) · 할 일 없음(줄이 없음 · 이미 ready · 멈춤) ·
+ * 실패(상태 줄에 적었다 — 실패 수 · 멈춤)
+ */
+export type BuildOutcome = 'ready' | 'partial' | 'skipped' | 'failed';
+
+/** 한 묶음의 결과 */
+type StepOutcome = 'continue' | BuildOutcome;
+
+/**
+ * 지난 메일 채우기 (14단계 설계 B3) — 직원이 처음 로그인하면 상태 줄이 `building` 으로 생기고, 밤에 한 사람씩 채운다.
+ *
+ * - 시작: 엔진의 지금 Email state(S0)와 메일 수를 적는다 — 그때부터 새로 온 메일 · 바뀐 메일은 맞추기(B2)가 바로 넣는다
+ * - 받은 차례 최신부터 BUILD_BATCH_SIZE 통씩 글을 읽어 넣고 마지막 메일(anchor) · 넣은 수를 적는다 — 한 묶음마다 직원의 차례(MailSearchRuns)를
+ *   한 번씩 잡고 놓는다(그사이 맞추기가 끼어든다). 묶음 뒤 BUILD_BATCH_PAUSE_MS 쉰다(엔진 메모리 1g)
+ * - anchor 가 지워졌으면 넣은 수의 위치로 이어 간다 — 몇 통 겹치거나 빠질 수 있어 마지막 대조가 채운다
+ * - 다 읽으면: 맞추기로 따라잡고 → 전체 대조(빠진 것 넣기 · 없어진 것 지우기) → `ready`. 이 마무리는 남은 시간이 FINISH_MIN_REMAINING_MS 이상일 때만
+ *   (= 새 차례의 처음에) 시작한다 — 시간 안에 끝나지 않으면 이어 하기로 두고 다음 차례에 다시 한다(넣은 것은 남으니 메일함이 커도 끝내 ready 가 된다)
+ * - **시간 끝은 실패가 아니다** — 남은 시간이 STEP_MIN_REMAINING_MS 보다 적으면 다음 묶음을 시작하지 않고, 엔진 읽기가 끝 시각에 걸리면
+ *   (IndexDeadlineError) 그 묶음을 쓰지 않고 이어 하기로 끝낸다(실패 수 · 경고 · 미루기 없음)
+ * - 밤에만: 1분마다 깨어 창(isBuildWindow — 한국 시각 22:00 ~ 02:45 · 05:00 ~ 07:30) 안이면 사내 도메인 직원 한 사람을 BUILD_RUN_BUDGET_MS 동안.
+ *   창이 닫히면 다음 묶음을 시작하지 않는다. 시험에서는 build() 를 바로 불러 창을 건너뛴다
+ * 다 만들기 전 그 직원의 검색 · 대화는 엔진 방식이다(14단계 2차 · 3차가 상태를 본다).
+ *
+ * ⚠️ 1분 차례의 겹침 막기(running)는 프로세스 메모리다 — 인스턴스가 둘이면 두 차례가 같은 직원을 함께 채운다 (nestjs 스킬의 Redis 목록)
+ */
+@Injectable()
+export class MailSearchBuildService implements OnApplicationBootstrap {
+  private readonly logger = new Logger(MailSearchBuildService.name);
+  private running = false;
+  /** 판이 다른 줄을 되돌렸나 — 서버가 뜰 때 못 했으면 1분 차례마다 다시 해 본다 (그동안 상태 API · 검색은 판을 보고 building 으로 다룬다) */
+  private formatsReset = false;
+  private readonly timing: MailSearchTiming;
+
+  constructor(
+    @Inject(MAIL_INDEX_SOURCE) private readonly source: MailIndexSource,
+    private readonly repository: MailSearchIndexRepository,
+    private readonly runs: MailSearchRuns,
+    private readonly sync: MailSearchSyncService,
+    @Optional() @Inject(MAIL_SEARCH_TIMING) timing?: MailSearchTiming,
+  ) {
+    this.timing = timing ?? SYSTEM_SEARCH_TIMING;
+  }
+
+  /**
+   * 서버가 뜰 때 — 판(INDEX_FORMAT)이 다른 사내 직원의 상태 줄을 building 으로 되돌린다(밤에 다시 채운다 — 그동안 검색은 엔진 방식).
+   * 되돌리지 못해도 서버는 뜬다 — 1분 차례가 다시 해 본다. 그동안 그 직원은 ready 여도 판이 달라 검색은 엔진 방식이고(isSearchReady)
+   * 상태 API 도 building 으로 보인다(toStatusView)
+   */
+  async onApplicationBootstrap(): Promise<void> {
+    await this.resetOutdatedFormats();
+  }
+
+  /** 판이 다른 줄 되돌리기 — 한 번 되면 다시 하지 않는다. 던지지 않는다 */
+  private async resetOutdatedFormats(): Promise<void> {
+    const suffix = this.sync.indexedAddressSuffix;
+    if (suffix === null || this.formatsReset) return;
+    try {
+      const reset = await this.repository.resetOutdatedFormats(
+        suffix,
+        INDEX_FORMAT,
+        new Date(this.timing.now()),
+      );
+      this.formatsReset = true;
+      if (reset > 0) {
+        // 배포마다 한 번뿐인 상태 변화 — 수만 (주소 없음)
+        this.logger.log(
+          `검색 색인의 판이 바뀌어 ${reset}명의 색인을 밤에 다시 채웁니다 (판 ${INDEX_FORMAT}).`,
+        );
+      }
+    } catch (error) {
+      this.logger.warn(
+        `[SYS_001] 판이 바뀐 검색 색인을 되돌리지 못했습니다(그 직원의 검색은 엔진 방식 — 1분 뒤 다시): ${error instanceof Error ? error.name : typeof error}`,
+      );
+    }
+  }
+
+  /** 1분마다 — 밤 창 안이면 채울 사내 직원 한 사람 (앞 차례가 아직 돌면 건너뛴다) */
+  @Cron('0 * * * * *', {
+    name: 'mail-search-build',
+    timeZone: SEARCH_CRON_TIME_ZONE,
+  })
+  async tick(): Promise<BuildOutcome | null> {
+    const startedAt = this.timing.now();
+    if (this.running || this.sync.isStopping) return null;
+    // 서버가 뜰 때 판을 되돌리지 못했으면 낮에도 다시 해 본다 (한 번 되면 하지 않는다)
+    await this.resetOutdatedFormats();
+    if (!isBuildWindow(new Date(startedAt))) return null;
+    this.running = true;
+    try {
+      const candidates = await this.repository.buildCandidates(
+        BUILD_CANDIDATES_LIMIT,
+      );
+      const next = candidates.find(
+        (state) =>
+          this.sync.isIndexedAddress(state.userEmail) &&
+          isDueAfterFailures(state.failureCount, state.updatedAt, startedAt),
+      );
+      if (!next) return null;
+      return await this.build(
+        next.userEmail,
+        startedAt + BUILD_RUN_BUDGET_MS,
+        () => isBuildWindow(new Date(this.timing.now())),
+      );
+    } catch (error) {
+      this.logger.error(
+        `[SYS_001] 검색 색인 채우기 차례를 읽지 못했습니다: ${error instanceof Error ? error.name : typeof error}`,
+      );
+      return null;
+    } finally {
+      this.running = false;
+    }
+  }
+
+  /**
+   * 한 직원의 지난 메일을 끝 시각까지 채운다 — `keepGoing` 이 false 가 되면(밤 창이 닫힘) 다음 묶음을 시작하지 않는다. 던지지 않는다
+   */
+  async build(
+    user: string,
+    deadline: number,
+    keepGoing: () => boolean = () => true,
+  ): Promise<BuildOutcome> {
+    const key = user.trim().toLowerCase();
+    for (;;) {
+      if (!this.hasTime(deadline) || !keepGoing()) return 'partial';
+      const step = await this.runs.run(key, () => this.step(key, deadline));
+      if (step !== 'continue') return step;
+      await this.timing.sleep(BUILD_BATCH_PAUSE_MS);
+    }
+  }
+
+  /** 한 묶음 — 그 직원의 차례 안에서 */
+  private async step(user: string, deadline: number): Promise<StepOutcome> {
+    try {
+      if (!this.hasTime(deadline)) return 'partial';
+      const state = await this.repository.findState(user);
+      if (
+        !state ||
+        state.status !== 'building' ||
+        state.pausedReason !== null
+      ) {
+        return 'skipped';
+      }
+      const now = new Date(this.timing.now());
+
+      if (state.buildStartedAt === null || state.emailState === null) {
+        // 시작 — 지금 state(S0)부터는 맞추기가 넣는다. 처음 시작이면(판을 되돌린 직원 포함) 남은 색인 줄을 함께 지운다 — 옛 판 줄이 남지 않게
+        const snapshot = await this.source.snapshot(user, { deadline });
+        const result = await this.repository.write(
+          user,
+          {
+            clearIndex: state.buildStartedAt === null,
+            state: {
+              emailState: snapshot.state,
+              buildStartedAt: now,
+              buildTotal: snapshot.total,
+              buildDone: 0,
+              buildAnchor: null,
+            },
+          },
+          now,
+        );
+        return result.written ? 'continue' : 'skipped';
+      }
+
+      const page = await this.source.pageIds(
+        user,
+        { anchor: state.buildAnchor, position: state.buildDone },
+        BUILD_BATCH_SIZE,
+        { deadline },
+      );
+      if (page.ids.length === 0) {
+        // 다 읽었다 — 마무리는 새 차례의 처음에만 (남은 시간이 모자라면 다음 차례가 이것부터 한다)
+        if (this.timing.now() > deadline - FINISH_MIN_REMAINING_MS) {
+          return 'partial';
+        }
+        return await this.finish(user, deadline);
+      }
+
+      const indexable = page.ids.filter(isIndexableId);
+      const rows = await this.sync.readRows(user, indexable, deadline);
+      if (rows === null) return 'partial';
+      const result = await this.repository.write(
+        user,
+        {
+          upserts: rows,
+          state: {
+            // 다음 쪽의 자리 — 표에 넣을 수 있는 id 만(열 길이). 하나도 없으면 넣은 수의 위치로 잇는다
+            buildAnchor: indexable[indexable.length - 1] ?? null,
+            buildDone: page.position + page.ids.length,
+          },
+        },
+        new Date(this.timing.now()),
+      );
+      return result.written ? 'continue' : 'skipped';
+    } catch (error) {
+      // 차례의 끝 시각에 걸렸다 — 실패가 아니라 이어 하기 (이 묶음은 쓰지 않았다)
+      if (error instanceof IndexDeadlineError) return 'partial';
+      await this.sync.handleFailure(user, error, 'build');
+      return 'failed';
+    }
+  }
+
+  /** 다 읽었다 — 따라잡기 → 전체 대조(빠진 것 넣기) → ready (던진다 — step 이 받는다) */
+  private async finish(user: string, deadline: number): Promise<StepOutcome> {
+    if (!(await this.sync.catchUp(user, deadline))) return 'partial';
+    const startedAt = (await this.repository.findState(user))?.buildStartedAt;
+    let count = 0;
+    const done = await this.sync.reconcile(user, deadline, {
+      addMissing: true,
+      refreshMutable: false,
+      finalState: (indexed) => {
+        count = indexed;
+        return {
+          status: 'ready',
+          readyAt: new Date(this.timing.now()),
+          buildAnchor: null,
+          buildDone: indexed,
+          buildTotal: indexed,
+        };
+      },
+    });
+    if (!done) return 'partial';
+    const minutes = startedAt
+      ? Math.round((this.timing.now() - startedAt.getTime()) / MS_PER_MINUTE)
+      : null;
+    // 직원마다 한 번뿐인 상태 변화라 info 로 남긴다 (메일 수 · 걸린 때만 — 글 · 주소 없음)
+    this.logger.log(
+      `검색 색인을 다 만들었습니다: user=${maskEmail(user)}, 메일 ${count}통${minutes === null ? '' : `, 시작부터 ${minutes}분`}`,
+    );
+    return 'ready';
+  }
+
+  /** 다음 묶음을 시작할 시간이 있나 — 끝 시각까지 STEP_MIN_REMAINING_MS 이상 */
+  private hasTime(deadline: number): boolean {
+    return (
+      !this.sync.isStopping &&
+      this.timing.now() <= deadline - STEP_MIN_REMAINING_MS
+    );
+  }
+}
diff --git a/backend/src/modules/mail-search/mail-search-index.repository.ts b/backend/src/modules/mail-search/mail-search-index.repository.ts
new file mode 100644
index 0000000..0a326e1
--- /dev/null
+++ b/backend/src/modules/mail-search/mail-search-index.repository.ts
@@ -0,0 +1,410 @@
+import { Injectable } from '@nestjs/common';
+import { InjectDataSource } from '@nestjs/typeorm';
+import type { DataSource, EntityManager } from 'typeorm';
+
+import type { IndexRowValues } from './index-document';
+import type { IndexMutable } from './mail-index-source';
+import { MailSearchMessageEntity } from './mail-search-message.entity';
+import { MailSearchStateEntity } from './mail-search-state.entity';
+import {
+  INDEX_FORMAT,
+  SEARCH_MESSAGES_TABLE,
+  SEARCH_STATES_TABLE,
+} from './mail-search.constants';
+import { mergeThreadKeys } from './thread-keys';
+import type {
+  SearchIndexStatus,
+  SearchPausedReason,
+} from './mail-search.types';
+
+/** 상태 줄에 함께 쓰는 칸 (쓰기가 성공하면 실패 수는 0 으로) */
+export interface SearchStatePatch {
+  readonly status?: SearchIndexStatus;
+  readonly emailState?: string | null;
+  readonly buildAnchor?: string | null;
+  readonly buildDone?: number;
+  readonly buildTotal?: number | null;
+  readonly buildStartedAt?: Date | null;
+  readonly readyAt?: Date | null;
+  readonly lastSyncedAt?: Date | null;
+}
+
+/** 한 트랜잭션에 쓰는 것 — (그 직원의 색인 줄 모두 지우기) → 지우기 → 넣기(있으면 바꾸기) → 메일함 · 키워드 바꾸기 → 상태 줄 */
+export interface SearchIndexWrite {
+  /**
+   * 그 직원의 색인 줄을 모두 지운다 — 채우기를 처음부터 시작할 때(판이 바뀌어 되돌린 직원 포함). 채우기는 위치로 건너뛸 수 있고 마지막 대조는
+   * 없는 줄만 넣으므로, 남겨 두면 옛 판(접기 규칙)의 줄이 그대로 남았다. 그동안(building) 검색은 엔진 방식이다
+   */
+  readonly clearIndex?: boolean;
+  readonly deletes?: readonly string[];
+  readonly upserts?: readonly IndexRowValues[];
+  readonly updates?: readonly IndexMutable[];
+  readonly state?: SearchStatePatch;
+}
+
+/** 쓰기 결과 — 상태 줄이 없으면(퇴사 마무리가 지웠다) 아무것도 쓰지 않고 written false */
+export interface SearchIndexWriteResult {
+  readonly written: boolean;
+  /** 메일함 · 키워드를 바꾼 메일 id — 색인에 없던 메일은 빠진다 */
+  readonly updatedIds: ReadonlySet<string>;
+}
+
+/**
+ * 넣기에서 바꿀 칸 (열 이름) — 키(user_email · email_id)와 대화 키(thread_key) 밖의 모두.
+ * 대화 키는 이미 있는 줄이면 그대로 둔다 — 합친 대화를 다시 넣기(겹친 채우기 등)가 풀지 않게 (새 줄은 그 메일의 id 로 넣고 linkThreads 가 잇는다)
+ */
+const UPSERT_COLUMNS = [
+  'mailbox_ids',
+  'keywords',
+  'received_at',
+  'size',
+  'message_id',
+  'refs',
+  'subject',
+  'subject_base',
+  'from_text',
+  'from_email',
+  'from_name',
+  'to_text',
+  'cc_text',
+  'attachment_names',
+  'has_attachment',
+  'preview',
+  'body_text',
+  'fold_from',
+  'fold_to',
+  'fold_subject',
+  'fold_attachment',
+  'fold_body',
+  'grams',
+  'engine_thread_id',
+  'indexed_at',
+];
+
+/**
+ * 메일 검색 색인 표(`mail_search_messages` · `mail_search_states`) 접근 (14단계 설계 A).
+ * 색인 줄을 쓰는 일(write)은 모두 그 직원의 상태 줄을 잠그고(FOR UPDATE) 같은 트랜잭션에서 한다 — 상태 줄이 없으면 쓰지 않는다
+ * (퇴사 마무리가 상태 줄 → 색인 줄 차례로 지운다 — ops-data.service.ts. 그사이 끝난 맞추기가 줄을 되살리지 않게).
+ * 언제나 직원 주소(user_email)로 묻는다.
+ */
+@Injectable()
+export class MailSearchIndexRepository {
+  constructor(@InjectDataSource() private readonly dataSource: DataSource) {}
+
+  findState(userEmail: string): Promise<MailSearchStateEntity | null> {
+    return this.dataSource.manager.findOneBy(MailSearchStateEntity, {
+      userEmail,
+    });
+  }
+
+  /**
+   * 상태 줄이 없으면 `building` 으로 만들고, 멈춰 있으면 푼다(실패 수도 0) — 직원이 로그인했으니 대리 접근이 다시 될 것이다.
+   * 있고 멈추지 않았으면 쓰지 않는다(로그인 · 상태 묻기마다 줄을 고쳐 쓰지 않게).
+   *
+   * 퇴사 마무리 바로 뒤 남은 액세스 토큰으로 GET /api/search-index 가 오면 빈 상태 줄(building)이 다시 생길 수 있다 — 고치지 않는다:
+   * 엔진 계정이 먼저 지워졌으므로 채우기 · 맞추기는 대리 접근에서 막혀(AUTH_001) 그 줄을 멈출 뿐 메일 줄은 생기지 않고,
+   * 끊은 세션은 15초 안에 막힌다. 같은 주소를 새 사람이 쓰면 그 사람의 로그인이 그 줄로 처음부터 채운다(옛 메일 줄이 없다)
+   */
+  async ensureState(
+    userEmail: string,
+    now: Date,
+  ): Promise<MailSearchStateEntity> {
+    const existing = await this.findState(userEmail);
+    if (existing && existing.pausedReason === null) return existing;
+    if (existing) {
+      await this.dataSource.manager.update(
+        MailSearchStateEntity,
+        { userEmail },
+        { pausedReason: null, failureCount: 0, updatedAt: now },
+      );
+    } else {
+      await this.dataSource.manager
+        .createQueryBuilder()
+        .insert()
+        .into(MailSearchStateEntity)
+        .values({
+          userEmail,
+          status: 'building',
+          emailState: null,
+          buildAnchor: null,
+          buildDone: 0,
+          buildTotal: null,
+          buildStartedAt: null,
+          readyAt: null,
+          lastSyncedAt: null,
+          pausedReason: null,
+          failureCount: 0,
+          indexFormat: INDEX_FORMAT,
+          createdAt: now,
+          updatedAt: now,
+        })
+        .orIgnore()
+        .execute();
+    }
+    const saved = await this.findState(userEmail);
+    if (!saved) {
+      // 만든 바로 뒤 다른 곳(퇴사 마무리)이 지웠다 — 처음 상태로 본다
+      const fresh = new MailSearchStateEntity();
+      Object.assign(fresh, {
+        userEmail,
+        status: 'building',
+        emailState: null,
+        buildAnchor: null,
+        buildDone: 0,
+        buildTotal: null,
+        buildStartedAt: null,
+        readyAt: null,
+        lastSyncedAt: null,
+        pausedReason: null,
+        failureCount: 0,
+        indexFormat: INDEX_FORMAT,
+        createdAt: now,
+        updatedAt: now,
+      });
+      return fresh;
+    }
+    return saved;
+  }
+
+  /**
+   * 판이 다른 줄을 building 으로 되돌린다 (색인 판 — mail-search.constants.ts 의 INDEX_FORMAT) → 되돌린 줄 수.
+   * 맞출 기준 · 채우기 자리를 지워 밤에 처음부터 다시 채운다 — 옛 색인 줄은 채우기가 시작하는 첫 묶음에서 지운다(SearchIndexWrite 의 clearIndex).
+   * 그동안 그 직원의 검색은 엔진 방식이다. `addressSuffix`(`@사내 도메인`)로 끝나는 주소만 (같은 DB 의 다른 도메인 줄은 그쪽 서버가 한다)
+   */
+  async resetOutdatedFormats(
+    addressSuffix: string,
+    format: number,
+    now: Date,
+  ): Promise<number> {
+    const [rows] = await this.dataSource.query<[unknown[], number]>(
+      `UPDATE "${SEARCH_STATES_TABLE}"
+          SET "status" = 'building', "email_state" = NULL, "build_anchor" = NULL, "build_done" = 0, "build_total" = NULL,
+              "build_started_at" = NULL, "ready_at" = NULL, "failure_count" = 0, "index_format" = $2, "updated_at" = $3
+        WHERE "index_format" <> $2 AND right("user_email", length($1)) = $1
+        RETURNING "user_email"`,
+      [addressSuffix, format, now],
+    );
+    return rows.length;
+  }
+
+  /** 5분 맞추기의 차례 — 맞출 기준(email_state)이 있고 멈추지 않은 직원, 오래 맞추지 않은 차례로 */
+  syncCandidates(): Promise<MailSearchStateEntity[]> {
+    return this.dataSource.manager
+      .createQueryBuilder(MailSearchStateEntity, 'state')
+      .where('state.email_state IS NOT NULL')
+      .andWhere('state.paused_reason IS NULL')
+      .orderBy('state.last_synced_at', 'ASC', 'NULLS FIRST')
+      .addOrderBy('state.user_email', 'ASC')
+      .getMany();
+  }
+
+  /** 밤 채우기의 차례 — building 이고 멈추지 않은 직원: 실패가 적은 · 먼저 시작한 · 먼저 만든 차례로 */
+  buildCandidates(limit: number): Promise<MailSearchStateEntity[]> {
+    return this.dataSource.manager
+      .createQueryBuilder(MailSearchStateEntity, 'state')
+      .where('state.status = :status', { status: 'building' })
+      .andWhere('state.paused_reason IS NULL')
+      .orderBy('state.failure_count', 'ASC')
+      .addOrderBy('state.build_started_at', 'ASC', 'NULLS LAST')
+      .addOrderBy('state.created_at', 'ASC')
+      .limit(limit)
+      .getMany();
+  }
+
+  /** 실패 한 번 → 이어진 실패 수 (줄이 없으면 0) */
+  async recordFailure(userEmail: string, now: Date): Promise<number> {
+    // UPDATE 의 결과는 [줄들, 바꾼 수] (TypeORM 의 postgres 드라이버)
+    const [rows] = await this.dataSource.query<
+      [{ failure_count: number }[], number]
+    >(
+      `UPDATE "${SEARCH_STATES_TABLE}" SET "failure_count" = "failure_count" + 1, "updated_at" = $2 WHERE "user_email" = $1 RETURNING "failure_count"`,
+      [userEmail, now],
+    );
+    return Number(rows[0]?.failure_count ?? 0);
+  }
+
+  /** 대리 접근이 막혀 멈춘다 (다음 로그인 때 ensureState 가 푼다) */
+  async pause(
+    userEmail: string,
+    reason: SearchPausedReason,
+    now: Date,
+  ): Promise<void> {
+    await this.dataSource.manager.update(
+      MailSearchStateEntity,
+      { userEmail },
+      { pausedReason: reason, updatedAt: now },
+    );
+  }
+
+  /** 그 직원의 색인 줄 수 */
+  async countMessages(userEmail: string): Promise<number> {
+    const rows: { count: number }[] = await this.dataSource.query(
+      `SELECT count(*)::int AS "count" FROM "${SEARCH_MESSAGES_TABLE}" WHERE "user_email" = $1`,
+      [userEmail],
+    );
+    return Number(rows[0]?.count ?? 0);
+  }
+
+  /** 주어진 id 가운데 그 직원의 색인에 있는 것 */
+  async existingIds(
+    userEmail: string,
+    ids: readonly string[],
+  ): Promise<Set<string>> {
+    if (ids.length === 0) return new Set();
+    const rows: { email_id: string }[] = await this.dataSource.query(
+      `SELECT "email_id" FROM "${SEARCH_MESSAGES_TABLE}" WHERE "user_email" = $1 AND "email_id" = ANY($2::text[])`,
+      [userEmail, [...ids]],
+    );
+    return new Set(rows.map((row) => row.email_id));
+  }
+
+  /** 그 직원의 색인에 든 메일 id 모두 (전체 대조) */
+  async indexedIds(userEmail: string): Promise<string[]> {
+    const rows: { email_id: string }[] = await this.dataSource.query(
+      `SELECT "email_id" FROM "${SEARCH_MESSAGES_TABLE}" WHERE "user_email" = $1`,
+      [userEmail],
+    );
+    return rows.map((row) => row.email_id);
+  }
+
+  /**
+   * 한 트랜잭션에 쓴다 — 상태 줄을 잠그고(없으면 쓰지 않는다), (모두 지우기) → 지우기 → 넣기 → 메일함 · 키워드 → 상태 줄(실패 수 0).
+   * `now` 는 넣은 줄의 indexed_at · 상태 줄의 updated_at
+   */
+  async write(
+    userEmail: string,
+    change: SearchIndexWrite,
+    now: Date,
+  ): Promise<SearchIndexWriteResult> {
+    return this.dataSource.transaction(async (manager) => {
+      const locked: unknown[] = await manager.query(
+        `SELECT 1 FROM "${SEARCH_STATES_TABLE}" WHERE "user_email" = $1 FOR UPDATE`,
+        [userEmail],
+      );
+      if (locked.length === 0) {
+        return { written: false, updatedIds: new Set<string>() };
+      }
+      if (change.clearIndex) {
+        await manager.query(
+          `DELETE FROM "${SEARCH_MESSAGES_TABLE}" WHERE "user_email" = $1`,
+          [userEmail],
+        );
+      }
+      const deletes = [...new Set(change.deletes ?? [])];
+      if (deletes.length > 0) {
+        await manager.query(
+          `DELETE FROM "${SEARCH_MESSAGES_TABLE}" WHERE "user_email" = $1 AND "email_id" = ANY($2::text[])`,
+          [userEmail, deletes],
+        );
+      }
+      const upserted = await this.upsertRows(
+        manager,
+        userEmail,
+        change.upserts ?? [],
+        now,
+      );
+      await this.linkThreads(manager, userEmail, upserted);
+      const updatedIds = await this.updateMutable(
+        manager,
+        userEmail,
+        change.updates ?? [],
+      );
+      if (change.state) {
+        await manager.update(
+          MailSearchStateEntity,
+          { userEmail },
+          { ...change.state, failureCount: 0, updatedAt: now },
+        );
+      }
+      return { written: true, updatedIds };
+    });
+  }
+
+  /** 넣기(있으면 대화 키 밖의 모든 칸을 바꾸기) → 넣은 id — 한 요청에 같은 id 가 둘이면 뒤의 것만 (ON CONFLICT 는 한 문장 안의 같은 키를 받지 않는다) */
+  private async upsertRows(
+    manager: EntityManager,
+    userEmail: string,
+    rows: readonly IndexRowValues[],
+    now: Date,
+  ): Promise<string[]> {
+    if (rows.length === 0) return [];
+    const latest = new Map(rows.map((row) => [row.emailId, row]));
+    await manager
+      .createQueryBuilder()
+      .insert()
+      .into(MailSearchMessageEntity)
+      .values(
+        [...latest.values()].map((row) => ({
+          ...row,
+          userEmail,
+          indexedAt: now,
+        })),
+      )
+      .orUpdate(UPSERT_COLUMNS, ['user_email', 'email_id'])
+      .execute();
+    return [...latest.keys()];
+  }
+
+  /**
+   * 대화 키 잇기 (14단계 설계 B4) — 넣은 메일 M 마다, M 의 답장 관계(refs)가 가리키는 메일과 M 을 가리키는 메일 가운데 말머리를 뗀 제목이 같은 것의
+   * 키를 M 의 키와 하나로(가장 작은 키 — thread-keys.ts). Message-ID 가 없는 메일은 잇지 않는다(혼자). 그 직원의 줄만 본다.
+   * 쿼리 둘: 이어진 키 쌍 읽기(주소 + Message-ID 색인 · refs GIN) → 바꿀 키를 한 문장으로 UPDATE(주소 + 대화 키 색인). 쓰기 트랜잭션 안이다(상태 줄 잠금 — 같은 직원은 차례로)
+   */
+  private async linkThreads(
+    manager: EntityManager,
+    userEmail: string,
+    ids: readonly string[],
+  ): Promise<void> {
+    if (ids.length === 0) return;
+    const links = await manager.query<{ a: string; b: string }[]>(
+      `SELECT "n"."thread_key" AS "a", "o"."thread_key" AS "b"
+         FROM "${SEARCH_MESSAGES_TABLE}" AS "n"
+         JOIN "${SEARCH_MESSAGES_TABLE}" AS "o"
+           ON "o"."user_email" = "n"."user_email" AND "o"."message_id" = ANY("n"."refs") AND "o"."subject_base" = "n"."subject_base"
+        WHERE "n"."user_email" = $1 AND "n"."email_id" = ANY($2::text[]) AND "n"."message_id" IS NOT NULL
+          AND "o"."thread_key" <> "n"."thread_key"
+       UNION
+       SELECT "n"."thread_key", "o"."thread_key"
+         FROM "${SEARCH_MESSAGES_TABLE}" AS "n"
+         JOIN "${SEARCH_MESSAGES_TABLE}" AS "o"
+           ON "o"."user_email" = "n"."user_email" AND "o"."refs" @> ARRAY["n"."message_id"]::text[] AND "o"."subject_base" = "n"."subject_base"
+        WHERE "n"."user_email" = $1 AND "n"."email_id" = ANY($2::text[]) AND "n"."message_id" IS NOT NULL
+          AND "o"."message_id" IS NOT NULL AND "o"."thread_key" <> "n"."thread_key"`,
+      [userEmail, [...ids]],
+    );
+    const renames = mergeThreadKeys(links.map((link) => [link.a, link.b]));
+    if (renames.size === 0) return;
+    await manager.query(
+      `UPDATE "${SEARCH_MESSAGES_TABLE}" AS "message" SET "thread_key" = "rename"."to"
+         FROM unnest($2::text[], $3::text[]) AS "rename"("from", "to")
+        WHERE "message"."user_email" = $1 AND "message"."thread_key" = "rename"."from"`,
+      [userEmail, [...renames.keys()], [...renames.values()]],
+    );
+  }
+
+  /** 메일함 · 키워드만 바꾼다 (한 문장) → 바꾼 id */
+  private async updateMutable(
+    manager: EntityManager,
+    userEmail: string,
+    updates: readonly IndexMutable[],
+  ): Promise<Set<string>> {
+    if (updates.length === 0) return new Set();
+    const values: Record<string, { m: string[]; k: string[] }> = {};
+    for (const update of updates) {
+      values[update.id] = {
+        m: [...new Set(update.mailboxIds)],
+        k: [...new Set(update.keywords)],
+      };
+    }
+    const [rows] = await manager.query<[{ email_id: string }[], number]>(
+      `UPDATE "${SEARCH_MESSAGES_TABLE}" AS "message"
+         SET "mailbox_ids" = ARRAY(SELECT jsonb_array_elements_text("change"."value" -> 'm')),
+             "keywords" = ARRAY(SELECT jsonb_array_elements_text("change"."value" -> 'k'))
+        FROM jsonb_each($2::jsonb) AS "change"("key", "value")
+       WHERE "message"."user_email" = $1 AND "message"."email_id" = "change"."key"
+       RETURNING "message"."email_id"`,
+      [userEmail, JSON.stringify(values)],
+    );
+    return new Set(rows.map((row) => row.email_id));
+  }
+}
diff --git a/backend/src/modules/mail-search/mail-search-index.service.spec.ts b/backend/src/modules/mail-search/mail-search-index.service.spec.ts
new file mode 100644
index 0000000..9c29424
--- /dev/null
+++ b/backend/src/modules/mail-search/mail-search-index.service.spec.ts
@@ -0,0 +1,135 @@
+import { Logger } from '@nestjs/common';
+
+import type { MailSearchIndexRepository } from './mail-search-index.repository';
+import {
+  MailSearchIndexService,
+  toStatusView,
+} from './mail-search-index.service';
+import { INDEX_FORMAT } from './mail-search.constants';
+
+const ARA = 'ara.kim@arasystem.test';
+
+describe('MailSearchIndexService (검색 색인의 직원 상태)', () => {
+  let ensureState: jest.Mock;
+  let findState: jest.Mock;
+  let service: MailSearchIndexService;
+  let warnings: string[];
+
+  beforeEach(() => {
+    ensureState = jest.fn().mockResolvedValue({
+      status: 'building',
+      buildDone: 0,
+      buildTotal: null,
+      indexFormat: INDEX_FORMAT,
+    });
+    findState = jest.fn().mockResolvedValue(null);
+    service = new MailSearchIndexService({
+      ensureState,
+      findState,
+    } as unknown as MailSearchIndexRepository);
+    warnings = [];
+    jest.spyOn(Logger.prototype, 'warn').mockImplementation((message) => {
+      warnings.push(String(message));
+    });
+  });
+
+  afterEach(() => jest.restoreAllMocks());
+
+  it('상태를 물으면 줄을 만들거나 멈춤을 풀고(소문자 주소로) 준비 상태를 준다', async () => {
+    expect(await service.status(' Ara.Kim@ARASYSTEM.test ')).toEqual({
+      status: 'building',
+      done: 0,
+      total: null,
+    });
+    expect(ensureState).toHaveBeenCalledWith(ARA, expect.any(Date));
+  });
+
+  it('로그인 뒤 줄 만들기가 실패해도 던지지 않는다 — 경고만 (주소 · DB 문장은 가려서)', async () => {
+    ensureState.mockRejectedValue(
+      Object.assign(new Error(`duplicate key (${ARA})`), { code: '23505' }),
+    );
+    await expect(service.enrollAfterLogin(ARA)).resolves.toBeUndefined();
+    expect(warnings).toHaveLength(1);
+    expect(warnings[0]).toContain('Error/23505');
+    expect(warnings[0]).not.toContain(ARA);
+  });
+
+  it('toStatusView — 다 만들었으면 채운 수 = 채울 수', () => {
+    expect(
+      toStatusView({
+        status: 'ready',
+        buildDone: 120,
+        buildTotal: 120,
+        indexFormat: INDEX_FORMAT,
+      }),
+    ).toEqual({ status: 'ready', done: 120, total: 120 });
+  });
+
+  it('toStatusView — 채운 수는 채울 수를 넘지 않는다 (채우는 동안 온 메일 · 위치로 이어 간 겹침) · 시작 전에는 채울 수 null', () => {
+    expect(
+      toStatusView({
+        status: 'building',
+        buildDone: 130,
+        buildTotal: 120,
+        indexFormat: INDEX_FORMAT,
+      }),
+    ).toEqual({ status: 'building', done: 120, total: 120 });
+    expect(
+      toStatusView({
+        status: 'building',
+        buildDone: 0,
+        buildTotal: null,
+        indexFormat: INDEX_FORMAT,
+      }),
+    ).toEqual({ status: 'building', done: 0, total: null });
+  });
+
+  it('toStatusView — 판이 다른 줄은 되돌리기 전이어도 building · 채운 0 (검색 방식과 같은 판정)', () => {
+    expect(
+      toStatusView({
+        status: 'ready',
+        buildDone: 120,
+        buildTotal: 120,
+        indexFormat: INDEX_FORMAT - 1,
+      }),
+    ).toEqual({ status: 'building', done: 0, total: null });
+  });
+
+  describe('색인으로 찾을 수 있나 (isSearchReady)', () => {
+    const ready = {
+      status: 'ready',
+      indexFormat: INDEX_FORMAT,
+      pausedReason: null,
+    };
+
+    it('다 만들었고 · 지금 판이고 · 멈추지 않았을 때만 (소문자 주소로 묻는다)', async () => {
+      findState.mockResolvedValue(ready);
+      await expect(
+        service.isSearchReady(' Ara.Kim@ARASYSTEM.test '),
+      ).resolves.toBe(true);
+      expect(findState).toHaveBeenCalledWith(ARA);
+    });
+
+    it.each([
+      ['줄 없음', null],
+      ['채우는 중', { ...ready, status: 'building' }],
+      ['판이 다름(되돌리기 전)', { ...ready, indexFormat: INDEX_FORMAT - 1 }],
+      ['대리 접근이 막혀 멈춤', { ...ready, pausedReason: 'locked' }],
+    ])('%s 이면 엔진 방식', async (_label, state) => {
+      findState.mockResolvedValue(state);
+      await expect(service.isSearchReady(ARA)).resolves.toBe(false);
+    });
+
+    it('상태를 읽지 못하면(DB 장애) 엔진 방식 — 경고만, 주소 · DB 문장은 가린다', async () => {
+      findState.mockRejectedValue(
+        Object.assign(new Error(`connection to ${ARA} lost`), {
+          code: '57P01',
+        }),
+      );
+      await expect(service.isSearchReady(ARA)).resolves.toBe(false);
+      expect(warnings).toHaveLength(1);
+      expect(warnings[0]).toContain('Error/57P01');
+      expect(warnings[0]).not.toContain(ARA);
+    });
+  });
+});
diff --git a/backend/src/modules/mail-search/mail-search-index.service.ts b/backend/src/modules/mail-search/mail-search-index.service.ts
new file mode 100644
index 0000000..9107daf
--- /dev/null
+++ b/backend/src/modules/mail-search/mail-search-index.service.ts
@@ -0,0 +1,94 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+import { traceTag } from '@/shared/logger/request-context';
+import { maskEmail } from '@/shared/utils/mask';
+import { MailSearchIndexRepository } from './mail-search-index.repository';
+import { INDEX_FORMAT } from './mail-search.constants';
+import type { MailSearchStateEntity } from './mail-search-state.entity';
+import type { SearchIndexStatusView } from './mail-search.types';
+
+/**
+ * 상태 줄 → 화면의 준비 상태 (GET /api/search-index). 채운 수는 채울 수를 넘지 않게 묶는다 —
+ * 채울 수는 시작할 때의 메일 수라, 채우는 동안 온 메일 · 위치로 이어 간 겹침으로 넣은 수가 더 커질 수 있다.
+ * 판(INDEX_FORMAT)이 다른 줄은 아직 되돌리지 못했어도 building · 채운 0 으로 보인다 — 검색 방식(isSearchReady)과 같은 판정이다
+ */
+export function toStatusView(
+  state: Pick<
+    MailSearchStateEntity,
+    'status' | 'buildDone' | 'buildTotal' | 'indexFormat'
+  >,
+): SearchIndexStatusView {
+  if (state.indexFormat !== INDEX_FORMAT) {
+    return { status: 'building', done: 0, total: null };
+  }
+  const done = Math.max(0, state.buildDone);
+  const total =
+    state.buildTotal === null ? null : Math.max(0, state.buildTotal);
+  return {
+    status: state.status,
+    done: total === null ? done : Math.min(done, total),
+    total,
+  };
+}
+
+/** DB 오류의 문장에는 값(주소 등)이 들어갈 수 있다 — 종류와 코드만 */
+function errorKind(error: unknown): string {
+  const name = error instanceof Error ? error.name : typeof error;
+  const code = (error as { code?: unknown } | null)?.code;
+  return typeof code === 'string' ? `${name}/${code}` : name;
+}
+
+/**
+ * 검색 색인의 직원 상태 (14단계 설계 A2 · C1) — 상태 줄 만들기 · 멈춤 풀기 · 준비 상태 알리기.
+ * 줄은 직원이 웹메일에 로그인할 때(AuthService) · 검색 준비 상태를 물을 때 만든다 — 로그인한 적 없는 계정은 색인하지 않는다.
+ * 대리 접근이 막혀 멈췄던 줄은 이때 푼다(로그인했으니 다시 될 것이다).
+ */
+@Injectable()
+export class MailSearchIndexService {
+  private readonly logger = new Logger(MailSearchIndexService.name);
+
+  constructor(private readonly repository: MailSearchIndexRepository) {}
+
+  /** 로그인에 성공한 직원 — 상태 줄을 만들거나 멈춤을 푼다. 던지지 않는다(못 해도 로그인은 그대로 — 다음 로그인 · 검색 때 다시) */
+  async enrollAfterLogin(user: string): Promise<void> {
+    try {
+      await this.repository.ensureState(normalize(user), new Date());
+    } catch (error) {
+      this.logger.warn(
+        `[SYS_001]${traceTag()} 검색 색인의 상태 줄을 만들지 못했습니다(다음 로그인 때 다시): user=${maskEmail(user)}, reason=${errorKind(error)}`,
+      );
+    }
+  }
+
+  /**
+   * 색인으로 찾을 수 있나 (14단계 — 검색 방식 고르기) — 다 만들었고(ready) · 지금 판(INDEX_FORMAT)이고 · 멈추지 않았을 때.
+   * 상태를 읽지 못하면(DB 장애) false — 엔진 방식으로 찾는다(검색을 실패로 만들지 않는다)
+   */
+  async isSearchReady(user: string): Promise<boolean> {
+    try {
+      const state = await this.repository.findState(normalize(user));
+      return (
+        state !== null &&
+        state.status === 'ready' &&
+        state.indexFormat === INDEX_FORMAT &&
+        state.pausedReason === null
+      );
+    } catch (error) {
+      this.logger.warn(
+        `[SYS_001]${traceTag()} 검색 색인 상태를 읽지 못해 엔진 방식으로 찾습니다: user=${maskEmail(user)}, reason=${errorKind(error)}`,
+      );
+      return false;
+    }
+  }
+
+  /** GET /api/search-index — 줄이 없던 직원은 이때 만든다(building · 채운 0) */
+  async status(user: string): Promise<SearchIndexStatusView> {
+    return toStatusView(
+      await this.repository.ensureState(normalize(user), new Date()),
+    );
+  }
+}
+
+function normalize(user: string): string {
+  return user.trim().toLowerCase();
+}
diff --git a/backend/src/modules/mail-search/mail-search-message.entity.ts b/backend/src/modules/mail-search/mail-search-message.entity.ts
new file mode 100644
index 0000000..dc16e8f
--- /dev/null
+++ b/backend/src/modules/mail-search/mail-search-message.entity.ts
@@ -0,0 +1,171 @@
+import { Column, Entity, Index, PrimaryColumn } from 'typeorm';
+
+import {
+  INDEX_FROM_NAME_MAX_CHARS,
+  SEARCH_EMAIL_COLUMN_LENGTH,
+  SEARCH_ID_COLUMN_LENGTH,
+  SEARCH_MESSAGES_TABLE,
+} from './mail-search.constants';
+
+/**
+ * 메일 검색 색인의 한 줄 — 직원 주소 + 엔진 메일 id 마다 (14단계 설계 A1).
+ * 언제나 로그인한 직원 주소(user_email)로만 묻는다 — 남의 줄을 읽는 길이 없다.
+ *
+ * 글 칸은 둘씩이다 — 원문(NFC — 맞은 곳의 위치를 그 위에 그린다)과 접기 글(fold_* — shared/utils/search-text.ts 의 foldText, strpos 확인용).
+ * 접기는 코드 포인트 하나씩 바꾸므로 두 글의 위치가 같다. grams 는 다섯 접기 칸의 글자 두 개 묶음(겹치지 않게 — 칸 경계 · 공백을 넘지 않는다)이고
+ * GIN 으로 후보를 좁힌다.
+ *
+ * GIN 색인 둘((lower(user_email), grams, mailbox_ids) · refs)은 마이그레이션이 직접 만든다 — TypeORM 이 GIN 을 적지 못해 `synchronize: false` 로 이름만 알린다
+ * (migration:generate 가 지우지 않게). 찾기 GIN 은 직원 주소 · 묶음 · 메일함을 한 색인에 담는다(btree_gin — 14단계 2차 `SearchIndexUserGrams` →
+ * 실사용 시험 `SearchIndexUserGramsMailboxes`). GIN 의 posting 은 칸마다 따로라 흔한 묶음 · 메일함 id 는 **회사 전체** 줄의 posting 이다
+ * (메일함 id 는 계정마다 같은 꼴(a · b …)이다) — 색인 하나가 그 직원 주소의 posting 과 맞추고 맞은 줄만 읽는다(10명 흉내에서 '계약' 7만여 줄 · 수 ms).
+ * 주소 칸은 lower 식이라 후보 쿼리(search-sql.ts 의 candidatesSql)만 이 색인을 쓴다. **메일함만 담은 GIN 을 다시 만들지 않는다** — 계획기가 그것만으로
+ * 메일함의 줄을 모두 읽고 묶음 배열(TOAST)을 줄마다 풀어 보는 길을 고를 수 있게 된다(2026-11-06 — 1만 통 메일함 안 1.1초 · 남의 큰 메일함과 id 가 같은 빈 메일함 1.6초)
+ */
+@Entity({ name: SEARCH_MESSAGES_TABLE })
+@Index('IDX_mail_search_messages_received', [
+  'userEmail',
+  'receivedAt',
+  'emailId',
+])
+@Index('IDX_mail_search_messages_message_id', ['userEmail', 'messageId'])
+@Index('IDX_mail_search_messages_thread_key', ['userEmail', 'threadKey'])
+@Index('IDX_mail_search_messages_user_grams_mailboxes', { synchronize: false })
+@Index('IDX_mail_search_messages_refs', { synchronize: false })
+export class MailSearchMessageEntity {
+  @PrimaryColumn({
+    name: 'user_email',
+    type: 'varchar',
+    length: SEARCH_EMAIL_COLUMN_LENGTH,
+  })
+  userEmail!: string;
+
+  /** 엔진 메일 id */
+  @PrimaryColumn({
+    name: 'email_id',
+    type: 'varchar',
+    length: SEARCH_ID_COLUMN_LENGTH,
+  })
+  emailId!: string;
+
+  /** 든 메일함 id 들 — 메일함 범위 · 휴지통 · 스팸메일함 빼기 */
+  @Column({ name: 'mailbox_ids', type: 'text', array: true })
+  mailboxIds!: string[];
+
+  /** 켜진 키워드(`$seen` · `$flagged` · `$draft` · 우리 내부 키워드) — 엔진이 준 그대로 */
+  @Column({ type: 'text', array: true })
+  keywords!: string[];
+
+  /** 받은 시각 — 차례 · 기간 */
+  @Column({ name: 'received_at', type: 'timestamptz' })
+  receivedAt!: Date;
+
+  @Column({ type: 'integer' })
+  size!: number;
+
+  /** 첫 Message-ID (꺾쇠 없이) — 없으면 null */
+  @Column({ name: 'message_id', type: 'text', nullable: true })
+  messageId!: string | null;
+
+  /** 답장 관계 — In-Reply-To 다음 References 를 가까운 것부터(겹치지 않게, 앞 INDEX_REFS_MAX 개) */
+  @Column({ type: 'text', array: true })
+  refs!: string[];
+
+  /** 제목 원문(NFC) */
+  @Column({ type: 'text' })
+  subject!: string;
+
+  /** 말머리를 뗀 제목의 접기 글 — 대화 키를 정할 때 (shared/utils/subject-base.ts) */
+  @Column({ name: 'subject_base', type: 'text' })
+  subjectBase!: string;
+
+  /** "이름 <주소>" 를 줄바꿈으로 이은 원문(NFC) — 보낸 사람 조건 검색(fold_from)의 바탕 */
+  @Column({ name: 'from_text', type: 'text' })
+  fromText!: string;
+
+  /**
+   * 첫 보낸 사람의 주소 (14단계 3차 리뷰 L3 — 묶은 목록의 참여자) — 엔진이 준 주소 그대로(앞뒤 공백만 지운 NFC). 주소가 없거나
+   * SEARCH_EMAIL_COLUMN_LENGTH 를 넘으면 null — 이름에 든 `<주소>` 꼴을 주소로 읽지 않는다 (참여자는 이 칸만 본다)
+   */
+  @Column({
+    name: 'from_email',
+    type: 'varchar',
+    length: SEARCH_EMAIL_COLUMN_LENGTH,
+    nullable: true,
+  })
+  fromEmail!: string | null;
+
+  /** 첫 보낸 사람의 이름 — 앞 INDEX_FROM_NAME_MAX_CHARS 코드 포인트, 없으면 null */
+  @Column({
+    name: 'from_name',
+    type: 'varchar',
+    length: INDEX_FROM_NAME_MAX_CHARS,
+    nullable: true,
+  })
+  fromName!: string | null;
+
+  @Column({ name: 'to_text', type: 'text' })
+  toText!: string;
+
+  @Column({ name: 'cc_text', type: 'text' })
+  ccText!: string;
+
+  /** 진짜 첨부(본문 그림이 아닌 것)의 이름을 줄바꿈으로 */
+  @Column({ name: 'attachment_names', type: 'text' })
+  attachmentNames!: string;
+
+  /** 목록과 같은 판정 (html/inline-images.ts 의 hasRealAttachment) */
+  @Column({ name: 'has_attachment', type: 'boolean' })
+  hasAttachment!: boolean;
+
+  /** 엔진의 미리 보기 */
+  @Column({ type: 'text' })
+  preview!: string;
+
+  /** 본문 글(HTML 이면 글자만) 앞 INDEX_BODY_MAX_CHARS 코드 포인트 */
+  @Column({ name: 'body_text', type: 'text' })
+  bodyText!: string;
+
+  @Column({ name: 'fold_from', type: 'text' })
+  foldFrom!: string;
+
+  /** 받는 사람과 참조를 함께 (조건 검색의 "받는 사람"은 참조를 포함한다) */
+  @Column({ name: 'fold_to', type: 'text' })
+  foldTo!: string;
+
+  @Column({ name: 'fold_subject', type: 'text' })
+  foldSubject!: string;
+
+  @Column({ name: 'fold_attachment', type: 'text' })
+  foldAttachment!: string;
+
+  @Column({ name: 'fold_body', type: 'text' })
+  foldBody!: string;
+
+  /** 다섯 접기 칸의 글자 두 개 묶음 — GIN (`grams @> 찾는 말의 묶음`) */
+  @Column({ type: 'text', array: true })
+  grams!: string[];
+
+  /**
+   * 우리 대화 키 (14단계 3차 — 설계 B4) — 넣을 때는 그 메일 id, 이어진 메일(답장 관계 + 말머리를 뗀 제목이 같음)을 찾으면 대화의 가장 작은 키로 합친다
+   * (mail-search-index.repository.ts 의 linkThreads). 다시 넣어도 이미 있는 줄의 키는 그대로다
+   */
+  @Column({
+    name: 'thread_key',
+    type: 'varchar',
+    length: SEARCH_ID_COLUMN_LENGTH,
+  })
+  threadKey!: string;
+
+  /** 엔진의 threadId (참고용 — 색인을 다 만들기 전의 대화 · 묶기는 엔진에 바로 묻는다) */
+  @Column({
+    name: 'engine_thread_id',
+    type: 'varchar',
+    length: SEARCH_ID_COLUMN_LENGTH,
+    nullable: true,
+  })
+  engineThreadId!: string | null;
+
+  @Column({ name: 'indexed_at', type: 'timestamptz' })
+  indexedAt!: Date;
+}
diff --git a/backend/src/modules/mail-search/mail-search-query.service.spec.ts b/backend/src/modules/mail-search/mail-search-query.service.spec.ts
new file mode 100644
index 0000000..6fb7f56
--- /dev/null
+++ b/backend/src/modules/mail-search/mail-search-query.service.spec.ts
@@ -0,0 +1,573 @@
+import type { DataSource } from 'typeorm';
+
+import { BusinessException } from '@/common/errors/business.exception';
+import {
+  SEARCH_CANDIDATE_COUNT_LIMIT,
+  SEARCH_CHECK_ROWS_GROWTH,
+  SEARCH_CHECK_ROWS_LIMIT,
+  SEARCH_FIRST_CHECK_ROWS,
+  SEARCH_TOTAL_LIMIT,
+} from './mail-search.constants';
+import { MailSearchQueryService } from './mail-search-query.service';
+import type { SearchCriteria, SearchScope } from './mail-search.types';
+import {
+  decodeIndexCursor,
+  encodeIndexCursor,
+  searchScopeKey,
+} from './search-cursor';
+import { planSearch } from './search-plan';
+
+const USER = 'ara.kim@arasystem.test';
+const SCOPE: SearchScope = {
+  mailboxId: null,
+  excludedMailboxIds: ['b', 'c'],
+  excludedKeywords: ['$ara-sending'],
+};
+
+/** 쿼리의 종류 — 쿼리마다 다른 모양으로 가른다 (search-sql.ts) */
+type QueryKind =
+  | 'candidates'
+  | 'check'
+  | 'keyset'
+  | 'frontier'
+  | 'keysetCount'
+  | 'plainPage'
+  | 'plainCount'
+  | 'highlight';
+
+function kindOf(sql: string): QueryKind {
+  if (sql.includes('lower("user_email")')) return 'candidates';
+  if (sql.includes('"body_text"')) return 'highlight';
+  if (sql.includes('AS "hits"')) return 'keysetCount';
+  if (sql.includes('AS "scanned"')) return 'frontier';
+  if (sql.includes('AS "matches"')) return 'plainCount';
+  if (sql.includes('AS "scan"')) return 'keyset';
+  if (sql.includes('= ANY(')) return 'check';
+  return 'plainPage';
+}
+
+interface Recorded {
+  readonly kind: QueryKind;
+  readonly sql: string;
+  readonly params: unknown[];
+  /** 그 쿼리 앞에 건 계획기 설정 (그 트랜잭션의 것) */
+  readonly settings: string[];
+  /** 몇 번째 트랜잭션의 쿼리인가 (트랜잭션 밖이면 null) · 그 격리 수준 */
+  readonly transaction: number | null;
+  readonly isolation: string | null;
+}
+
+interface Row {
+  readonly email_id: string;
+  readonly received_at: Date;
+}
+
+/** 받은 시각이 최신부터인 줄들 — id 는 m1, m2 … */
+function rows(count: number, from = 0): Row[] {
+  return Array.from({ length: count }, (_, index) => ({
+    email_id: `m${from + index + 1}`,
+    received_at: new Date(
+      Date.UTC(2026, 10, 2, 0, 0, 0) - (from + index) * 60_000,
+    ),
+  }));
+}
+
+/** 확인 쿼리의 id 매개변수 */
+const idsOf = (query: Recorded) => query.params[1] as string[];
+
+function fakeDataSource(
+  answers: Partial<Record<QueryKind, (params: unknown[]) => unknown[]>>,
+) {
+  const recorded: Recorded[] = [];
+  let transactions = 0;
+  const answer = (
+    sql: string,
+    params: unknown[] | undefined,
+    context: {
+      settings: string[];
+      transaction: number | null;
+      isolation: string | null;
+    },
+  ) => {
+    const kind = kindOf(sql);
+    recorded.push({ kind, sql, params: params ?? [], ...context });
+    const respond = answers[kind];
+    if (!respond) throw new Error(`준비하지 않은 쿼리: ${kind}`);
+    return Promise.resolve(respond(params ?? []));
+  };
+  const dataSource = {
+    transaction: jest.fn(
+      (
+        isolation: string,
+        run: (manager: {
+          query: (sql: string, params?: unknown[]) => Promise<unknown>;
+        }) => Promise<unknown>,
+      ) => {
+        transactions += 1;
+        const context = {
+          settings: [] as string[],
+          transaction: transactions,
+          isolation,
+        };
+        return run({
+          query: (sql: string, params?: unknown[]) => {
+            if (sql.startsWith('SET LOCAL')) {
+              context.settings.push(sql);
+              return Promise.resolve([]);
+            }
+            return answer(sql, params, context);
+          },
+        });
+      },
+    ),
+    query: jest.fn((sql: string, params?: unknown[]) =>
+      answer(sql, params, { settings: [], transaction: null, isolation: null }),
+    ),
+  };
+  return {
+    recorded,
+    service: new MailSearchQueryService(dataSource as unknown as DataSource),
+  };
+}
+
+/** 확인 — 준 id 가운데 `matches` 를 만족하는 것만 맞았다고 답한다 */
+const answerChecks =
+  (matches: (id: string) => boolean) =>
+  (params: unknown[]): unknown[] =>
+    (params[1] as string[]).filter(matches).map((email_id) => ({ email_id }));
+
+const numberOf = (id: string) => Number(id.slice(1));
+
+const criteria = (overrides: Partial<SearchCriteria>): SearchCriteria => ({
+  hasAttachment: false,
+  ...overrides,
+});
+
+async function search(
+  service: MailSearchQueryService,
+  given: SearchCriteria,
+  page: { limit: number; cursor?: string } = { limit: 20 },
+  user = USER,
+) {
+  return service.search(user, SCOPE, given, planSearch(given), page);
+}
+
+describe('MailSearchQueryService (색인으로 찾기 — 14단계 설계 G)', () => {
+  const bitmapHint = [
+    'SET LOCAL enable_seqscan = off',
+    'SET LOCAL enable_indexscan = off',
+  ];
+  const keysetHint = [
+    'SET LOCAL enable_bitmapscan = off',
+    'SET LOCAL enable_seqscan = off',
+  ];
+
+  describe('묶음이 있는 찾기 — 후보(GIN)를 받은 시각으로 읽고 필요한 만큼만 확인', () => {
+    it(`후보는 GIN 의 bitmap 으로만 · 받은 시각 최신부터 확인 상한 + 1(${SEARCH_CHECK_ROWS_LIMIT + 1})줄까지 — 두 글자 낱말뿐이면 후보가 곧 결과(확인하지 않는다)`, async () => {
+      const { service, recorded } = fakeDataSource({
+        candidates: () => rows(25),
+      });
+
+      const page = await search(service, criteria({ text: '계약' }));
+
+      expect(recorded.map((query) => query.kind)).toEqual(['candidates']);
+      expect(recorded[0].settings).toEqual(bitmapHint);
+      expect(recorded[0].params.at(-1)).toBe(SEARCH_CHECK_ROWS_LIMIT + 1);
+      expect(page.hits.map((hit) => hit.id)).toEqual(
+        rows(20).map((row) => row.email_id),
+      );
+      expect(page.hasNext).toBe(true);
+      expect(page.total).toBe(25);
+      // 다음 쪽 커서 — 이 쪽의 마지막 줄 다음부터, 같은 검색에서만
+      const key = searchScopeKey(undefined, criteria({ text: '계약' }));
+      expect(decodeIndexCursor(page.nextCursor!, key)).toEqual({
+        receivedAt: rows(20)[19].received_at,
+        emailId: 'm20',
+      });
+    });
+
+    it(`두 글자 낱말뿐인 찾기의 total — ${SEARCH_TOTAL_LIMIT}을 넘거나 후보가 상한 밖까지 있으면 null`, async () => {
+      for (const count of [
+        SEARCH_TOTAL_LIMIT + 1,
+        SEARCH_CHECK_ROWS_LIMIT + 1,
+      ]) {
+        const { service } = fakeDataSource({ candidates: () => rows(count) });
+        const page = await search(service, criteria({ text: '계약 확인' }));
+        expect(page.total).toBeNull();
+        expect(page.hits).toHaveLength(20);
+        expect(page.hasNext).toBe(true);
+      }
+    });
+
+    it(`후보가 ${SEARCH_CANDIDATE_COUNT_LIMIT}개 이하면 한 번에 모두 확인한다 — 첫 쪽의 total 은 맞은 수`, async () => {
+      const { service, recorded } = fakeDataSource({
+        candidates: () => rows(40),
+        check: answerChecks((id) => numberOf(id) % 4 !== 0),
+      });
+
+      const page = await search(service, criteria({ text: '계약서' }));
+
+      expect(recorded.map((query) => query.kind)).toEqual([
+        'candidates',
+        'check',
+      ]);
+      expect(idsOf(recorded[1])).toHaveLength(40);
+      // 확인은 기본 키로 그 줄만 — 계획기 설정 없이
+      expect(recorded[1].settings).toEqual([]);
+      expect(page.hits).toHaveLength(20);
+      expect(page.hits.map((hit) => hit.id)).not.toContain('m4');
+      expect(page.hasNext).toBe(true);
+      expect(page.total).toBe(30);
+    });
+
+    it(`후보가 많으면 받은 차례로 ${SEARCH_FIRST_CHECK_ROWS}줄부터 ${SEARCH_CHECK_ROWS_GROWTH}배씩 확인하다 쪽이 차면 멈춘다 — total 은 모른다(null)`, async () => {
+      const { service, recorded } = fakeDataSource({
+        candidates: () => rows(2_500),
+        check: answerChecks((id) => numberOf(id) % 100 === 0),
+      });
+
+      const page = await search(service, criteria({ text: '"계약 갱신"' }));
+
+      const checks = recorded.filter((query) => query.kind === 'check');
+      expect(checks.map((query) => idsOf(query).length)).toEqual([
+        SEARCH_FIRST_CHECK_ROWS,
+        SEARCH_FIRST_CHECK_ROWS * SEARCH_CHECK_ROWS_GROWTH,
+        SEARCH_FIRST_CHECK_ROWS * SEARCH_CHECK_ROWS_GROWTH ** 2,
+      ]);
+      // 확인은 받은 차례 그대로 이어진다
+      expect(idsOf(checks[1])[0]).toBe('m101');
+      expect(page.hits).toHaveLength(20);
+      expect(page.hits[0].id).toBe('m100');
+      expect(page.hasNext).toBe(true);
+      expect(page.total).toBeNull();
+    });
+
+    it('후보가 많아도 상한 안이면(상한 밖 후보 없음) 다 확인하고 끝 — 쪽을 못 채워도 hasNext 없음, 맞은 수를 안다', async () => {
+      const { service, recorded } = fakeDataSource({
+        candidates: () => rows(2_500),
+        check: answerChecks((id) => ['m7', 'm2400'].includes(id)),
+      });
+
+      const page = await search(service, criteria({ text: '"계약 갱신"' }));
+
+      const checked = recorded
+        .filter((query) => query.kind === 'check')
+        .reduce((sum, query) => sum + idsOf(query).length, 0);
+      expect(checked).toBe(2_500);
+      expect(page).toMatchObject({
+        hasNext: false,
+        nextCursor: null,
+        total: 2,
+      });
+      expect(page.hits.map((hit) => hit.id)).toEqual(['m7', 'm2400']);
+    });
+
+    it('상한 밖에도 후보가 있고 상한까지 확인해도 쪽을 못 채우면 찾은 것까지와 이어 찾기 커서 — 쪽이 비어 있어도 hasNext', async () => {
+      const lastChecked = rows(1, SEARCH_CHECK_ROWS_LIMIT - 1)[0];
+      const { service, recorded } = fakeDataSource({
+        candidates: () => rows(SEARCH_CHECK_ROWS_LIMIT + 1),
+        check: answerChecks((id) => id === 'm42'),
+      });
+
+      const page = await search(service, criteria({ text: '확인계약' }));
+
+      const checked = recorded
+        .filter((query) => query.kind === 'check')
+        .flatMap(idsOf);
+      expect(checked).toHaveLength(SEARCH_CHECK_ROWS_LIMIT);
+      expect(checked).not.toContain(`m${SEARCH_CHECK_ROWS_LIMIT + 1}`);
+      expect(page.hits.map((hit) => hit.id)).toEqual(['m42']);
+      expect(page.hasNext).toBe(true);
+      expect(page.total).toBeNull();
+      const key = searchScopeKey(undefined, criteria({ text: '확인계약' }));
+      // 이어 찾을 자리는 마지막으로 **확인한** 후보 — 맞은 줄이 아니다
+      expect(decodeIndexCursor(page.nextCursor!, key)).toEqual({
+        receivedAt: lastChecked.received_at,
+        emailId: lastChecked.email_id,
+      });
+
+      const empty = fakeDataSource({
+        candidates: () => rows(SEARCH_CHECK_ROWS_LIMIT + 1),
+        check: () => [],
+      });
+      const emptyPage = await search(
+        empty.service,
+        criteria({ text: '확인계약' }),
+      );
+      expect(emptyPage.hits).toEqual([]);
+      expect(emptyPage.hasNext).toBe(true);
+      expect(emptyPage.nextCursor).not.toBeNull();
+    });
+
+    it('후보가 없으면 확인하지 않는다 — 빈 쪽 · total 0', async () => {
+      const { service, recorded } = fakeDataSource({ candidates: () => [] });
+      await expect(
+        search(service, criteria({ text: '뷁뷁뷁' })),
+      ).resolves.toEqual({
+        hits: [],
+        hasNext: false,
+        nextCursor: null,
+        total: 0,
+      });
+      expect(recorded.map((query) => query.kind)).toEqual(['candidates']);
+    });
+
+    it('직원 주소는 소문자로 맞춰 묻는다 (표의 주소는 늘 소문자)', async () => {
+      const { service, recorded } = fakeDataSource({
+        candidates: () => rows(1),
+      });
+      await search(
+        service,
+        criteria({ text: '계약' }),
+        { limit: 20 },
+        ' Ara.Kim@ArASystem.test ',
+      );
+      expect(recorded[0].params[0]).toBe(USER);
+    });
+  });
+
+  it('묶음이 없으면(한 글자 낱말뿐) 받은 차례로 확인 상한까지 — 쪽이 차면 total 은 창 안에서 센다', async () => {
+    const { service, recorded } = fakeDataSource({
+      keyset: (params) => rows(Number(params.at(-1))),
+      keysetCount: () => [{ count: 120 }],
+      frontier: () => [{ ...rows(1, 2_399)[0], scanned: 2_400 }],
+    });
+
+    const page = await search(service, criteria({ text: '묵' }));
+
+    expect(recorded.map((query) => query.kind)).toEqual([
+      'keyset',
+      'keysetCount',
+      'frontier',
+    ]);
+    expect(recorded[0].settings).toEqual(keysetHint);
+    expect(recorded[0].sql).not.toContain('"grams"');
+    expect(recorded[0].sql).not.toContain('strpos("fold_body"');
+    expect(recorded[0].params.slice(-3)).toEqual([
+      SEARCH_CHECK_ROWS_LIMIT,
+      '묵',
+      21,
+    ]);
+    expect(page.hits).toHaveLength(20);
+    expect(page.hasNext).toBe(true);
+    expect(page.total).toBe(120);
+  });
+
+  it('한 글자 낱말 — 창을 다 훑지 못하고 쪽을 못 채우면 이어 찾기, 다 훑었으면 끝', async () => {
+    const lastScanned = rows(1, 2_999)[0];
+    const unfinished = fakeDataSource({
+      keyset: () => rows(3),
+      frontier: () => [{ ...lastScanned, scanned: SEARCH_CHECK_ROWS_LIMIT }],
+    });
+    const page = await search(unfinished.service, criteria({ text: '뷁' }));
+    expect(page.hits).toHaveLength(3);
+    expect(page.hasNext).toBe(true);
+    expect(page.total).toBeNull();
+    const key = searchScopeKey(undefined, criteria({ text: '뷁' }));
+    expect(decodeIndexCursor(page.nextCursor!, key)).toEqual({
+      receivedAt: lastScanned.received_at,
+      emailId: lastScanned.email_id,
+    });
+
+    const done = fakeDataSource({
+      keyset: () => rows(7),
+      frontier: () => [{ ...rows(1, 1_499)[0], scanned: 1_500 }],
+    });
+    expect(await search(done.service, criteria({ text: '뷁' }))).toMatchObject({
+      hasNext: false,
+      nextCursor: null,
+      total: 7,
+    });
+
+    const over = fakeDataSource({
+      keyset: () => rows(21),
+      keysetCount: () => [{ count: SEARCH_TOTAL_LIMIT + 1 }],
+    });
+    expect(
+      (await search(over.service, criteria({ text: '팀' }))).total,
+    ).toBeNull();
+  });
+
+  it('낱말 확인이 없으면(기간 · 첨부만) 받은 차례로 바로 — total 은 상한 + 1 까지 세어 넘으면 null', async () => {
+    const { service, recorded } = fakeDataSource({
+      plainPage: (params) => rows(Number(params.at(-1))),
+      plainCount: () => [{ count: SEARCH_TOTAL_LIMIT + 1 }],
+    });
+
+    const page = await search(service, criteria({ hasAttachment: true }), {
+      limit: 10,
+    });
+
+    expect(recorded.map((query) => query.kind)).toEqual([
+      'plainPage',
+      'plainCount',
+    ]);
+    expect(recorded[0].params.at(-1)).toBe(11);
+    expect(recorded[1].params.at(-1)).toBe(SEARCH_TOTAL_LIMIT + 1);
+    expect(
+      recorded.every((query) => query.settings.join() === keysetHint.join()),
+    ).toBe(true);
+    expect(page.hits).toHaveLength(10);
+    expect(page.hasNext).toBe(true);
+    expect(page.total).toBeNull();
+
+    const few = fakeDataSource({
+      plainPage: () => rows(3),
+      plainCount: () => [{ count: 3 }],
+    });
+    expect(
+      await search(few.service, criteria({ hasAttachment: true })),
+    ).toMatchObject({ hasNext: false, nextCursor: null, total: 3 });
+  });
+
+  it('다음 쪽은 커서의 자리부터 · total 은 늘 null — 다른 검색의 커서는 묻기 전에 VAL_001', async () => {
+    const given = criteria({ text: '계약' });
+    const position = {
+      receivedAt: new Date('2026-11-01T00:00:00Z'),
+      emailId: 'm40',
+    };
+    const cursor = encodeIndexCursor(
+      position,
+      searchScopeKey(undefined, given),
+    );
+    const { service, recorded } = fakeDataSource({
+      candidates: () => rows(3, 40),
+    });
+
+    const page = await search(service, given, { limit: 20, cursor });
+
+    expect(recorded[0].params).toEqual(
+      expect.arrayContaining([position.receivedAt, 'm40']),
+    );
+    expect(page.total).toBeNull();
+    expect(page.hasNext).toBe(false);
+
+    const other = fakeDataSource({});
+    await expect(
+      search(other.service, criteria({ text: '견적' }), { limit: 20, cursor }),
+    ).rejects.toMatchObject({ code: 'VAL_001' });
+    expect(other.recorded).toEqual([]);
+  });
+
+  it('아무것도 맞을 수 없는 계획이면 묻지 않는다 — 빈 쪽 · total 0', async () => {
+    const { service, recorded } = fakeDataSource({});
+    await expect(search(service, criteria({ text: '…' }))).resolves.toEqual({
+      hits: [],
+      hasNext: false,
+      nextCursor: null,
+      total: 0,
+    });
+    await expect(
+      search(service, criteria({ body: '묵' })),
+    ).resolves.toMatchObject({ hits: [], total: 0 });
+    expect(recorded).toEqual([]);
+  });
+
+  it('강조에 쓰는 글 — 찾은 쪽의 줄만 한 번에(본문 밖의 접은 칸 넷도 — 미리 보기 고르기), id 가 없으면 묻지 않는다', async () => {
+    const { service, recorded } = fakeDataSource({
+      highlight: () => [
+        {
+          email_id: 'm1',
+          subject: '계약',
+          body_text: '본문',
+          preview: '미리',
+          fold_from: '이도윤 <doyun.lee@arasystem.test>',
+          fold_to: '김아라 <ara.kim@arasystem.test>',
+          fold_subject: '계약',
+          fold_attachment: '계약서.pdf',
+        },
+      ],
+    });
+
+    await expect(service.highlightTexts(USER, [])).resolves.toEqual(new Map());
+    expect(recorded).toEqual([]);
+
+    const texts = await service.highlightTexts(USER, ['m1', 'm2']);
+    expect(recorded[0].params).toEqual([USER, ['m1', 'm2']]);
+    expect([...texts.entries()]).toEqual([
+      [
+        'm1',
+        {
+          subject: '계약',
+          bodyText: '본문',
+          preview: '미리',
+          otherFields: [
+            '이도윤 <doyun.lee@arasystem.test>',
+            '김아라 <ara.kim@arasystem.test>',
+            '계약',
+            '계약서.pdf',
+          ],
+        },
+      ],
+    ]);
+  });
+
+  it('DB 실패는 그대로 던진다 — 부르는 쪽(목록 서비스)이 첫 쪽이면 엔진 방식으로 찾는다', async () => {
+    const { service } = fakeDataSource({
+      candidates: () => {
+        throw new Error('db down');
+      },
+    });
+    const error = await search(service, criteria({ text: '계약' })).catch(
+      (caught: unknown) => caught,
+    );
+    expect(error).toBeInstanceOf(Error);
+    expect(error).not.toBeInstanceOf(BusinessException);
+  });
+
+  it('다음 쪽에서는 후보가 적어도 모두 확인하지 않는다 — 쪽이 찰 때까지만 늘려 가며 (total 이 없다 — 리뷰 L3)', async () => {
+    const given = criteria({ text: '계약서' });
+    const cursor = encodeIndexCursor(
+      { receivedAt: new Date('2026-11-01T00:00:00Z'), emailId: 'm9' },
+      searchScopeKey(undefined, given),
+    );
+    const { service, recorded } = fakeDataSource({
+      candidates: () => rows(1_500, 9),
+      check: answerChecks(() => true),
+    });
+
+    const page = await search(service, given, { limit: 20, cursor });
+
+    const checks = recorded.filter((query) => query.kind === 'check');
+    expect(checks.map((query) => idsOf(query).length)).toEqual([
+      SEARCH_FIRST_CHECK_ROWS,
+    ]);
+    expect(page.hits).toHaveLength(20);
+    expect(page.total).toBeNull();
+  });
+
+  it('한 글자 낱말 길의 맞은 줄 · 창의 끝 · 수는 한 스냅숏(REPEATABLE READ 트랜잭션 하나)에서 — 후보 · 낱말 확인 없는 길도 (리뷰 L4)', async () => {
+    const keyset = fakeDataSource({
+      keyset: (params) => rows(Number(params.at(-1))),
+      keysetCount: () => [{ count: 120 }],
+      frontier: () => [{ ...rows(1, 2_399)[0], scanned: 2_400 }],
+    });
+    await search(keyset.service, criteria({ text: '묵' }));
+    expect(new Set(keyset.recorded.map((query) => query.transaction))).toEqual(
+      new Set([1]),
+    );
+    expect(keyset.recorded.map((query) => query.isolation)).toEqual([
+      'REPEATABLE READ',
+      'REPEATABLE READ',
+      'REPEATABLE READ',
+    ]);
+
+    const unfinished = fakeDataSource({
+      keyset: () => rows(3),
+      frontier: () => [
+        { ...rows(1, 2_999)[0], scanned: SEARCH_CHECK_ROWS_LIMIT },
+      ],
+    });
+    await search(unfinished.service, criteria({ text: '뷁' }));
+    expect(unfinished.recorded.map((query) => query.transaction)).toEqual([
+      1, 1,
+    ]);
+
+    const plain = fakeDataSource({
+      plainPage: () => rows(3),
+      plainCount: () => [{ count: 3 }],
+    });
+    await search(plain.service, criteria({ hasAttachment: true }));
+    expect(plain.recorded.map((query) => query.transaction)).toEqual([1, 1]);
+  });
+});
diff --git a/backend/src/modules/mail-search/mail-search-query.service.ts b/backend/src/modules/mail-search/mail-search-query.service.ts
new file mode 100644
index 0000000..7acf18d
--- /dev/null
+++ b/backend/src/modules/mail-search/mail-search-query.service.ts
@@ -0,0 +1,429 @@
+import { Injectable } from '@nestjs/common';
+import { InjectDataSource } from '@nestjs/typeorm';
+import type { DataSource } from 'typeorm';
+
+import {
+  SEARCH_CANDIDATE_COUNT_LIMIT,
+  SEARCH_CHECK_ROWS_GROWTH,
+  SEARCH_CHECK_ROWS_LIMIT,
+  SEARCH_FIRST_CHECK_ROWS,
+  SEARCH_TOTAL_LIMIT,
+} from './mail-search.constants';
+import type { SearchCriteria, SearchScope } from './mail-search.types';
+import {
+  decodeIndexCursor,
+  encodeIndexCursor,
+  searchScopeKey,
+} from './search-cursor';
+import type { SearchPlan } from './search-plan';
+import {
+  candidatesSql,
+  checkHitsSql,
+  highlightTextsSql,
+  keysetCountSql,
+  keysetFrontierSql,
+  keysetHitsSql,
+  plainCountSql,
+  plainPageSql,
+  type SearchPosition,
+  type SqlQuery,
+} from './search-sql';
+
+/** 찾은 메일 하나 — 엔진 id 와 받은 시각 */
+export interface IndexHit {
+  readonly id: string;
+  readonly receivedAt: Date;
+}
+
+/** 색인으로 찾은 한 쪽 */
+export interface IndexSearchPage {
+  readonly hits: readonly IndexHit[];
+  readonly hasNext: boolean;
+  readonly nextCursor: string | null;
+  /** 첫 쪽에서만 SEARCH_TOTAL_LIMIT 까지 센다 — 넘거나 이 요청 안에서 다 세지 못하면 null, 다음 쪽은 늘 null */
+  readonly total: number | null;
+}
+
+/** 강조에 쓰는 색인의 글 */
+export interface IndexHighlightText {
+  readonly subject: string;
+  readonly bodyText: string;
+  readonly preview: string;
+  /** 본문 밖의 접은 칸 — 보낸 사람 · 받는 사람과 참조 · 제목 · 첨부 이름 (미리 보기 고르기 — search-highlight.ts) */
+  readonly otherFields: readonly string[];
+}
+
+/** 쿼리의 줄 */
+interface HitRow {
+  readonly email_id: string;
+  readonly received_at: Date;
+}
+
+/** 한 쪽을 찾은 결과 — 커서는 search() 가 만든다 */
+interface Found {
+  readonly hits: IndexHit[];
+  readonly hasNext: boolean;
+  /** 이어 찾을 자리 — hasNext 일 때만 */
+  readonly next: SearchPosition | null;
+  readonly total: number | null;
+}
+
+/** 계획기를 거드는 설정 — 그 쿼리만 (SET LOCAL — 트랜잭션이 끝나면 돌아온다) */
+type PlannerHint =
+  /**
+   * 후보 — 찾기 GIN(주소 · 묶음 · 메일함 — 이것 말고 받을 색인이 없다)의 bitmap 으로만 (줄마다 묶음 배열을 풀어 보는 순차 읽기를 고르지 않게)
+   */
+  | 'bitmap'
+  /** 받은 차례 색인으로 훑는다 — 계획기가 그 직원의 줄을 모두 모은 뒤 놓지 않게 */
+  | 'keyset';
+
+/** 한 스냅숏 안의 쿼리 하나 */
+type Ask = <T>(query: SqlQuery) => Promise<T>;
+
+/** 계획기 설정 — e2e 의 계획 시험(실제 PostgreSQL)도 같은 설정으로 본다 */
+export const PLANNER_SETTINGS: Readonly<
+  Record<PlannerHint, readonly string[]>
+> = {
+  bitmap: [
+    'SET LOCAL enable_seqscan = off',
+    'SET LOCAL enable_indexscan = off',
+  ],
+  keyset: [
+    'SET LOCAL enable_bitmapscan = off',
+    'SET LOCAL enable_seqscan = off',
+  ],
+};
+
+function toHit(row: HitRow): IndexHit {
+  return {
+    id: row.email_id,
+    receivedAt:
+      row.received_at instanceof Date
+        ? row.received_at
+        : new Date(row.received_at),
+  };
+}
+
+function positionOf(hit: IndexHit): SearchPosition {
+  return { receivedAt: hit.receivedAt, emailId: hit.id };
+}
+
+/** 첫 쪽의 수 — SEARCH_TOTAL_LIMIT 를 넘으면 null */
+function capTotal(count: number): number | null {
+  return count > SEARCH_TOTAL_LIMIT ? null : count;
+}
+
+/** 맞은 줄(받은 시각 최신부터)에서 한 쪽 — 넘치면 다음 쪽이 있고, 이어 찾을 자리는 이 쪽의 마지막 줄 */
+function pageOf(
+  hits: readonly IndexHit[],
+  limit: number,
+  total: number | null,
+): Found {
+  const page = hits.slice(0, limit);
+  const hasNext = hits.length > limit;
+  return {
+    hits: page,
+    hasNext,
+    next: hasNext ? positionOf(page[page.length - 1]) : null,
+    total,
+  };
+}
+
+/** 표의 직원 주소 — 늘 소문자다 (MailSearchIndexService 와 같은 맞춤) */
+function normalize(user: string): string {
+  return user.trim().toLowerCase();
+}
+
+/**
+ * 색인으로 찾기 (14단계 설계 C1 · G — 2026-11-05 다시 잼) — 계획(search-plan.ts)을 쿼리(search-sql.ts)로 돌린다. 엔진을 모른다.
+ *
+ * - 낱말 확인이 없으면(기간 · 첨부 · 메일함만): 받은 차례로 바로
+ * - 묶음이 있으면: 후보를 주소 + 묶음 + 메일함(GIN 하나)만으로 받은 시각 최신부터 SEARCH_CHECK_ROWS_LIMIT + 1 줄까지 읽는다(줄의 글을 풀지 않는다). 그다음
+ *   - 두 글자 낱말뿐(exactByGrams)이면 후보가 곧 결과
+ *   - 후보가 SEARCH_CANDIDATE_COUNT_LIMIT 이하면 모두 확인 — 첫 쪽의 total 을 안다
+ *   - 넘으면 받은 차례로 SEARCH_FIRST_CHECK_ROWS 줄부터 SEARCH_CHECK_ROWS_GROWTH 배씩 확인하다 쪽이 차면 멈춘다.
+ *     SEARCH_CHECK_ROWS_LIMIT 줄을 확인하고도 쪽을 채우지 못하면 찾은 것까지와 마지막으로 확인한 줄의 커서를 준다(hasNext — 쪽이 비어 있을 수도 있다)
+ * - 묶음이 없으면(한 글자 낱말뿐 — 본문은 훑지 않아 확인이 값싸다): 받은 차례로 SEARCH_CHECK_ROWS_LIMIT 줄까지 확인한다(이어 찾기는 위와 같다)
+ * - total 은 첫 쪽에서만 SEARCH_TOTAL_LIMIT 까지 — 넘거나 이 요청 안에서 다 세지 못하면 null
+ */
+@Injectable()
+export class MailSearchQueryService {
+  constructor(@InjectDataSource() private readonly dataSource: DataSource) {}
+
+  async search(
+    user: string,
+    scope: SearchScope,
+    criteria: SearchCriteria,
+    plan: SearchPlan,
+    page: { readonly limit: number; readonly cursor?: string },
+  ): Promise<IndexSearchPage> {
+    const key = normalize(user);
+    const scopeKey = searchScopeKey(scope.mailboxId ?? undefined, criteria);
+    // 커서는 찾기 전에 본다 — 다른 검색의 커서면 VAL_001
+    const after = page.cursor ? decodeIndexCursor(page.cursor, scopeKey) : null;
+    if (plan.matchesNothing) {
+      return { hits: [], hasNext: false, nextCursor: null, total: 0 };
+    }
+    const firstPage = after === null;
+    const found =
+      plan.checks.length === 0
+        ? await this.plain(key, scope, plan, after, page.limit, firstPage)
+        : plan.grams.length === 0
+          ? await this.keyset(key, scope, plan, after, page.limit, firstPage)
+          : await this.byGrams(key, scope, plan, after, page.limit, firstPage);
+    return {
+      hits: found.hits,
+      hasNext: found.hasNext,
+      nextCursor:
+        found.hasNext && found.next
+          ? encodeIndexCursor(found.next, scopeKey)
+          : null,
+      total: firstPage ? found.total : null,
+    };
+  }
+
+  /** 강조에 쓰는 글 — 찾은 쪽의 줄만 (없는 줄은 빠진다) */
+  async highlightTexts(
+    user: string,
+    ids: readonly string[],
+  ): Promise<Map<string, IndexHighlightText>> {
+    if (ids.length === 0) return new Map();
+    const query = highlightTextsSql(normalize(user), ids);
+    const rows = await this.dataSource.query<
+      {
+        email_id: string;
+        subject: string;
+        body_text: string;
+        preview: string;
+        fold_from: string;
+        fold_to: string;
+        fold_subject: string;
+        fold_attachment: string;
+      }[]
+    >(query.sql, query.params);
+    return new Map(
+      rows.map((row) => [
+        row.email_id,
+        {
+          subject: row.subject,
+          bodyText: row.body_text,
+          preview: row.preview,
+          otherFields: [
+            row.fold_from,
+            row.fold_to,
+            row.fold_subject,
+            row.fold_attachment,
+          ],
+        },
+      ]),
+    );
+  }
+
+  /** 낱말 확인 없이 — 받은 차례로 (첫 쪽은 SEARCH_TOTAL_LIMIT + 1 까지 센다 — 쪽과 수는 같은 스냅숏에서) */
+  private plain(
+    user: string,
+    scope: SearchScope,
+    plan: SearchPlan,
+    after: SearchPosition | null,
+    limit: number,
+    firstPage: boolean,
+  ): Promise<Found> {
+    return this.snapshot('keyset', async (ask) => {
+      const rows = await ask<HitRow[]>(
+        plainPageSql(user, scope, plan, after, limit + 1),
+      );
+      let total: number | null = null;
+      if (firstPage) {
+        const counted = await ask<{ count: number }[]>(
+          plainCountSql(user, scope, plan, SEARCH_TOTAL_LIMIT + 1),
+        );
+        total = capTotal(Number(counted[0]?.count ?? 0));
+      }
+      return pageOf(rows.map(toHit), limit, total);
+    });
+  }
+
+  /** 묶음이 있다 — 후보(GIN)를 받은 시각으로 읽고 필요한 만큼만 확인한다 */
+  private async byGrams(
+    user: string,
+    scope: SearchScope,
+    plan: SearchPlan,
+    after: SearchPosition | null,
+    limit: number,
+    firstPage: boolean,
+  ): Promise<Found> {
+    const candidates = (
+      await this.snapshot('bitmap', (ask) =>
+        ask<HitRow[]>(
+          candidatesSql(user, scope, plan, after, SEARCH_CHECK_ROWS_LIMIT + 1),
+        ),
+      )
+    ).map(toHit);
+    // 확인 상한 밖에도 후보가 있다 — 이 요청은 상한까지만 본다
+    const more = candidates.length > SEARCH_CHECK_ROWS_LIMIT;
+    const window = more
+      ? candidates.slice(0, SEARCH_CHECK_ROWS_LIMIT)
+      : candidates;
+
+    // 두 글자 낱말뿐 — 후보가 곧 결과다
+    if (plan.exactByGrams) {
+      return pageOf(candidates, limit, more ? null : capTotal(window.length));
+    }
+
+    // 첫 쪽이고 후보가 적다 — 모두 확인해 total 을 안다 (다음 쪽은 total 이 없으니 쪽이 찰 때까지만 확인한다)
+    if (firstPage && !more && window.length <= SEARCH_CANDIDATE_COUNT_LIMIT) {
+      const matched = await this.check(user, plan, window);
+      const hits = window.filter((hit) => matched.has(hit.id));
+      return pageOf(hits, limit, capTotal(hits.length));
+    }
+
+    // 후보가 많다 — 받은 차례로 조금씩 확인하다 쪽이 차면 멈춘다
+    const hits: IndexHit[] = [];
+    let checked = 0;
+    let size = Math.max(SEARCH_FIRST_CHECK_ROWS, (limit + 1) * 2);
+    while (hits.length <= limit && checked < window.length) {
+      const slice = window.slice(checked, checked + size);
+      const matched = await this.check(user, plan, slice);
+      for (const hit of slice) if (matched.has(hit.id)) hits.push(hit);
+      checked += slice.length;
+      size *= SEARCH_CHECK_ROWS_GROWTH;
+    }
+    if (hits.length > limit) return pageOf(hits, limit, null);
+    // 후보를 다 확인했다 — 끝이고 맞은 수를 안다
+    if (!more) {
+      return { hits, hasNext: false, next: null, total: capTotal(hits.length) };
+    }
+    // 확인 상한에 닿았다 — 마지막으로 확인한 후보 다음부터 이어 찾는다
+    return {
+      hits,
+      hasNext: true,
+      next: positionOf(window[window.length - 1]),
+      total: null,
+    };
+  }
+
+  /** 후보 가운데 낱말이 모두 맞은 줄의 id */
+  private async check(
+    user: string,
+    plan: SearchPlan,
+    candidates: readonly IndexHit[],
+  ): Promise<Set<string>> {
+    if (candidates.length === 0) return new Set();
+    const query = checkHitsSql(
+      user,
+      plan,
+      candidates.map((hit) => hit.id),
+    );
+    const rows = await this.dataSource.query<{ email_id: string }[]>(
+      query.sql,
+      query.params,
+    );
+    return new Set(rows.map((row) => row.email_id));
+  }
+
+  /**
+   * 묶음이 없다(한 글자 낱말뿐) — 받은 차례로 확인 상한까지 (확인하는 칸이 작아 값싸다).
+   * 맞은 줄 · 창의 끝 · 첫 쪽의 수는 **같은 스냅숏**에서 읽는다 — 그사이 온 메일로 창이 밀리면 이어 찾을 자리가 어긋나 같은 메일이 다음 쪽에 또 나왔다
+   */
+  private keyset(
+    user: string,
+    scope: SearchScope,
+    plan: SearchPlan,
+    after: SearchPosition | null,
+    limit: number,
+    firstPage: boolean,
+  ): Promise<Found> {
+    return this.snapshot('keyset', async (ask) => {
+      const rows = await ask<HitRow[]>(
+        keysetHitsSql(
+          user,
+          scope,
+          plan,
+          after,
+          SEARCH_CHECK_ROWS_LIMIT,
+          limit + 1,
+        ),
+      );
+      if (rows.length > limit) {
+        return pageOf(
+          rows.map(toHit),
+          limit,
+          firstPage ? await this.keysetTotal(ask, user, scope, plan) : null,
+        );
+      }
+      // 쪽을 채우지 못했다 — 확인한 창을 다 훑었나(그러면 끝), 아니면 그 창의 끝부터 이어 찾는다
+      const hits = rows.map(toHit);
+      const frontier = await this.frontier(ask, user, scope, plan, after);
+      if (frontier === null || frontier.scanned < SEARCH_CHECK_ROWS_LIMIT) {
+        return {
+          hits,
+          hasNext: false,
+          next: null,
+          total: capTotal(hits.length),
+        };
+      }
+      return { hits, hasNext: true, next: frontier.last, total: null };
+    });
+  }
+
+  /** 받은 차례로 훑는 창의 끝 — 그 창의 마지막 줄 · 줄 수 (창이 비었으면 null) */
+  private async frontier(
+    ask: Ask,
+    user: string,
+    scope: SearchScope,
+    plan: SearchPlan,
+    after: SearchPosition | null,
+  ): Promise<{ last: SearchPosition; scanned: number } | null> {
+    const rows = await ask<(HitRow & { scanned: number })[]>(
+      keysetFrontierSql(user, scope, plan, after, SEARCH_CHECK_ROWS_LIMIT),
+    );
+    const row = rows[0];
+    if (!row) return null;
+    return {
+      last: positionOf(toHit(row)),
+      scanned: Number(row.scanned),
+    };
+  }
+
+  /** 받은 차례 길의 첫 쪽 total — 창 안에서 SEARCH_TOTAL_LIMIT + 1 까지 센다. 넘거나 창을 다 훑지 못했으면 null */
+  private async keysetTotal(
+    ask: Ask,
+    user: string,
+    scope: SearchScope,
+    plan: SearchPlan,
+  ): Promise<number | null> {
+    const counted = await ask<{ count: number }[]>(
+      keysetCountSql(
+        user,
+        scope,
+        plan,
+        SEARCH_CHECK_ROWS_LIMIT,
+        SEARCH_TOTAL_LIMIT + 1,
+      ),
+    );
+    const count = Number(counted[0]?.count ?? 0);
+    if (count > SEARCH_TOTAL_LIMIT) return null;
+    const frontier = await this.frontier(ask, user, scope, plan, null);
+    return frontier === null || frontier.scanned < SEARCH_CHECK_ROWS_LIMIT
+      ? count
+      : null;
+  }
+
+  /**
+   * 한 스냅숏(REPEATABLE READ — 읽기만 한다)에서 계획기 설정을 건 뒤 쿼리들을 묻는다 (SET LOCAL — 트랜잭션이 끝나면 돌아온다).
+   * 스냅숏은 설정 다음의 첫 쿼리에서 잡힌다
+   */
+  private snapshot<T>(
+    hint: PlannerHint,
+    work: (ask: Ask) => Promise<T>,
+  ): Promise<T> {
+    return this.dataSource.transaction('REPEATABLE READ', async (manager) => {
+      for (const setting of PLANNER_SETTINGS[hint]) {
+        await manager.query(setting);
+      }
+      return work(<R>(query: SqlQuery) =>
+        manager.query<R>(query.sql, query.params),
+      );
+    });
+  }
+}
diff --git a/backend/src/modules/mail-search/mail-search-runs.ts b/backend/src/modules/mail-search/mail-search-runs.ts
new file mode 100644
index 0000000..c4c3166
--- /dev/null
+++ b/backend/src/modules/mail-search/mail-search-runs.ts
@@ -0,0 +1,71 @@
+import { Injectable } from '@nestjs/common';
+
+import { runOutsideRequestContext } from '@/shared/logger/request-context';
+
+/**
+ * 직원마다 색인 일을 한 번에 하나씩 (14단계 설계 B2 — "같은 직원은 한 번에 하나") — 맞추기 · 채우기 한 묶음 · 전체 대조가 같은 줄에 선다.
+ * 앞의 일이 실패해도 다음 일은 한다. 일은 요청 컨텍스트 밖에서 돈다 — 처음 부른 요청의 추적 ID 를 물려받지 않게.
+ *
+ * ⚠️ 프로세스 안의 차례다 — 인스턴스를 늘리면 두 인스턴스가 같은 직원을 함께 맞춘다(쓰기는 상태 줄을 잠가 차례로 되지만 같은 일을 두 번 한다).
+ *    그때는 잠금(Redis `SET NX PX` 또는 `pg_advisory_lock`)으로 옮긴다 (nestjs 스킬의 Redis 목록)
+ */
+@Injectable()
+export class MailSearchRuns {
+  private readonly tails = new Map<string, Promise<void>>();
+
+  /** 그 직원의 앞선 일이 끝난 뒤 `task` 를 한다 → 그 결과 */
+  run<T>(user: string, task: () => Promise<T>): Promise<T> {
+    const key = user.toLowerCase();
+    const previous = this.tails.get(key) ?? Promise.resolve();
+    const start = () => runOutsideRequestContext(task);
+    const result = previous.then(start, start);
+    const tail = result.then(
+      () => undefined,
+      () => undefined,
+    );
+    this.tails.set(key, tail);
+    void tail.then(() => {
+      if (this.tails.get(key) === tail) this.tails.delete(key);
+    });
+    return result;
+  }
+
+  /** 그 직원의 일이 줄에 있거나 도는 중인가 */
+  isBusy(user: string): boolean {
+    return this.tails.has(user.toLowerCase());
+  }
+}
+
+/**
+ * 함께 도는 일의 수 — 넘는 일은 먼저 온 차례로 기다린다 (14단계 — 실시간 소식이 직원 수만큼 한꺼번에 와도 맞추기는 이만큼만 함께).
+ * 앞의 일이 실패해도 자리는 돌려준다.
+ *
+ * ⚠️ 프로세스 안의 셈이다 — 인스턴스를 늘리면 인스턴스마다 따로 센다 (nestjs 스킬의 Redis 목록)
+ */
+export class ConcurrencyGate {
+  private active = 0;
+  private readonly waiting: (() => void)[] = [];
+
+  constructor(private readonly limit: number) {}
+
+  /** 지금 도는 일 · 기다리는 일의 수 (시험용) */
+  get load(): { readonly active: number; readonly waiting: number } {
+    return { active: this.active, waiting: this.waiting.length };
+  }
+
+  async run<T>(task: () => Promise<T>): Promise<T> {
+    if (this.active >= this.limit) {
+      await new Promise<void>((resolve) => this.waiting.push(resolve));
+    } else {
+      this.active += 1;
+    }
+    try {
+      return await task();
+    } finally {
+      // 기다리는 일에 자리를 그대로 넘긴다 (자리 수는 그대로) — 없으면 돌려준다
+      const next = this.waiting.shift();
+      if (next) next();
+      else this.active -= 1;
+    }
+  }
+}
diff --git a/backend/src/modules/mail-search/mail-search-state.entity.ts b/backend/src/modules/mail-search/mail-search-state.entity.ts
new file mode 100644
index 0000000..46e43f2
--- /dev/null
+++ b/backend/src/modules/mail-search/mail-search-state.entity.ts
@@ -0,0 +1,90 @@
+import { Column, Entity, Index, PrimaryColumn } from 'typeorm';
+
+import {
+  SEARCH_EMAIL_COLUMN_LENGTH,
+  SEARCH_ID_COLUMN_LENGTH,
+  SEARCH_STATES_TABLE,
+  SEARCH_WORD_COLUMN_LENGTH,
+} from './mail-search.constants';
+import type {
+  SearchIndexStatus,
+  SearchPausedReason,
+} from './mail-search.types';
+
+/**
+ * 직원마다 색인 상태 한 줄 (14단계 설계 A2) — 직원이 웹메일에 처음 로그인하거나 검색 준비 상태를 물을 때 `building` 으로 만든다.
+ * 로그인한 적 없는 계정은 색인하지 않는다.
+ *
+ * 색인 줄을 쓰는 일은 모두 이 줄을 잠그고(SELECT … FOR UPDATE) 같은 트랜잭션에서 한다 — 줄이 없으면(퇴사 마무리가 지웠다) 쓰지 않는다.
+ * 퇴사 마무리는 이 줄을 먼저 지우고 색인 줄을 지운다 (ops-data.service.ts — 그사이 끝난 쓰기가 남지 않게)
+ */
+@Entity({ name: SEARCH_STATES_TABLE })
+@Index('IDX_mail_search_states_status', ['status'])
+export class MailSearchStateEntity {
+  @PrimaryColumn({
+    name: 'user_email',
+    type: 'varchar',
+    length: SEARCH_EMAIL_COLUMN_LENGTH,
+  })
+  userEmail!: string;
+
+  @Column({ type: 'varchar', length: SEARCH_WORD_COLUMN_LENGTH })
+  status!: SearchIndexStatus;
+
+  /** 엔진 Email state — 맞추기(Email/changes)의 기준. 채우기를 시작하기 전에는 null (그때는 맞추지 않는다) */
+  @Column({ name: 'email_state', type: 'text', nullable: true })
+  emailState!: string | null;
+
+  /** 채우기를 이어 할 자리 — 마지막으로 넣은 메일 id (받은 차례 최신부터) */
+  @Column({
+    name: 'build_anchor',
+    type: 'varchar',
+    length: SEARCH_ID_COLUMN_LENGTH,
+    nullable: true,
+  })
+  buildAnchor!: string | null;
+
+  /** 채운 메일 수 (anchor 가 지워졌을 때 이어 갈 위치이기도 하다) */
+  @Column({ name: 'build_done', type: 'integer', default: 0 })
+  buildDone!: number;
+
+  /** 채울 메일 수 — 채우기를 시작할 때의 엔진 메일 수 */
+  @Column({ name: 'build_total', type: 'integer', nullable: true })
+  buildTotal!: number | null;
+
+  @Column({ name: 'build_started_at', type: 'timestamptz', nullable: true })
+  buildStartedAt!: Date | null;
+
+  @Column({ name: 'ready_at', type: 'timestamptz', nullable: true })
+  readyAt!: Date | null;
+
+  /** 마지막으로 맞춘 때 */
+  @Column({ name: 'last_synced_at', type: 'timestamptz', nullable: true })
+  lastSyncedAt!: Date | null;
+
+  /** 대리 접근이 막혀 멈춘 까닭 — 없으면 null (mail-search.types.ts) */
+  @Column({
+    name: 'paused_reason',
+    type: 'varchar',
+    length: SEARCH_WORD_COLUMN_LENGTH,
+    nullable: true,
+  })
+  pausedReason!: SearchPausedReason | null;
+
+  /**
+   * 이 줄의 색인을 만든 판 (mail-search.constants.ts 의 INDEX_FORMAT) — 다르면 building 으로 돌려 다시 채운다(그동안 검색은 엔진 방식).
+   * 판을 적기 전에 만든 줄은 1
+   */
+  @Column({ name: 'index_format', type: 'smallint', default: 1 })
+  indexFormat!: number;
+
+  /** 이어진 실패 수 — 성공하면 0. 많을수록 차례에서 뒤로 미룬다 */
+  @Column({ name: 'failure_count', type: 'integer', default: 0 })
+  failureCount!: number;
+
+  @Column({ name: 'created_at', type: 'timestamptz' })
+  createdAt!: Date;
+
+  @Column({ name: 'updated_at', type: 'timestamptz' })
+  updatedAt!: Date;
+}
diff --git a/backend/src/modules/mail-search/mail-search-sync.service.spec.ts b/backend/src/modules/mail-search/mail-search-sync.service.spec.ts
new file mode 100644
index 0000000..8431f07
--- /dev/null
+++ b/backend/src/modules/mail-search/mail-search-sync.service.spec.ts
@@ -0,0 +1,971 @@
+import { Logger } from '@nestjs/common';
+
+import { BusinessException } from '@/common/errors/business.exception';
+import {
+  AccountLoginDisabledException,
+  PasswordExpiredException,
+} from '@/modules/mail/mail.provider';
+import type { IndexRowValues } from './index-document';
+import {
+  IndexDeadlineError,
+  type IndexChanges,
+  type IndexDocument,
+  type IndexIdPage,
+  type IndexMutable,
+  type IndexReadOptions,
+  type MailIndexSource,
+} from './mail-index-source';
+import { MailSearchBuildService } from './mail-search-build.service';
+import type {
+  MailSearchIndexRepository,
+  SearchIndexWrite,
+} from './mail-search-index.repository';
+import { MailSearchRuns } from './mail-search-runs';
+import type { MailSearchStateEntity } from './mail-search-state.entity';
+import { MailSearchSyncService } from './mail-search-sync.service';
+import type { MailSearchTiming } from './mail-search-timing';
+import {
+  BUILD_BATCH_SIZE,
+  BUILD_RUN_BUDGET_MS,
+  INDEX_CALL_MIN_MS,
+  INDEX_FORMAT,
+  STEP_MIN_REMAINING_MS,
+  SYNC_CONCURRENCY,
+  SYNC_DEBOUNCE_MS,
+} from './mail-search.constants';
+
+const DOMAIN = 'arasystem.test';
+const ARA = `ara.kim@${DOMAIN}`;
+/** 한국 시각 밤 23시 — 채우기 창 안 */
+const NIGHT = Date.parse('2026-11-05T23:00:00+09:00');
+/** 넉넉한 끝 시각 (시계는 쉬기 · 엔진 읽기 값만큼만 간다) */
+const LONG = 3_600_000;
+
+/** 시험의 시계 — 엔진 대역과 서비스가 함께 본다 */
+interface TestClock {
+  now(): number;
+  advance(ms: number): void;
+}
+
+type ChangeEntry = {
+  created: string[];
+  updated: string[];
+  destroyed: string[];
+};
+
+/**
+ * 대역 엔진 — 메일 · state · 변화 기록. 테스트가 메일을 넣고 · 바꾸고 · 지운다.
+ * 실제 어댑터처럼 끝 시각까지 남은 시간이 INDEX_CALL_MIN_MS 보다 적으면 읽지 않고 IndexDeadlineError, 읽을 때마다 callCostMs 만큼 시계가 간다
+ */
+class FakeEngine implements MailIndexSource {
+  readonly emails = new Map<
+    string,
+    { receivedAt: number; mailboxIds: string[]; keywords: string[] }
+  >();
+  private stateNumber = 0;
+  /** state 번호 → 그 state 가 된 변화 */
+  private readonly log: ChangeEntry[] = [];
+  /** 이보다 오래된 state 는 셀 수 없다 */
+  forgetBefore = 0;
+  /** 다음 부름에 던질 실패 */
+  failNext: Error | null = null;
+  /** 엔진 읽기 한 번에 가는 시간 */
+  callCostMs = 0;
+  /** 있으면 changes 가 답을 만든 뒤 이것이 풀릴 때까지 기다린다 (맞추는 중인 때를 만든다) */
+  changesGate: Promise<void> | null = null;
+  /** 지금 답을 기다리는 changes 수 · 가장 많았던 수 */
+  inFlight = 0;
+  maxInFlight = 0;
+  readonly calls: string[] = [];
+  /** documents 에 실린 id 들 (부름마다) */
+  readonly documentRequests: string[][] = [];
+
+  constructor(private readonly clock: TestClock) {}
+
+  get state(): string {
+    return `s${this.stateNumber}`;
+  }
+
+  add(id: string, receivedAt: number, mailboxIds = ['inbox']): void {
+    this.emails.set(id, { receivedAt, mailboxIds, keywords: [] });
+    this.record({ created: [id], updated: [], destroyed: [] });
+  }
+
+  move(id: string, mailboxIds: string[]): void {
+    const email = this.emails.get(id);
+    if (email) email.mailboxIds = mailboxIds;
+    this.record({ created: [], updated: [id], destroyed: [] });
+  }
+
+  remove(id: string): void {
+    this.emails.delete(id);
+    this.record({ created: [], updated: [], destroyed: [id] });
+  }
+
+  /** 엔진이 같은 쪽에 만든 메일을 바뀐 메일로도 함께 알린다 (RFC 8620 은 둘 다 실을 수 있다) */
+  addReportedTwice(id: string, receivedAt: number): void {
+    this.emails.set(id, { receivedAt, mailboxIds: ['inbox'], keywords: [] });
+    this.record({ created: [id], updated: [id, id], destroyed: [] });
+  }
+
+  /** 변화 기록 없이 넣는다 (지난 메일) */
+  seed(count: number, prefix = 'old'): void {
+    for (let index = 0; index < count; index += 1) {
+      this.emails.set(`${prefix}${index}`, {
+        receivedAt: 1_000 + index,
+        mailboxIds: ['inbox'],
+        keywords: [],
+      });
+    }
+  }
+
+  private record(entry: ChangeEntry): void {
+    this.log.push(entry);
+    this.stateNumber += 1;
+  }
+
+  private check(name: string, options: IndexReadOptions): void {
+    this.calls.push(name);
+    if (this.failNext) {
+      const error = this.failNext;
+      this.failNext = null;
+      throw error;
+    }
+    if (options.deadline - this.clock.now() < INDEX_CALL_MIN_MS) {
+      throw new IndexDeadlineError();
+    }
+    this.clock.advance(this.callCostMs);
+  }
+
+  snapshot(_user: string, options: IndexReadOptions) {
+    this.check('snapshot', options);
+    return Promise.resolve({ state: this.state, total: this.emails.size });
+  }
+
+  async changes(
+    _user: string,
+    sinceState: string,
+    maxChanges: number,
+    options: IndexReadOptions,
+  ): Promise<IndexChanges> {
+    this.check('changes', options);
+    const since = Number(sinceState.slice(1));
+    let result: IndexChanges;
+    if (!Number.isInteger(since) || since < this.forgetBefore) {
+      result = { kind: 'cannotCalculate' };
+    } else {
+      const entries = this.log.slice(since, since + maxChanges);
+      result = {
+        kind: 'changes',
+        created: entries.flatMap((entry) => entry.created),
+        updated: entries.flatMap((entry) => entry.updated),
+        destroyed: entries.flatMap((entry) => entry.destroyed),
+        newState: `s${since + entries.length}`,
+        hasMore: since + entries.length < this.stateNumber,
+      };
+    }
+    this.inFlight += 1;
+    this.maxInFlight = Math.max(this.maxInFlight, this.inFlight);
+    try {
+      if (this.changesGate) await this.changesGate;
+    } finally {
+      this.inFlight -= 1;
+    }
+    return result;
+  }
+
+  documents(
+    _user: string,
+    ids: readonly string[],
+    options: IndexReadOptions,
+  ): Promise<IndexDocument[]> {
+    this.check('documents', options);
+    this.documentRequests.push([...ids]);
+    return Promise.resolve(
+      ids.flatMap((id) => {
+        const email = this.emails.get(id);
+        if (!email) return [];
+        return [
+          {
+            id,
+            threadId: `t-${id}`,
+            mailboxIds: email.mailboxIds,
+            keywords: email.keywords,
+            receivedAt: new Date(email.receivedAt).toISOString(),
+            size: 10,
+            messageIds: [`${id}@example.com`],
+            inReplyTo: [],
+            references: [],
+            subject: `제목 ${id}`,
+            from: [{ name: null, email: 'partner@example.com' }],
+            to: [{ name: null, email: ARA }],
+            cc: [],
+            attachmentNames: [],
+            hasAttachment: false,
+            preview: '',
+            bodyText: `본문 ${id}`,
+          },
+        ];
+      }),
+    );
+  }
+
+  mutable(
+    _user: string,
+    ids: readonly string[],
+    options: IndexReadOptions,
+  ): Promise<IndexMutable[]> {
+    this.check('mutable', options);
+    return Promise.resolve(
+      ids.flatMap((id) => {
+        const email = this.emails.get(id);
+        return email
+          ? [{ id, mailboxIds: email.mailboxIds, keywords: email.keywords }]
+          : [];
+      }),
+    );
+  }
+
+  newestFirst(): string[] {
+    return [...this.emails.entries()]
+      .sort((a, b) => b[1].receivedAt - a[1].receivedAt)
+      .map(([id]) => id);
+  }
+
+  pageIds(
+    _user: string,
+    from: { anchor: string | null; position: number },
+    limit: number,
+    options: IndexReadOptions,
+  ): Promise<IndexIdPage> {
+    this.check('pageIds', options);
+    const all = this.newestFirst();
+    // anchor 가 지워졌으면 위치로 (실제 어댑터와 같다)
+    const anchorAt = from.anchor === null ? -1 : all.indexOf(from.anchor);
+    const start = anchorAt >= 0 ? anchorAt + 1 : from.position;
+    return Promise.resolve({
+      ids: all.slice(start, start + limit),
+      position: start,
+      total: all.length,
+    });
+  }
+
+  allIds(_user: string, options: IndexReadOptions) {
+    this.check('allIds', options);
+    return Promise.resolve({ state: this.state, ids: this.newestFirst() });
+  }
+}
+
+/** 대역 표 — 상태 줄 · 색인 줄을 메모리에 (색인 줄은 한 직원 것만 본다) */
+class FakeRepository {
+  readonly states = new Map<string, MailSearchStateEntity>();
+  readonly rows = new Map<string, IndexRowValues>();
+  readonly writes: SearchIndexWrite[] = [];
+  /** 판 되돌리기 — 부른 수 · 앞으로 실패할 수(DB 장애 흉내) */
+  resetCalls = 0;
+  failResets = 0;
+
+  /** 실제 SQL(mail-search-index.repository.ts)과 같은 판정 — 판이 다르고 주소가 그 도메인으로 끝나는 줄만 */
+  resetOutdatedFormats(suffix: string, format: number, now: Date) {
+    this.resetCalls += 1;
+    if (this.failResets > 0) {
+      this.failResets -= 1;
+      return Promise.reject(new Error('db down'));
+    }
+    let count = 0;
+    for (const state of this.states.values()) {
+      if (state.indexFormat === format || !state.userEmail.endsWith(suffix)) {
+        continue;
+      }
+      Object.assign(state, {
+        status: 'building',
+        emailState: null,
+        buildAnchor: null,
+        buildDone: 0,
+        buildTotal: null,
+        buildStartedAt: null,
+        readyAt: null,
+        failureCount: 0,
+        indexFormat: format,
+        updatedAt: now,
+      });
+      count += 1;
+    }
+    return Promise.resolve(count);
+  }
+
+  addState(
+    overrides: Partial<MailSearchStateEntity> = {},
+  ): MailSearchStateEntity {
+    const state: MailSearchStateEntity = {
+      userEmail: ARA,
+      status: 'building',
+      emailState: null,
+      buildAnchor: null,
+      buildDone: 0,
+      buildTotal: null,
+      buildStartedAt: null,
+      readyAt: null,
+      lastSyncedAt: null,
+      pausedReason: null,
+      failureCount: 0,
+      indexFormat: INDEX_FORMAT,
+      createdAt: new Date(0),
+      updatedAt: new Date(0),
+      ...overrides,
+    };
+    this.states.set(state.userEmail, state);
+    return state;
+  }
+
+  findState(user: string) {
+    return Promise.resolve(this.states.get(user) ?? null);
+  }
+
+  syncCandidates() {
+    return Promise.resolve(
+      [...this.states.values()].filter(
+        (state) => state.emailState !== null && state.pausedReason === null,
+      ),
+    );
+  }
+
+  buildCandidates() {
+    return Promise.resolve(
+      [...this.states.values()].filter(
+        (state) => state.status === 'building' && state.pausedReason === null,
+      ),
+    );
+  }
+
+  recordFailure(user: string, now: Date) {
+    const state = this.states.get(user);
+    if (!state) return Promise.resolve(0);
+    state.failureCount += 1;
+    state.updatedAt = now;
+    return Promise.resolve(state.failureCount);
+  }
+
+  pause(user: string, reason: MailSearchStateEntity['pausedReason']) {
+    const state = this.states.get(user);
+    if (state) state.pausedReason = reason;
+    return Promise.resolve();
+  }
+
+  countMessages() {
+    return Promise.resolve(this.rows.size);
+  }
+
+  existingIds(_user: string, ids: readonly string[]) {
+    return Promise.resolve(new Set(ids.filter((id) => this.rows.has(id))));
+  }
+
+  indexedIds() {
+    return Promise.resolve([...this.rows.keys()]);
+  }
+
+  write(user: string, change: SearchIndexWrite, now: Date) {
+    const state = this.states.get(user);
+    if (!state) {
+      return Promise.resolve({ written: false, updatedIds: new Set<string>() });
+    }
+    this.writes.push(change);
+    if (change.clearIndex) this.rows.clear();
+    for (const id of change.deletes ?? []) this.rows.delete(id);
+    for (const row of change.upserts ?? []) this.rows.set(row.emailId, row);
+    const updatedIds = new Set<string>();
+    for (const update of change.updates ?? []) {
+      const row = this.rows.get(update.id);
+      if (!row) continue;
+      this.rows.set(update.id, {
+        ...row,
+        mailboxIds: [...update.mailboxIds],
+        keywords: [...update.keywords],
+      });
+      updatedIds.add(update.id);
+    }
+    if (change.state) {
+      Object.assign(state, change.state, { failureCount: 0, updatedAt: now });
+    }
+    return Promise.resolve({ written: true, updatedIds });
+  }
+}
+
+describe('검색 색인 맞추기 · 채우기 (MailSearchSyncService · MailSearchBuildService)', () => {
+  let engine: FakeEngine;
+  let repository: FakeRepository;
+  let clock: number;
+  let timing: MailSearchTiming;
+  let sync: MailSearchSyncService;
+  let build: MailSearchBuildService;
+  let logs: string[];
+
+  const changesCalls = () =>
+    engine.calls.filter((call) => call === 'changes').length;
+  const failureLogs = () =>
+    logs.filter((line) => line.includes('못했습니다') || line.includes('실패'));
+
+  beforeEach(() => {
+    clock = NIGHT;
+    engine = new FakeEngine({
+      now: () => clock,
+      advance: (ms) => {
+        clock += ms;
+      },
+    });
+    repository = new FakeRepository();
+    timing = {
+      now: () => clock,
+      // 쉬는 동안 시계만 간다 — 진짜로 기다리지 않는다
+      sleep: (ms) => {
+        clock += ms;
+        return Promise.resolve();
+      },
+    };
+    const runs = new MailSearchRuns();
+    const repo = repository as unknown as MailSearchIndexRepository;
+    sync = new MailSearchSyncService(
+      engine,
+      repo,
+      runs,
+      { domain: DOMAIN },
+      timing,
+    );
+    build = new MailSearchBuildService(engine, repo, runs, sync, timing);
+    logs = [];
+    const record = (message: unknown) => {
+      logs.push(String(message));
+    };
+    jest.spyOn(Logger.prototype, 'log').mockImplementation(record);
+    jest.spyOn(Logger.prototype, 'warn').mockImplementation(record);
+    jest.spyOn(Logger.prototype, 'error').mockImplementation(record);
+  });
+
+  afterEach(() => {
+    sync.beforeApplicationShutdown();
+    jest.useRealTimers();
+    jest.restoreAllMocks();
+  });
+
+  describe('채우기 (B3)', () => {
+    it('시작할 때 state(S0) · 메일 수를 적고, 최신부터 묶음씩 넣은 뒤 따라잡기 · 전체 대조 → ready', async () => {
+      engine.seed(BUILD_BATCH_SIZE * 2 + 7);
+      repository.addState();
+
+      const outcome = await build.build(ARA, clock + LONG);
+
+      expect(outcome).toBe('ready');
+      const state = repository.states.get(ARA)!;
+      expect(state).toMatchObject({
+        status: 'ready',
+        emailState: engine.state,
+        buildAnchor: null,
+        buildDone: BUILD_BATCH_SIZE * 2 + 7,
+        buildTotal: BUILD_BATCH_SIZE * 2 + 7,
+      });
+      expect(state.buildStartedAt).not.toBeNull();
+      expect(state.readyAt).not.toBeNull();
+      expect(repository.rows.size).toBe(BUILD_BATCH_SIZE * 2 + 7);
+      // 묶음 셋(50 · 50 · 7) + 빈 쪽 — 최신부터
+      expect(engine.calls.filter((call) => call === 'pageIds')).toHaveLength(4);
+      expect(
+        logs.some((line) => line.includes('검색 색인을 다 만들었습니다')),
+      ).toBe(true);
+      expect(logs.join('\n')).not.toContain(ARA);
+    });
+
+    it('채우는 동안 온 메일 · 옮긴 메일 · 지운 메일은 맞추기가 넣는다 — 색인에 없던 옮긴 메일은 채우기에 맡긴다', async () => {
+      engine.seed(BUILD_BATCH_SIZE * 2);
+      repository.addState();
+      // 시작과 첫 묶음까지만 (시계는 묶음 사이 쉬는 동안만 간다 — 끝 시각을 짧게)
+      await build.build(ARA, clock + STEP_MIN_REMAINING_MS + 300);
+      expect(repository.states.get(ARA)?.buildDone).toBe(BUILD_BATCH_SIZE);
+
+      engine.add('new1', 999_999);
+      engine.move('old0', ['archive']); // 아직 넣지 않은 지난 메일 (가장 오래된 것)
+      engine.remove(`old${BUILD_BATCH_SIZE * 2 - 1}`); // 이미 넣은 최신 메일
+      expect(await sync.syncUser(ARA, clock + LONG)).toBe(true);
+      expect(repository.rows.has('new1')).toBe(true);
+      expect(repository.rows.has('old0')).toBe(false);
+      expect(repository.rows.has(`old${BUILD_BATCH_SIZE * 2 - 1}`)).toBe(false);
+
+      expect(await build.build(ARA, clock + LONG)).toBe('ready');
+      expect(repository.rows.get('old0')?.mailboxIds).toEqual(['archive']);
+      expect(repository.rows.size).toBe(engine.emails.size);
+    });
+
+    it('anchor 가 지워지면 위치로 이어 가고(몇 통 건너뛸 수 있다) 마지막 전체 대조가 빠진 것을 채운다', async () => {
+      engine.seed(120);
+      repository.addState();
+      await build.build(ARA, clock + STEP_MIN_REMAINING_MS + 300);
+      const first = repository.states.get(ARA)!;
+      expect(first.buildDone).toBe(BUILD_BATCH_SIZE);
+      // 첫 묶음은 old119 ~ old70 — 그 마지막(anchor)을 지운다. 위치 50 은 이제 old68 이라 old69 를 건너뛴다
+      expect(first.buildAnchor).toBe('old70');
+      engine.remove('old70');
+
+      expect(await build.build(ARA, clock + LONG)).toBe('ready');
+      expect(repository.rows.has('old70')).toBe(false);
+      expect(repository.rows.has('old69')).toBe(true);
+      expect([...repository.rows.keys()].sort()).toEqual(
+        engine.newestFirst().sort(),
+      );
+    });
+
+    it('판을 되돌리면 채우기의 첫 묶음이 옛 판 줄을 모두 지운다 — 위치로 건너뛴 메일도 마지막 대조가 새로 넣어 옛 판 줄이 남지 않는다 (리뷰 M1)', async () => {
+      engine.seed(120);
+      repository.addState();
+      expect(await build.build(ARA, clock + LONG)).toBe('ready');
+      // 옛 판(다른 접기 규칙)으로 만든 줄처럼 꾸민다
+      for (const [id, row] of repository.rows) {
+        repository.rows.set(id, { ...row, foldBody: 'old-format' });
+      }
+      repository.states.get(ARA)!.indexFormat = INDEX_FORMAT - 1;
+
+      await build.onApplicationBootstrap();
+      expect(repository.states.get(ARA)).toMatchObject({
+        status: 'building',
+        buildStartedAt: null,
+        emailState: null,
+        indexFormat: INDEX_FORMAT,
+      });
+
+      // 시작 + 첫 묶음(old119 ~ old70) → 그 anchor 를 지워 위치로 건너뛰게(old69 를 건너뛴다) → 끝까지
+      await build.build(ARA, clock + STEP_MIN_REMAINING_MS + 300);
+      expect(repository.writes.some((write) => write.clearIndex)).toBe(true);
+      expect(repository.states.get(ARA)?.buildAnchor).toBe('old70');
+      engine.remove('old70');
+      expect(await build.build(ARA, clock + LONG)).toBe('ready');
+
+      const old = [...repository.rows.values()].filter(
+        (row) => row.foldBody === 'old-format',
+      );
+      expect(old).toEqual([]);
+      expect([...repository.rows.keys()].sort()).toEqual(
+        engine.newestFirst().sort(),
+      );
+      // 처음부터 시작할 때만 지운다 — 이어 하는 묶음은 지우지 않는다
+      expect(
+        repository.writes.filter((write) => write.clearIndex),
+      ).toHaveLength(2);
+    });
+
+    it('서버가 뜰 때 판 되돌리기가 실패하면 1분 차례가 다시 해 본다(낮에도) — 한 번 되면 다시 하지 않고, 사내 도메인 줄만 (리뷰 L5)', async () => {
+      const state = repository.addState({
+        status: 'ready',
+        emailState: 's',
+        buildStartedAt: new Date(0),
+        indexFormat: INDEX_FORMAT - 1,
+      });
+      const other = repository.addState({
+        userEmail: 'search.index@e2e.arasystem.test',
+        status: 'ready',
+        indexFormat: INDEX_FORMAT - 1,
+      });
+      repository.failResets = 1;
+
+      await build.onApplicationBootstrap();
+      expect(state.status).toBe('ready');
+      expect(logs.some((line) => line.includes('되돌리지 못했습니다'))).toBe(
+        true,
+      );
+
+      clock = Date.parse('2026-11-05T12:00:00+09:00');
+      expect(await build.tick()).toBeNull();
+      expect(state).toMatchObject({
+        status: 'building',
+        buildStartedAt: null,
+        indexFormat: INDEX_FORMAT,
+      });
+      // 다른 도메인 줄은 그쪽 서버의 몫
+      expect(other).toMatchObject({
+        status: 'ready',
+        indexFormat: INDEX_FORMAT - 1,
+      });
+      expect(repository.resetCalls).toBe(2);
+      await build.tick();
+      expect(repository.resetCalls).toBe(2);
+      // 낮이라 채우지는 않는다
+      expect(engine.calls).toEqual([]);
+    });
+
+    it('채우는 중 엔진이 변화를 셀 수 없으면 대조하되 빠진 메일은 넣지 않는다(채우기가 넣는다) — 지운 것 · 옮긴 것은 맞춘다', async () => {
+      engine.seed(BUILD_BATCH_SIZE * 2);
+      repository.addState();
+      await build.build(ARA, clock + STEP_MIN_REMAINING_MS + 300);
+      const newest = engine.newestFirst()[0];
+      repository.rows.set('ghost', {
+        ...repository.rows.get(newest)!,
+        emailId: 'ghost',
+      });
+      engine.emails.get(newest)!.mailboxIds = ['trash'];
+      // 그사이 온 메일(가장 오래된 받은 시각 — 채우기의 끝에서 읽힌다) — 대조는 넣지 않고 state 만 앞으로
+      engine.add('late', 5);
+      engine.forgetBefore = Number.MAX_SAFE_INTEGER;
+
+      expect(await sync.syncUser(ARA, clock + LONG)).toBe(true);
+
+      const state = repository.states.get(ARA)!;
+      expect(state.status).toBe('building');
+      expect(state.emailState).toBe(engine.state);
+      expect(repository.rows.has('ghost')).toBe(false);
+      expect(repository.rows.get(newest)?.mailboxIds).toEqual(['trash']);
+      // 아직 채우지 않은 쪽은 그대로 — 채우기가 넣는다
+      expect(repository.rows.size).toBe(BUILD_BATCH_SIZE);
+
+      engine.forgetBefore = 0;
+      expect(await build.build(ARA, clock + LONG)).toBe('ready');
+      expect(repository.rows.size).toBe(engine.emails.size);
+      expect(repository.rows.has('late')).toBe(true);
+    });
+
+    it('끝 시각 · 창이 닫힘에 닿으면 다음 묶음을 시작하지 않는다 — 다음 차례가 이어 한다', async () => {
+      engine.seed(BUILD_BATCH_SIZE * 3);
+      repository.addState();
+      let open = true;
+      const outcome = await build.build(ARA, clock + LONG, () => {
+        const keep = open;
+        open = false;
+        return keep;
+      });
+      expect(outcome).toBe('partial');
+      expect(repository.states.get(ARA)?.status).toBe('building');
+      expect(await build.build(ARA, clock + LONG)).toBe('ready');
+      expect(repository.rows.size).toBe(BUILD_BATCH_SIZE * 3);
+    });
+
+    it('표에 넣을 수 없는 긴 id 는 anchor 로 쓰지 않는다 — 넣을 수 있는 마지막 id', async () => {
+      const longId = 'x'.repeat(65);
+      engine.seed(3);
+      engine.emails.set(longId, {
+        receivedAt: 1,
+        mailboxIds: ['inbox'],
+        keywords: [],
+      });
+      repository.addState();
+      expect(await build.build(ARA, clock + LONG)).toBe('ready');
+      const anchors = repository.writes
+        .map((write) => write.state?.buildAnchor)
+        .filter((anchor): anchor is string => typeof anchor === 'string');
+      expect(anchors).toEqual(['old0']);
+      expect(repository.rows.has(longId)).toBe(false);
+    });
+
+    it('1분 차례는 밤 창 안 · 사내 도메인 주소만 — 낮에는 아무것도 하지 않는다', async () => {
+      engine.seed(3);
+      repository.addState({ userEmail: 'search.index@e2e.arasystem.test' });
+      repository.addState();
+      clock = Date.parse('2026-11-05T12:00:00+09:00');
+      expect(await build.tick()).toBeNull();
+      expect(engine.calls).toEqual([]);
+      clock = NIGHT;
+      expect(await build.tick()).toBe('ready');
+      expect(
+        repository.states.get('search.index@e2e.arasystem.test')
+          ?.buildStartedAt,
+      ).toBeNull();
+    });
+
+    it('상태 줄이 그사이 지워지면(퇴사 마무리) 쓰지 않고 멈춘다', async () => {
+      engine.seed(BUILD_BATCH_SIZE * 2);
+      repository.addState();
+      await build.build(ARA, clock + STEP_MIN_REMAINING_MS + 300);
+      repository.states.delete(ARA);
+      expect(await build.build(ARA, clock + LONG)).toBe('skipped');
+    });
+  });
+
+  describe('시간 끝은 실패가 아니다 (이어 하기)', () => {
+    it('엔진 읽기가 끝 시각에 걸리면(IndexDeadlineError) 그 묶음을 쓰지 않고 이어 하기 — 실패 수 · 경고 없음', async () => {
+      engine.seed(BUILD_BATCH_SIZE);
+      repository.addState();
+      engine.failNext = new IndexDeadlineError();
+      expect(await build.build(ARA, clock + LONG)).toBe('partial');
+      expect(repository.states.get(ARA)?.failureCount).toBe(0);
+
+      repository.states.get(ARA)!.status = 'ready';
+      repository.states.get(ARA)!.emailState = engine.state;
+      engine.failNext = new IndexDeadlineError();
+      expect(await sync.syncUser(ARA, clock + LONG)).toBe(false);
+      expect(repository.states.get(ARA)?.failureCount).toBe(0);
+      expect(failureLogs()).toEqual([]);
+    });
+
+    it('남은 시간이 모자라면 다음 쪽 · 묶음을 시작하지 않는다 — 엔진이 느려도(읽기 4초) 끝 시각 전에 멈추고 쓴 데까지 남긴다', async () => {
+      repository.addState({ status: 'ready', emailState: engine.state });
+      for (let index = 0; index < 120; index += 1)
+        engine.add(`m${index}`, index);
+      engine.callCostMs = 4_000;
+
+      // 20초: changes(4초) → 글 50통 둘(8초) → 다음 쪽 changes(4초) → 그 쪽의 글은 남은 시간이 STEP_MIN_REMAINING_MS 보다 적어 시작하지 않는다
+      expect(await sync.syncUser(ARA, clock + 20_000)).toBe(false);
+      expect(repository.states.get(ARA)?.failureCount).toBe(0);
+      expect(failureLogs()).toEqual([]);
+      // 끝 시각 전에 멈췄다 — 엔진 읽기가 끝 시각을 넘지 않았다
+      expect(engine.calls.filter((call) => call === 'documents')).toHaveLength(
+        2,
+      );
+
+      // 다음 차례들이 이어 해서 끝내 따라잡는다
+      let caught = false;
+      for (let round = 0; round < 10 && !caught; round += 1) {
+        caught = await sync.syncUser(ARA, clock + 60_000);
+      }
+      expect(caught).toBe(true);
+      expect(repository.rows.size).toBe(120);
+      expect(repository.states.get(ARA)?.failureCount).toBe(0);
+    });
+
+    it('마무리(따라잡기 · 전체 대조)는 새 차례의 처음에만 시작하고, 시간 안에 끝나지 않아도 다음 차례에 이어 해 끝내 ready', async () => {
+      engine.seed(300);
+      // 지난 메일을 다 읽었는데(빈 쪽) 색인에는 하나도 없다 — 마무리의 대조가 300통을 넣어야 한다
+      repository.addState({
+        emailState: engine.state,
+        buildStartedAt: new Date(clock),
+        buildAnchor: 'old0',
+        buildDone: 300,
+        buildTotal: 300,
+      });
+      engine.callCostMs = 10_000;
+
+      // 빈 쪽을 읽은 뒤 남은 시간이 마무리에 모자라면(차례의 끝 무렵) 시작하지 않는다
+      expect(await build.build(ARA, clock + 35_000)).toBe('partial');
+      expect(engine.calls).not.toContain('allIds');
+
+      const outcomes: string[] = [];
+      for (let run = 0; run < 8; run += 1) {
+        const outcome = await build.build(ARA, clock + BUILD_RUN_BUDGET_MS);
+        outcomes.push(outcome);
+        if (outcome === 'ready') break;
+      }
+      expect(outcomes[outcomes.length - 1]).toBe('ready');
+      expect(outcomes.length).toBeGreaterThan(1);
+      expect(
+        outcomes.slice(0, -1).every((outcome) => outcome === 'partial'),
+      ).toBe(true);
+      expect(repository.rows.size).toBe(300);
+      expect(repository.states.get(ARA)?.failureCount).toBe(0);
+      expect(failureLogs()).toEqual([]);
+    });
+  });
+
+  describe('맞추기 (B2)', () => {
+    beforeEach(() => {
+      repository.addState({ status: 'ready', emailState: engine.state });
+    });
+
+    it('만든 · 바꾼 · 지운 메일을 넣고 state 를 함께 적는다 — 여러 쪽이면 이어 묻는다', async () => {
+      for (let index = 0; index < 150; index += 1) {
+        engine.add(`m${index}`, index);
+      }
+      engine.move('m0', ['archive']);
+      engine.remove('m1');
+
+      expect(await sync.syncUser(ARA, clock + LONG)).toBe(true);
+
+      expect(repository.rows.size).toBe(149);
+      expect(repository.rows.get('m0')?.mailboxIds).toEqual(['archive']);
+      expect(repository.states.get(ARA)?.emailState).toBe(engine.state);
+      expect(changesCalls()).toBeGreaterThan(1);
+    });
+
+    it('한 쪽에 만든 메일이 바뀐 메일로도 함께 오면 글을 한 번만 읽는다', async () => {
+      engine.addReportedTwice('dup', 1);
+      expect(await sync.syncUser(ARA, clock + LONG)).toBe(true);
+      expect(engine.documentRequests).toEqual([['dup']]);
+      expect(engine.calls).not.toContain('mutable');
+      expect(repository.rows.has('dup')).toBe(true);
+    });
+
+    it('다 만든 직원의 색인에 없던 바뀐 메일은 글째 넣는다', async () => {
+      engine.seed(1);
+      engine.move('old0', ['archive']);
+      await sync.syncUser(ARA, clock + LONG);
+      expect(repository.rows.get('old0')?.mailboxIds).toEqual(['archive']);
+    });
+
+    it('엔진이 변화를 셀 수 없으면 전체 대조 — 없어진 것은 지우고 빠진 것은 넣고 메일함을 다시 읽는다', async () => {
+      engine.add('a', 1);
+      engine.add('b', 2);
+      await sync.syncUser(ARA, clock + LONG);
+      // 색인에만 있는 줄 · 엔진에서 옮긴 메일 · 색인에 없는 메일
+      repository.rows.set('ghost', {
+        ...repository.rows.get('a')!,
+        emailId: 'ghost',
+      });
+      engine.emails.get('a')!.mailboxIds = ['trash'];
+      engine.seed(2);
+      engine.forgetBefore = Number.MAX_SAFE_INTEGER;
+
+      expect(await sync.syncUser(ARA, clock + LONG)).toBe(true);
+
+      expect([...repository.rows.keys()].sort()).toEqual([
+        'a',
+        'b',
+        'old0',
+        'old1',
+      ]);
+      expect(repository.rows.get('a')?.mailboxIds).toEqual(['trash']);
+      expect(repository.states.get(ARA)?.emailState).toBe(engine.state);
+    });
+
+    it('실시간 소식은 모아서 한 번 — 맞추는 중에 온 소식은 한 번 더(그사이 여러 번 와도 한 번), 끝나면 둘 다 들어 있다', async () => {
+      jest.useFakeTimers({
+        doNotFake: ['nextTick', 'setImmediate', 'queueMicrotask'],
+      });
+      const settle = async () => {
+        for (let round = 0; round < 10; round += 1) {
+          await new Promise((resolve) => setImmediate(resolve));
+        }
+      };
+      let release: () => void = () => undefined;
+      engine.changesGate = new Promise<void>((resolve) => {
+        release = resolve;
+      });
+
+      engine.add('a', 1);
+      sync.requestSync(ARA);
+      sync.requestSync(ARA);
+      sync.requestSync(' Ara.Kim@arasystem.test ');
+      await jest.advanceTimersByTimeAsync(SYNC_DEBOUNCE_MS);
+      await settle();
+      // 첫 맞추기가 엔진의 답을 기다리는 중 — 그사이 새 메일과 소식 셋
+      expect(changesCalls()).toBe(1);
+      engine.add('b', 2);
+      for (let index = 0; index < 3; index += 1) {
+        sync.requestSync(ARA);
+        await jest.advanceTimersByTimeAsync(SYNC_DEBOUNCE_MS);
+      }
+      expect(changesCalls()).toBe(1);
+
+      engine.changesGate = null;
+      release();
+      await settle();
+
+      // 첫 맞추기(a 까지 본 답) 뒤 한 번 더 — b 까지
+      expect(changesCalls()).toBe(2);
+      expect(repository.rows.has('a')).toBe(true);
+      expect(repository.rows.has('b')).toBe(true);
+    });
+
+    it('서버 전체에서 함께 도는 맞추기는 SYNC_CONCURRENCY 개까지 — 나머지는 기다렸다 모두 맞춘다', async () => {
+      const users = Array.from(
+        { length: SYNC_CONCURRENCY + 2 },
+        (_, index) => `user${index}@${DOMAIN}`,
+      );
+      for (const user of users) {
+        repository.addState({
+          userEmail: user,
+          status: 'ready',
+          emailState: engine.state,
+        });
+      }
+      let release: () => void = () => undefined;
+      engine.changesGate = new Promise<void>((resolve) => {
+        release = resolve;
+      });
+      const syncs = users.map((user) => sync.syncBeforeRead(user, LONG));
+      for (let round = 0; round < 10; round += 1) {
+        await new Promise((resolve) => setImmediate(resolve));
+      }
+      expect(engine.inFlight).toBe(SYNC_CONCURRENCY);
+
+      engine.changesGate = null;
+      release();
+      expect(await Promise.all(syncs)).toEqual(users.map(() => true));
+      expect(engine.maxInFlight).toBe(SYNC_CONCURRENCY);
+      expect(changesCalls()).toBe(users.length);
+    });
+
+    it('검색 바로 전 맞추기는 기다리는 만큼만 — 기다리는 맞추기가 있으면 함께 기다린다', async () => {
+      engine.add('a', 1);
+      const [first, second] = await Promise.all([
+        sync.syncBeforeRead(ARA, 5_000),
+        sync.syncBeforeRead(ARA, 5_000),
+      ]);
+      expect(first).toBe(true);
+      expect(second).toBe(true);
+      expect(changesCalls()).toBe(1);
+    });
+
+    it('5분 차례는 맞출 기준이 있는 사내 직원만, 실패가 이어진 직원은 때가 될 때까지 건너뛴다', async () => {
+      repository.addState({ userEmail: `new@${DOMAIN}` }); // 채우기를 시작하지 않음
+      repository.addState({
+        userEmail: `failing@${DOMAIN}`,
+        status: 'ready',
+        emailState: engine.state,
+        failureCount: 3,
+        updatedAt: new Date(clock),
+      });
+      // 같은 DB 의 다른 도메인 줄(e2e 등) — 맞추지 않는다
+      repository.addState({
+        userEmail: 'search.index@e2e.arasystem.test',
+        status: 'ready',
+        emailState: engine.state,
+      });
+      engine.add('a', 1);
+      await sync.syncAll();
+      expect(repository.rows.has('a')).toBe(true);
+      expect(changesCalls()).toBe(1);
+      expect(sync.isIndexedAddress('x@e2e.arasystem.test')).toBe(false);
+      expect(sync.isIndexedAddress(' Ara.Kim@ARASYSTEM.test ')).toBe(true);
+    });
+  });
+
+  describe('실패', () => {
+    beforeEach(() => {
+      repository.addState({ status: 'ready', emailState: engine.state });
+      engine.add('a', 1);
+    });
+
+    it.each([
+      [
+        '비밀번호 만료',
+        new PasswordExpiredException(ARA, 'ara.kim'),
+        'password-expired',
+      ],
+      ['잠김', new AccountLoginDisabledException(ARA), 'locked'],
+      [
+        '엔진에 없음',
+        new BusinessException('AUTH_001', {
+          context: { reason: 'impersonation-rejected' },
+        }),
+        'locked',
+      ],
+    ] as const)(
+      '대리 접근이 막히면(%s) 멈춘다 — 맞추기 차례에서 빠진다',
+      async (_name, error, reason) => {
+        engine.failNext = error;
+        expect(await sync.syncUser(ARA, clock + LONG)).toBe(false);
+        expect(repository.states.get(ARA)?.pausedReason).toBe(reason);
+        expect(await repository.syncCandidates()).toEqual([]);
+        expect(logs.join('\n')).not.toContain(ARA);
+      },
+    );
+
+    it('엔진 장애는 실패 수를 더하고 처음 한 번만 경고한다 — 성공하면 0 (엔진 설명 문장은 남기지 않는다)', async () => {
+      const outage = () =>
+        new BusinessException('MAIL_001', {
+          context: {
+            reason: 'http-error',
+            jmapType: 'serverFail',
+            description: '비밀 문장',
+          },
+        });
+      engine.failNext = outage();
+      await sync.syncUser(ARA, clock + LONG);
+      engine.failNext = outage();
+      await sync.syncUser(ARA, clock + LONG);
+      expect(repository.states.get(ARA)?.failureCount).toBe(2);
+      const warnings = logs.filter((line) =>
+        line.includes('맞추지 못했습니다'),
+      );
+      expect(warnings).toHaveLength(1);
+      expect(warnings[0]).toContain('MAIL_001/http-error/serverFail');
+      expect(logs.join('\n')).not.toContain('비밀 문장');
+
+      expect(await sync.syncUser(ARA, clock + LONG)).toBe(true);
+      expect(repository.states.get(ARA)?.failureCount).toBe(0);
+    });
+  });
+});
diff --git a/backend/src/modules/mail-search/mail-search-sync.service.ts b/backend/src/modules/mail-search/mail-search-sync.service.ts
new file mode 100644
index 0000000..bae36c8
--- /dev/null
+++ b/backend/src/modules/mail-search/mail-search-sync.service.ts
@@ -0,0 +1,483 @@
+import {
+  BeforeApplicationShutdown,
+  Inject,
+  Injectable,
+  Logger,
+  Optional,
+} from '@nestjs/common';
+import { Cron } from '@nestjs/schedule';
+
+import { BusinessException } from '@/common/errors/business.exception';
+import {
+  AccountLoginDisabledException,
+  PasswordExpiredException,
+} from '@/modules/mail/mail.provider';
+import { MAIL_SETTINGS, type MailSettings } from '@/modules/mail/mail.settings';
+import { maskEmail } from '@/shared/utils/mask';
+import { settledWithin } from '@/shared/utils/settle';
+import {
+  isIndexableId,
+  toIndexRow,
+  type IndexRowValues,
+} from './index-document';
+import {
+  IndexDeadlineError,
+  MAIL_INDEX_SOURCE,
+  type IndexChanges,
+  type IndexMutable,
+  type MailIndexSource,
+} from './mail-index-source';
+import {
+  MailSearchIndexRepository,
+  type SearchStatePatch,
+} from './mail-search-index.repository';
+import { ConcurrencyGate, MailSearchRuns } from './mail-search-runs';
+import {
+  MAIL_SEARCH_TIMING,
+  SYSTEM_SEARCH_TIMING,
+  type MailSearchTiming,
+} from './mail-search-timing';
+import {
+  DOCUMENT_READ_BATCH,
+  FAILURE_BACKOFF_STEPS_MAX,
+  MUTABLE_READ_BATCH,
+  PRE_READ_SYNC_WAIT_MS,
+  RECONCILE_BUDGET_MS,
+  RECONCILE_WRITE_BATCH,
+  SEARCH_CRON_TIME_ZONE,
+  STEP_MIN_REMAINING_MS,
+  SYNC_BUDGET_MS,
+  SYNC_CHANGES_PAGE,
+  SYNC_CONCURRENCY,
+  SYNC_DEBOUNCE_MS,
+} from './mail-search.constants';
+import type {
+  SearchIndexStatus,
+  SearchPausedReason,
+} from './mail-search.types';
+import { isDueAfterFailures } from './search-index-schedule';
+
+/** 전체 대조에서 무엇을 하나 */
+export interface ReconcileOptions {
+  /** 엔진에는 있는데 색인에 없는 메일을 넣는다 — 채우는 중(building)이면 채우기가 할 일이라 넣지 않는다 */
+  readonly addMissing: boolean;
+  /** 색인에 있는 메일의 메일함 · 키워드를 다시 읽는다 — 변화를 놓쳤을 때(cannotCalculateChanges) */
+  readonly refreshMutable: boolean;
+  /** 끝에 상태 줄에 함께 쓸 것 (채우기의 마무리 — ready) */
+  readonly finalState?: (indexed: number) => SearchStatePatch;
+}
+
+/** 줄을 나눈다 */
+function chunks<T>(items: readonly T[], size: number): T[][] {
+  const out: T[][] = [];
+  for (let index = 0; index < items.length; index += size) {
+    out.push(items.slice(index, index + size));
+  }
+  return out;
+}
+
+/** 로그에 남길 실패 요약 — 코드 · 사유 · 엔진 오류 종류만 (엔진 설명 문장 · 주소 · 글은 넣지 않는다) */
+function failureSummary(error: unknown): string {
+  if (error instanceof BusinessException) {
+    const reason = error.context?.reason;
+    const jmapType = error.context?.jmapType;
+    return [
+      error.code,
+      typeof reason === 'string' ? reason : null,
+      typeof jmapType === 'string' ? jmapType : null,
+    ]
+      .filter(Boolean)
+      .join('/');
+  }
+  // DB 오류의 문장에는 값(주소 등)이 들어갈 수 있다 — 종류와 코드만
+  const name = error instanceof Error ? error.name : typeof error;
+  const code = (error as { code?: unknown } | null)?.code;
+  return typeof code === 'string' ? `${name}/${code}` : name;
+}
+
+/** 대리 접근이 막힌 실패인가 → 멈출 까닭 (아니면 null) */
+function pausedReasonOf(error: unknown): SearchPausedReason | null {
+  if (error instanceof PasswordExpiredException) return 'password-expired';
+  if (error instanceof AccountLoginDisabledException) return 'locked';
+  // 엔진에 그 계정이 없다(대리 접근 401) — 로그인할 수 없는 계정이라 멈춘다
+  if (error instanceof BusinessException && error.code === 'AUTH_001') {
+    return 'locked';
+  }
+  return null;
+}
+
+/**
+ * 검색 색인 맞추기 (14단계 설계 B2) — 엔진의 Email state 부터 변화(Email/changes)를 받아 색인에 넣는다. 엔진을 모른다(포트 MAIL_INDEX_SOURCE).
+ *
+ * 부르는 때: ① 실시간 연결의 state 소식(SYNC_DEBOUNCE_MS 모음 — mail-events.service.ts) ② 5분마다 모든 직원(한 사람씩 · SYNC_BUDGET_MS 안)
+ * ③ 검색 · 대화 · 묶은 목록 바로 전 한 번(PRE_READ_SYNC_WAIT_MS 까지 기다린다 — 넘으면 지금 색인으로 답하고 맞추기는 이어 한다 — 14단계 2차부터 부른다).
+ * 같은 직원은 한 번에 하나(MailSearchRuns) — 기다리는 맞추기가 있으면 새로 넣지 않고 그것을 함께 기다린다.
+ * 서버 전체에서는 SYNC_CONCURRENCY 개까지 함께 맞춘다(ConcurrencyGate) — 전 직원에게 메일 한 통이 와도 엔진에 한꺼번에 몰리지 않게.
+ * 맞추는 직원은 사내 도메인(MAIL_DOMAIN) 주소뿐이다 — 로그인할 수 있는 주소만 상태 줄이 생긴다(같은 DB 의 다른 도메인 줄 — e2e 등 — 은 건드리지 않는다).
+ *
+ * - 만든 메일 → 글을 읽어 넣는다. 바뀐 메일 → 메일함 · 키워드만(JMAP 에서 글은 바뀌지 않는다) — 색인에 없던 메일은 다 만든 직원(ready)이면 글을 읽어 넣고,
+ *   채우는 중이면 건너뛴다(채우기가 최신 글로 넣는다). 없어진 메일 → 지운다
+ * - 한 쪽(SYNC_CHANGES_PAGE)마다 그 쪽의 쓰기와 새 state 를 한 트랜잭션에 — 끝 시각에 닿으면 쓴 데까지가 맞춘 곳이다
+ * - **시간 끝은 실패가 아니다** — 남은 시간이 STEP_MIN_REMAINING_MS 보다 적으면 다음 쪽 · 묶음을 시작하지 않고, 엔진 읽기가 끝 시각에 걸려
+ *   멈추면(IndexDeadlineError) 쓴 데까지 두고 다음 차례에 이어 한다(실패 수 · 경고 · 미루기 없음)
+ * - 엔진이 셀 수 없다(cannotCalculateChanges) → 전체 대조(reconcile — 모든 id 를 견주어 없는 것은 지우고, 메일함 · 키워드를 다시 읽는다)
+ * - 대리 접근이 막혔다(비밀번호 만료 · 잠김 · 계정 없음) → 멈춘다(paused_reason — 다음 로그인 · 비밀번호 바꾸기 때 푼다). 그 밖의 실패는 실패 수를 더하고
+ *   다음 차례를 늦춘다(isDueAfterFailures). 로그는 처음 실패 · 오래 이어질 때만 — 코드 · 사유뿐이다(엔진 설명 문장 · 메일 글 · 주소 없음)
+ *
+ * ⚠️ 차례 · 모음 · 동시 수(debounces · queued · syncingAll · gate)는 프로세스 메모리다 — 인스턴스를 늘리면 옮긴다 (nestjs 스킬의 Redis 목록)
+ */
+@Injectable()
+export class MailSearchSyncService implements BeforeApplicationShutdown {
+  private readonly logger = new Logger(MailSearchSyncService.name);
+  private readonly debounces = new Map<string, NodeJS.Timeout>();
+  /** 줄에 넣었지만 아직 시작하지 않은 맞추기 — 같은 직원의 새 요청이 함께 기다린다 */
+  private readonly queued = new Map<string, Promise<boolean>>();
+  /** 서버 전체에서 함께 도는 맞추기 수 */
+  private readonly gate = new ConcurrencyGate(SYNC_CONCURRENCY);
+  private syncingAll = false;
+  private stopping = false;
+  private readonly timing: MailSearchTiming;
+  /** 맞추는 주소의 끝 — `@사내 도메인` (설정이 없으면 null — 아무도 맞추지 않는다) */
+  private readonly addressSuffix: string | null;
+
+  constructor(
+    @Inject(MAIL_INDEX_SOURCE) private readonly source: MailIndexSource,
+    private readonly repository: MailSearchIndexRepository,
+    private readonly runs: MailSearchRuns,
+    @Inject(MAIL_SETTINGS) settings: Pick<MailSettings, 'domain'>,
+    @Optional() @Inject(MAIL_SEARCH_TIMING) timing?: MailSearchTiming,
+  ) {
+    this.timing = timing ?? SYSTEM_SEARCH_TIMING;
+    const domain = settings.domain?.trim().toLowerCase();
+    this.addressSuffix = domain ? `@${domain}` : null;
+  }
+
+  /** 색인하는 주소의 끝 — `@사내 도메인` (설정이 없으면 null) — 판이 바뀐 줄 되돌리기가 쓴다 */
+  get indexedAddressSuffix(): string | null {
+    return this.addressSuffix;
+  }
+
+  /** 색인하는 주소인가 — 사내 도메인(MAIL_DOMAIN)의 주소만 (5분 맞추기 · 밤 채우기의 차례가 본다) */
+  isIndexedAddress(user: string): boolean {
+    return (
+      this.addressSuffix !== null &&
+      user.trim().toLowerCase().endsWith(this.addressSuffix)
+    );
+  }
+
+  /** 실시간 소식 — SYNC_DEBOUNCE_MS 동안 모아 맞추기 한 번 (던지지 않는다) */
+  requestSync(user: string): void {
+    const key = user.trim().toLowerCase();
+    if (this.stopping || key === '' || this.debounces.has(key)) return;
+    const timer = setTimeout(() => {
+      this.debounces.delete(key);
+      void this.enqueueSync(key);
+    }, SYNC_DEBOUNCE_MS);
+    timer.unref();
+    this.debounces.set(key, timer);
+  }
+
+  /**
+   * 검색 · 대화 · 묶은 목록 바로 전 — 맞추기를 `waitMs` 까지 기다린다 → 그 안에 다 맞췄으면 true.
+   * 넘으면 false 이고 맞추기는 뒤에서 이어 한다 (부른 쪽은 지금 색인으로 답한다). 던지지 않는다
+   */
+  async syncBeforeRead(
+    user: string,
+    waitMs: number = PRE_READ_SYNC_WAIT_MS,
+  ): Promise<boolean> {
+    const key = user.trim().toLowerCase();
+    if (this.stopping || key === '') return false;
+    const sync = this.enqueueSync(key);
+    const settled = await settledWithin(sync, waitMs);
+    return settled && (await sync);
+  }
+
+  /** 5분마다 — 맞출 기준이 있는 사내 직원을 한 사람씩 (실패가 이어진 직원은 때가 될 때까지 건너뛴다) */
+  @Cron('0 */5 * * * *', {
+    name: 'mail-search-sync',
+    timeZone: SEARCH_CRON_TIME_ZONE,
+  })
+  async syncAll(): Promise<void> {
+    if (this.syncingAll || this.stopping) return;
+    this.syncingAll = true;
+    try {
+      const candidates = await this.repository.syncCandidates();
+      for (const state of candidates) {
+        if (this.stopping) break;
+        if (
+          !this.isIndexedAddress(state.userEmail) ||
+          !isDueAfterFailures(
+            state.failureCount,
+            state.updatedAt,
+            this.timing.now(),
+          )
+        ) {
+          continue;
+        }
+        await this.enqueueSync(state.userEmail);
+      }
+    } catch (error) {
+      this.logger.error(
+        `[SYS_001] 검색 색인 맞추기 차례를 읽지 못했습니다: ${failureSummary(error)}`,
+      );
+    } finally {
+      this.syncingAll = false;
+    }
+  }
+
+  beforeApplicationShutdown(): void {
+    this.stopping = true;
+    for (const timer of this.debounces.values()) clearTimeout(timer);
+    this.debounces.clear();
+  }
+
+  /** 서버가 닫히는 중인가 — 채우기도 멈춘다 */
+  get isStopping(): boolean {
+    return this.stopping;
+  }
+
+  /**
+   * 한 직원을 끝 시각까지 맞춘다 → 다 따라잡았으면 true. 던지지 않는다 — 실패는 상태 줄(멈춤 · 실패 수)과 로그로,
+   * 시간 끝(IndexDeadlineError)은 실패로 세지 않고 false 다(다음 차례에 이어 한다). 그 직원의 차례(MailSearchRuns) 안에서 부른다
+   */
+  async syncUser(user: string, deadline: number): Promise<boolean> {
+    try {
+      return await this.catchUp(user, deadline);
+    } catch (error) {
+      if (!(error instanceof IndexDeadlineError)) {
+        await this.handleFailure(user, error, 'sync');
+      }
+      return false;
+    }
+  }
+
+  /**
+   * syncUser 의 던지는 판 — 채우기의 마무리가 쓴다. 상태 줄이 없거나 · 멈췄거나 · 맞출 기준(email_state)이 없으면 false.
+   * 끝 시각 · 서버 종료에 닿아도 false (쓴 데까지가 맞춘 곳이다). 엔진 읽기가 끝 시각에 걸리면 IndexDeadlineError 를 던진다
+   */
+  async catchUp(user: string, deadline: number): Promise<boolean> {
+    const state = await this.repository.findState(user);
+    if (!state || state.pausedReason !== null || state.emailState === null) {
+      return false;
+    }
+    let since = state.emailState;
+    for (;;) {
+      if (!this.hasTime(deadline)) return false;
+      const changes = await this.source.changes(
+        user,
+        since,
+        SYNC_CHANGES_PAGE,
+        { deadline },
+      );
+      if (changes.kind === 'cannotCalculate') {
+        // 변화를 놓쳤다 — 모든 메일을 견준다(더 긴 시간 안에서). 채우는 중이면 없는 메일은 채우기가 넣는다
+        return this.reconcile(
+          user,
+          Math.max(deadline, this.timing.now() + RECONCILE_BUDGET_MS),
+          {
+            addMissing: state.status === 'ready',
+            refreshMutable: true,
+          },
+        );
+      }
+      const applied = await this.applyChanges(
+        user,
+        state.status,
+        changes,
+        deadline,
+      );
+      if (!applied) return false;
+      since = changes.newState;
+      if (!changes.hasMore) return true;
+    }
+  }
+
+  /**
+   * 전체 대조 — 엔진의 모든 메일 id 와 색인을 견주어 색인에만 있는 것을 지우고, 고르면 없는 것을 넣고 · 메일함 · 키워드를 다시 읽는다.
+   * 끝에 그 대조를 시작하기 바로 전의 state 를 맞출 기준으로 적는다(그 뒤의 변화는 다음 맞추기가 다시 한다 — 넣기 · 지우기는 몇 번 해도 같다).
+   * 끝 시각에 닿으면 false 이고 기준은 그대로다 — 지운 것 · 넣은 것은 남으므로 다음 대조는 남은 것만 한다(메일함이 커도 끝내 끝난다). 던진다
+   */
+  async reconcile(
+    user: string,
+    deadline: number,
+    options: ReconcileOptions,
+  ): Promise<boolean> {
+    const engine = await this.source.allIds(user, { deadline });
+    const engineIds = engine.ids.filter(isIndexableId);
+    const engineSet = new Set(engineIds);
+    const indexed = new Set(await this.repository.indexedIds(user));
+
+    const stale = [...indexed].filter((id) => !engineSet.has(id));
+    for (const batch of chunks(stale, RECONCILE_WRITE_BATCH)) {
+      if (!(await this.write(user, { deletes: batch }))) return false;
+    }
+
+    if (options.addMissing) {
+      const missing = engineIds.filter((id) => !indexed.has(id));
+      for (const batch of chunks(missing, DOCUMENT_READ_BATCH)) {
+        const rows = await this.readRows(user, batch, deadline);
+        if (rows === null) return false;
+        if (!(await this.write(user, { upserts: rows }))) return false;
+      }
+    }
+
+    if (options.refreshMutable) {
+      const kept = engineIds.filter((id) => indexed.has(id));
+      for (const batch of chunks(kept, MUTABLE_READ_BATCH)) {
+        if (!this.hasTime(deadline)) return false;
+        const updates = await this.source.mutable(user, batch, { deadline });
+        if (!(await this.write(user, { updates }))) return false;
+      }
+    }
+
+    const indexedCount = await this.repository.countMessages(user);
+    return this.write(user, {
+      state: {
+        emailState: engine.state,
+        lastSyncedAt: new Date(this.timing.now()),
+        ...(options.finalState ? options.finalState(indexedCount) : {}),
+      },
+    });
+  }
+
+  /**
+   * 실패 하나를 다룬다 — 대리 접근이 막혔으면 멈추고(warn), 아니면 실패 수를 더한다(처음 · FAILURE_BACKOFF_STEPS_MAX 번째에만 로그). 던지지 않는다.
+   * 시간 끝(IndexDeadlineError)은 실패가 아니라 아무것도 하지 않는다
+   */
+  async handleFailure(
+    user: string,
+    error: unknown,
+    phase: 'sync' | 'build',
+  ): Promise<void> {
+    if (error instanceof IndexDeadlineError) return;
+    const now = new Date(this.timing.now());
+    const summary = failureSummary(error);
+    try {
+      const reason = pausedReasonOf(error);
+      if (reason !== null) {
+        await this.repository.pause(user, reason, now);
+        this.logger.warn(
+          `[${error instanceof BusinessException ? error.code : 'MAIL_001'}] 대리 접근이 막혀 검색 색인을 멈춥니다(다음 로그인 때 다시): user=${maskEmail(user)}, reason=${reason}`,
+        );
+        return;
+      }
+      const failures = await this.repository.recordFailure(user, now);
+      const code = error instanceof BusinessException ? error.code : 'SYS_001';
+      if (failures === 1) {
+        this.logger.warn(
+          `[${code}] 검색 색인을 ${phase === 'sync' ? '맞추지' : '채우지'} 못했습니다(뒤에 다시): user=${maskEmail(user)}, ${summary}`,
+        );
+      } else if (failures === FAILURE_BACKOFF_STEPS_MAX) {
+        this.logger.error(
+          `[${code}] 검색 색인 ${phase === 'sync' ? '맞추기' : '채우기'}가 ${failures}번 이어 실패했습니다: user=${maskEmail(user)}, ${summary}`,
+        );
+      }
+    } catch (recordError) {
+      this.logger.error(
+        `[SYS_001] 검색 색인의 실패를 적지 못했습니다: user=${maskEmail(user)}, ${summary}, record=${failureSummary(recordError)}`,
+      );
+    }
+  }
+
+  /**
+   * 줄에 맞추기를 넣는다 — 기다리는 맞추기(아직 엔진에 묻기 전 — 그 직원의 차례 · 서버 전체 자리를 기다리는 중)가 있으면 그것을 함께 기다린다
+   */
+  private enqueueSync(user: string): Promise<boolean> {
+    const waiting = this.queued.get(user);
+    if (waiting) return waiting;
+    const sync = this.runs.run(user, () =>
+      this.gate.run(() => {
+        // 시작했다 — 이 뒤의 소식은 맞추기를 하나 더 넣는다 (이 맞추기가 놓칠 수 있다)
+        this.queued.delete(user);
+        if (this.stopping) return Promise.resolve(false);
+        return this.syncUser(user, this.timing.now() + SYNC_BUDGET_MS);
+      }),
+    );
+    this.queued.set(user, sync);
+    void sync.catch(() => this.queued.delete(user));
+    return sync;
+  }
+
+  /** 한 쪽의 변화를 한 트랜잭션에 → 썼으면 true (상태 줄이 없거나 끝 시각이면 false) */
+  private async applyChanges(
+    user: string,
+    status: SearchIndexStatus,
+    changes: Extract<IndexChanges, { kind: 'changes' }>,
+    deadline: number,
+  ): Promise<boolean> {
+    const destroyed = new Set(changes.destroyed);
+    const created = new Set(
+      changes.created.filter((id) => isIndexableId(id) && !destroyed.has(id)),
+    );
+    // 만든 메일은 글째 넣으므로 바뀐 메일에서 뺀다 (한 쪽에 둘 다 오면 Email/get 에 두 번 싣지 않게)
+    const updated = [
+      ...new Set(
+        changes.updated.filter(
+          (id) => isIndexableId(id) && !destroyed.has(id) && !created.has(id),
+        ),
+      ),
+    ];
+
+    const existing = await this.repository.existingIds(user, updated);
+    // 색인에 없던 바뀐 메일 — 다 만든 직원이면 글째 넣는다 (채우는 중이면 채우기가 넣는다)
+    const unknown =
+      status === 'ready' ? updated.filter((id) => !existing.has(id)) : [];
+    const rows = await this.readRows(user, [...created, ...unknown], deadline);
+    if (rows === null) return false;
+
+    let updates: IndexMutable[] = [];
+    const known = updated.filter((id) => existing.has(id));
+    if (known.length > 0) {
+      if (!this.hasTime(deadline)) return false;
+      updates = await this.source.mutable(user, known, { deadline });
+    }
+    return this.write(user, {
+      deletes: [...destroyed],
+      upserts: rows,
+      updates,
+      state: {
+        emailState: changes.newState,
+        lastSyncedAt: new Date(this.timing.now()),
+      },
+    });
+  }
+
+  /**
+   * 메일 글을 DOCUMENT_READ_BATCH 씩 읽어 색인 줄로 (그사이 없어진 메일은 빠진다) — 다음 묶음을 시작할 시간(STEP_MIN_REMAINING_MS)이 없으면 null.
+   * 묶음 안의 엔진 읽기가 끝 시각에 걸리면 IndexDeadlineError 를 던진다
+   */
+  async readRows(
+    user: string,
+    ids: readonly string[],
+    deadline: number,
+  ): Promise<IndexRowValues[] | null> {
+    const rows: IndexRowValues[] = [];
+    for (const batch of chunks(ids, DOCUMENT_READ_BATCH)) {
+      if (!this.hasTime(deadline)) return null;
+      const documents = await this.source.documents(user, batch, { deadline });
+      for (const document of documents) {
+        if (isIndexableId(document.id)) rows.push(toIndexRow(document));
+      }
+    }
+    return rows;
+  }
+
+  private async write(
+    user: string,
+    change: Parameters<MailSearchIndexRepository['write']>[1],
+  ): Promise<boolean> {
+    const result = await this.repository.write(
+      user,
+      change,
+      new Date(this.timing.now()),
+    );
+    return result.written;
+  }
+
+  /** 다음 쪽 · 묶음을 시작할 시간이 있나 — 끝 시각까지 STEP_MIN_REMAINING_MS 이상 */
+  private hasTime(deadline: number): boolean {
+    return (
+      !this.stopping && this.timing.now() <= deadline - STEP_MIN_REMAINING_MS
+    );
+  }
+}
diff --git a/backend/src/modules/mail-search/mail-search-timing.ts b/backend/src/modules/mail-search/mail-search-timing.ts
new file mode 100644
index 0000000..42b4b24
--- /dev/null
+++ b/backend/src/modules/mail-search/mail-search-timing.ts
@@ -0,0 +1,19 @@
+/**
+ * 검색 색인의 시계 · 쉬기 (14단계) — 테스트가 바꿔 끼운다(고정 대기 없이 — testing 규칙).
+ * 앱은 Date.now · setTimeout(unref — 종료를 붙잡지 않는다)이다
+ */
+export const MAIL_SEARCH_TIMING = Symbol('MAIL_SEARCH_TIMING');
+
+export interface MailSearchTiming {
+  now(): number;
+  sleep(ms: number): Promise<void>;
+}
+
+export const SYSTEM_SEARCH_TIMING: MailSearchTiming = {
+  now: () => Date.now(),
+  sleep: (ms) =>
+    new Promise((resolve) => {
+      const timer = setTimeout(resolve, ms);
+      timer.unref();
+    }),
+};
diff --git a/backend/src/modules/mail-search/mail-search.constants.ts b/backend/src/modules/mail-search/mail-search.constants.ts
new file mode 100644
index 0000000..ef50865
--- /dev/null
+++ b/backend/src/modules/mail-search/mail-search.constants.ts
@@ -0,0 +1,178 @@
+/**
+ * 메일 검색 색인 (14단계 — 자체 검색 색인 · 대화 묶기의 바탕) 의 상수.
+ * 묶음 크기 · 시간 한도는 개발 엔진에서 잰 뒤 바꾼다 (설계 E 의 2 — 1만 통 재기). 바꿀 때는 이 파일만 고친다.
+ */
+
+/** 표의 이름 — 마이그레이션 `AddMailSearchIndex` 와 같다 */
+export const SEARCH_MESSAGES_TABLE = 'mail_search_messages';
+export const SEARCH_STATES_TABLE = 'mail_search_states';
+
+/** 메일 주소 최대 길이 (RFC 5321 경로 한도) — mail.constants 의 MAX_EMAIL_LENGTH 와 같다 */
+export const SEARCH_EMAIL_COLUMN_LENGTH = 254;
+/** 엔진 id(메일 · 대화)의 열 길이 — Stalwart 는 13자 안팎이다. 넘는 id 는 색인하지 않는다 (index-document.ts) */
+export const SEARCH_ID_COLUMN_LENGTH = 64;
+/** 짧은 낱말 열(상태 · 멈춘 까닭) */
+export const SEARCH_WORD_COLUMN_LENGTH = 32;
+
+/**
+ * 본문 글을 색인에 담는 길이 — 처음 이만큼의 코드 포인트 (설계 A1, 처음 값 20,000 — 잰 뒤 정한다).
+ * 그 뒤의 글로는 찾지 못한다 (긴 메일의 뒷부분)
+ */
+export const INDEX_BODY_MAX_CHARS = 20_000;
+/** 제목을 담는 길이 (코드 포인트) — 바깥에서 온 메일의 아주 긴 제목이 줄을 키우지 않게 */
+export const INDEX_SUBJECT_MAX_CHARS = 1_000;
+/** 보낸 사람 · 받는 사람 · 참조 한 칸에 담는 주소 수 — 받는 사람이 수천인 메일이 줄을 키우지 않게 */
+export const INDEX_ADDRESSES_MAX = 200;
+/** 주소 한 줄("이름 <주소>")의 길이 (코드 포인트) */
+export const INDEX_ADDRESS_LINE_MAX_CHARS = 400;
+/**
+ * 첫 보낸 사람의 이름을 담는 길이 (코드 포인트 — 열 `from_name` 의 varchar 길이와 같다). 묶은 목록의 참여자 이름이다 (14단계 3차 리뷰 L3).
+ * 주소(`from_email`)는 SEARCH_EMAIL_COLUMN_LENGTH 까지 — 넘으면 담지 않는다
+ */
+export const INDEX_FROM_NAME_MAX_CHARS = 100;
+/** 첨부 이름을 담는 수 · 이름 하나의 길이 (코드 포인트) */
+export const INDEX_ATTACHMENT_NAMES_MAX = 100;
+export const INDEX_ATTACHMENT_NAME_MAX_CHARS = 255;
+/** 미리 보기(엔진 preview)의 길이 (코드 포인트) — 엔진은 256자 안쪽을 준다 */
+export const INDEX_PREVIEW_MAX_CHARS = 512;
+/** 답장 관계(In-Reply-To ∪ References)를 담는 수 · Message-ID 하나의 길이 — 넘는 것은 담지 않는다 */
+export const INDEX_REFS_MAX = 50;
+export const INDEX_MESSAGE_ID_MAX_LENGTH = 255;
+
+/**
+ * 시간 끝 — 차례(맞추기 · 채우기)의 끝 시각에 닿아 멈추는 것은 실패가 아니라 "이어 하기"다 (실패 수 · 경고 · 미루기 없음).
+ * - 엔진 읽기 한 번은 남은 시간이 INDEX_CALL_MIN_MS 보다 적으면 시작하지 않고(IndexDeadlineError), 한 번에 INDEX_CALL_TIMEOUT_MS 까지만 기다린다
+ * - 맞추기 한 쪽 · 채우기 한 묶음 · 대조의 한 걸음은 남은 시간이 STEP_MIN_REMAINING_MS 보다 적으면 시작하지 않는다 — 시작한 묶음이 짧은 시간에 잘리지 않게
+ * - 채우기의 마무리(따라잡기 · 전체 대조)는 남은 시간이 FINISH_MIN_REMAINING_MS 이상일 때만(= 새 차례의 처음) 시작한다
+ */
+export const INDEX_CALL_MIN_MS = 2_000;
+export const INDEX_CALL_TIMEOUT_MS = 15_000;
+export const STEP_MIN_REMAINING_MS = 5_000;
+export const FINISH_MIN_REMAINING_MS = 30_000;
+/** 전체 대조(엔진이 변화를 셀 수 없을 때)의 시간 — 모든 메일의 메일함 · 키워드를 다시 읽는다 */
+export const RECONCILE_BUDGET_MS = 120_000;
+
+/**
+ * 본문 값을 한 번에 읽는 메일의 크기 상한 — 메일 **전체** 크기(엔진의 size)의 합. 엔진은 값을 만들며 원문을 읽으므로,
+ * 큰 첨부가 든 메일 여럿을 한 요청에 묶으면 엔진(메모리 1g)이 한꺼번에 그만큼 읽는다. 이보다 큰 메일 한 통은 혼자 읽는다.
+ * (처음 값 — 큰 첨부 메일로 잰 뒤 다시 정한다)
+ */
+export const BODY_READ_BATCH_MESSAGE_BYTES = 32 * 1024 * 1024;
+export const BODY_READ_SOLO_MESSAGE_BYTES = 16 * 1024 * 1024;
+
+/** 지난 메일 채우기의 한 묶음 — 받은 차례(최신부터)로 이만큼씩 읽어 넣는다 (설계 B3, 잰 뒤 정한다) */
+export const BUILD_BATCH_SIZE = 50;
+/** 한 묶음을 넣은 뒤 쉬는 시간 — 엔진(메모리 1g)이 다른 요청을 받을 틈 */
+export const BUILD_BATCH_PAUSE_MS = 200;
+/** 밤 채우기 한 차례(1분마다 깨어 한 사람) 의 시간 */
+export const BUILD_RUN_BUDGET_MS = 50_000;
+
+/** 맞추기(Email/changes) 한 번에 받는 변화 수 — 만든 메일의 글을 같은 차례에 읽으므로 작게 */
+export const SYNC_CHANGES_PAGE = 100;
+/** 맞추기 한 차례의 시간 — 5분마다 한 사람씩 · 실시간 소식 (설계 B2) */
+export const SYNC_BUDGET_MS = 20_000;
+/** 실시간 소식(state)을 모으는 시간 — 잇달아 온 소식을 맞추기 한 번으로 */
+export const SYNC_DEBOUNCE_MS = 300;
+/** 검색 · 대화 · 묶은 목록 바로 전의 맞추기를 기다리는 시간 — 넘으면 지금 색인으로 답하고 맞추기는 뒤에서 이어 한다 */
+export const PRE_READ_SYNC_WAIT_MS = 1_500;
+/**
+ * 서버 전체에서 함께 도는 맞추기 수 — 전 직원에게 메일 한 통이 오면 실시간 소식이 직원 수만큼 한꺼번에 온다.
+ * 넘는 맞추기는 차례를 기다린다(그동안 같은 직원의 새 소식은 기다리는 맞추기에 합친다)
+ */
+export const SYNC_CONCURRENCY = 4;
+
+/** 메일 글을 한 번에 읽는 수 (Email/get — 엔진의 maxObjectsInGet 500 이하, 본문은 따로 나눠 읽는다) */
+export const DOCUMENT_READ_BATCH = 50;
+/** 표시 · 메일함만 한 번에 읽는 수 (바뀐 메일 — maxObjectsInGet 500) */
+export const MUTABLE_READ_BATCH = 500;
+/** 전체 대조에서 엔진의 메일 id 를 한 번에 묻는 수 — 엔진이 줄이면 받은 만큼 이어 묻는다 */
+export const ALL_IDS_PAGE = 5_000;
+/** 전체 대조에서 우리 표에 한 번에 넣고 지우는 수 */
+export const RECONCILE_WRITE_BATCH = 500;
+
+/** 실패가 이만큼 이어지면 5분 맞추기 · 밤 채우기의 차례에서 뒤로 미룬다 (failure_count — 성공하면 0) */
+export const FAILURE_BACKOFF_STEPS_MAX = 6;
+/** 실패한 직원을 다시 해 보기까지 — 실패 수마다 두 배(5분 · 10분 · … 상한 FAILURE_BACKOFF_STEPS_MAX 단계) */
+export const FAILURE_BACKOFF_BASE_MS = 5 * 60_000;
+
+/**
+ * 밤 채우기의 창 (한국 시간, 하루의 분) — 22:00 ~ 02:45 · 05:00 ~ 07:30.
+ * 03:00 · 04:00 · 04:30 엔진 정리(휴지통 · 스팸메일함 비우기)와 03:30 백업(엔진을 잠깐 멈춘다)을 피한다 (설계 B3)
+ */
+export const BUILD_WINDOWS_KST: readonly (readonly [
+  startMinute: number,
+  endMinute: number,
+])[] = [
+  [22 * 60, 24 * 60],
+  [0, 2 * 60 + 45],
+  [5 * 60, 7 * 60 + 30],
+];
+
+/** 실행 시각 표의 시간대 — 컨테이너는 UTC 로 돈다 */
+export const SEARCH_CRON_TIME_ZONE = 'Asia/Seoul';
+
+/**
+ * 색인 판 — 접기(foldText) · 글자 두 개 묶음(gramsOf) · 색인 줄의 모양을 바꾸면 올린다 (상태 줄의 index_format).
+ * 판이 다른 직원은 building 으로 돌아가 밤에 다시 채운다(옛 줄은 다시 채우며 덮고, 마지막 대조가 남은 것을 지운다) — 그동안 검색은 엔진 방식이다.
+ * 1: 14단계 1차 · 2: 공백류를 띄어쓰기로 접는다(14단계 2차 — 구절이 줄바꿈으로 갈린 글에도 맞게)
+ * · 3: 대화 키를 잇는다(14단계 3차 — 답장 관계 + 말머리를 뗀 제목. 판 2 까지의 줄은 키가 메일마다 따로다)
+ * · 4: 첫 보낸 사람의 주소 · 이름 칸(from_email · from_name — 3차 리뷰 L3, 마이그레이션 AddMailSearchSender. 판 3 까지의 줄은 칸이 비었다)
+ */
+export const INDEX_FORMAT = 4;
+
+/**
+ * 찾기 (14단계 2차 — 설계 G · 2026-11-05 다시 잼 · 2026-11-06 메일함 범위 다시 잼). 줄의 글을 푸는 일(TOAST — 묶음 배열 0.1ms · 접은 본문 확인 0.15~0.3ms)이
+ * 비싸 그 수를 묶는다:
+ * - 후보: 주소 + 묶음 + 메일함(GIN 하나 — 마이그레이션 SearchIndexUserGramsMailboxes 의 lower 식)만으로 받은 시각 최신부터 SEARCH_CHECK_ROWS_LIMIT + 1 줄까지
+ *   읽는다(줄의 글을 풀지 않는다 — 1만 통 직원의 흔한 낱말이 전체 · 큰 메일함 10~30ms, 작은 메일함 1~7ms. 맞은 줄이 표에 흩어져 있으면 그 줄 수만큼 더 든다)
+ * - 두 글자 낱말뿐(검색어 — 다섯 칸)이면 묶음 하나가 곧 그 낱말이라 후보가 곧 결과다 — 확인하지 않는다
+ * - 후보가 SEARCH_CANDIDATE_COUNT_LIMIT 이하면 모두 확인한다(첫 쪽의 total 을 안다), 넘으면 받은 차례로 SEARCH_FIRST_CHECK_ROWS 줄부터
+ *   SEARCH_CHECK_ROWS_GROWTH 배씩 확인하다 쪽이 차면 멈춘다 — 한 요청이 확인하는 줄은 SEARCH_CHECK_ROWS_LIMIT 까지(≈ 0.5~0.8초 — 캐시가 찬 때.
+ *   2026-11-06 1만 통 직원의 드문 구절로 3,000줄 0.51~0.58초).
+ *   넘으면 찾은 것까지와 이어 찾기 커서를 준다(쪽이 limit 보다 적어도 hasNext)
+ * - total 은 첫 쪽에서 SEARCH_TOTAL_LIMIT 까지만 센다 — 넘거나 이 요청 안에서 다 세지 못하면 null
+ */
+export const SEARCH_CANDIDATE_COUNT_LIMIT = 2_000;
+export const SEARCH_CHECK_ROWS_LIMIT = 3_000;
+export const SEARCH_FIRST_CHECK_ROWS = 100;
+export const SEARCH_CHECK_ROWS_GROWTH = 4;
+export const SEARCH_TOTAL_LIMIT = 1_000;
+
+/**
+ * 한 글자 낱말(글자 두 개 묶음이 없는 낱말)만으로 찾을 때 본문은 훑지 않는다 — 제목 · 사람(보낸 사람 · 받는 사람 · 참조) · 첨부 이름에서만 찾는다.
+ * 두 글자 넘는 낱말과 함께면 한 글자 낱말은 확인에만 쓴다(본문 포함). false 로 두면 한 글자 낱말만이어도 본문까지 훑는다(확인 상한 안에서)
+ */
+export const SINGLE_CHAR_TERMS_SKIP_BODY = true;
+
+/** 목록의 미리 보기 둘레 — 맞은 말 앞 글자 수 · 모두 글자 수(남짓 — 말 경계에서 자른다) · 말 경계를 찾는 여유 (UTF-16 — 서로게이트 쌍은 가르지 않는다) */
+export const SNIPPET_LEAD_CHARS = 20;
+export const SNIPPET_TOTAL_CHARS = 80;
+export const SNIPPET_BOUNDARY_SLACK = 10;
+
+/**
+ * 대화 (14단계 3차 — 설계 C3 · C4). 같은 대화 칸의 한 쪽(기본이자 최대 — 화면이 한 번에 보인다) · 묶은 목록 줄의 참여자 수 상한(보낸 사람 — 받은 차례로 앞에서부터)
+ * · 묶은 목록 줄의 messageIds 상한(그 메일함 안 — 최신부터, 3차 리뷰 L4. 넘는 오래된 메일은 줄의 여러 통 처리에 들지 않는다)
+ */
+export const CONVERSATION_PAGE_LIMIT = 100;
+export const CONVERSATION_PARTICIPANTS_MAX = 10;
+export const CONVERSATION_MESSAGE_IDS_MAX = 500;
+
+/**
+ * 엔진 방식 대화(색인 전 · 첫 쪽 DB 장애의 대신 — modules/mail/jmap/jmap-conversations.ts)의 상한 (3차 리뷰 H1) — GitHub · Jira 알림처럼
+ * 수천 통인 스레드에서도 한 요청이 엔진을 크게 쓰지 않게.
+ * - 거르기(휴지통 · 스팸메일함에만 든 메일 · 내부 초안)는 값싼 속성만 읽고, 요약 속성은 내보낼 메일(같은 대화 — 한 쪽 · 묶은 목록 — 줄마다 마지막 메일)만 읽는다
+ * - 같은 대화: 한 요청이 훑는 메일 CONVERSATION_ENGINE_SCAN_MAX 통까지 — 스레드가 그 이하면 모두 읽어 total 을 세고, 넘으면 커서 자리부터 필요한 만큼만(total null)
+ * - 묶은 목록: 스레드마다 최신 CONVERSATION_ENGINE_THREAD_SCAN_MAX 통 · 한 요청 모두 CONVERSATION_ENGINE_LIST_SCAN_MAX 통까지(작은 스레드부터 다 주고 남는 몫을 나눈다)
+ * - 한 요청의 시간 CONVERSATION_ENGINE_BUDGET_MS (메일함 처리의 BulkRun 과 같은 결) — 훑는 호출은 기본 제한 시간과 "남은 시간 − CONVERSATION_ENGINE_RESERVE_MS"
+ *   중 짧은 쪽(마지막 요약 읽기 몫을 늘 남긴다 — 3차 재확인 N1), 마지막 읽기만 남은 시간을 다 쓴다. 남은 시간이 그 몫보다 적으면 더 훑지 않고,
+ *   훑던 호출이 시간 때문에 끊기면 읽은 데까지로 답한다(같은 대화: 다 세야 하는 작은 스레드 · 아무것도 못 읽음은 503 MAIL_001 / 묶은 목록: 어림 줄)
+ */
+export const CONVERSATION_ENGINE_SCAN_MAX = 1_000;
+export const CONVERSATION_ENGINE_THREAD_SCAN_MAX = 500;
+export const CONVERSATION_ENGINE_LIST_SCAN_MAX = 2_000;
+export const CONVERSATION_ENGINE_BUDGET_MS = 15_000;
+export const CONVERSATION_ENGINE_RESERVE_MS = 3_000;
+
+/** 색인의 키워드(엔진이 준 그대로 — JMAP 표준) 가운데 묶은 목록이 보는 것 — 읽음 · 중요 표시 */
+export const SEEN_KEYWORD = '$seen';
+export const FLAGGED_KEYWORD = '$flagged';
diff --git a/backend/src/modules/mail-search/mail-search.module.ts b/backend/src/modules/mail-search/mail-search.module.ts
new file mode 100644
index 0000000..259d1df
--- /dev/null
+++ b/backend/src/modules/mail-search/mail-search.module.ts
@@ -0,0 +1,49 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { JmapIndexSource } from '@/modules/mail/jmap/jmap-index-source';
+import { MailEngineModule } from '@/modules/mail/mail-engine.module';
+import { MailConversationQueryService } from './mail-conversation-query.service';
+import { MAIL_INDEX_SOURCE } from './mail-index-source';
+import { MailSearchBuildService } from './mail-search-build.service';
+import { MailSearchIndexRepository } from './mail-search-index.repository';
+import { MailSearchIndexService } from './mail-search-index.service';
+import { MailSearchQueryService } from './mail-search-query.service';
+import { MailSearchMessageEntity } from './mail-search-message.entity';
+import { MailSearchRuns } from './mail-search-runs';
+import { MailSearchStateEntity } from './mail-search-state.entity';
+import { MailSearchSyncService } from './mail-search-sync.service';
+import { SearchIndexController } from './search-index.controller';
+
+/**
+ * 메일 검색 색인 모듈 (14단계 — 자체 검색 색인 · 대화 묶기의 바탕).
+ * 엔진을 바꿀 때는 `MAIL_INDEX_SOURCE` 의 구현(useClass)만 바꾼다 — 맞추기 · 채우기는 포트만 안다.
+ * 지금 구현은 Stalwart(JMAP) — 메일과 같은 엔진 연결(MailEngineModule)을 쓰고, 어댑터는 `modules/mail/jmap/jmap-index-source.ts` 에 있다.
+ *
+ * 메일 모듈(실시간 소식 → 맞추기)과 인증 모듈(로그인 → 상태 줄)이 가져다 쓴다 — 이 모듈은 둘을 가져오지 않는다 (순환 없음).
+ * 운영 도구(서버와 다른 프로세스)는 이 모듈을 가져오지 않는다 — 퇴사 마무리는 표만 지운다 (ops-data.service.ts)
+ */
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([MailSearchMessageEntity, MailSearchStateEntity]),
+    MailEngineModule,
+  ],
+  controllers: [SearchIndexController],
+  providers: [
+    { provide: MAIL_INDEX_SOURCE, useClass: JmapIndexSource },
+    MailSearchIndexRepository,
+    MailSearchRuns,
+    MailSearchSyncService,
+    MailSearchBuildService,
+    MailSearchIndexService,
+    MailSearchQueryService,
+    MailConversationQueryService,
+  ],
+  exports: [
+    MailSearchIndexService,
+    MailSearchSyncService,
+    MailSearchQueryService,
+    MailConversationQueryService,
+  ],
+})
+export class MailSearchModule {}
diff --git a/backend/src/modules/mail-search/mail-search.types.ts b/backend/src/modules/mail-search/mail-search.types.ts
new file mode 100644
index 0000000..f5f52ea
--- /dev/null
+++ b/backend/src/modules/mail-search/mail-search.types.ts
@@ -0,0 +1,79 @@
+/**
+ * 메일 검색 색인의 도메인 타입 (14단계) — 엔진을 모른다.
+ */
+
+/** 색인 상태 — 지난 메일을 채우는 중 · 다 만들었음 (설계 A2) */
+export type SearchIndexStatus = 'building' | 'ready';
+
+/**
+ * 맞추기를 멈춘 까닭 — 대리 접근이 막혔다 (설계 B2). 다음 로그인(또는 검색 준비 상태를 물을 때) 푼다.
+ * - password-expired: 비밀번호가 만료됐다 (엔진이 메일 기능을 막는다 — 13단계)
+ * - locked: 로그인할 수 없는 계정 — 잠김(로그인 권한 없음) · 엔진에 없음
+ */
+export type SearchPausedReason = 'password-expired' | 'locked';
+
+/** GET /api/search-index 의 응답 (설계 C1) — 화면의 "검색 준비 중" 줄 */
+export interface SearchIndexStatusView {
+  readonly status: SearchIndexStatus;
+  /** 채운 메일 수 — 다 만들었으면 그때 색인에 든 수 */
+  readonly done: number;
+  /** 채울 메일 수(채우기를 시작할 때의 엔진 메일 수) — 아직 시작하지 않았으면 null */
+  readonly total: number | null;
+}
+
+/**
+ * 검색 조건 (GET /api/messages — 14단계 설계 C1) — DTO 가 검사한 값. 글 칸은 앞뒤 공백을 뺀 값이고 빈 글은 없는 것이다.
+ * after · before 는 ISO 8601 시각 — 받은 시각이 after 이상 · before 미만
+ */
+export interface SearchCriteria {
+  /** 검색어(q) — 보낸 사람 · 받는 사람 · 참조 · 제목 · 첨부 이름 · 본문 */
+  readonly text?: string;
+  readonly from?: string;
+  /** 받는 사람 — 참조도 */
+  readonly to?: string;
+  readonly subject?: string;
+  readonly body?: string;
+  readonly after?: string;
+  readonly before?: string;
+  /** true 면 첨부 파일이 있는 메일만 (목록의 첨부 표시와 같은 판정) */
+  readonly hasAttachment?: boolean;
+}
+
+/** 검색어 밖의 조건 — 엔진 방식 검색이 JMAP 필터로 쓴다 */
+export type SearchConditions = Omit<SearchCriteria, 'text'>;
+
+/**
+ * 찾는 범위 (엔진이 알려 준다 — 메일 포트의 searchScope): 메일함 하나, 또는 빼는 메일함(휴지통 · 스팸메일함)에만 있지 않은 메일.
+ * 목록에서 빼는 키워드(발송 중인 내부 초안)가 있는 메일은 찾지 않는다
+ */
+export interface SearchScope {
+  readonly mailboxId: string | null;
+  readonly excludedMailboxIds: readonly string[];
+  readonly excludedKeywords: readonly string[];
+}
+
+/** 맞은 곳 — [시작, 끝) UTF-16 */
+export type SearchRange = readonly [start: number, end: number];
+
+/** 목록 항목의 강조 (색인으로 찾았을 때만 — 엔진 방식이면 null) */
+export interface MessageListHighlight {
+  readonly subject: SearchRange[];
+  /** 본문에서 맞았으면 맞은 말 둘레, 아니면 엔진의 미리 보기 */
+  readonly preview: { readonly text: string; readonly ranges: SearchRange[] };
+}
+
+/** 읽기 화면의 강조 — 첨부는 맞은 것만(첨부 id → 맞은 곳) */
+export interface MessageDetailHighlight {
+  readonly subject: SearchRange[];
+  readonly attachments: Record<string, SearchRange[]>;
+  readonly textBody: SearchRange[];
+}
+
+/** 대화의 참여자 — 보낸 사람 (메일 모듈의 MailAddress 와 같은 모양) */
+export interface ConversationParticipant {
+  readonly name: string | null;
+  readonly email: string;
+}
+
+/** 대화의 기준 — 우리 색인(답장 관계 + 말머리를 뗀 제목 — 14단계 B4) · 엔진의 스레드(색인을 다 만들기 전) */
+export type ConversationBasis = 'index' | 'engine';
diff --git a/backend/src/modules/mail-search/search-cursor.spec.ts b/backend/src/modules/mail-search/search-cursor.spec.ts
new file mode 100644
index 0000000..ab9f27b
--- /dev/null
+++ b/backend/src/modules/mail-search/search-cursor.spec.ts
@@ -0,0 +1,137 @@
+import { BusinessException } from '@/common/errors/business.exception';
+import { encodeCursor } from '@/modules/mail/jmap/jmap-cursor';
+import type { SearchCriteria } from './mail-search.types';
+import {
+  cursorMethod,
+  decodeIndexCursor,
+  encodeIndexCursor,
+  searchScopeKey,
+} from './search-cursor';
+
+const criteria = (overrides: Partial<SearchCriteria>): SearchCriteria => ({
+  hasAttachment: false,
+  ...overrides,
+});
+
+function codeOf(run: () => unknown): string | null {
+  try {
+    run();
+    return null;
+  } catch (error) {
+    return error instanceof BusinessException ? error.code : 'NOT_BUSINESS';
+  }
+}
+
+describe('색인 검색의 커서 (search-cursor — 14단계 설계 C1)', () => {
+  const position = {
+    receivedAt: new Date('2026-11-02T01:23:45.678Z'),
+    emailId: 'm9x',
+  };
+  const key = searchScopeKey(undefined, criteria({ text: '계약' }));
+
+  it('자리(받은 시각 ms · id)를 그대로 되돌린다 — URL 에 그대로 넣을 수 있는 글자만', () => {
+    const cursor = encodeIndexCursor(position, key);
+    expect(cursor).toMatch(/^[A-Za-z0-9_-]+$/);
+    expect(decodeIndexCursor(cursor, key)).toEqual(position);
+  });
+
+  it('방식을 커서로 안다 — 색인 커서는 index, 엔진 커서(1판) · 알 수 없는 값은 engine(엔진 쪽이 검사한다)', () => {
+    expect(cursorMethod(encodeIndexCursor(position, key))).toBe('index');
+    expect(
+      cursorMethod(
+        encodeCursor({ anchor: 'm9x', position: 20 }, { text: '계약' }),
+      ),
+    ).toBe('engine');
+    for (const cursor of ['', 'not-a-cursor', 'a'.repeat(600), 'bnVsbA']) {
+      expect(cursorMethod(cursor)).toBe('engine');
+    }
+  });
+
+  it('범위 지문에는 메일함 · 검색어 · 모든 조건이 든다 — 하나라도 다르면 다른 검색의 커서라 VAL_001', () => {
+    const base = criteria({
+      text: '계약',
+      from: '이도윤',
+      after: '2026-10-31T15:00:00.000Z',
+    });
+    const cursor = encodeIndexCursor(position, searchScopeKey('a', base));
+
+    expect(decodeIndexCursor(cursor, searchScopeKey('a', base))).toEqual(
+      position,
+    );
+    for (const [mailboxId, other] of [
+      [undefined, base],
+      ['b', base],
+      ['a', { ...base, text: '견적' }],
+      ['a', { ...base, from: undefined }],
+      ['a', { ...base, to: '이도윤' }],
+      ['a', { ...base, subject: '계약' }],
+      ['a', { ...base, body: '계약' }],
+      ['a', { ...base, after: '2026-10-30T15:00:00.000Z' }],
+      ['a', { ...base, before: '2026-11-30T15:00:00.000Z' }],
+      ['a', { ...base, hasAttachment: true }],
+    ] as const) {
+      expect(
+        codeOf(() =>
+          decodeIndexCursor(cursor, searchScopeKey(mailboxId, other)),
+        ),
+      ).toBe('VAL_001');
+    }
+  });
+
+  it('칸이 달라도 이은 글이 같아지지 않는다 — 같은 글을 다른 칸에 둔 검색은 다른 범위', () => {
+    expect(searchScopeKey(undefined, criteria({ from: '계약' }))).not.toBe(
+      searchScopeKey(undefined, criteria({ to: '계약' })),
+    );
+    expect(searchScopeKey('a', criteria({}))).not.toBe(
+      searchScopeKey(undefined, criteria({})),
+    );
+  });
+
+  it('모양이 틀린 커서는 VAL_001 — 엔진 커서 · 틀린 판 · 이상한 id · 음수 시각 · 너무 긴 값', () => {
+    const forge = (payload: object) =>
+      Buffer.from(JSON.stringify(payload)).toString('base64url');
+    for (const cursor of [
+      encodeCursor({ anchor: 'm9x', position: 20 }, { text: '계약' }),
+      forge({ v: 3, m: 'i', t: 1, id: 'm1', s: 'x' }),
+      forge({ v: 2, m: 'e', t: 1, id: 'm1', s: 'x' }),
+      forge({ v: 2, m: 'i', t: -1, id: 'm1', s: 'x' }),
+      forge({ v: 2, m: 'i', t: 1.5, id: 'm1', s: 'x' }),
+      forge({ v: 2, m: 'i', t: 1, id: '../x', s: 'x' }),
+      forge({ v: 2, m: 'i', t: 1, id: 'm1' }),
+      'not-json',
+      'a'.repeat(600),
+    ]) {
+      expect(codeOf(() => decodeIndexCursor(cursor, key))).toBe('VAL_001');
+    }
+  });
+
+  it('Date 로 읽을 수 없는 시각(안전한 정수지만 ±8.64e15 ms 밖)의 커서는 VAL_001 — 범위 지문이 맞아도 500 이 아니다 (리뷰 L1)', () => {
+    // 이 검색의 진짜 커서에서 시각만 바꾼다 — 범위 지문(s)은 맞는다
+    const real = JSON.parse(
+      Buffer.from(encodeIndexCursor(position, key), 'base64url').toString(
+        'utf8',
+      ),
+    ) as Record<string, unknown>;
+    const withTime = (t: number) =>
+      Buffer.from(JSON.stringify({ ...real, t })).toString('base64url');
+    expect(Number.isSafeInteger(9e15)).toBe(true);
+    expect(codeOf(() => decodeIndexCursor(withTime(9e15), key))).toBe(
+      'VAL_001',
+    );
+    // 한도 끝(8.64e15)까지는 날짜다 — 그대로 읽는다
+    expect(decodeIndexCursor(withTime(8.64e15), key)).toEqual({
+      receivedAt: new Date(8.64e15),
+      emailId: position.emailId,
+    });
+  });
+
+  it('범위 지문은 JSON 으로 잇는다 — 글 칸에 줄바꿈을 넣어 다른 칸을 흉내 내도 다른 범위 (리뷰 L7)', () => {
+    const NL = String.fromCharCode(10);
+    expect(searchScopeKey(undefined, criteria({ from: `a${NL}b` }))).not.toBe(
+      searchScopeKey(undefined, criteria({ from: 'a', to: 'b' })),
+    );
+    expect(searchScopeKey(undefined, criteria({ text: `계약${NL}` }))).not.toBe(
+      searchScopeKey(undefined, criteria({ text: '계약', from: '' })),
+    );
+  });
+});
diff --git a/backend/src/modules/mail-search/search-cursor.ts b/backend/src/modules/mail-search/search-cursor.ts
new file mode 100644
index 0000000..6d796b7
--- /dev/null
+++ b/backend/src/modules/mail-search/search-cursor.ts
@@ -0,0 +1,122 @@
+import { createHash } from 'crypto';
+
+import { BusinessException } from '@/common/errors/business.exception';
+import { MAIL_ID_PATTERN } from '@/modules/mail/mail.constants';
+import type { SearchCriteria } from './mail-search.types';
+import type { SearchPosition } from './search-sql';
+
+/**
+ * 색인으로 찾은 검색의 커서 (14단계 설계 C1 — 클라이언트에게는 불투명 문자열).
+ * `{ v: 2, m: 'i', t: 받은 시각(ms), id, s: 범위 지문 }` — 그 줄 다음(받은 시각 · id 가 더 작은 쪽)부터 이어 찾는다.
+ * 다 찾지 못하고 확인 상한에 닿은 쪽(이어 찾기)도 같은 꼴이다 — 마지막으로 **훑은** 줄이 자리다.
+ *
+ * 방식(m)이 커서에 실려, 쪽을 넘기는 중에 색인이 준비되거나 다시 채우기에 들어가도 그 검색은 처음 방식대로 이어 간다 —
+ * 엔진 방식의 커서(jmap-cursor.ts — `m` 이 없다)는 엔진으로, 이 커서는 색인으로.
+ * 범위 지문에는 메일함 · 검색어 · 모든 조건이 든다 — 다른 검색의 커서를 섞어 쓰면 VAL_001. 지문은 짧은 해시라 글을 담지 않는다
+ */
+const CURSOR_VERSION = 2;
+const INDEX_METHOD = 'i';
+const MAX_CURSOR_LENGTH = 512;
+const SCOPE_HASH_LENGTH = 16;
+/** "모든 메일함"(휴지통 · 스팸메일함 제외) 범위 — 메일함 id 형식에 없는 글자 */
+const ALL_MAILBOXES_SCOPE = '*';
+
+interface EncodedIndexCursor {
+  v: number;
+  m: string;
+  t: number;
+  id: string;
+  s: string;
+}
+
+/** 검색 방식 — 커서를 읽어 본다. 색인 커서가 아니면(엔진 방식 · 모양이 틀림) 'engine' — 엔진 쪽이 검사한다 */
+export function cursorMethod(cursor: string): 'index' | 'engine' {
+  if (cursor.length > MAX_CURSOR_LENGTH) return 'engine';
+  try {
+    const parsed = JSON.parse(
+      Buffer.from(cursor, 'base64url').toString('utf8'),
+    ) as Partial<EncodedIndexCursor> | null;
+    return parsed?.v === CURSOR_VERSION && parsed.m === INDEX_METHOD
+      ? 'index'
+      : 'engine';
+  } catch {
+    return 'engine';
+  }
+}
+
+/**
+ * 범위 지문의 글 — 메일함 · 검색어 · 조건을 정해진 차례로 (빈 칸은 빈 글).
+ * 배열을 JSON 으로 잇는다 — 글 칸에 줄바꿈이 들어도 칸의 경계가 섞이지 않게 (from 에 줄바꿈을 넣어 to 칸을 흉내 낼 수 없다)
+ */
+export function searchScopeKey(
+  mailboxId: string | undefined,
+  criteria: SearchCriteria,
+): string {
+  return JSON.stringify([
+    mailboxId ?? ALL_MAILBOXES_SCOPE,
+    criteria.text ?? '',
+    criteria.from ?? '',
+    criteria.to ?? '',
+    criteria.subject ?? '',
+    criteria.body ?? '',
+    criteria.after ?? '',
+    criteria.before ?? '',
+    criteria.hasAttachment === true,
+  ]);
+}
+
+function scopeHash(scopeKey: string): string {
+  return createHash('sha256')
+    .update(scopeKey)
+    .digest('base64url')
+    .slice(0, SCOPE_HASH_LENGTH);
+}
+
+function invalidCursor(reason: string): BusinessException {
+  return new BusinessException('VAL_001', {
+    context: { reason: `invalid-cursor:${reason}` },
+  });
+}
+
+export function encodeIndexCursor(
+  position: SearchPosition,
+  scopeKey: string,
+): string {
+  const payload: EncodedIndexCursor = {
+    v: CURSOR_VERSION,
+    m: INDEX_METHOD,
+    t: position.receivedAt.getTime(),
+    id: position.emailId,
+    s: scopeHash(scopeKey),
+  };
+  return Buffer.from(JSON.stringify(payload)).toString('base64url');
+}
+
+/** 커서를 읽는다 — 모양이 틀리거나 다른 검색의 커서면 VAL_001 */
+export function decodeIndexCursor(
+  cursor: string,
+  scopeKey: string,
+): SearchPosition {
+  if (cursor.length > MAX_CURSOR_LENGTH) throw invalidCursor('too-long');
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'));
+  } catch {
+    throw invalidCursor('not-json');
+  }
+  const { v, m, t, id, s } = (parsed ?? {}) as Partial<EncodedIndexCursor>;
+  const valid =
+    v === CURSOR_VERSION &&
+    m === INDEX_METHOD &&
+    typeof t === 'number' &&
+    Number.isSafeInteger(t) &&
+    t >= 0 &&
+    // 날짜로 읽을 수 있는 시각만 — Date 의 한도(±8.64e15 ms) 밖이면 Invalid Date 라 쿼리 값으로 쓰면 500 이었다
+    Number.isFinite(new Date(t).getTime()) &&
+    typeof id === 'string' &&
+    MAIL_ID_PATTERN.test(id) &&
+    typeof s === 'string';
+  if (!valid) throw invalidCursor('shape');
+  if (s !== scopeHash(scopeKey)) throw invalidCursor('other-list');
+  return { receivedAt: new Date(t), emailId: id };
+}
diff --git a/backend/src/modules/mail-search/search-highlight.spec.ts b/backend/src/modules/mail-search/search-highlight.spec.ts
new file mode 100644
index 0000000..e8bdc1e
--- /dev/null
+++ b/backend/src/modules/mail-search/search-highlight.spec.ts
@@ -0,0 +1,382 @@
+import { startCpuTimer } from '@/../test/cpu-time';
+import { foldText, matchRanges } from '@/shared/utils/search-text';
+import {
+  SNIPPET_BOUNDARY_SLACK,
+  SNIPPET_LEAD_CHARS,
+  SNIPPET_TOTAL_CHARS,
+} from './mail-search.constants';
+import {
+  highlightedSubject,
+  listHighlight,
+  snippetAround,
+} from './search-highlight';
+import type { HighlightTerms } from './search-plan';
+
+const terms = (...words: string[]): HighlightTerms => ({
+  subject: words,
+  body: words,
+  attachment: words,
+  query: words,
+});
+
+/** 색인의 접은 칸 — 보낸 사람 · 받는 사람과 참조 · 제목 · 첨부 이름 (listHighlight 의 otherFields) */
+const otherFields = (fields: {
+  from?: string;
+  to?: string;
+  subject?: string;
+  attachment?: string;
+}): string[] =>
+  [fields.from, fields.to, fields.subject, fields.attachment].map((field) =>
+    foldText(field ?? ''),
+  );
+
+/** 글에서 낱말이 처음 맞은 곳 */
+const firstMatch = (body: string, word: string) =>
+  matchRanges(body, [word], 1)[0];
+
+/** 범위가 가리키는 글 */
+const slices = (text: string, ranges: readonly (readonly [number, number])[]) =>
+  ranges.map(([start, end]) => text.slice(start, end));
+
+describe('목록의 검색 강조 (search-highlight — 14단계 설계 C1)', () => {
+  describe('맞은 말 둘레 (snippetAround)', () => {
+    it('짧은 본문은 그대로 — 잘라 낸 글이 없으면 "…" 도 없다', () => {
+      const body = '이번 달 계약 갱신 일정입니다.';
+      expect(snippetAround(body, firstMatch(body, '계약'))).toBe(body);
+    });
+
+    it(`맞은 곳 앞 ${SNIPPET_LEAD_CHARS}자 남짓부터 모두 ${SNIPPET_TOTAL_CHARS}자 남짓 — 낱말 경계(공백)에서 자르고 앞뒤에 "…"`, () => {
+      const before = Array.from({ length: 30 }, (_, i) => `앞말${i}`).join(' ');
+      const after = Array.from({ length: 30 }, (_, i) => `뒷말${i}`).join(' ');
+      const body = `${before} 계약서를 보내 드립니다 ${after}`;
+
+      const snippet = snippetAround(body, firstMatch(body, '계약'));
+
+      expect(snippet.startsWith('…')).toBe(true);
+      expect(snippet.endsWith('…')).toBe(true);
+      const inner = snippet.slice(1, -1);
+      expect(inner).toContain('계약서를');
+      // 낱말 가운데를 자르지 않았다 — 앞 · 뒤 조각이 본문의 낱말 그대로
+      const words = inner.split(' ');
+      for (const word of [words[0], words[words.length - 1]]) {
+        expect(body.split(' ')).toContain(word);
+      }
+      // 맞은 곳 앞은 SNIPPET_LEAD_CHARS + 여유 안, 모두 SNIPPET_TOTAL_CHARS + 여유 안
+      expect(inner.indexOf('계약')).toBeLessThanOrEqual(
+        SNIPPET_LEAD_CHARS + SNIPPET_BOUNDARY_SLACK,
+      );
+      expect(inner.length).toBeLessThanOrEqual(
+        SNIPPET_TOTAL_CHARS + SNIPPET_BOUNDARY_SLACK * 2,
+      );
+    });
+
+    it('공백이 없는 긴 글은 그 자리에서 자르고 "…" — 맞은 곳은 늘 담는다', () => {
+      const body = `${'가'.repeat(100)}계약${'나'.repeat(200)}`;
+      const snippet = snippetAround(body, firstMatch(body, '계약'));
+
+      expect(snippet).toBe(
+        `…${'가'.repeat(SNIPPET_LEAD_CHARS)}계약${'나'.repeat(SNIPPET_TOTAL_CHARS - SNIPPET_LEAD_CHARS - 2)}…`,
+      );
+    });
+
+    it('맞은 말이 쪽보다 길어도 다 담는다', () => {
+      const long = '계'.repeat(150);
+      const body = `안내 ${long} 끝`;
+      const snippet = snippetAround(body, [3, 3 + long.length]);
+      expect(snippet).toContain(long);
+    });
+
+    it('줄바꿈 · 탭 · 여러 칸 공백은 띄어쓰기 하나로 — 잘라 낸 쪽이 공백뿐이면 "…" 를 붙이지 않는다', () => {
+      const body = `${' '.repeat(30)}계약\n\n\t갱신   일정${'\n'.repeat(5)}`;
+      expect(snippetAround(body, firstMatch(body, '계약'))).toBe(
+        '계약 갱신 일정',
+      );
+    });
+
+    it('서로게이트 쌍(이모지) 가운데를 가르지 않는다', () => {
+      const body = `${'😀'.repeat(40)}계약${'😀'.repeat(60)}`;
+      const snippet = snippetAround(body, firstMatch(body, '계약'));
+      // 짝이 없는 서로게이트가 없다
+      expect(snippet).toBe(snippet.normalize());
+      expect(() => encodeURIComponent(snippet)).not.toThrow();
+      expect(snippet).toContain('계약');
+    });
+  });
+
+  describe('항목 하나의 강조 (listHighlight)', () => {
+    it('제목의 맞은 곳(합친 범위) · 본문에서 처음 맞은 곳 둘레의 미리 보기와 그 안의 맞은 곳', () => {
+      const highlight = listHighlight(
+        {
+          subject: '[공지] 계약 갱신 · 계약서',
+          preview: '엔진의 미리 보기',
+          bodyText:
+            '안녕하세요. 계약 갱신 건으로 연락드립니다. 갱신 계약서는 첨부를 보세요.',
+          otherFields: null,
+        },
+        terms('계약', '갱신'),
+      );
+
+      expect(slices('[공지] 계약 갱신 · 계약서', highlight.subject)).toEqual([
+        '계약',
+        '갱신',
+        '계약',
+      ]);
+      expect(highlight.preview.text).toBe(
+        '안녕하세요. 계약 갱신 건으로 연락드립니다. 갱신 계약서는 첨부를 보세요.',
+      );
+      expect(slices(highlight.preview.text, highlight.preview.ranges)).toEqual([
+        '계약',
+        '갱신',
+        '갱신',
+        '계약',
+      ]);
+    });
+
+    it('본문에 맞은 곳이 없으면(제목에서만 맞음) 엔진의 미리 보기 — 한 줄로, 맞은 곳이 있으면 그 자리', () => {
+      const highlight = listHighlight(
+        {
+          subject: '계약 안내',
+          preview: '첨부한  계약서를\n확인해 주세요',
+          bodyText: null,
+          otherFields: null,
+        },
+        terms('계약'),
+      );
+      expect(highlight.preview).toEqual({
+        text: '첨부한 계약서를 확인해 주세요',
+        ranges: [[4, 6]],
+      });
+
+      const notInBody = listHighlight(
+        {
+          subject: '계약 안내',
+          preview: '첨부 확인',
+          bodyText: '첨부 확인',
+          otherFields: otherFields({ subject: '계약 안내' }),
+        },
+        terms('계약'),
+      );
+      expect(notInBody.preview).toEqual({ text: '첨부 확인', ranges: [] });
+      expect(notInBody.subject).toEqual([[0, 2]]);
+    });
+
+    it('본문에 강조할 말이 없으면(제목 조건만) 미리 보기는 맞은 곳 없이 엔진의 것', () => {
+      const highlight = listHighlight(
+        {
+          subject: '견적 요청',
+          preview: '견적 부탁드립니다',
+          bodyText: '견적 부탁드립니다',
+          otherFields: null,
+        },
+        { subject: ['견적'], body: [], attachment: [], query: [] },
+      );
+      expect(highlight).toEqual({
+        subject: [[0, 2]],
+        preview: { text: '견적 부탁드립니다', ranges: [] },
+      });
+    });
+
+    it('접어서 맞춘다 — 대문자 · 전각 · NFD 로 적은 미리 보기도 NFC 글 기준 위치', () => {
+      const nfd = '계약 PROJECT'.normalize('NFD');
+      const highlight = listHighlight(
+        {
+          subject: 'ＰＲＯＪＥＣＴ 안내',
+          preview: nfd,
+          bodyText: null,
+          otherFields: null,
+        },
+        terms('project', '계약'),
+      );
+      expect(highlight.subject).toEqual([[0, 7]]);
+      expect(highlight.preview.text).toBe('계약 PROJECT');
+      expect(slices(highlight.preview.text, highlight.preview.ranges)).toEqual([
+        '계약',
+        'PROJECT',
+      ]);
+    });
+
+    it('응답의 제목은 NFC — 강조 위치의 기준', () => {
+      const nfd = '계약 안내'.normalize('NFD');
+      expect(highlightedSubject(nfd)).toBe('계약 안내');
+      expect(highlightedSubject(nfd).length).toBe(5);
+    });
+  });
+
+  describe('답장의 원문 인용(> 줄)과 미리 보기 (2026-11-06 사용자 관점 점검)', () => {
+    /** 미리 보기 — 본문 · 강조할 말 · 색인의 접은 칸(없으면 null) */
+    const previewOf = (
+      bodyText: string,
+      words: HighlightTerms,
+      fields: string[] | null = null,
+    ) =>
+      listHighlight(
+        {
+          subject: '제목',
+          preview: '엔진의 미리 보기',
+          bodyText,
+          otherFields: fields,
+        },
+        words,
+      ).preview;
+
+    const REPLY_SUBJECT = 'RE: 해오름 프로젝트 견적 검토 요청';
+    const REPLY_FIELDS = otherFields({
+      from: '이도윤 <doyun.lee@arasystem.test>',
+      to: '김아라 <ara.kim@arasystem.test>',
+      subject: REPLY_SUBJECT,
+    });
+
+    it('인용 밖과 안에서 모두 맞으면 인용 밖의 맞은 곳 — 본문에서 먼저 나온 인용 안의 맞은 곳보다 먼저', () => {
+      const preview = previewOf(
+        '> 견적 부탁드립니다.\n\n견적서 확인했습니다. 금요일까지 회신 드리겠습니다.',
+        terms('견적'),
+      );
+      expect(preview).toEqual({
+        text: '…견적서 확인했습니다. 금요일까지 회신 드리겠습니다.',
+        ranges: [[1, 3]],
+      });
+    });
+
+    it('인용 밖에서 맞은 곳의 둘레는 인용 줄에 닿기 전까지 — 뒤따르는 인용은 싣지 않고 "…"', () => {
+      const preview = previewOf(
+        '금요일까지 견적서 회신 드리겠습니다.\n\n> 원본 메일\n> 해오름 프로젝트 견적 자료를 보냅니다.',
+        terms('견적'),
+      );
+      expect(preview).toEqual({
+        text: '금요일까지 견적서 회신 드리겠습니다.…',
+        ranges: [[6, 8]],
+      });
+    });
+
+    it('인용 안에서만 맞고 그 말이 다른 칸(제목 · 사람 · 첨부 이름)에서도 맞으면 인용 앞의 글 — 그 글에 맞은 곳이 없으면 범위도 없다', () => {
+      const body =
+        '네, 확인했습니다. 다음 주에 뵙겠습니다.\n\n> 제목: 해오름 프로젝트 견적 검토 요청\n> > 도윤 님, 견적 부탁드립니다.';
+      const expected = {
+        text: '네, 확인했습니다. 다음 주에 뵙겠습니다.…',
+        ranges: [],
+      };
+      // 제목에서 맞음
+      expect(previewOf(body, terms('견적'), REPLY_FIELDS)).toEqual(expected);
+      // 보낸 사람에서 맞음
+      expect(previewOf(body, terms('도윤'), REPLY_FIELDS)).toEqual(expected);
+      // 첨부 이름에서 맞음
+      expect(
+        previewOf(
+          body,
+          terms('검토'),
+          otherFields({ subject: '회신', attachment: '검토 의견.pdf' }),
+        ),
+      ).toEqual(expected);
+    });
+
+    it('인용 안에서만 맞고 다른 칸에서는 맞지 않으면 인용 조각 — 줄 앞의 > 를 뺀 글을 그 인용 안에서만, 위치는 보이는 글 기준', () => {
+      const preview = previewOf(
+        '네, 받았습니다.\n\n> 원본 메일\n> 해오름 프로젝트 R9A51 자료를 보냅니다.',
+        terms('R9A51'),
+        otherFields({ subject: 'RE: 해오름 프로젝트 안내' }),
+      );
+      expect(preview).toEqual({
+        text: '…원본 메일 해오름 프로젝트 R9A51 자료를 보냅니다.',
+        ranges: [[16, 21]],
+      });
+      expect(slices(preview.text, preview.ranges)).toEqual(['R9A51']);
+    });
+
+    it('본문에서 맞은 말 가운데 하나라도 다른 칸에서 맞지 않으면 인용 조각 — 내용 조건의 말은 본문에서만 찾으므로 다른 칸에 있어도 인용 조각', () => {
+      const body =
+        '네, 받았습니다.\n\n> 원본 메일\n> 해오름 프로젝트 R9A51 자료를 보냅니다.';
+      const fields = otherFields({ subject: 'RE: 해오름 프로젝트 안내' });
+
+      const both = previewOf(body, terms('해오름', 'R9A51'), fields);
+      expect(both.text).toBe(
+        '…원본 메일 해오름 프로젝트 R9A51 자료를 보냅니다.',
+      );
+      expect(slices(both.text, both.ranges)).toEqual(['해오름', 'R9A51']);
+
+      const bodyCondition = previewOf(
+        body,
+        { subject: [], body: ['해오름'], attachment: [], query: [] },
+        fields,
+      );
+      expect(bodyCondition.text).toBe(
+        '…원본 메일 해오름 프로젝트 R9A51 자료를 보냅니다.',
+      );
+      expect(slices(bodyCondition.text, bodyCondition.ranges)).toEqual([
+        '해오름',
+      ]);
+    });
+
+    it('인용으로 시작하는 본문(인용 아래에 쓴 답장)은 인용 밖의 첫 글 — 본문이 모두 인용이면 다른 칸에서 맞아도 인용 조각', () => {
+      expect(
+        previewOf(
+          '> 해오름 프로젝트 견적 부탁드립니다.\n\n네, 금요일까지 보내 드리겠습니다.',
+          terms('견적'),
+          REPLY_FIELDS,
+        ),
+      ).toEqual({ text: '…네, 금요일까지 보내 드리겠습니다.', ranges: [] });
+
+      const quoteOnly = previewOf(
+        '> 해오름 프로젝트 견적 부탁드립니다.\n> 감사합니다.',
+        terms('견적'),
+        REPLY_FIELDS,
+      );
+      expect(quoteOnly.text).toBe(
+        '해오름 프로젝트 견적 부탁드립니다. 감사합니다.',
+      );
+      expect(slices(quoteOnly.text, quoteOnly.ranges)).toEqual(['견적']);
+    });
+
+    it('인용 줄 알아보기 — 앞 공백 · 탭 뒤의 > · 겹친 표시(>> · > >) · CRLF, 줄 가운데의 > 는 인용이 아니다', () => {
+      expect(
+        previewOf('a > b 견적 정리\r\n  >> > 견적 원문', terms('견적')),
+      ).toEqual({ text: 'a > b 견적 정리…', ranges: [[6, 8]] });
+
+      expect(
+        previewOf('  >> > 견적 원문\r\n\t> 두 번째 견적', terms('견적')),
+      ).toEqual({
+        text: '견적 원문 두 번째 견적',
+        ranges: [
+          [0, 2],
+          [11, 13],
+        ],
+      });
+    });
+
+    it('인용 조각도 서로게이트 쌍을 가르지 않고 위치는 NFC 글 기준 — NFD 로 적은 말도 맞는다', () => {
+      const body = `확인했습니다.\n\n> ${'😀'.repeat(15)} 계약서 보내 드립니다 ${'😀'.repeat(40)}`;
+      const preview = previewOf(body, terms('계약'.normalize('NFD')));
+
+      expect(preview.text).not.toContain('>');
+      expect(() => encodeURIComponent(preview.text)).not.toThrow();
+      expect(slices(preview.text, preview.ranges)).toEqual(['계약']);
+      expect(preview.text.startsWith('…')).toBe(true);
+    });
+
+    it('본문 길이에 비례한다 — 인용 줄이 많은 긴 본문(색인 본문 상한 남짓)에서 끝의 인용 조각을 골라도', () => {
+      const bodyOf = (lines: number) =>
+        `확인했습니다.\n\n${Array.from(
+          { length: lines },
+          (_, index) => `> > 인용 줄 ${index} 가나다라마바사`,
+        ).join('\n')}\n> 마지막 견적 줄`;
+      const run = (body: string) => {
+        for (let round = 0; round < 20; round += 1) {
+          previewOf(body, terms('견적'));
+        }
+      };
+      const small = bodyOf(50);
+      const large = bodyOf(1_000);
+      expect(previewOf(large, terms('견적')).text).toContain('마지막 견적 줄');
+      run(small);
+
+      const smallCpu = startCpuTimer();
+      run(small);
+      const smallMs = smallCpu();
+      const largeCpu = startCpuTimer();
+      run(large);
+      const largeMs = largeCpu();
+      // 20배 입력 — 제곱이면 400배다. 지금 값의 10배쯤을 한도로 둔다 (test/cpu-time.ts)
+      expect(largeMs).toBeLessThan(Math.max(smallMs, 20) * 20 * 10);
+      expect(largeMs).toBeLessThan(5_000);
+    });
+  });
+});
diff --git a/backend/src/modules/mail-search/search-highlight.ts b/backend/src/modules/mail-search/search-highlight.ts
new file mode 100644
index 0000000..9aa450d
--- /dev/null
+++ b/backend/src/modules/mail-search/search-highlight.ts
@@ -0,0 +1,345 @@
+import {
+  foldTerms,
+  foldText,
+  isSpaceCode,
+  matchFoldedRanges,
+  matchRanges,
+  type MatchRange,
+} from '@/shared/utils/search-text';
+import {
+  SNIPPET_BOUNDARY_SLACK,
+  SNIPPET_LEAD_CHARS,
+  SNIPPET_TOTAL_CHARS,
+} from './mail-search.constants';
+import type { MessageListHighlight, SearchRange } from './mail-search.types';
+import type { HighlightTerms } from './search-plan';
+
+/**
+ * 목록의 검색 강조 (순수 함수 — 14단계 설계 C1) — 제목의 맞은 곳과 미리 보기 한 줄.
+ * - 제목: 검색어 · 제목 조건의 말이 맞은 곳 (위치는 NFC 제목 기준 — 부르는 쪽이 응답의 제목도 NFC 로 둔다)
+ * - 미리 보기: 본문(색인의 글 — NFC)에서 맞은 곳을 아래 차례로 고르고(2026-11-06 사용자 관점 점검 — 답장은 처음 맞은 곳이 거의 늘 원문 인용 안이라
+ *   셋째 줄로 답장끼리 가를 수 없었다), 본문에서 맞지 않았으면 엔진의 미리 보기
+ *   1. 인용 줄(앞 공백 뒤 `>` 로 시작하는 줄) 밖에서 처음 맞은 곳의 둘레 — 인용 줄에 닿기 전까지만
+ *   2. 인용 안에서만 맞았고 본문에서 맞은 말이 모두 다른 칸(제목 · 사람 · 첨부 이름 — 검색어의 낱말)에서도 맞았으면 인용 밖의 첫 글(보통 인용 앞의 글)
+ *   3. 그 밖에는 인용 안에서 처음 맞은 곳의 둘레 — 줄 앞의 `>` 표시를 뺀 글로, 그 인용(이어진 인용 줄) 안에서만
+ *   다른 메일 프로그램의 인용 꼴(`>` 없이 "-----Original Message-----" 아래에 두는 것 등)은 알아보지 않는다
+ * - 둘레는 맞은 곳 앞 SNIPPET_LEAD_CHARS 자 남짓 · 모두 SNIPPET_TOTAL_CHARS 자 남짓 — SNIPPET_BOUNDARY_SLACK 안의 공백에서 자르고, 앞뒤에 잘라 낸 글이 있으면 "…".
+ *   공백은 하나로 줄인 한 줄이고 맞은 곳은 보이는 그 글에서 다시 찾는다(그 글에 맞은 곳이 없으면 범위도 없다)
+ * 위치는 UTF-16 [시작, 끝)
+ */
+
+const ELLIPSIS = '…';
+/** 인용 줄의 표시 `>` */
+const QUOTE_MARK_CODE = 0x3e;
+const LINE_BREAK = '\n';
+
+function isHighSurrogate(code: number): boolean {
+  return code >= 0xd800 && code <= 0xdbff;
+}
+
+/** 서로게이트 쌍 가운데를 가르지 않게 — 그 자리가 쌍의 뒤쪽이면 한 칸 앞으로 */
+function alignStart(text: string, index: number): number {
+  if (index <= 0 || index >= text.length) return Math.max(0, index);
+  return isHighSurrogate(text.charCodeAt(index - 1)) ? index - 1 : index;
+}
+
+/** 서로게이트 쌍 가운데를 가르지 않게 — 그 자리가 쌍의 뒤쪽이면 한 칸 뒤로 */
+function alignEnd(text: string, index: number): number {
+  if (index <= 0 || index >= text.length) return Math.min(text.length, index);
+  return isHighSurrogate(text.charCodeAt(index - 1)) ? index + 1 : index;
+}
+
+/** `from` 에서 `to` 쪽으로 가며 처음 만나는 공백의 자리 — 없으면 -1 (from · to 를 포함) */
+function findSpace(text: string, from: number, to: number): number {
+  const step = from <= to ? 1 : -1;
+  for (let index = from; step > 0 ? index <= to : index >= to; index += step) {
+    if (
+      index >= 0 &&
+      index < text.length &&
+      isSpaceCode(text.charCodeAt(index))
+    ) {
+      return index;
+    }
+  }
+  return -1;
+}
+
+/** [from, to) 에 공백이 아닌 글자가 있나 — 잘라 낸 쪽에 보이는 글이 있을 때만 "…" 를 붙이려고 */
+function hasVisible(text: string, from: number, to: number): boolean {
+  for (let index = from; index < to; index += 1) {
+    if (!isSpaceCode(text.charCodeAt(index))) return true;
+  }
+  return false;
+}
+
+/** 공백류의 이어짐을 띄어쓰기 하나로 · 앞뒤 공백 빼기 (한 줄로 보이는 미리 보기) */
+function oneLine(text: string): string {
+  let line = '';
+  let pendingSpace = false;
+  for (let index = 0; index < text.length; index += 1) {
+    if (isSpaceCode(text.charCodeAt(index))) {
+      pendingSpace = line !== '';
+      continue;
+    }
+    if (pendingSpace) line += ' ';
+    pendingSpace = false;
+    line += text[index];
+  }
+  return line;
+}
+
+/**
+ * 맞은 말 둘레 — 처음 맞은 곳(`first`)을 담아 앞 SNIPPET_LEAD_CHARS · 모두 SNIPPET_TOTAL_CHARS 남짓을 말 경계에서 자른다.
+ * `bounds`([시작, 끝) — 처음 값은 글 전체) 밖으로는 나가지 않는다(인용 줄에 닿기 전까지 등).
+ * 앞 · 뒤에 잘라 낸 글(공백만이 아닌 — `bounds` 밖도 센다)이 있으면 "…" 를 붙이고 한 줄로 만든다
+ */
+export function snippetAround(
+  body: string,
+  first: MatchRange,
+  bounds: MatchRange = [0, body.length],
+): string {
+  const [low, high] = bounds;
+  const [matchStart, matchEnd] = first;
+  // 시작 — 맞은 곳 앞 SNIPPET_LEAD_CHARS 자 둘레의 공백 뒤(앞으로 여유만큼, 없으면 맞은 곳 쪽으로), 그래도 없으면 그 자리
+  const lead = Math.max(low, matchStart - SNIPPET_LEAD_CHARS);
+  let start = lead;
+  if (lead > low) {
+    const before = findSpace(
+      body,
+      lead,
+      Math.max(low, lead - SNIPPET_BOUNDARY_SLACK),
+    );
+    const after =
+      before < 0 ? findSpace(body, lead, Math.max(lead, matchStart - 1)) : -1;
+    const space = before >= 0 ? before : after;
+    if (space >= 0) start = space + 1;
+  }
+  start = Math.max(low, alignStart(body, start));
+  // 끝 — 시작에서 SNIPPET_TOTAL_CHARS 자 둘레의 공백 앞(뒤로 여유만큼, 없으면 앞으로), 맞은 곳은 늘 담는다
+  const target = Math.max(matchEnd, start + SNIPPET_TOTAL_CHARS);
+  let end = Math.min(high, target);
+  if (end < high) {
+    const back = findSpace(
+      body,
+      end,
+      Math.max(matchEnd, end - SNIPPET_BOUNDARY_SLACK),
+    );
+    const forward =
+      back < 0
+        ? findSpace(body, end, Math.min(high - 1, end + SNIPPET_BOUNDARY_SLACK))
+        : -1;
+    const space = back >= 0 ? back : forward;
+    if (space >= 0) end = space;
+  }
+  end = Math.min(high, alignEnd(body, end));
+  const text = oneLine(body.slice(start, end));
+  const head = hasVisible(body, 0, start) ? ELLIPSIS : '';
+  const tail = hasVisible(body, end, body.length) ? ELLIPSIS : '';
+  return `${head}${text}${tail}`;
+}
+
+/** 본문의 한 줄 — [start, end) (줄바꿈 글자는 빼고). 인용 줄이면 `quoteText` 가 표시 다음 글의 시작, 아니면 null */
+interface BodyLine {
+  readonly start: number;
+  readonly end: number;
+  readonly quoteText: number | null;
+}
+
+/** 인용 줄이면 표시 다음 글의 시작 — 앞 공백 뒤 `>` 로 시작하는 줄 (`> > 글` 처럼 겹친 표시와 그 사이 · 뒤 공백을 모두 넘는다) */
+function quoteTextStart(
+  body: string,
+  start: number,
+  end: number,
+): number | null {
+  let index = start;
+  while (index < end && isSpaceCode(body.charCodeAt(index))) index += 1;
+  if (index >= end || body.charCodeAt(index) !== QUOTE_MARK_CODE) return null;
+  while (index < end) {
+    const code = body.charCodeAt(index);
+    if (code !== QUOTE_MARK_CODE && !isSpaceCode(code)) break;
+    index += 1;
+  }
+  return index;
+}
+
+/** 본문의 줄들 — 한 번 훑는다 */
+function bodyLines(body: string): BodyLine[] {
+  const lines: BodyLine[] = [];
+  for (let start = 0; ; ) {
+    const found = body.indexOf(LINE_BREAK, start);
+    const end = found < 0 ? body.length : found;
+    lines.push({ start, end, quoteText: quoteTextStart(body, start, end) });
+    if (found < 0) return lines;
+    start = found + 1;
+  }
+}
+
+/** 그 자리를 담은 줄의 차례 (줄은 시작 차례로 놓여 있다) */
+function lineIndexAt(lines: readonly BodyLine[], position: number): number {
+  let low = 0;
+  let high = lines.length - 1;
+  while (low < high) {
+    const middle = (low + high + 1) >> 1;
+    if (lines[middle].start <= position) low = middle;
+    else high = middle - 1;
+  }
+  return low;
+}
+
+/** 인용 줄을 공백으로 덮은 글 — 위치 · 길이는 그대로 (인용 밖에서만 맞추려고) */
+function maskQuotes(text: string, lines: readonly BodyLine[]): string {
+  let masked = '';
+  let from = 0;
+  for (const line of lines) {
+    if (line.quoteText === null) continue;
+    masked += text.slice(from, line.start) + ' '.repeat(line.end - line.start);
+    from = line.end;
+  }
+  return masked + text.slice(from);
+}
+
+/** 그 줄과 같은 쪽(인용 · 인용 밖)인 줄들의 이어진 범위 [시작, 끝) — 미리 보기가 인용과 인용 밖을 섞지 않게 */
+function runAround(lines: readonly BodyLine[], index: number): MatchRange {
+  const quoted = lines[index].quoteText !== null;
+  const same = (line: BodyLine) => (line.quoteText !== null) === quoted;
+  let first = index;
+  while (first > 0 && same(lines[first - 1])) first -= 1;
+  let last = index;
+  while (last + 1 < lines.length && same(lines[last + 1])) last += 1;
+  return [lines[first].start, lines[last].end];
+}
+
+/** 인용 밖의 첫 글 — 보이는 글이 있는 첫 인용 밖 줄부터 다음 인용 줄 전까지 (없으면 null) */
+function firstPlainRun(
+  body: string,
+  lines: readonly BodyLine[],
+): MatchRange | null {
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (line.quoteText === null && hasVisible(body, line.start, line.end)) {
+      return [line.start, runAround(lines, index)[1]];
+    }
+  }
+  return null;
+}
+
+/** 인용 표시를 뺀 글 — 줄은 그대로 잇고, 원래 글의 자리를 이 글의 자리로 바꾸는 함수를 함께 준다 */
+function stripQuoteMarks(
+  body: string,
+  lines: readonly BodyLine[],
+): { readonly text: string; readonly at: (position: number) => number } {
+  const parts: string[] = [];
+  const starts: number[] = [];
+  let length = 0;
+  lines.forEach((line, index) => {
+    if (index > 0) {
+      parts.push(LINE_BREAK);
+      length += LINE_BREAK.length;
+    }
+    starts.push(length);
+    const from = line.quoteText ?? line.start;
+    parts.push(body.slice(from, line.end));
+    length += line.end - from;
+  });
+  return {
+    text: parts.join(''),
+    at: (position) => {
+      const index = lineIndexAt(lines, position);
+      const line = lines[index];
+      const from = line.quoteText ?? line.start;
+      return (
+        starts[index] + Math.min(Math.max(0, position - from), line.end - from)
+      );
+    },
+  };
+}
+
+/**
+ * 본문에서 맞은 말(`words` — 접은 말)이 모두 다른 칸에서도 맞았나 — 검색어의 낱말이고(내용 조건의 낱말은 본문에서만 찾는다)
+ * 색인의 접은 칸(보낸 사람 · 받는 사람과 참조 · 제목 · 첨부 이름) 가운데 하나에 든다. 칸을 모르면(null) 아니다
+ */
+function matchedElsewhere(
+  folded: string,
+  words: readonly string[],
+  query: readonly string[],
+  otherFields: readonly string[] | null,
+): boolean {
+  if (otherFields === null) return false;
+  const queryWords = new Set(foldTerms(query));
+  return words
+    .filter((word) => folded.includes(word))
+    .every(
+      (word) =>
+        queryWords.has(word) &&
+        otherFields.some((field) => field.includes(word)),
+    );
+}
+
+/** 본문에서 고른 미리 보기 한 줄 (위의 1 · 2 · 3) — 본문에서 맞지 않았으면 null */
+function bodySnippet(
+  text: string,
+  terms: HighlightTerms,
+  otherFields: readonly string[] | null,
+): string | null {
+  // 접은 글은 NFC 본문과 위치가 같다 — 줄 · 인용은 본문에서, 맞추기는 접은 글에서 (색인의 본문은 이미 NFC 다 — 거의 그대로 돌아온다)
+  const body = text.normalize('NFC');
+  const folded = foldText(body);
+  const words = foldTerms(terms.body);
+  const lines = bodyLines(body);
+  const [outside] = matchFoldedRanges(maskQuotes(folded, lines), words, 1);
+  if (outside) {
+    return snippetAround(
+      body,
+      outside,
+      runAround(lines, lineIndexAt(lines, outside[0])),
+    );
+  }
+  const [inside] = matchFoldedRanges(folded, words, 1);
+  if (!inside) return null;
+  if (matchedElsewhere(folded, words, terms.query, otherFields)) {
+    const run = firstPlainRun(body, lines);
+    if (run) return snippetAround(body, [run[0], run[0]], run);
+  }
+  // 인용 조각 — 그 인용(이어진 인용 줄)에 닿기 전까지, `>` 표시를 뺀 글에서
+  const stripped = stripQuoteMarks(body, lines);
+  const [runStart, runEnd] = runAround(lines, lineIndexAt(lines, inside[0]));
+  return snippetAround(
+    stripped.text,
+    [stripped.at(inside[0]), stripped.at(inside[1])],
+    [stripped.at(runStart), stripped.at(runEnd)],
+  );
+}
+
+function toRanges(ranges: readonly MatchRange[]): SearchRange[] {
+  return ranges.map(([start, end]) => [start, end] as const);
+}
+
+/**
+ * 목록 항목 하나의 강조 — `subject` 는 응답에 실을 제목(NFC), `preview` 는 엔진의 미리 보기, `bodyText` 는 색인의 본문 글(NFC — 없으면 null),
+ * `otherFields` 는 색인의 접은 칸(보낸 사람 · 받는 사람과 참조 · 제목 · 첨부 이름 — 없으면 null)
+ */
+export function listHighlight(
+  input: {
+    readonly subject: string;
+    readonly preview: string;
+    readonly bodyText: string | null;
+    readonly otherFields: readonly string[] | null;
+  },
+  terms: HighlightTerms,
+): MessageListHighlight {
+  const subject = toRanges(matchRanges(input.subject, terms.subject));
+  const fromBody =
+    input.bodyText && terms.body.length > 0
+      ? bodySnippet(input.bodyText, terms, input.otherFields)
+      : null;
+  const text = fromBody ?? oneLine(input.preview.normalize('NFC'));
+  return {
+    subject,
+    preview: { text, ranges: toRanges(matchRanges(text, terms.body)) },
+  };
+}
+
+/** 응답에 실을 제목 — 강조 위치의 기준인 NFC (화면에는 같게 보인다) */
+export function highlightedSubject(subject: string): string {
+  return subject.normalize('NFC');
+}
diff --git a/backend/src/modules/mail-search/search-index-schedule.spec.ts b/backend/src/modules/mail-search/search-index-schedule.spec.ts
new file mode 100644
index 0000000..bb46d60
--- /dev/null
+++ b/backend/src/modules/mail-search/search-index-schedule.spec.ts
@@ -0,0 +1,91 @@
+import { MailSearchRuns } from './mail-search-runs';
+import { FAILURE_BACKOFF_BASE_MS } from './mail-search.constants';
+import { isBuildWindow, isDueAfterFailures } from './search-index-schedule';
+
+/** 한국 시각 'HH:MM' → 그 시각(2026-11-05 한국 날짜)의 Date */
+function kst(time: string): Date {
+  return new Date(`2026-11-05T${time}:00+09:00`);
+}
+
+describe('isBuildWindow (밤 채우기의 창 — 한국 시각)', () => {
+  it.each([
+    ['22:00', true],
+    ['23:59', true],
+    ['00:00', true],
+    ['02:44', true],
+    ['02:45', false],
+    ['03:00', false],
+    ['03:30', false],
+    ['04:30', false],
+    ['04:59', false],
+    ['05:00', true],
+    ['07:29', true],
+    ['07:30', false],
+    ['12:00', false],
+    ['21:59', false],
+  ])('%s → %s', (time, inside) => {
+    expect(isBuildWindow(kst(time))).toBe(inside);
+  });
+});
+
+describe('isDueAfterFailures (실패가 이어진 직원을 다시 해 볼 때)', () => {
+  const at = new Date('2026-11-05T00:00:00Z');
+
+  it('실패가 없으면 늘 된다', () => {
+    expect(isDueAfterFailures(0, at, at.getTime())).toBe(true);
+  });
+
+  it('실패 수마다 기다림이 두 배 — 상한 단계에서 멈춘다', () => {
+    expect(
+      isDueAfterFailures(1, at, at.getTime() + FAILURE_BACKOFF_BASE_MS - 1),
+    ).toBe(false);
+    expect(
+      isDueAfterFailures(1, at, at.getTime() + FAILURE_BACKOFF_BASE_MS),
+    ).toBe(true);
+    expect(
+      isDueAfterFailures(3, at, at.getTime() + FAILURE_BACKOFF_BASE_MS * 3),
+    ).toBe(false);
+    expect(
+      isDueAfterFailures(3, at, at.getTime() + FAILURE_BACKOFF_BASE_MS * 4),
+    ).toBe(true);
+    // 100번이어도 상한(6단계 — 32배)까지만 기다린다
+    expect(
+      isDueAfterFailures(100, at, at.getTime() + FAILURE_BACKOFF_BASE_MS * 32),
+    ).toBe(true);
+  });
+});
+
+describe('MailSearchRuns (직원마다 한 번에 하나)', () => {
+  it('같은 직원의 일은 차례로, 다른 직원은 함께 — 앞 일이 실패해도 다음 일은 한다', async () => {
+    const runs = new MailSearchRuns();
+    const order: string[] = [];
+    let release: () => void = () => undefined;
+    const gate = new Promise<void>((resolve) => {
+      release = resolve;
+    });
+
+    const first = runs.run('Ara@x', async () => {
+      order.push('ara-1 시작');
+      await gate;
+      order.push('ara-1 끝');
+      throw new Error('실패');
+    });
+    const second = runs.run('ara@x', () => {
+      order.push('ara-2');
+      return Promise.resolve(2);
+    });
+    const other = runs.run('doyun@x', () => {
+      order.push('doyun');
+      return Promise.resolve(3);
+    });
+
+    await other;
+    expect(runs.isBusy('ARA@x')).toBe(true);
+    release();
+    await expect(first).rejects.toThrow('실패');
+    await expect(second).resolves.toBe(2);
+    expect(order).toEqual(['ara-1 시작', 'doyun', 'ara-1 끝', 'ara-2']);
+    await new Promise((resolve) => setImmediate(resolve));
+    expect(runs.isBusy('ara@x')).toBe(false);
+  });
+});
diff --git a/backend/src/modules/mail-search/search-index-schedule.ts b/backend/src/modules/mail-search/search-index-schedule.ts
new file mode 100644
index 0000000..9236434
--- /dev/null
+++ b/backend/src/modules/mail-search/search-index-schedule.ts
@@ -0,0 +1,33 @@
+import { kstMinuteOfDay } from '@/shared/utils/kst-date';
+import {
+  BUILD_WINDOWS_KST,
+  FAILURE_BACKOFF_BASE_MS,
+  FAILURE_BACKOFF_STEPS_MAX,
+} from './mail-search.constants';
+
+/**
+ * 검색 색인의 때 고르기 (순수 함수 — 14단계 설계 B2 · B3).
+ */
+
+/** 밤 채우기의 창 안인가 — 한국 시각 22:00 ~ 02:45 · 05:00 ~ 07:30 (끝 분은 들지 않는다) */
+export function isBuildWindow(at: Date): boolean {
+  const minute = kstMinuteOfDay(at);
+  return BUILD_WINDOWS_KST.some(
+    ([start, end]) => minute >= start && minute < end,
+  );
+}
+
+/**
+ * 실패가 이어진 직원을 다시 해 볼 때가 됐나 — 실패 수마다 두 배(5분 · 10분 · 20분 …, FAILURE_BACKOFF_STEPS_MAX 단계에서 멈춤).
+ * 실패가 없으면 늘 된다. `lastAttemptAt` 은 마지막 실패를 적은 때(상태 줄의 updated_at)
+ */
+export function isDueAfterFailures(
+  failureCount: number,
+  lastAttemptAt: Date,
+  now: number,
+): boolean {
+  if (failureCount <= 0) return true;
+  const steps = Math.min(failureCount, FAILURE_BACKOFF_STEPS_MAX);
+  const wait = FAILURE_BACKOFF_BASE_MS * 2 ** (steps - 1);
+  return now - lastAttemptAt.getTime() >= wait;
+}
diff --git a/backend/src/modules/mail-search/search-index.controller.ts b/backend/src/modules/mail-search/search-index.controller.ts
new file mode 100644
index 0000000..796e245
--- /dev/null
+++ b/backend/src/modules/mail-search/search-index.controller.ts
@@ -0,0 +1,38 @@
+import { Controller, Get, UseGuards } from '@nestjs/common';
+import { ApiCookieAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+
+import {
+  ApiSessionErrors,
+  ApiStandardResponse,
+} from '@/common/decorators/api-standard-response.decorator';
+import {
+  CurrentUser,
+  type AuthenticatedUser,
+} from '@/common/decorators/current-user.decorator';
+import { JwtAuthGuard } from '@/common/guards/jwt-auth.guard';
+import { SearchIndexStatusDto } from './dto/search-index-status.dto';
+import { MailSearchIndexService } from './mail-search-index.service';
+
+/** 검색 준비 상태 라우트 (`/api/search-index`) — 14단계 */
+export const SEARCH_INDEX_ROUTE = 'search-index';
+
+// 검색 준비 상태 (14단계 — 자체 검색 색인). 줄이 없던 직원은 이때 만든다
+@ApiTags('Mail')
+@ApiCookieAuth()
+@UseGuards(JwtAuthGuard)
+@ApiSessionErrors('로그인 필요 (쿠키 없음·만료)')
+@Controller(SEARCH_INDEX_ROUTE)
+export class SearchIndexController {
+  constructor(private readonly searchIndex: MailSearchIndexService) {}
+
+  @Get()
+  @ApiOperation({
+    summary: '검색 준비 상태',
+    description:
+      '지난 메일의 검색 색인을 만드는 중(building)이면 그 직원의 검색은 엔진 방식이다 — 화면은 "검색 준비 중" 줄을 보인다. 색인은 밤에 한 사람씩 채운다. 처음 묻는 직원(상태 줄 없음)은 이때 building 으로 만든다.',
+  })
+  @ApiStandardResponse(SearchIndexStatusDto, { description: '지금 상태' })
+  status(@CurrentUser() user: AuthenticatedUser) {
+    return this.searchIndex.status(user.email);
+  }
+}
diff --git a/backend/src/modules/mail-search/search-plan.spec.ts b/backend/src/modules/mail-search/search-plan.spec.ts
new file mode 100644
index 0000000..5a5b560
--- /dev/null
+++ b/backend/src/modules/mail-search/search-plan.spec.ts
@@ -0,0 +1,300 @@
+import { SINGLE_CHAR_TERMS_SKIP_BODY } from './mail-search.constants';
+import type { SearchCriteria } from './mail-search.types';
+import {
+  ALL_FOLD_FIELDS,
+  highlightTermsOf,
+  isSearchCriteria,
+  planSearch,
+} from './search-plan';
+
+const criteria = (overrides: Partial<SearchCriteria>): SearchCriteria => ({
+  hasAttachment: false,
+  ...overrides,
+});
+
+describe('검색 계획 (search-plan — 14단계 설계 C1 · G)', () => {
+  it('검색인가 — 검색어 · 글 조건 · 기간 · 첨부 가운데 하나라도 (빈 글 · 첨부 false 는 없는 것)', () => {
+    expect(isSearchCriteria(criteria({}))).toBe(false);
+    expect(isSearchCriteria(criteria({ text: '', subject: '' }))).toBe(false);
+    for (const overrides of [
+      { text: '계약' },
+      { from: '이도윤' },
+      { to: 'ara' },
+      { subject: '견적' },
+      { body: '일정' },
+      { after: '2026-10-31T15:00:00.000Z' },
+      { before: '2026-11-30T15:00:00.000Z' },
+      { hasAttachment: true },
+    ]) {
+      expect(isSearchCriteria(criteria(overrides))).toBe(true);
+    }
+  });
+
+  it('검색어의 낱말은 다섯 칸 어디서든 — 접은 낱말로 확인하고 글자 두 개 묶음으로 후보를 좁힌다', () => {
+    const plan = planSearch(criteria({ text: '계약 PROJECT' }));
+
+    expect(plan.checks).toEqual([
+      { term: '계약', fields: ALL_FOLD_FIELDS },
+      { term: 'project', fields: ALL_FOLD_FIELDS },
+    ]);
+    expect(plan.grams).toEqual(['계약', 'pr', 'ro', 'oj', 'je', 'ec', 'ct']);
+    expect(plan.matchesNothing).toBe(false);
+    expect(plan.bodySkipped).toBe(false);
+    // 강조는 접기 전 낱말 그대로 (맞추기가 접는다)
+    expect(plan.highlight).toEqual({
+      subject: ['계약', 'PROJECT'],
+      body: ['계약', 'PROJECT'],
+      attachment: ['계약', 'PROJECT'],
+      query: ['계약', 'PROJECT'],
+    });
+  });
+
+  it('큰따옴표 구절은 띄어쓰기까지 그대로 하나의 확인 — 묶음은 공백을 넘지 않는다, 앞뒤 문장부호를 뗀 낱말 · 같은 낱말은 한 번', () => {
+    const plan = planSearch(criteria({ text: '"계약 갱신" (계약), 계약' }));
+
+    expect(plan.checks.map((check) => check.term)).toEqual([
+      '계약 갱신',
+      '계약',
+    ]);
+    expect(plan.grams).toEqual(['계약', '갱신']);
+  });
+
+  it('조건의 낱말은 그 칸에서만 — 받는 사람(to)은 받는 사람 · 참조를 담은 칸, 보낸 사람 · 받는 사람은 강조하지 않는다', () => {
+    const plan = planSearch(
+      criteria({
+        from: '이도윤',
+        to: 'ara.kim',
+        subject: '견적',
+        body: '"단가 조정"',
+      }),
+    );
+
+    expect(plan.checks).toEqual([
+      { term: '이도윤', fields: ['fold_from'] },
+      { term: 'ara.kim', fields: ['fold_to'] },
+      { term: '견적', fields: ['fold_subject'] },
+      { term: '단가 조정', fields: ['fold_body'] },
+    ]);
+    expect(plan.highlight).toEqual({
+      subject: ['견적'],
+      body: ['단가 조정'],
+      attachment: [],
+      query: [],
+    });
+  });
+
+  it('같은 낱말이라도 찾는 칸이 다르면 따로 확인한다', () => {
+    const plan = planSearch(criteria({ text: '견적', subject: '견적' }));
+    expect(plan.checks).toEqual([
+      { term: '견적', fields: ALL_FOLD_FIELDS },
+      { term: '견적', fields: ['fold_subject'] },
+    ]);
+    expect(plan.grams).toEqual(['견적']);
+  });
+
+  it('한 글자 낱말은 두 글자 넘는 낱말과 함께면 확인에만 쓴다 — 본문에서도 찾는다', () => {
+    const plan = planSearch(criteria({ text: '묵 계약' }));
+
+    expect(plan.bodySkipped).toBe(false);
+    expect(plan.grams).toEqual(['계약']);
+    expect(plan.checks).toEqual([
+      { term: '묵', fields: ALL_FOLD_FIELDS },
+      { term: '계약', fields: ALL_FOLD_FIELDS },
+    ]);
+    // 본문 강조는 두 글자 이상 낱말만 — 한 글자 낱말은 제목 · 첨부 이름에만 (2026-11-06 실사용 시험)
+    expect(plan.highlight).toEqual({
+      subject: ['묵', '계약'],
+      body: ['계약'],
+      attachment: ['묵', '계약'],
+      query: ['묵', '계약'],
+    });
+  });
+
+  it('본문 강조는 본문을 찾은 두 글자 이상 낱말만 — 내용 조건과 섞여도 · 묶음이 없는 구절(한 글자씩 띄운 것)도 한 글자 낱말과 같다', () => {
+    // 내용 조건의 두 글자 이상 낱말과 섞임 — 검색어의 한 글자 낱말은 본문에 강조하지 않는다
+    expect(
+      planSearch(criteria({ text: '견', body: '계약서' })).highlight.body,
+    ).toEqual(['계약서']);
+    // 두 글자 이상 낱말이 강조하지 않는 칸(보낸 사람)에만 있어도 섞인 검색이다 — 본문에 강조할 말이 없다
+    const withSender = planSearch(criteria({ text: '견', from: '김아라' }));
+    expect(withSender.bodySkipped).toBe(false);
+    expect(withSender.highlight.body).toEqual([]);
+    expect(withSender.highlight.subject).toEqual(['견']);
+    // 한 글자씩 띄운 구절은 묶음이 없다
+    expect(planSearch(criteria({ text: '"a b" 계약' })).highlight.body).toEqual(
+      ['계약'],
+    );
+  });
+
+  it('한 글자 낱말뿐이면 본문은 훑지 않는다 — 제목 · 사람 · 첨부 이름에서만 (SINGLE_CHAR_TERMS_SKIP_BODY)', () => {
+    expect(SINGLE_CHAR_TERMS_SKIP_BODY).toBe(true);
+    const plan = planSearch(criteria({ text: '묵 뷁', from: '김' }));
+
+    expect(plan.bodySkipped).toBe(true);
+    expect(plan.grams).toEqual([]);
+    expect(plan.matchesNothing).toBe(false);
+    expect(plan.checks).toEqual([
+      {
+        term: '묵',
+        fields: ['fold_from', 'fold_to', 'fold_subject', 'fold_attachment'],
+      },
+      {
+        term: '뷁',
+        fields: ['fold_from', 'fold_to', 'fold_subject', 'fold_attachment'],
+      },
+      { term: '김', fields: ['fold_from'] },
+    ]);
+    // 본문을 찾지 않았으니 본문(미리 보기 · 읽기 화면)에는 강조하지 않는다 — 제목 · 첨부 이름에는 그대로 (2026-11-06 실사용 시험)
+    expect(plan.highlight).toEqual({
+      subject: ['묵', '뷁'],
+      body: [],
+      attachment: ['묵', '뷁'],
+      query: ['묵', '뷁'],
+    });
+  });
+
+  it('한 글자 낱말뿐인데 내용 조건이 있으면 찾을 곳이 없다 — 아무것도 맞지 않는다', () => {
+    expect(planSearch(criteria({ body: '묵' })).matchesNothing).toBe(true);
+    expect(
+      planSearch(criteria({ text: '묵', body: '뷁' })).matchesNothing,
+    ).toBe(true);
+    // 두 글자 넘는 낱말과 함께면 한 글자 내용 조건도 확인한다
+    const together = planSearch(criteria({ text: '계약', body: '묵' }));
+    expect(together.matchesNothing).toBe(false);
+    expect(together.checks).toContainEqual({
+      term: '묵',
+      fields: ['fold_body'],
+    });
+  });
+
+  it('글을 준 칸에 찾을 낱말이 하나도 없으면(문장부호뿐 · 빈 따옴표) 아무것도 맞지 않는다 — 범위 전체를 돌려주지 않는다', () => {
+    for (const overrides of [
+      { text: '…' },
+      { text: '""' },
+      { from: '-' },
+      { text: '계약', subject: '—' },
+    ]) {
+      expect(planSearch(criteria(overrides)).matchesNothing).toBe(true);
+    }
+  });
+
+  it('기간 · 첨부만의 검색은 확인도 묶음도 없다 — 받은 시각 · 첨부 표시로만', () => {
+    const plan = planSearch(
+      criteria({
+        after: '2026-10-31T15:00:00.000Z',
+        before: '2026-11-30T15:00:00.000Z',
+        hasAttachment: true,
+      }),
+    );
+
+    expect(plan.checks).toEqual([]);
+    expect(plan.grams).toEqual([]);
+    expect(plan.matchesNothing).toBe(false);
+    expect(plan.after?.toISOString()).toBe('2026-10-31T15:00:00.000Z');
+    expect(plan.before?.toISOString()).toBe('2026-11-30T15:00:00.000Z');
+    expect(plan.hasAttachment).toBe(true);
+  });
+
+  it('전각 · 대문자 · 공백류는 접어서 확인한다 — 구절 안의 줄바꿈도 띄어쓰기 하나와 같다', () => {
+    const plan = planSearch(criteria({ text: '"ＥＲＰ\u3000도입"' }));
+    expect(plan.checks.map((check) => check.term)).toEqual(['erp 도입']);
+    expect(plan.grams).toEqual(['er', 'rp', '도입']);
+  });
+
+  it('두 글자 낱말뿐인 검색어는 묶음만으로 정해진다(exactByGrams) — 세 글자 · 구절 · 한 글자 · 조건 칸이 섞이면 확인한다', () => {
+    // 서로게이트 쌍 글자(CJK 확장 B — 글자)도 코드 포인트 하나로 센다
+    const astralAndLetter = `${String.fromCodePoint(0x20000)}가`;
+    for (const text of [
+      '계약',
+      '계약 확인',
+      'ab',
+      'ＡＢ',
+      astralAndLetter,
+      '(계약),',
+    ]) {
+      expect(planSearch(criteria({ text })).exactByGrams).toBe(true);
+    }
+    expect(
+      planSearch(
+        criteria({
+          text: '계약',
+          after: '2026-10-31T15:00:00.000Z',
+          hasAttachment: true,
+        }),
+      ).exactByGrams,
+    ).toBe(true);
+    for (const overrides of [
+      { text: '계약서' },
+      { text: '"계약 갱신"' },
+      { text: '묵 계약' },
+      { text: '계약', subject: '견적' },
+      { subject: '계약' },
+      { hasAttachment: true },
+    ]) {
+      expect(planSearch(criteria(overrides)).exactByGrams).toBe(false);
+    }
+  });
+
+  describe('읽기 화면의 강조할 말 (highlightTermsOf — 설계 C2)', () => {
+    it('검색어는 제목 · 본문 · 첨부 이름에, 제목 조건은 제목에, 내용 조건은 본문에', () => {
+      expect(
+        highlightTermsOf({
+          text: '계약',
+          subject: '견적',
+          body: '"단가 조정"',
+        }),
+      ).toEqual({
+        subject: ['계약', '견적'],
+        body: ['계약', '단가 조정'],
+        attachment: ['계약'],
+        query: ['계약'],
+      });
+    });
+
+    it('강조할 말이 없으면 null — 검색어 · 제목 · 내용 조건이 없거나 문장부호뿐', () => {
+      expect(highlightTermsOf({})).toBeNull();
+      expect(highlightTermsOf({ text: '…', subject: '""' })).toBeNull();
+    });
+
+    it('본문에는 목록과 같이 본문을 찾은 낱말만 — 한 글자 낱말뿐이면 제목 · 첨부 이름에만, 섞이면 두 글자 이상 낱말만 (보낸 사람 · 받는 사람 조건도 섞임을 정한다)', () => {
+      expect(highlightTermsOf({ text: '견' })).toEqual({
+        subject: ['견'],
+        body: [],
+        attachment: ['견'],
+        query: ['견'],
+      });
+      expect(highlightTermsOf({ text: '견 계약서' })?.body).toEqual(['계약서']);
+      expect(highlightTermsOf({ text: '견', to: '김아라' })?.body).toEqual([]);
+      // 한 글자 내용 조건뿐 — 찾을 곳이 없어 강조할 말도 없다
+      expect(highlightTermsOf({ body: '견' })).toBeNull();
+      // 목록의 계획과 같은 강조
+      for (const given of [
+        { text: '견' },
+        { text: '견 계약서', subject: '회' },
+        { text: '견', from: '김아라', body: '단가' },
+      ]) {
+        expect(highlightTermsOf(given)).toEqual(
+          planSearch(criteria(given)).highlight,
+        );
+      }
+    });
+  });
+
+  it('검색 글의 NUL 은 U+FFFD 로 — 확인 · 묶음 · 강조가 같은 글자를 쓴다 (리뷰 L2)', () => {
+    const NUL = String.fromCharCode(0);
+    const FFFD = String.fromCharCode(0xfffd);
+    const plan = planSearch(criteria({ text: `계${NUL}약`, body: `a${NUL}b` }));
+    expect(plan.checks.map((check) => check.term)).toEqual([
+      `계${FFFD}약`,
+      `a${FFFD}b`,
+    ]);
+    expect(plan.grams).toEqual([
+      `계${FFFD}`,
+      `${FFFD}약`,
+      `a${FFFD}`,
+      `${FFFD}b`,
+    ]);
+    expect(JSON.stringify(plan)).not.toContain(NUL);
+    expect(plan.highlight.body).toEqual([`계${FFFD}약`, `a${FFFD}b`]);
+  });
+});
diff --git a/backend/src/modules/mail-search/search-plan.ts b/backend/src/modules/mail-search/search-plan.ts
new file mode 100644
index 0000000..3b4ed10
--- /dev/null
+++ b/backend/src/modules/mail-search/search-plan.ts
@@ -0,0 +1,231 @@
+import { parseSearchTerms } from '@/shared/utils/search-query';
+import { foldText, gramsOf, isSpaceCode } from '@/shared/utils/search-text';
+import { SINGLE_CHAR_TERMS_SKIP_BODY } from './mail-search.constants';
+import type { SearchCriteria } from './mail-search.types';
+
+/**
+ * 검색 조건 → 색인에서 찾을 계획 (순수 함수 — 14단계 설계 C1 · G).
+ *
+ * - 검색어(q)의 낱말 · 구절은 다섯 칸(보낸 사람 · 받는 사람(참조 포함) · 제목 · 첨부 이름 · 본문) 가운데 어디든, 조건 칸(from · to · subject · body)의
+ *   낱말 · 구절은 그 칸에서 — 모두 맞아야 한다(AND). 낱말 · 구절 나누기는 엔진 검색과 같다(parseSearchTerms — 큰따옴표 구절 · 앞뒤 문장부호 떼기)
+ * - 낱말마다 접기(foldText) 뒤 부분 일치(strpos)로 확인하고, 모든 낱말의 글자 두 개 묶음(gramsOf)으로 후보를 좁힌다(GIN `grams @>`) —
+ *   낱말이 한 칸 안에 이어 있으니 그 묶음은 늘 그 줄의 묶음 안에 있다
+ * - 한 글자 낱말(묶음이 없는 낱말): 묶음이 있는 낱말과 함께면 확인에만 쓴다. 한 글자 낱말뿐이면(SINGLE_CHAR_TERMS_SKIP_BODY) 본문은 훑지 않는다 —
+ *   검색어의 낱말은 제목 · 사람 · 첨부 이름에서만, 내용(body) 조건의 낱말은 찾을 곳이 없어 아무것도 맞지 않는다
+ * - 글을 준 칸인데 찾을 낱말이 하나도 없으면(문장부호뿐 · 빈 따옴표) 아무것도 맞지 않는다 — 범위 전체를 돌려주지 않는다(엔진 검색과 같다)
+ * - 검색어의 낱말이 모두 두 글자(코드 포인트 둘 · 공백 없음)면 묶음 하나가 곧 그 낱말이다 — 묶음이 맞은 줄은 다섯 칸 가운데 어딘가에 그 낱말이 있다(exactByGrams).
+ *   색인의 묶음은 저장한 접기 칸 그대로에서 만든다(index-document.ts) — 그래서 확인하지 않아도 된다
+ * - 본문(목록 미리 보기 · 읽기 화면)에는 본문을 찾은 낱말만 강조한다(2026-11-06 실사용 시험 — bodyHighlightOf). 제목 · 첨부 이름 강조는 낱말 그대로다
+ */
+
+/** 확인하는 접기 칸 — 표의 열 이름 */
+export type FoldField =
+  | 'fold_from'
+  | 'fold_to'
+  | 'fold_subject'
+  | 'fold_attachment'
+  | 'fold_body';
+
+/** 검색어(q)의 낱말을 찾는 칸 — 다섯 칸 모두 */
+export const ALL_FOLD_FIELDS: readonly FoldField[] = [
+  'fold_from',
+  'fold_to',
+  'fold_subject',
+  'fold_attachment',
+  'fold_body',
+];
+
+/** 조건 칸 → 그 칸의 접기 열 */
+const CONDITION_FIELDS = {
+  from: 'fold_from',
+  to: 'fold_to',
+  subject: 'fold_subject',
+  body: 'fold_body',
+} as const satisfies Record<string, FoldField>;
+
+type ConditionName = keyof typeof CONDITION_FIELDS;
+const CONDITION_NAMES = Object.keys(CONDITION_FIELDS) as ConditionName[];
+
+/** 낱말 하나의 확인 — 접은 낱말이 그 칸들 가운데 하나에 들어 있어야 한다 */
+export interface TermCheck {
+  readonly term: string;
+  readonly fields: readonly FoldField[];
+}
+
+/** 강조할 말 — 원래 낱말 · 구절(접기 전) — 제목 · 본문 · 첨부 이름 */
+export interface HighlightTerms {
+  readonly subject: readonly string[];
+  /** 본문을 찾은 낱말만 (bodyHighlightOf) — 한 글자 낱말은 들지 않는다 */
+  readonly body: readonly string[];
+  readonly attachment: readonly string[];
+  /**
+   * 검색어(q)의 낱말 — 다섯 칸 어디서든 찾는다. 목록 미리 보기가 본문의 인용 안에서만 맞은 말을 다른 칸(제목 · 사람 · 첨부 이름)에서도
+   * 찾았는지 볼 때 쓴다(search-highlight.ts). 내용 조건(body)의 낱말은 본문에서만 찾으므로 들지 않는다
+   */
+  readonly query: readonly string[];
+}
+
+export interface SearchPlan {
+  /** 낱말 확인 — 모두 맞아야 한다. 비었으면 범위 · 기간 · 첨부만으로 찾는다 */
+  readonly checks: readonly TermCheck[];
+  /** 후보를 좁히는 글자 두 개 묶음 — 비었으면 GIN 을 쓰지 못한다 */
+  readonly grams: readonly string[];
+  readonly after: Date | null;
+  readonly before: Date | null;
+  readonly hasAttachment: boolean;
+  /** 아무것도 맞을 수 없다 — 묻지 않고 빈 결과 */
+  readonly matchesNothing: boolean;
+  /** 한 글자 낱말뿐이라 본문을 훑지 않았다 (SINGLE_CHAR_TERMS_SKIP_BODY) */
+  readonly bodySkipped: boolean;
+  /** 묶음만으로 정해진다 — 검색어(다섯 칸)의 두 글자 낱말뿐이라 확인(strpos)이 늘 참이다 */
+  readonly exactByGrams: boolean;
+  readonly highlight: HighlightTerms;
+}
+
+/** 검색인가 — 검색어나 조건이 하나라도 있으면 (빈 글은 없는 것) */
+export function isSearchCriteria(criteria: SearchCriteria): boolean {
+  return (
+    Boolean(criteria.text) ||
+    CONDITION_NAMES.some((name) => Boolean(criteria[name])) ||
+    criteria.after !== undefined ||
+    criteria.before !== undefined ||
+    criteria.hasAttachment === true
+  );
+}
+
+/** 글을 낱말 · 구절로 — 접기 전 글(강조)과 접은 글(확인) */
+function termsOf(text: string | undefined): {
+  readonly given: boolean;
+  readonly raw: string[];
+} {
+  if (!text) return { given: false, raw: [] };
+  return { given: true, raw: parseSearchTerms(text).map((term) => term.text) };
+}
+
+/** 두 글자 낱말인가 — 코드 포인트 둘 · 공백 없음 (그 낱말의 묶음 하나가 곧 그 낱말이다) */
+function isGramWord(term: string): boolean {
+  const points = [...term];
+  return (
+    points.length === 2 &&
+    points.every((point) => !isSpaceCode(point.charCodeAt(0)))
+  );
+}
+
+function dateOf(value: string | undefined): Date | null {
+  if (value === undefined) return null;
+  const time = Date.parse(value);
+  return Number.isNaN(time) ? null : new Date(time);
+}
+
+/** 묶음이 있는 낱말인가 — 접어서 글자 두 개 묶음이 하나라도 나온다 (한 글자 낱말 · 한 글자씩 띄운 구절은 없다) */
+function hasGrams(raw: string): boolean {
+  return gramsOf(foldText(raw)).size > 0;
+}
+
+/**
+ * 본문에 강조할 말 (2026-11-06 실사용 시험) — 본문을 찾은 낱말만이다. 검색어 · 내용 조건의 낱말(`raws`) 가운데
+ * - 한 글자 낱말뿐이라 본문을 훑지 않았으면(bodySkipped) 없다
+ * - 묶음이 있는 낱말(두 글자 이상)이 하나라도 있으면(`anyGrams` — 다섯 칸의 낱말 어디든) 그 낱말만 — 한 글자 낱말은 함께 찾아 본문도 확인했지만
+ *   본문 곳곳에 맞아 미리 보기 · 읽기 화면의 강조가 흩어진다
+ * - 묶음이 하나도 없는데 본문을 훑었으면(SINGLE_CHAR_TERMS_SKIP_BODY 를 끈 때) 모두
+ */
+function bodyHighlightOf(
+  raws: readonly string[],
+  bodySkipped: boolean,
+  anyGrams: boolean,
+): string[] {
+  if (bodySkipped) return [];
+  return anyGrams ? raws.filter(hasGrams) : [...raws];
+}
+
+export function planSearch(criteria: SearchCriteria): SearchPlan {
+  const query = termsOf(criteria.text);
+  const conditions = CONDITION_NAMES.map((name) => ({
+    name,
+    ...termsOf(criteria[name]),
+  }));
+  // 글을 준 칸에 찾을 낱말이 없다 — 아무것도 맞지 않는다
+  let matchesNothing =
+    (query.given && query.raw.length === 0) ||
+    conditions.some(
+      (condition) => condition.given && condition.raw.length === 0,
+    );
+
+  const grams = new Set<string>();
+  const pending: { term: string; fields: readonly FoldField[] }[] = [];
+  const add = (raw: string, fields: readonly FoldField[]) => {
+    const term = foldText(raw);
+    gramsOf(term, grams);
+    pending.push({ term, fields });
+  };
+  for (const raw of query.raw) add(raw, ALL_FOLD_FIELDS);
+  for (const condition of conditions) {
+    for (const raw of condition.raw)
+      add(raw, [CONDITION_FIELDS[condition.name]]);
+  }
+
+  // 한 글자 낱말뿐 — 본문은 훑지 않는다 (제목 · 사람 · 첨부 이름만)
+  const bodySkipped =
+    SINGLE_CHAR_TERMS_SKIP_BODY && pending.length > 0 && grams.size === 0;
+  const seen = new Set<string>();
+  const checks: TermCheck[] = [];
+  for (const check of pending) {
+    const fields = bodySkipped
+      ? check.fields.filter((field) => field !== 'fold_body')
+      : check.fields;
+    if (fields.length === 0) {
+      matchesNothing = true;
+      continue;
+    }
+    const key = `${check.term}\n${fields.join(',')}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    checks.push({ term: check.term, fields });
+  }
+
+  const exactByGrams =
+    checks.length > 0 &&
+    checks.every(
+      (check) =>
+        check.fields.length === ALL_FOLD_FIELDS.length &&
+        isGramWord(check.term),
+    );
+  const subjectTerms = conditions.find((c) => c.name === 'subject')?.raw ?? [];
+  const bodyTerms = conditions.find((c) => c.name === 'body')?.raw ?? [];
+  return {
+    checks,
+    grams: [...grams],
+    after: dateOf(criteria.after),
+    before: dateOf(criteria.before),
+    hasAttachment: criteria.hasAttachment === true,
+    matchesNothing,
+    bodySkipped,
+    exactByGrams,
+    highlight: {
+      subject: [...query.raw, ...subjectTerms],
+      body: bodyHighlightOf(
+        [...query.raw, ...bodyTerms],
+        bodySkipped,
+        grams.size > 0,
+      ),
+      attachment: [...query.raw],
+      query: [...query.raw],
+    },
+  };
+}
+
+/**
+ * 강조할 말만 (읽기 화면 — 설계 C2): 검색어의 낱말은 제목 · 본문 · 첨부 이름에, 제목 조건은 제목에, 내용 조건은 본문에 — 목록과 같은 계획(planSearch)에서 꺼낸다.
+ * 본문에는 본문을 찾은 낱말만(한 글자 낱말 — bodyHighlightOf). 보낸 사람 · 받는 사람 조건은 강조하지 않지만 받는다 — 두 글자 이상 낱말이
+ * 그 칸에만 있어도 한 글자 낱말과 "섞인" 검색이다(목록의 찾기와 같은 판정). 강조할 말이 하나도 없으면 null
+ */
+export function highlightTermsOf(
+  criteria: Pick<SearchCriteria, 'text' | 'from' | 'to' | 'subject' | 'body'>,
+): HighlightTerms | null {
+  const { highlight } = planSearch({ ...criteria, hasAttachment: false });
+  // 첨부 이름의 말(검색어)은 늘 제목의 말 안에 든다
+  if (highlight.subject.length === 0 && highlight.body.length === 0) {
+    return null;
+  }
+  return highlight;
+}
diff --git a/backend/src/modules/mail-search/search-sql.spec.ts b/backend/src/modules/mail-search/search-sql.spec.ts
new file mode 100644
index 0000000..56528b0
--- /dev/null
+++ b/backend/src/modules/mail-search/search-sql.spec.ts
@@ -0,0 +1,196 @@
+import type { SearchCriteria, SearchScope } from './mail-search.types';
+import { planSearch } from './search-plan';
+import {
+  candidatesSql,
+  checkHitsSql,
+  highlightTextsSql,
+  keysetCountSql,
+  keysetFrontierSql,
+  keysetHitsSql,
+  plainCountSql,
+  plainPageSql,
+} from './search-sql';
+
+const USER = 'ara.kim@arasystem.test';
+const ALL: SearchScope = {
+  mailboxId: null,
+  excludedMailboxIds: ['b', 'c'],
+  excludedKeywords: ['$ara-sending'],
+};
+const INBOX: SearchScope = {
+  mailboxId: 'a',
+  excludedMailboxIds: [],
+  excludedKeywords: [],
+};
+
+const plan = (overrides: Partial<SearchCriteria>) =>
+  planSearch({ hasAttachment: false, ...overrides });
+
+/** SQL 의 공백을 하나로 (비교 편하게) */
+const flat = (sql: string) => sql.replace(/\s+/g, ' ');
+
+describe('색인 찾기의 SQL (search-sql — 14단계 설계 G)', () => {
+  it('후보 — 주소(찾기 GIN 의 lower 식) · 빼는 메일함 · 빼는 키워드 · 묶음만으로 받은 시각 최신부터 limit 줄 (확인하지 않는다), 값은 모두 매개변수', () => {
+    const query = candidatesSql(
+      USER,
+      ALL,
+      plan({ text: '계약 갱신' }),
+      null,
+      3_001,
+    );
+
+    expect(flat(query.sql)).toBe(
+      'SELECT "email_id", "received_at" FROM "mail_search_messages" WHERE lower("user_email") = $1 ' +
+        'AND NOT ("mailbox_ids" <@ $2::text[]) AND NOT ("keywords" && $3::text[]) AND "grams" @> $4::text[] ' +
+        'ORDER BY "received_at" DESC, "email_id" DESC LIMIT $5',
+    );
+    expect(query.params).toEqual([
+      USER,
+      ['b', 'c'],
+      ['$ara-sending'],
+      ['계약', '갱신'],
+      3_001,
+    ]);
+    // 주소 그대로("user_email" = …)는 btree 로 그 직원의 줄을 다 읽게 둔다 — 후보 쿼리에는 쓰지 않는다
+    expect(query.sql).not.toContain('"user_email" =');
+    expect(query.sql).not.toContain('strpos');
+  });
+
+  it('메일함 범위는 찾기 GIN 이 함께 맞추는 꼴(@>) — = ANY 로 적으면 그 직원의 묶음 줄을 모두 읽고 메일함을 줄마다 거른다 (2026-11-06 실사용 시험), 기간 · 첨부 · 이어 찾을 자리(받은 시각 · id 가 더 작은 쪽)', () => {
+    const after = {
+      receivedAt: new Date('2026-11-01T00:00:00Z'),
+      emailId: 'm9',
+    };
+    const query = candidatesSql(
+      USER,
+      INBOX,
+      plan({
+        text: '계약',
+        after: '2026-10-31T15:00:00.000Z',
+        before: '2026-11-30T15:00:00.000Z',
+        hasAttachment: true,
+      }),
+      after,
+      10,
+    );
+
+    expect(flat(query.sql)).toContain(
+      'lower("user_email") = $1 AND "mailbox_ids" @> $2::text[] AND "received_at" >= $3::timestamptz AND "received_at" < $4::timestamptz ' +
+        'AND "has_attachment" AND ("received_at", "email_id") < ($5::timestamptz, $6) AND "grams" @> $7::text[]',
+    );
+    expect(query.sql).not.toContain('ANY("mailbox_ids")');
+    expect(query.params).toEqual([
+      USER,
+      ['a'],
+      new Date('2026-10-31T15:00:00.000Z'),
+      new Date('2026-11-30T15:00:00.000Z'),
+      after.receivedAt,
+      'm9',
+      ['계약'],
+      10,
+    ]);
+  });
+
+  it('확인 — 후보 id 의 줄만 기본 키로 읽어 낱말마다 그 칸들 가운데 하나의 strpos', () => {
+    const query = checkHitsSql(USER, plan({ text: '계약', from: '이도윤' }), [
+      'm1',
+      'm2',
+    ]);
+
+    expect(flat(query.sql)).toBe(
+      'SELECT "email_id" FROM "mail_search_messages" WHERE "user_email" = $1 AND "email_id" = ANY($2::text[]) ' +
+        'AND (strpos("fold_from", $3) > 0 OR strpos("fold_to", $3) > 0 OR strpos("fold_subject", $3) > 0 ' +
+        'OR strpos("fold_attachment", $3) > 0 OR strpos("fold_body", $3) > 0) AND (strpos("fold_from", $4) > 0)',
+    );
+    expect(query.params).toEqual([USER, ['m1', 'm2'], '계약', '이도윤']);
+  });
+
+  it('묶음이 없는 찾기(한 글자 낱말뿐) — 안쪽에서 확인 상한만큼 받은 차례로 자른 뒤 바깥에서 확인하고 쪽 크기에서 멈춘다, 묶음은 보지 않는다', () => {
+    const query = keysetHitsSql(
+      USER,
+      INBOX,
+      plan({ text: '묵' }),
+      null,
+      3_000,
+      21,
+    );
+    const sql = flat(query.sql);
+
+    expect(sql).toMatch(
+      /^SELECT "email_id", "received_at" FROM \(SELECT "email_id", "received_at", "fold_from", "fold_to", "fold_subject", "fold_attachment", "fold_body" FROM "mail_search_messages" WHERE "user_email" = \$1 AND "mailbox_ids" @> \$2::text\[\] ORDER BY "received_at" DESC, "email_id" DESC LIMIT \$3\) AS "scan" WHERE \(strpos\("fold_from", \$4\) > 0 .+\) ORDER BY "received_at" DESC, "email_id" DESC LIMIT \$5$/,
+    );
+    expect(sql).not.toContain('"grams"');
+    // 본문은 훑지 않는다 (SINGLE_CHAR_TERMS_SKIP_BODY)
+    expect(sql).not.toContain('strpos("fold_body"');
+    expect(query.params.slice(2)).toEqual([3_000, '묵', 21]);
+  });
+
+  it('훑은 창의 끝 · 창 안의 맞은 수 — 끝은 확인 없이 그 창의 가장 오래된 줄과 줄 수, 수는 countLimit 까지', () => {
+    const frontier = keysetFrontierSql(
+      USER,
+      INBOX,
+      plan({ text: '묵' }),
+      null,
+      3_000,
+    );
+    expect(flat(frontier.sql)).toMatch(
+      /^SELECT "email_id", "received_at", count\(\*\) OVER \(\)::int AS "scanned" FROM \(SELECT "email_id", "received_at" FROM .+ LIMIT \$3\) AS "scan" ORDER BY "received_at" ASC, "email_id" ASC LIMIT 1$/,
+    );
+    expect(frontier.sql).not.toContain('strpos');
+
+    const count = keysetCountSql(
+      USER,
+      INBOX,
+      plan({ text: '묵' }),
+      3_000,
+      1_001,
+    );
+    expect(flat(count.sql)).toMatch(
+      /^SELECT count\(\*\)::int AS "count" FROM \(SELECT 1 FROM \(SELECT .+ LIMIT \$3\) AS "scan" WHERE .+strpos.+ LIMIT \$5\) AS "hits"$/,
+    );
+    expect(count.params.slice(2)).toEqual([3_000, '묵', 1_001]);
+  });
+
+  it('낱말 확인이 없을 때(기간 · 첨부만) — 묶음 · strpos 없이 받은 차례로 · 수도 같은 조건으로', () => {
+    const only = plan({ hasAttachment: true });
+    const page = plainPageSql(USER, ALL, only, null, 21);
+    expect(flat(page.sql)).toBe(
+      'SELECT "email_id", "received_at" FROM "mail_search_messages" WHERE "user_email" = $1 AND NOT ("mailbox_ids" <@ $2::text[]) ' +
+        'AND NOT ("keywords" && $3::text[]) AND "has_attachment" ORDER BY "received_at" DESC, "email_id" DESC LIMIT $4',
+    );
+    const count = plainCountSql(USER, ALL, only, 1_001);
+    expect(flat(count.sql)).toContain(
+      'AND "has_attachment" LIMIT $4) AS "matches"',
+    );
+    expect(count.params).toEqual([USER, ['b', 'c'], ['$ara-sending'], 1_001]);
+  });
+
+  it('검색 글은 SQL 에 이어 붙이지 않는다 — 따옴표 · 세미콜론이 든 낱말도 매개변수로만', () => {
+    const hostile = `x'); DROP TABLE users; --`;
+    const checked = [
+      checkHitsSql(USER, plan({ text: hostile }), ['m1']),
+      keysetHitsSql(USER, ALL, plan({ subject: hostile }), null, 10, 10),
+    ];
+    for (const query of [
+      ...checked,
+      candidatesSql(USER, ALL, plan({ body: hostile }), null, 10),
+    ]) {
+      expect(query.sql).not.toMatch(/drop|users|x'/i);
+    }
+    // 낱말은 접은 글로 매개변수에만 (앞뒤 문장부호를 뗀 x · drop · table · users)
+    for (const query of checked) {
+      expect(query.params).toEqual(
+        expect.arrayContaining(['x', 'drop', 'table', 'users']),
+      );
+    }
+  });
+
+  it('강조에 쓰는 글 — 그 직원의 찾은 줄만 (본문 밖의 접은 칸 넷도 — 미리 보기가 인용 안에서만 맞은 말을 다른 칸에서 찾았는지 본다)', () => {
+    const query = highlightTextsSql(USER, ['m1', 'm2']);
+    expect(flat(query.sql)).toBe(
+      'SELECT "email_id", "subject", "body_text", "preview", "fold_from", "fold_to", "fold_subject", "fold_attachment" ' +
+        'FROM "mail_search_messages" WHERE "user_email" = $1 AND "email_id" = ANY($2::text[])',
+    );
+    expect(query.params).toEqual([USER, ['m1', 'm2']]);
+  });
+});
diff --git a/backend/src/modules/mail-search/search-sql.ts b/backend/src/modules/mail-search/search-sql.ts
new file mode 100644
index 0000000..210cbb8
--- /dev/null
+++ b/backend/src/modules/mail-search/search-sql.ts
@@ -0,0 +1,279 @@
+import { SEARCH_MESSAGES_TABLE } from './mail-search.constants';
+import type { SearchScope } from './mail-search.types';
+import type { SearchPlan } from './search-plan';
+
+/**
+ * 색인 찾기의 SQL (순수 함수 — 14단계 설계 G). 값은 모두 매개변수다 — 글 · 주소를 SQL 에 이어 붙이지 않는다.
+ *
+ * 줄의 글(묶음 배열 · 접은 본문)은 TOAST 에 있어 줄마다 풀면 비싸다(0.1~0.3ms). 그래서 쿼리를 둘로 나눈다:
+ * - 후보(candidatesSql): 주소 + 묶음 + 메일함을 GIN 하나(`IDX_mail_search_messages_user_grams_mailboxes` — 마이그레이션 SearchIndexUserGramsMailboxes)에서만
+ *   거른다 — 주소를 `lower("user_email")` 식으로 적어(색인과 같은 식) 다른 색인을 쓸 수 없게 한다. 메일함 범위는 `"mailbox_ids" @> $n` 그대로 둔다 —
+ *   같은 GIN 이 메일함까지 맞춰 맞은 줄만 읽는다(`= ANY` 로 적으면 그 직원의 그 묶음 줄을 모두 읽고 메일함을 줄마다 거른다).
+ *   주소 그대로면 계획기가 흔한 묶음에서 주소의 btree 로 그 직원의 줄을 모두 읽고 묶음을 줄마다 풀었다(2026-11-05 측정 — 260~700ms → 10ms).
+ *   메일함만 담은 GIN 이 있던 때는 계획기가 그것만으로 메일함의 줄을 모두 읽고 묶음을 줄마다 풀었다(2026-11-06 실사용 시험 — 1만 통 메일함 안 1.1초).
+ *   줄에서는 작은 칸(받은 시각 · 메일함 · 키워드 · 첨부)만 읽는다
+ * - 확인(checkHitsSql): 받은 후보 id 의 줄만 기본 키로 읽어 낱말을 strpos 로 본다
+ * 묶음이 없는 찾기(한 글자 낱말뿐 — 본문을 훑지 않는다)는 받은 차례(keyset — btree)로 값싼 칸만 확인하고, 낱말 확인이 없는 찾기(기간 · 첨부만)는
+ * 받은 차례로 바로 읽는다.
+ */
+
+const TABLE = `"${SEARCH_MESSAGES_TABLE}"`;
+/** 받은 시각 최신부터 (같은 시각은 id 로) — 색인 IDX_mail_search_messages_received 의 거꾸로 */
+const NEWEST_FIRST = '"received_at" DESC, "email_id" DESC';
+const OLDEST_FIRST = '"received_at" ASC, "email_id" ASC';
+/** 확인에 쓰는 접기 칸 — 안쪽 쿼리가 바깥으로 넘긴다 */
+const FOLD_COLUMNS =
+  '"fold_from", "fold_to", "fold_subject", "fold_attachment", "fold_body"';
+
+/** 이어 찾을 자리 — 이 줄 다음(받은 시각 · id 가 더 작은 쪽)부터 */
+export interface SearchPosition {
+  readonly receivedAt: Date;
+  readonly emailId: string;
+}
+
+export interface SqlQuery {
+  readonly sql: string;
+  readonly params: unknown[];
+}
+
+/** 매개변수를 차례로 쌓는다 */
+class Params {
+  readonly values: unknown[] = [];
+
+  add(value: unknown): string {
+    this.values.push(value);
+    return `$${this.values.length}`;
+  }
+}
+
+/**
+ * 직원을 거르는 길 — `gin`: 찾기 GIN 의 식(lower)으로 묶음 · 메일함과 함께(후보), `btree`: 주소 그대로(받은 차례 · 기본 키 —
+ * 메일함 조건은 줄을 읽은 뒤 거른다. 이 길의 쿼리는 bitmap 을 끈다)
+ * 표의 주소는 늘 소문자라 두 식은 같은 줄을 고른다
+ */
+type UserMatch = 'gin' | 'btree';
+
+/** 값싼 조건 — 직원 · 범위 · 기간 · 첨부 · 빼는 키워드 · 이어 찾을 자리 (`gin` 이면 묶음도) */
+function cheapConditions(
+  params: Params,
+  user: string,
+  scope: SearchScope,
+  plan: SearchPlan,
+  after: SearchPosition | null,
+  userMatch: UserMatch,
+): string {
+  const where = [
+    userMatch === 'gin'
+      ? `lower("user_email") = ${params.add(user)}`
+      : `"user_email" = ${params.add(user)}`,
+  ];
+  if (scope.mailboxId !== null) {
+    where.push(`"mailbox_ids" @> ${params.add([scope.mailboxId])}::text[]`);
+  }
+  if (scope.excludedMailboxIds.length > 0) {
+    // 빼는 메일함에만 든 메일을 뺀다 — 다른 메일함에도 있으면 찾는다 (엔진의 inMailboxOtherThan 과 같다)
+    where.push(
+      `NOT ("mailbox_ids" <@ ${params.add([...scope.excludedMailboxIds])}::text[])`,
+    );
+  }
+  if (scope.excludedKeywords.length > 0) {
+    where.push(
+      `NOT ("keywords" && ${params.add([...scope.excludedKeywords])}::text[])`,
+    );
+  }
+  if (plan.after !== null) {
+    where.push(`"received_at" >= ${params.add(plan.after)}::timestamptz`);
+  }
+  if (plan.before !== null) {
+    where.push(`"received_at" < ${params.add(plan.before)}::timestamptz`);
+  }
+  if (plan.hasAttachment) where.push('"has_attachment"');
+  if (after !== null) {
+    where.push(
+      `("received_at", "email_id") < (${params.add(after.receivedAt)}::timestamptz, ${params.add(after.emailId)})`,
+    );
+  }
+  if (userMatch === 'gin') {
+    where.push(`"grams" @> ${params.add([...plan.grams])}::text[]`);
+  }
+  return where.join(' AND ');
+}
+
+/** 낱말 확인 — 낱말마다 그 칸들 가운데 하나에 들어 있어야 한다 (모두 AND, 확인할 낱말이 없으면 늘 참) */
+function checkConditions(params: Params, plan: SearchPlan): string {
+  if (plan.checks.length === 0) return 'TRUE';
+  return plan.checks
+    .map((check) => {
+      const term = params.add(check.term);
+      return `(${check.fields.map((field) => `strpos("${field}", ${term}) > 0`).join(' OR ')})`;
+    })
+    .join(' AND ');
+}
+
+/** 후보 — 주소 + 묶음 + 메일함(GIN 하나)과 값싼 조건만으로 받은 시각 최신부터 `limit` 줄 (확인하지 않는다 — 묶음이 있는 계획만) */
+export function candidatesSql(
+  user: string,
+  scope: SearchScope,
+  plan: SearchPlan,
+  after: SearchPosition | null,
+  limit: number,
+): SqlQuery {
+  const params = new Params();
+  const where = cheapConditions(params, user, scope, plan, after, 'gin');
+  return {
+    sql: `SELECT "email_id", "received_at" FROM ${TABLE} WHERE ${where} ORDER BY ${NEWEST_FIRST} LIMIT ${params.add(limit)}`,
+    params: params.values,
+  };
+}
+
+/** 확인 — 후보 id 가운데 낱말이 모두 맞은 줄의 id (기본 키로 그 줄만 읽는다) */
+export function checkHitsSql(
+  user: string,
+  plan: SearchPlan,
+  ids: readonly string[],
+): SqlQuery {
+  const params = new Params();
+  const where = `"user_email" = ${params.add(user)} AND "email_id" = ANY(${params.add([...ids])}::text[])`;
+  const checks = checkConditions(params, plan);
+  return {
+    sql: `SELECT "email_id" FROM ${TABLE} WHERE ${where} AND ${checks}`,
+    params: params.values,
+  };
+}
+
+/** 받은 차례 쿼리의 안쪽 — 값싼 조건을 지난 줄을 최신부터 `scanLimit` 까지 (묶음은 보지 않는다) */
+function scanSubquery(
+  params: Params,
+  user: string,
+  scope: SearchScope,
+  plan: SearchPlan,
+  after: SearchPosition | null,
+  scanLimit: number,
+  columns: string,
+): string {
+  const where = cheapConditions(params, user, scope, plan, after, 'btree');
+  return `SELECT ${columns} FROM ${TABLE} WHERE ${where} ORDER BY ${NEWEST_FIRST} LIMIT ${params.add(scanLimit)}`;
+}
+
+/**
+ * 묶음이 없는 찾기(한 글자 낱말뿐) — 받은 차례로 `scanLimit` 줄까지 확인하며 맞은 줄을 `pageLimit` 개까지 (차면 멈춘다).
+ * 묶음 배열을 줄마다 풀지 않게 묶음이 있는 계획에는 쓰지 않는다(candidatesSql)
+ */
+export function keysetHitsSql(
+  user: string,
+  scope: SearchScope,
+  plan: SearchPlan,
+  after: SearchPosition | null,
+  scanLimit: number,
+  pageLimit: number,
+): SqlQuery {
+  const params = new Params();
+  const scan = scanSubquery(
+    params,
+    user,
+    scope,
+    plan,
+    after,
+    scanLimit,
+    `"email_id", "received_at", ${FOLD_COLUMNS}`,
+  );
+  const checks = checkConditions(params, plan);
+  return {
+    sql: `SELECT "email_id", "received_at" FROM (${scan}) AS "scan" WHERE ${checks} ORDER BY ${NEWEST_FIRST} LIMIT ${params.add(pageLimit)}`,
+    params: params.values,
+  };
+}
+
+/** 받은 차례로 훑은 창의 끝 — 그 창의 마지막 줄과 줄 수 (확인하지 않는다 — 다 훑었는지 · 이어 찾을 자리) */
+export function keysetFrontierSql(
+  user: string,
+  scope: SearchScope,
+  plan: SearchPlan,
+  after: SearchPosition | null,
+  scanLimit: number,
+): SqlQuery {
+  const params = new Params();
+  const scan = scanSubquery(
+    params,
+    user,
+    scope,
+    plan,
+    after,
+    scanLimit,
+    '"email_id", "received_at"',
+  );
+  return {
+    sql: `SELECT "email_id", "received_at", count(*) OVER ()::int AS "scanned" FROM (${scan}) AS "scan" ORDER BY ${OLDEST_FIRST} LIMIT 1`,
+    params: params.values,
+  };
+}
+
+/** 받은 차례로 훑은 창 안의 맞은 줄 수 — `countLimit` 까지 */
+export function keysetCountSql(
+  user: string,
+  scope: SearchScope,
+  plan: SearchPlan,
+  scanLimit: number,
+  countLimit: number,
+): SqlQuery {
+  const params = new Params();
+  const scan = scanSubquery(
+    params,
+    user,
+    scope,
+    plan,
+    null,
+    scanLimit,
+    `"email_id", "received_at", ${FOLD_COLUMNS}`,
+  );
+  const checks = checkConditions(params, plan);
+  return {
+    sql: `SELECT count(*)::int AS "count" FROM (SELECT 1 FROM (${scan}) AS "scan" WHERE ${checks} LIMIT ${params.add(countLimit)}) AS "hits"`,
+    params: params.values,
+  };
+}
+
+/** 낱말 확인이 없을 때(기간 · 첨부 · 메일함만) — 받은 차례로 `pageLimit` 개 */
+export function plainPageSql(
+  user: string,
+  scope: SearchScope,
+  plan: SearchPlan,
+  after: SearchPosition | null,
+  pageLimit: number,
+): SqlQuery {
+  const params = new Params();
+  const where = cheapConditions(params, user, scope, plan, after, 'btree');
+  return {
+    sql: `SELECT "email_id", "received_at" FROM ${TABLE} WHERE ${where} ORDER BY ${NEWEST_FIRST} LIMIT ${params.add(pageLimit)}`,
+    params: params.values,
+  };
+}
+
+/** 낱말 확인이 없을 때의 수 — `countLimit` 까지 */
+export function plainCountSql(
+  user: string,
+  scope: SearchScope,
+  plan: SearchPlan,
+  countLimit: number,
+): SqlQuery {
+  const params = new Params();
+  const where = cheapConditions(params, user, scope, plan, null, 'btree');
+  return {
+    sql: `SELECT count(*)::int AS "count" FROM (SELECT 1 FROM ${TABLE} WHERE ${where} LIMIT ${params.add(countLimit)}) AS "matches"`,
+    params: params.values,
+  };
+}
+
+/**
+ * 강조에 쓰는 글 — 찾은 쪽의 줄만. 본문 밖의 접은 칸(보낸 사람 · 받는 사람과 참조 · 제목 · 첨부 이름)은 미리 보기를 고를 때
+ * 본문의 인용 안에서만 맞은 말을 그 칸에서도 찾았는지 본다(search-highlight.ts)
+ */
+export function highlightTextsSql(
+  user: string,
+  ids: readonly string[],
+): SqlQuery {
+  return {
+    sql: `SELECT "email_id", "subject", "body_text", "preview", "fold_from", "fold_to", "fold_subject", "fold_attachment" FROM ${TABLE} WHERE "user_email" = $1 AND "email_id" = ANY($2::text[])`,
+    params: [user, [...ids]],
+  };
+}
diff --git a/backend/src/modules/mail-search/thread-keys.spec.ts b/backend/src/modules/mail-search/thread-keys.spec.ts
new file mode 100644
index 0000000..40988f2
--- /dev/null
+++ b/backend/src/modules/mail-search/thread-keys.spec.ts
@@ -0,0 +1,59 @@
+import { startCpuTimer } from '@/../test/cpu-time';
+import { mergeThreadKeys } from './thread-keys';
+
+describe('대화 키 합치기 (mergeThreadKeys — 14단계 설계 B4)', () => {
+  it('이어진 두 키는 작은 키로 — 바뀌는 쪽만 돌려준다', () => {
+    expect([...mergeThreadKeys([['m9', 'm2']])]).toEqual([['m9', 'm2']]);
+    expect([...mergeThreadKeys([['m2', 'm9']])]).toEqual([['m9', 'm2']]);
+  });
+
+  it('잇닿은 쌍은 하나로 — 대화 전체가 가장 작은 키 (늦게 온 원본이 두 답장을 잇는 꼴)', () => {
+    const renames = mergeThreadKeys([
+      ['reply-b', 'orig-z'],
+      ['reply-a', 'orig-z'],
+      ['reply-c', 'reply-b'],
+    ]);
+    // 키는 글자 차례로 견준다 — 'orig-z' < 'reply-a'
+    expect(Object.fromEntries(renames)).toEqual({
+      'reply-a': 'orig-z',
+      'reply-b': 'orig-z',
+      'reply-c': 'orig-z',
+    });
+  });
+
+  it('따로인 대화는 따로 — 쌍의 차례와 상관없이 같은 결과', () => {
+    const links: [string, string][] = [
+      ['b', 'a'],
+      ['y', 'x'],
+      ['c', 'b'],
+      ['z', 'y'],
+    ];
+    const expected = { b: 'a', c: 'a', y: 'x', z: 'x' };
+    expect(Object.fromEntries(mergeThreadKeys(links))).toEqual(expected);
+    expect(Object.fromEntries(mergeThreadKeys([...links].reverse()))).toEqual(
+      expected,
+    );
+  });
+
+  it('같은 키끼리 · 빈 쌍은 바꿀 것이 없다', () => {
+    expect(mergeThreadKeys([])).toEqual(new Map());
+    expect(mergeThreadKeys([['a', 'a']])).toEqual(new Map());
+  });
+
+  it('긴 사슬도 쌍 수에 비례한다 (CPU 시간)', () => {
+    const links = Array.from(
+      { length: 50_000 },
+      (_, index) =>
+        [
+          `k${String(index + 1).padStart(6, '0')}`,
+          `k${String(index).padStart(6, '0')}`,
+        ] as const,
+    );
+    const cpuMs = startCpuTimer();
+    const renames = mergeThreadKeys(links);
+    // 지금 수십 ms — 부하를 견디게 10배 넘게
+    expect(cpuMs()).toBeLessThan(1_000);
+    expect(renames.size).toBe(50_000);
+    expect(new Set(renames.values())).toEqual(new Set(['k000000']));
+  });
+});
diff --git a/backend/src/modules/mail-search/thread-keys.ts b/backend/src/modules/mail-search/thread-keys.ts
new file mode 100644
index 0000000..28eab96
--- /dev/null
+++ b/backend/src/modules/mail-search/thread-keys.ts
@@ -0,0 +1,46 @@
+/**
+ * 대화 키 합치기 (순수 함수 — 14단계 설계 B4).
+ * 색인 줄마다 대화 키(thread_key)가 있다 — 처음에는 그 메일의 id 다. 이어진 메일(답장 관계 + 말머리를 뗀 제목이 같음)을 찾으면
+ * 두 키의 줄을 모두 **가장 작은 키**로 바꾼다. 이미 합친 대화는 한 키를 나눠 쓰므로, 새로 들어온 메일과 바로 이어진 메일의 키만 합치면
+ * 대화 전체가 한 키가 된다(늦게 온 원본이 둘로 갈려 있던 답장들을 잇는 것도 같다).
+ *
+ * `links` 는 [키, 키] 쌍들 — 이어진 두 메일의 지금 키. 돌려주는 것은 바꿀 키 → 새 키(가장 작은 키)이다. 바꿀 것이 없으면 빈 Map.
+ * 쌍 수에 거의 비례한다(경로 줄이기 · 크기로 잇기).
+ */
+export function mergeThreadKeys(
+  links: readonly (readonly [string, string])[],
+): Map<string, string> {
+  const parent = new Map<string, string>();
+  const find = (key: string): string => {
+    let root = key;
+    for (;;) {
+      const up = parent.get(root);
+      if (up === undefined || up === root) break;
+      root = up;
+    }
+    // 지나온 키를 뿌리에 바로 잇는다 (다음 찾기가 짧게)
+    let node = key;
+    while (node !== root) {
+      const up = parent.get(node) as string;
+      parent.set(node, root);
+      node = up;
+    }
+    return root;
+  };
+  for (const [a, b] of links) {
+    if (!parent.has(a)) parent.set(a, a);
+    if (!parent.has(b)) parent.set(b, b);
+    const rootA = find(a);
+    const rootB = find(b);
+    if (rootA === rootB) continue;
+    // 가장 작은 키가 뿌리가 되게 — 합친 대화의 키는 늘 그 대화의 가장 작은 키다
+    if (rootA < rootB) parent.set(rootB, rootA);
+    else parent.set(rootA, rootB);
+  }
+  const renames = new Map<string, string>();
+  for (const key of parent.keys()) {
+    const root = find(key);
+    if (root !== key) renames.set(key, root);
+  }
+  return renames;
+}
diff --git a/backend/src/modules/mail-user-settings/dto/mail-user-settings.dto.spec.ts b/backend/src/modules/mail-user-settings/dto/mail-user-settings.dto.spec.ts
index e52d968..7770471 100644
--- a/backend/src/modules/mail-user-settings/dto/mail-user-settings.dto.spec.ts
+++ b/backend/src/modules/mail-user-settings/dto/mail-user-settings.dto.spec.ts
@@ -46,4 +46,15 @@ describe('보내기 · 읽기 설정 PATCH 본문 (MailUserSettingsPatchDto)', (
       'whitelistValidation',
     ]);
   });
+
+  it('대화로 묶어 보기(14단계)는 참 · 거짓만 — 글로 쓴 값 · 숫자 · null 은 형식 오류', async () => {
+    for (const groupByConversation of [true, false]) {
+      expect(await constraintsOf({ groupByConversation })).toEqual([]);
+    }
+    for (const groupByConversation of ['true', 1, 0, null, 'on']) {
+      expect(await constraintsOf({ groupByConversation })).toEqual([
+        'isBoolean',
+      ]);
+    }
+  });
 });
diff --git a/backend/src/modules/mail-user-settings/dto/mail-user-settings.dto.ts b/backend/src/modules/mail-user-settings/dto/mail-user-settings.dto.ts
index 73f5850..3ca5bda 100644
--- a/backend/src/modules/mail-user-settings/dto/mail-user-settings.dto.ts
+++ b/backend/src/modules/mail-user-settings/dto/mail-user-settings.dto.ts
@@ -1,5 +1,5 @@
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
-import { IsIn, ValidateIf } from 'class-validator';
+import { IsBoolean, IsIn, ValidateIf } from 'class-validator';
 
 import {
   EXTERNAL_IMAGE_MODES,
@@ -16,6 +16,8 @@ const whenSent = (_object: object, value: unknown) => value !== undefined;
 const UNDO_DESCRIPTION =
   `보내기 취소 — [보내기]를 누른 뒤 메일 서버가 이 초만큼 붙잡았다가 보낸다(${UNDO_SEND_SECONDS_CHOICES.join(' · ')} — 0 이면 바로 보낸다). 처음 10. ` +
   '예약 발송에는 더하지 않는다';
+const GROUP_DESCRIPTION =
+  '목록을 대화로 묶어 보기(14단계) — true 면 화면이 메일함 목록을 GET /api/conversations 로 받는다. 처음 false. 검색 결과는 묶지 않는다';
 const IMAGES_DESCRIPTION =
   '외부 이미지 — ask 늘 묻기(처음 값) · trusted 보낸 사람이 내 주소록이나 사내 목록(직원 · 공용 주소)에 있으면 늘 보기 · always 늘 보기. ' +
   '스팸메일함의 메일은 설정과 상관없이 묻는다(images=show 로만 보인다)';
@@ -35,6 +37,9 @@ export class MailUserSettingsDto implements MailUserSettings {
     example: 'ask',
   })
   externalImages!: ExternalImageMode;
+
+  @ApiProperty({ description: GROUP_DESCRIPTION, example: false })
+  groupByConversation!: boolean;
 }
 
 /**
@@ -63,4 +68,9 @@ export class MailUserSettingsPatchDto implements MailUserSettingsPatch {
     message: '외부 이미지 설정을 다시 골라 주세요.',
   })
   externalImages?: ExternalImageMode;
+
+  @ApiPropertyOptional({ description: GROUP_DESCRIPTION, example: true })
+  @ValidateIf(whenSent)
+  @IsBoolean({ message: '대화로 묶어 보기를 다시 골라 주세요.' })
+  groupByConversation?: boolean;
 }
diff --git a/backend/src/modules/mail-user-settings/mail-user-settings.controller.ts b/backend/src/modules/mail-user-settings/mail-user-settings.controller.ts
index 98dc12c..2eb1377 100644
--- a/backend/src/modules/mail-user-settings/mail-user-settings.controller.ts
+++ b/backend/src/modules/mail-user-settings/mail-user-settings.controller.ts
@@ -33,7 +33,7 @@ export class MailUserSettingsController {
   @ApiOperation({
     summary: '보내기 · 읽기 설정',
     description:
-      '저장한 적 없으면 처음 값 { undoSendSeconds: 10, externalImages: "ask" } 이다. 서버는 발송 때 undoSendSeconds, 메일을 읽을 때 externalImages 를 본다.',
+      '저장한 적 없으면 처음 값 { undoSendSeconds: 10, externalImages: "ask", groupByConversation: false } 이다. 서버는 발송 때 undoSendSeconds, 메일을 읽을 때 externalImages 를 본다. groupByConversation 은 화면만 본다(14단계).',
   })
   @ApiStandardResponse(MailUserSettingsDto, { description: '지금 설정' })
   get(@CurrentUser() user: AuthenticatedUser) {
@@ -49,7 +49,7 @@ export class MailUserSettingsController {
   @ApiStandardResponse(MailUserSettingsDto, { description: '바꾼 뒤의 설정' })
   @ApiErrorResponse(
     'VAL_001',
-    '빈 바꾸기 · 고를 수 없는 값(보내기 취소 0 · 5 · 10 · 20 · 30 밖, 외부 이미지 ask · trusted · always 밖, null) · 모르는 필드',
+    '빈 바꾸기 · 고를 수 없는 값(보내기 취소 0 · 5 · 10 · 20 · 30 밖, 외부 이미지 ask · trusted · always 밖, 대화로 묶기가 true · false 아님, null) · 모르는 필드',
   )
   update(
     @CurrentUser() user: AuthenticatedUser,
@@ -58,6 +58,7 @@ export class MailUserSettingsController {
     return this.settings.update(user.email, {
       undoSendSeconds: dto.undoSendSeconds,
       externalImages: dto.externalImages,
+      groupByConversation: dto.groupByConversation,
     });
   }
 }
diff --git a/backend/src/modules/mail-user-settings/mail-user-settings.entity.ts b/backend/src/modules/mail-user-settings/mail-user-settings.entity.ts
index 291139d..f57b520 100644
--- a/backend/src/modules/mail-user-settings/mail-user-settings.entity.ts
+++ b/backend/src/modules/mail-user-settings/mail-user-settings.entity.ts
@@ -32,6 +32,13 @@ export class MailUserSettingsEntity {
   })
   externalImages!: string;
 
+  /**
+   * 목록을 대화로 묶어 보기 (14단계 — 기본 끔). 열은 14단계 1차의 마이그레이션(AddMailSearchIndex)이 만들고,
+   * 읽고 바꾸는 API(GET · PATCH /api/mail-settings 의 groupByConversation)는 3차에 더한다
+   */
+  @Column({ name: 'group_by_conversation', type: 'boolean', default: false })
+  groupByConversation!: boolean;
+
   @Column({ name: 'updated_at', type: 'timestamptz' })
   updatedAt!: Date;
 }
diff --git a/backend/src/modules/mail-user-settings/mail-user-settings.repository.ts b/backend/src/modules/mail-user-settings/mail-user-settings.repository.ts
index b0e40ec..986f46c 100644
--- a/backend/src/modules/mail-user-settings/mail-user-settings.repository.ts
+++ b/backend/src/modules/mail-user-settings/mail-user-settings.repository.ts
@@ -12,6 +12,7 @@ import type {
 const COLUMNS: Readonly<Record<keyof MailUserSettings, string>> = {
   undoSendSeconds: 'undo_send_seconds',
   externalImages: 'external_images',
+  groupByConversation: 'group_by_conversation',
 };
 
 /** RETURNING 한 줄 (열 이름이 키다) */
@@ -19,6 +20,7 @@ interface ReturnedRow {
   readonly user_email: string;
   readonly undo_send_seconds: number;
   readonly external_images: string;
+  readonly group_by_conversation: boolean;
   readonly updated_at: Date;
 }
 
@@ -58,6 +60,8 @@ export class MailUserSettingsRepository {
         userEmail,
         undoSendSeconds: patch.undoSendSeconds ?? base.undoSendSeconds,
         externalImages: patch.externalImages ?? base.externalImages,
+        groupByConversation:
+          patch.groupByConversation ?? base.groupByConversation,
         updatedAt: now,
       })
       .orUpdate([...changed, 'updated_at'], ['user_email'])
@@ -66,6 +70,7 @@ export class MailUserSettingsRepository {
         'userEmail',
         'undoSendSeconds',
         'externalImages',
+        'groupByConversation',
         'updatedAt',
       ])
       .execute();
@@ -74,6 +79,7 @@ export class MailUserSettingsRepository {
     saved.userEmail = row?.user_email ?? userEmail;
     saved.undoSendSeconds = Number(row?.undo_send_seconds);
     saved.externalImages = row?.external_images ?? '';
+    saved.groupByConversation = row?.group_by_conversation === true;
     saved.updatedAt = row?.updated_at ?? now;
     return saved;
   }
diff --git a/backend/src/modules/mail-user-settings/mail-user-settings.service.spec.ts b/backend/src/modules/mail-user-settings/mail-user-settings.service.spec.ts
index 463a047..65f7dd7 100644
--- a/backend/src/modules/mail-user-settings/mail-user-settings.service.spec.ts
+++ b/backend/src/modules/mail-user-settings/mail-user-settings.service.spec.ts
@@ -20,11 +20,13 @@ function row(
   userEmail: string,
   undoSendSeconds: number,
   externalImages: string,
+  groupByConversation = false,
 ): MailUserSettingsEntity {
   const entity = new MailUserSettingsEntity();
   entity.userEmail = userEmail;
   entity.undoSendSeconds = undoSendSeconds;
   entity.externalImages = externalImages;
+  entity.groupByConversation = groupByConversation;
   entity.updatedAt = new Date('2026-10-29T00:00:00.000Z');
   return entity;
 }
@@ -48,6 +50,9 @@ function fakeRepository() {
           current?.undoSendSeconds ??
           base.undoSendSeconds,
         patch.externalImages ?? current?.externalImages ?? base.externalImages,
+        patch.groupByConversation ??
+          current?.groupByConversation ??
+          base.groupByConversation,
       );
       rows.set(userEmail, saved);
       return Promise.resolve(saved);
@@ -94,10 +99,12 @@ describe('MailUserSettingsService — 보내기 · 읽기 설정 (9단계)', ()
     await expect(service.get(ARA)).resolves.toEqual({
       undoSendSeconds: 10,
       externalImages: 'ask',
+      groupByConversation: false,
     });
     expect(DEFAULT_MAIL_USER_SETTINGS).toEqual({
       undoSendSeconds: 10,
       externalImages: 'ask',
+      groupByConversation: false,
     });
     expect(fake.upsert).not.toHaveBeenCalled();
   });
@@ -111,10 +118,12 @@ describe('MailUserSettingsService — 보내기 · 읽기 설정 (9단계)', ()
     await expect(service.get(ARA)).resolves.toEqual({
       undoSendSeconds: 10,
       externalImages: 'always',
+      groupByConversation: false,
     });
     await expect(service.get('b@arasystem.test')).resolves.toEqual({
       undoSendSeconds: 30,
       externalImages: 'ask',
+      groupByConversation: false,
     });
   });
 
@@ -141,7 +150,11 @@ describe('MailUserSettingsService — 보내기 · 읽기 설정 (9단계)', ()
 
     await expect(
       service.update(ARA, { externalImages: 'always' }),
-    ).resolves.toEqual({ undoSendSeconds: 20, externalImages: 'always' });
+    ).resolves.toEqual({
+      undoSendSeconds: 20,
+      externalImages: 'always',
+      groupByConversation: false,
+    });
     expect(fake.upsert).toHaveBeenCalledWith(
       ARA,
       { externalImages: 'always' },
@@ -151,6 +164,7 @@ describe('MailUserSettingsService — 보내기 · 읽기 설정 (9단계)', ()
     await expect(service.get(ARA)).resolves.toEqual({
       undoSendSeconds: 20,
       externalImages: 'always',
+      groupByConversation: false,
     });
     expect(fake.find).toHaveBeenCalledTimes(1);
 
@@ -190,10 +204,12 @@ describe('MailUserSettingsService — 보내기 · 읽기 설정 (9단계)', ()
     await expect(reading).resolves.toEqual({
       undoSendSeconds: 30,
       externalImages: 'ask',
+      groupByConversation: false,
     });
     await expect(service.get(ARA)).resolves.toEqual({
       undoSendSeconds: 30,
       externalImages: 'ask',
+      groupByConversation: false,
     });
     expect(fake.find).toHaveBeenCalledTimes(1);
   });
@@ -215,4 +231,41 @@ describe('MailUserSettingsService — 보내기 · 읽기 설정 (9단계)', ()
     await service.get('first@arasystem.test');
     expect(fake.find).toHaveBeenCalledTimes(1);
   });
+
+  it('대화로 묶어 보기(14단계) — 처음 끔, 보낸 칸만 바꾸고 다른 칸은 그대로 · 로그에 켬/끔', async () => {
+    const fake = fakeRepository();
+    fake.rows.set(ARA, row(ARA, 20, 'trusted'));
+    const service = new MailUserSettingsService(fake.repository);
+
+    await expect(service.get(ARA)).resolves.toMatchObject({
+      groupByConversation: false,
+    });
+    await expect(
+      service.update(ARA, { groupByConversation: true }),
+    ).resolves.toEqual({
+      undoSendSeconds: 20,
+      externalImages: 'trusted',
+      groupByConversation: true,
+    });
+    expect(fake.upsert).toHaveBeenCalledWith(
+      ARA,
+      { groupByConversation: true },
+      DEFAULT_MAIL_USER_SETTINGS,
+      expect.any(Date),
+    );
+    const lines = logSpy.mock.calls.map(([line]) => String(line)).join('\n');
+    expect(lines).toContain('대화로 묶기 켬');
+  });
+
+  it('표의 대화로 묶기 값이 참 · 거짓이 아니면(손으로 고친 값) 처음 값(끔)으로 읽는다', async () => {
+    const fake = fakeRepository();
+    const odd = row(ARA, 20, 'trusted');
+    (odd as unknown as { groupByConversation: unknown }).groupByConversation =
+      'yes';
+    fake.rows.set(ARA, odd);
+    const service = new MailUserSettingsService(fake.repository);
+    await expect(service.get(ARA)).resolves.toMatchObject({
+      groupByConversation: false,
+    });
+  });
 });
diff --git a/backend/src/modules/mail-user-settings/mail-user-settings.service.ts b/backend/src/modules/mail-user-settings/mail-user-settings.service.ts
index bd13302..76fb919 100644
--- a/backend/src/modules/mail-user-settings/mail-user-settings.service.ts
+++ b/backend/src/modules/mail-user-settings/mail-user-settings.service.ts
@@ -39,11 +39,16 @@ function toSettings(row: MailUserSettingsEntity | null): MailUserSettings {
     externalImages: isExternalImageMode(row.externalImages)
       ? row.externalImages
       : DEFAULT_MAIL_USER_SETTINGS.externalImages,
+    groupByConversation:
+      typeof row.groupByConversation === 'boolean'
+        ? row.groupByConversation
+        : DEFAULT_MAIL_USER_SETTINGS.groupByConversation,
   };
 }
 
 /**
- * 보내기 · 읽기 설정 (계약 2절 "보내기 · 읽기 설정" — 9단계) — 발송(보내기 취소 초)과 메일 읽기(외부 이미지)가 읽는다.
+ * 보내기 · 읽기 설정 (계약 2절 "보내기 · 읽기 설정" — 9단계 · 14단계의 대화로 묶기) — 발송(보내기 취소 초)과 메일 읽기(외부 이미지)가 읽는다.
+ * 대화로 묶기는 화면만 본다(서버는 GET /api/conversations 를 부르면 묶는다 — 설정과 상관없이).
  * - 저장한 적 없으면 처음 값(10초 · 늘 묻기) — 읽기만으로는 줄을 만들지 않는다
  * - 바꾸기는 보낸 칸만(하나 이상 — 비면 VAL_001). 값의 형식은 요청 검증(dto)이 본다
  *
@@ -83,7 +88,8 @@ export class MailUserSettingsService {
   ): Promise<MailUserSettings> {
     if (
       patch.undoSendSeconds === undefined &&
-      patch.externalImages === undefined
+      patch.externalImages === undefined &&
+      patch.groupByConversation === undefined
     ) {
       throw new BusinessException('VAL_001', {
         context: { reason: 'empty-mail-settings-patch' },
@@ -99,7 +105,7 @@ export class MailUserSettingsService {
     );
     this.remember(cacheKey(userEmail), saved);
     this.logger.log(
-      `${traceTag()} 보내기 · 읽기 설정을 바꿨습니다: user=${maskEmail(userEmail)}, 보내기 취소 ${saved.undoSendSeconds}초, 외부 이미지 ${saved.externalImages}`,
+      `${traceTag()} 보내기 · 읽기 설정을 바꿨습니다: user=${maskEmail(userEmail)}, 보내기 취소 ${saved.undoSendSeconds}초, 외부 이미지 ${saved.externalImages}, 대화로 묶기 ${saved.groupByConversation ? '켬' : '끔'}`,
     );
     return saved;
   }
diff --git a/backend/src/modules/mail-user-settings/mail-user-settings.types.ts b/backend/src/modules/mail-user-settings/mail-user-settings.types.ts
index 90e6fde..aa328c5 100644
--- a/backend/src/modules/mail-user-settings/mail-user-settings.types.ts
+++ b/backend/src/modules/mail-user-settings/mail-user-settings.types.ts
@@ -17,15 +17,18 @@ export type ExternalImageMode = (typeof EXTERNAL_IMAGE_MODES)[number];
 export interface MailUserSettings {
   readonly undoSendSeconds: UndoSendSeconds;
   readonly externalImages: ExternalImageMode;
+  /** 목록을 대화로 묶어 보기 (14단계 — 처음 끔: 전환 직후 보던 목록을 바꾸지 않는다) */
+  readonly groupByConversation: boolean;
 }
 
 /** 바꿀 것 — 하나 이상 (빈 바꾸기는 서비스가 VAL_001) */
 export type MailUserSettingsPatch = Partial<MailUserSettings>;
 
-/** 저장한 적 없는 직원의 값 (계약 — 처음 10초 · 늘 묻기) */
+/** 저장한 적 없는 직원의 값 (계약 — 처음 10초 · 늘 묻기 · 대화로 묶지 않음) */
 export const DEFAULT_MAIL_USER_SETTINGS: MailUserSettings = Object.freeze({
   undoSendSeconds: 10,
   externalImages: 'ask',
+  groupByConversation: false,
 });
 
 /** 저장한 값이 아는 값인가 — DB 를 손으로 고쳤거나 옛 값이면 처음 값으로 읽는다 */
diff --git a/backend/src/modules/mail/conversation.controller.ts b/backend/src/modules/mail/conversation.controller.ts
new file mode 100644
index 0000000..5070aa9
--- /dev/null
+++ b/backend/src/modules/mail/conversation.controller.ts
@@ -0,0 +1,89 @@
+import { Controller, Get, Param, Query, UseGuards } from '@nestjs/common';
+import { ApiCookieAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+
+import {
+  ApiErrorResponse,
+  ApiSessionErrors,
+  ApiStandardResponse,
+} from '@/common/decorators/api-standard-response.decorator';
+import {
+  CurrentUser,
+  type AuthenticatedUser,
+} from '@/common/decorators/current-user.decorator';
+import { JwtAuthGuard } from '@/common/guards/jwt-auth.guard';
+import { CONVERSATION_PAGE_LIMIT } from '@/modules/mail-search/mail-search.constants';
+import { MailConversationService } from './conversation.service';
+import {
+  ConversationListQueryDto,
+  ConversationQueryDto,
+} from './dto/conversation-query.dto';
+import {
+  ConversationListPageDto,
+  ConversationPageDto,
+} from './dto/mail-response.dto';
+import { MESSAGES_ROUTE } from './mail.constants';
+import { MailIdPipe } from './mail-id.pipe';
+
+/**
+ * 대화 (14단계 — 계약 2절 "같은 대화" · "대화로 묶어 보기"). 같은 대화는 메일 자원 아래(`/api/messages/{id}/conversation`),
+ * 묶은 목록은 따로(`/api/conversations`) — 검색은 묶지 않는다
+ */
+@ApiTags('Mail')
+@ApiCookieAuth()
+@UseGuards(JwtAuthGuard)
+@ApiSessionErrors(
+  '로그인 필요 (쿠키 없음·만료) — 클라이언트는 /auth/refresh 를 한 번 시도한다',
+)
+@Controller()
+export class ConversationController {
+  constructor(private readonly conversations: MailConversationService) {}
+
+  @Get(`${MESSAGES_ROUTE}/:id/conversation`)
+  @ApiOperation({
+    summary: '같은 대화 — 그 메일과 답장 · 전달로 이어진 메일 (오래된 차례)',
+    description:
+      '보낸편지함을 포함한 모든 메일함에서 — 휴지통 · 스팸메일함에만 든 메일과 발송 중인 내부 초안은 빼되 지금 메일은 넣는다. 한 통뿐이면 그 메일 하나다. ' +
+      '기준(basis): 그 직원의 색인이 준비됐으면 index — 답장 관계(References · In-Reply-To)가 있고 말머리(Re · Fw · 회신 · 답장 · 전달 · [꼬리표] — 여러 겹)를 뗀 제목이 같은 메일, ' +
+      '준비 중이면 engine — 엔진의 스레드. 쪽을 넘기는 중에는 커서의 기준대로 이어 간다. ' +
+      `limit 은 처음 값이자 최대가 ${CONVERSATION_PAGE_LIMIT} 다. 항목은 목록과 같은 요약(기다리는 발송 pendingSend 포함)이다.`,
+  })
+  @ApiStandardResponse(ConversationPageDto, { description: '같은 대화' })
+  @ApiErrorResponse(
+    'VAL_001',
+    `limit 범위(1~${CONVERSATION_PAGE_LIMIT}) 밖 · 다른 대화의 커서 · 모르는 쿼리`,
+  )
+  @ApiErrorResponse('RES_001', '없는 메일 (남의 메일 포함)')
+  @ApiErrorResponse('MAIL_001', '메일 엔진 장애')
+  conversation(
+    @CurrentUser() user: AuthenticatedUser,
+    @Param('id', MailIdPipe) id: string,
+    @Query() query: ConversationQueryDto,
+  ) {
+    return this.conversations.conversation(user, id, query);
+  }
+
+  @Get('conversations')
+  @ApiOperation({
+    summary:
+      '대화로 묶은 목록 — 그 메일함의 대화 하나가 한 줄 (마지막 받은 시각 최신부터)',
+    description:
+      '그 메일함 안의 메일을 대화로 묶는다 — 줄마다 그 메일함 안 마지막 메일(latest) · 보낸 사람들 · 대화 전체의 통 수 · 그 메일함 안 메일 id(여러 통 처리에) · 읽음 · 중요 · 첨부. ' +
+      '기준(basis)은 같은 대화와 같다(색인 준비 전에는 엔진의 스레드 — collapseThreads). 발송 중인 내부 초안은 빠지고, 붙잡힌 메일(보내기 취소 · 예약 — pendingSend)은 목록처럼 보인다. ' +
+      '검색은 묶지 않는다(GET /api/messages).',
+  })
+  @ApiStandardResponse(ConversationListPageDto, {
+    description: '대화로 묶은 목록',
+  })
+  @ApiErrorResponse(
+    'VAL_001',
+    'mailboxId 없음 · 형식이 틀림 · limit 범위 밖 · 다른 메일함의 커서 · 모르는 쿼리',
+  )
+  @ApiErrorResponse('RES_001', '없는 메일함')
+  @ApiErrorResponse('MAIL_001', '메일 엔진 장애')
+  list(
+    @CurrentUser() user: AuthenticatedUser,
+    @Query() query: ConversationListQueryDto,
+  ) {
+    return this.conversations.list(user, query);
+  }
+}
diff --git a/backend/src/modules/mail/conversation.service.spec.ts b/backend/src/modules/mail/conversation.service.spec.ts
new file mode 100644
index 0000000..6d30600
--- /dev/null
+++ b/backend/src/modules/mail/conversation.service.spec.ts
@@ -0,0 +1,342 @@
+import { Logger } from '@nestjs/common';
+
+import { BusinessException } from '@/common/errors/business.exception';
+import { encodeConversationCursor } from '@/modules/mail-search/conversation-cursor';
+import type { MailConversationQueryService } from '@/modules/mail-search/mail-conversation-query.service';
+import type { MailSearchIndexService } from '@/modules/mail-search/mail-search-index.service';
+import type { MailSearchSyncService } from '@/modules/mail-search/mail-search-sync.service';
+import { MailConversationService } from './conversation.service';
+import { encodeCursor } from './jmap/jmap-cursor';
+import type { MailProvider } from './mail.provider';
+import type { MessageSummary } from './mail.types';
+
+const user = { email: 'ara.kim@arasystem.test', name: '김아라' };
+const SCOPE = {
+  mailboxId: null,
+  excludedMailboxIds: ['b', 'c'],
+  excludedKeywords: ['$ara-sending'],
+};
+
+function summary(id: string, mailboxIds = ['a']): MessageSummary {
+  return {
+    id,
+    threadId: 't1',
+    mailboxIds,
+    from: { name: '이도윤', email: 'doyun.lee@arasystem.test' },
+    to: [],
+    subject: `제목 ${id}`,
+    preview: '',
+    receivedAt: '2026-11-02T01:00:00.000Z',
+    isRead: true,
+    isFlagged: false,
+    hasAttachment: false,
+    size: 1,
+    pendingSend: null,
+  };
+}
+
+const forged = (payload: Record<string, unknown>) =>
+  Buffer.from(JSON.stringify(payload)).toString('base64url');
+
+function setup(ready = true) {
+  const summaries = (ids: readonly string[]) =>
+    ids
+      .filter((id) => id !== 'gone')
+      .map((id) => summary(id, id === 'moved' ? ['e'] : ['a']));
+  const provider = {
+    conversationScope: jest.fn().mockResolvedValue(SCOPE),
+    getSummaries: jest.fn((_user: string, ids: readonly string[]) =>
+      Promise.resolve(summaries(ids)),
+    ),
+    getSummariesWithHeld: jest.fn((_user: string, ids: readonly string[]) =>
+      Promise.resolve({
+        summaries: summaries(ids),
+        heldIds: new Set(['m1', 'elsewhere']),
+      }),
+    ),
+    getConversation: jest.fn().mockResolvedValue({
+      items: [summary('e1')],
+      hasNext: false,
+      nextCursor: null,
+      total: 1,
+    }),
+    listConversations: jest.fn().mockResolvedValue({
+      items: [],
+      hasNext: false,
+      nextCursor: null,
+      total: 0,
+    }),
+  };
+  const searchIndex = { isSearchReady: jest.fn().mockResolvedValue(ready) };
+  const searchSync = { syncBeforeRead: jest.fn().mockResolvedValue(true) };
+  const conversations = {
+    conversation: jest.fn().mockResolvedValue({
+      ids: ['m1', 'm2', 'gone'],
+      hasNext: true,
+      nextCursor: 'next',
+      total: 3,
+    }),
+    mailboxConversations: jest.fn().mockResolvedValue({
+      items: [
+        {
+          key: 'k1',
+          latestId: 'm2',
+          mailboxMessageIds: ['m2', 'm1'],
+          messageCount: 4,
+          participants: [{ name: '이도윤', email: 'doyun.lee@arasystem.test' }],
+          isRead: false,
+          isFlagged: true,
+          hasAttachment: false,
+        },
+        {
+          key: 'k2',
+          latestId: 'moved',
+          mailboxMessageIds: ['moved'],
+          messageCount: 1,
+          participants: [],
+          isRead: true,
+          isFlagged: false,
+          hasAttachment: false,
+        },
+      ],
+      hasNext: false,
+      nextCursor: null,
+      total: 2,
+    }),
+  };
+  const service = new MailConversationService(
+    provider as unknown as MailProvider,
+    searchIndex as unknown as MailSearchIndexService,
+    searchSync as unknown as MailSearchSyncService,
+    conversations as unknown as MailConversationQueryService,
+  );
+  return { service, provider, searchIndex, searchSync, conversations };
+}
+
+describe('MailConversationService (같은 대화 · 묶은 목록 — 14단계 C3 · C4)', () => {
+  let warnSpy: jest.SpyInstance;
+  beforeEach(() => {
+    warnSpy = jest.spyOn(Logger.prototype, 'warn').mockImplementation();
+  });
+  afterEach(() => warnSpy.mockRestore());
+
+  it('색인이 준비됐으면 색인 — 바로 전 맞추기 → 범위 → 색인의 쪽(그 메일의 키와 한 문장) → 요약은 엔진에서(없는 메일은 뺀다), basis index', async () => {
+    const { service, provider, searchSync, conversations } = setup();
+
+    const result = await service.conversation(user, 'm2', { limit: 100 });
+
+    expect(searchSync.syncBeforeRead).toHaveBeenCalledWith(user.email);
+    expect(provider.conversationScope).toHaveBeenCalledWith(user.email);
+    expect(conversations.conversation).toHaveBeenCalledWith(
+      user.email,
+      'm2',
+      SCOPE,
+      { limit: 100, after: null },
+    );
+    expect(result.items.map((item) => item.id)).toEqual(['m1', 'm2']);
+    expect(result.pageInfo).toEqual({
+      hasNext: true,
+      nextCursor: 'next',
+      total: 3,
+    });
+    expect(result.basis).toBe('index');
+    expect(provider.getConversation).not.toHaveBeenCalled();
+  });
+
+  it('색인이 준비 중 · 그 메일이 색인에 아직 없으면 엔진의 스레드 — basis engine', async () => {
+    const notReady = setup(false);
+    const engine = await notReady.service.conversation(user, 'm2', {
+      limit: 100,
+    });
+    expect(engine.basis).toBe('engine');
+    expect(notReady.provider.getConversation).toHaveBeenCalledWith(
+      user.email,
+      'm2',
+      { limit: 100, cursor: undefined },
+    );
+
+    const notIndexed = setup();
+    notIndexed.conversations.conversation.mockResolvedValue(null);
+    const fallback = await notIndexed.service.conversation(user, 'new', {
+      limit: 100,
+    });
+    expect(fallback.basis).toBe('engine');
+    expect(notIndexed.provider.getSummaries).not.toHaveBeenCalled();
+  });
+
+  it('쪽을 넘기는 중에는 커서의 방식대로 — 색인 커서는 입구에서 읽어 자리로 넘기고, 그 메일이 색인에서 사라졌으면 404 RES_001', async () => {
+    const at = new Date('2026-11-02T01:00:00.000Z');
+    const indexCursor = encodeConversationCursor(
+      'thread',
+      { at, key: 'm1' },
+      'm2',
+    );
+    const notReady = setup(false);
+    await notReady.service.conversation(user, 'm2', {
+      limit: 100,
+      cursor: indexCursor,
+    });
+    expect(notReady.conversations.conversation).toHaveBeenCalledWith(
+      user.email,
+      'm2',
+      SCOPE,
+      { limit: 100, after: { at, key: 'm1' } },
+    );
+    expect(notReady.searchIndex.isSearchReady).not.toHaveBeenCalled();
+
+    const ready = setup();
+    await ready.service.conversation(user, 'm2', {
+      limit: 100,
+      cursor: encodeCursor(
+        { anchor: 'm1', position: 1 },
+        { conditions: ['conversation', 'm2'] },
+      ),
+    });
+    expect(ready.provider.getConversation).toHaveBeenCalled();
+    expect(ready.conversations.conversation).not.toHaveBeenCalled();
+
+    const vanished = setup();
+    vanished.conversations.conversation.mockResolvedValue(null);
+    await expect(
+      vanished.service.conversation(user, 'm2', {
+        limit: 100,
+        cursor: indexCursor,
+      }),
+    ).rejects.toMatchObject({ code: 'RES_001' });
+  });
+
+  it('꾸민 색인 커서(모양이 틀림 · `m` 만 맞음 · 다른 메일의 커서)는 맞추기 · 엔진 · DB 에 묻기 전에 400 VAL_001 — 두 경로 모두 (리뷰 L1)', async () => {
+    const at = new Date('2026-11-02T01:00:00.000Z');
+    const threadCursors = [
+      forged({ m: 'ti' }),
+      forged({ v: 1, m: 'ti', t: 'x', k: 'm1', s: 'zz' }),
+      encodeConversationCursor('thread', { at, key: 'm1' }, 'other'),
+    ];
+    for (const cursor of threadCursors) {
+      const { service, provider, searchSync, conversations } = setup();
+      await expect(
+        service.conversation(user, 'm2', { limit: 100, cursor }),
+      ).rejects.toMatchObject({ code: 'VAL_001' });
+      expect(searchSync.syncBeforeRead).not.toHaveBeenCalled();
+      expect(provider.conversationScope).not.toHaveBeenCalled();
+      expect(conversations.conversation).not.toHaveBeenCalled();
+    }
+
+    const listCursors = [
+      forged({ m: 'li' }),
+      forged({ v: 1, m: 'li', t: -5, k: 'k1', s: 'zz' }),
+      encodeConversationCursor('list', { at, key: 'k1' }, 'sent'),
+    ];
+    for (const cursor of listCursors) {
+      const { service, provider, searchSync, conversations } = setup();
+      await expect(
+        service.list(user, { mailboxId: 'a', limit: 20, cursor }),
+      ).rejects.toMatchObject({ code: 'VAL_001' });
+      expect(searchSync.syncBeforeRead).not.toHaveBeenCalled();
+      expect(provider.conversationScope).not.toHaveBeenCalled();
+      expect(conversations.mailboxConversations).not.toHaveBeenCalled();
+    }
+  });
+
+  it('첫 쪽의 색인 읽기가 DB 장애면 엔진으로 — 코드가 있는 실패(RES_001 · MAIL_001)는 그대로', async () => {
+    const broken = setup();
+    broken.conversations.conversation.mockRejectedValue(new Error('db down'));
+    const result = await broken.service.conversation(user, 'm2', {
+      limit: 100,
+    });
+    expect(result.basis).toBe('engine');
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    const [line] = warnSpy.mock.calls[0] as [string];
+    expect(line).toContain('[SYS_001]');
+    expect(line).not.toContain(user.email);
+
+    const coded = setup();
+    coded.provider.conversationScope.mockRejectedValue(
+      new BusinessException('MAIL_001'),
+    );
+    await expect(
+      coded.service.conversation(user, 'm2', { limit: 100 }),
+    ).rejects.toMatchObject({ code: 'MAIL_001' });
+    expect(coded.provider.getConversation).not.toHaveBeenCalled();
+  });
+
+  it('묶은 목록 — 색인이면 그 메일함의 범위(있는지 본다) → 색인의 쪽 → 마지막 메일의 요약과 붙잡힌 메일을 한 번에, 줄의 pendingSendIds · 그 메일함을 떠난 대화는 뺀다 (리뷰 L6)', async () => {
+    const { service, provider, conversations } = setup();
+
+    const result = await service.list(user, { mailboxId: 'a', limit: 20 });
+
+    expect(provider.conversationScope).toHaveBeenCalledWith(user.email, 'a');
+    expect(conversations.mailboxConversations).toHaveBeenCalledWith(
+      user.email,
+      'a',
+      SCOPE,
+      { limit: 20, after: null },
+    );
+    expect(provider.getSummariesWithHeld).toHaveBeenCalledTimes(1);
+    expect(provider.getSummariesWithHeld).toHaveBeenCalledWith(user.email, [
+      'm2',
+      'moved',
+    ]);
+    expect(provider.getSummaries).not.toHaveBeenCalled();
+    expect(result.basis).toBe('index');
+    expect(result.items).toEqual([
+      {
+        id: 'k1',
+        latest: summary('m2'),
+        participants: [{ name: '이도윤', email: 'doyun.lee@arasystem.test' }],
+        messageCount: 4,
+        messageIds: ['m2', 'm1'],
+        pendingSendIds: ['m1'],
+        isRead: false,
+        isFlagged: true,
+        hasAttachment: false,
+      },
+    ]);
+    expect(result.pageInfo.total).toBe(2);
+
+    // 빈 쪽이면 엔진에 요약 · 제출을 묻지 않는다
+    const empty = setup();
+    empty.conversations.mailboxConversations.mockResolvedValue({
+      items: [],
+      hasNext: false,
+      nextCursor: null,
+      total: 0,
+    });
+    const none = await empty.service.list(user, { mailboxId: 'a', limit: 20 });
+    expect(none.items).toEqual([]);
+    expect(empty.provider.getSummariesWithHeld).not.toHaveBeenCalled();
+  });
+
+  it('묶은 목록 — 준비 중이면 엔진(collapseThreads), 커서의 방식은 이어 간다', async () => {
+    const notReady = setup(false);
+    const engine = await notReady.service.list(user, {
+      mailboxId: 'a',
+      limit: 20,
+    });
+    expect(engine.basis).toBe('engine');
+    expect(notReady.provider.listConversations).toHaveBeenCalledWith(
+      user.email,
+      { mailboxId: 'a', limit: 20, cursor: undefined },
+    );
+
+    const at = new Date('2026-11-02T01:00:00.000Z');
+    const indexCursor = encodeConversationCursor(
+      'list',
+      { at, key: 'k9' },
+      'a',
+    );
+    const resumed = setup(false);
+    const next = await resumed.service.list(user, {
+      mailboxId: 'a',
+      limit: 20,
+      cursor: indexCursor,
+    });
+    expect(next.basis).toBe('index');
+    expect(resumed.conversations.mailboxConversations).toHaveBeenCalledWith(
+      user.email,
+      'a',
+      SCOPE,
+      { limit: 20, after: { at, key: 'k9' } },
+    );
+  });
+});
diff --git a/backend/src/modules/mail/conversation.service.ts b/backend/src/modules/mail/conversation.service.ts
new file mode 100644
index 0000000..d899a96
--- /dev/null
+++ b/backend/src/modules/mail/conversation.service.ts
@@ -0,0 +1,249 @@
+import { Inject, Injectable, Logger } from '@nestjs/common';
+
+import type { AuthenticatedUser } from '@/common/decorators/current-user.decorator';
+import {
+  type PaginatedResult,
+  toPaginatedResult,
+} from '@/common/dto/pagination.dto';
+import { BusinessException } from '@/common/errors/business.exception';
+import {
+  conversationCursorMethod,
+  decodeConversationCursor,
+  type ConversationPosition,
+} from '@/modules/mail-search/conversation-cursor';
+import { MailConversationQueryService } from '@/modules/mail-search/mail-conversation-query.service';
+import { MailSearchIndexService } from '@/modules/mail-search/mail-search-index.service';
+import { MailSearchSyncService } from '@/modules/mail-search/mail-search-sync.service';
+import type { ConversationBasis } from '@/modules/mail-search/mail-search.types';
+import { traceTag } from '@/shared/logger/request-context';
+import { maskEmail } from '@/shared/utils/mask';
+import type {
+  ConversationListQueryDto,
+  ConversationQueryDto,
+} from './dto/conversation-query.dto';
+import { MAIL_PROVIDER, type MailProvider } from './mail.provider';
+import type { ConversationSummary, MessageSummary } from './mail.types';
+
+/** 대화 응답 — 목록 모양에 기준(basis)을 더한다 */
+export type ConversationResult<T> = PaginatedResult<T> & {
+  readonly basis: ConversationBasis;
+};
+
+function errorKind(error: unknown): string {
+  const name = error instanceof Error ? error.name : typeof error;
+  const code = (error as { code?: unknown } | null)?.code;
+  return typeof code === 'string' ? `${name}/${code}` : name;
+}
+
+/**
+ * 대화 (14단계 설계 C3 · C4 — 디자인 README "같은 대화" · "대화로 묶어 보기").
+ * - 기준: 커서가 있으면 그 커서의 방식(쪽을 넘기는 중에 준비가 끝나거나 다시 채우기에 들어가도 처음 방식대로), 없으면 그 직원의 색인이 준비됐으면(ready · 지금 판)
+ *   우리 색인(대화 키 — 답장 관계 + 말머리를 뗀 제목), 아니면 엔진의 스레드. 응답에 기준(basis)을 싣는다.
+ *   색인 커서는 입구에서 읽는다 — 모양이 틀리거나 다른 대화 · 메일함의 커서면 맞추기 · 엔진 · DB 에 묻기 전에 VAL_001 (3차 리뷰 L1)
+ * - 색인 방식: 바로 전 맞추기(1.5초 안) → 엔진에 범위(휴지통 · 스팸메일함 · 내부 초안 키워드 — 메일함이 있는지) → 색인 → 보일 메일의 요약은 엔진에서(목록과 같은 모양 · 기다리는 발송)
+ *   엔진에 없는 메일(그사이 지움)과 그 메일함을 떠난 마지막 메일의 대화는 뺀다. 첫 쪽의 색인 읽기가 DB 장애면 엔진 방식으로 답한다
+ * - 같은 대화: 그 메일이 색인에 없으면(방금 와 아직 넣지 않음) 엔진 방식 — 엔진에도 없으면 RES_001. 색인 커서로 이어 가는데 없으면 RES_001
+ * - 묶은 목록의 붙잡힌 메일(pendingSendIds): 마지막 메일의 요약을 읽는 요청에서 계정의 기다리는 제출을 한 번 읽어 줄의 messageIds 와 맞춘다(getSummariesWithHeld)
+ */
+@Injectable()
+export class MailConversationService {
+  private readonly logger = new Logger(MailConversationService.name);
+
+  constructor(
+    @Inject(MAIL_PROVIDER) private readonly provider: MailProvider,
+    private readonly searchIndex: MailSearchIndexService,
+    private readonly searchSync: MailSearchSyncService,
+    private readonly conversations: MailConversationQueryService,
+  ) {}
+
+  /** GET /api/messages/{id}/conversation */
+  async conversation(
+    user: AuthenticatedUser,
+    emailId: string,
+    query: ConversationQueryDto,
+  ): Promise<ConversationResult<MessageSummary>> {
+    if (query.cursor) {
+      if (conversationCursorMethod(query.cursor, 'thread') === 'index') {
+        const after = decodeConversationCursor('thread', query.cursor, emailId);
+        return this.conversationFromIndex(user, emailId, query.limit, after);
+      }
+      return this.conversationFromEngine(user, emailId, query);
+    }
+    if (!(await this.searchIndex.isSearchReady(user.email))) {
+      return this.conversationFromEngine(user, emailId, query);
+    }
+    try {
+      return await this.conversationFromIndex(user, emailId, query.limit, null);
+    } catch (error) {
+      if (error instanceof BusinessException) throw error;
+      this.warnFallback(user, error);
+      return this.conversationFromEngine(user, emailId, query);
+    }
+  }
+
+  /** GET /api/conversations */
+  async list(
+    user: AuthenticatedUser,
+    query: ConversationListQueryDto,
+  ): Promise<ConversationResult<ConversationSummary>> {
+    if (query.cursor) {
+      if (conversationCursorMethod(query.cursor, 'list') === 'index') {
+        const after = decodeConversationCursor(
+          'list',
+          query.cursor,
+          query.mailboxId,
+        );
+        return this.listFromIndex(user, query, after);
+      }
+      return this.listFromEngine(user, query);
+    }
+    if (!(await this.searchIndex.isSearchReady(user.email))) {
+      return this.listFromEngine(user, query);
+    }
+    try {
+      return await this.listFromIndex(user, query, null);
+    } catch (error) {
+      if (error instanceof BusinessException) throw error;
+      this.warnFallback(user, error);
+      return this.listFromEngine(user, query);
+    }
+  }
+
+  private async conversationFromEngine(
+    user: AuthenticatedUser,
+    emailId: string,
+    query: ConversationQueryDto,
+  ): Promise<ConversationResult<MessageSummary>> {
+    const page = await this.provider.getConversation(user.email, emailId, {
+      limit: query.limit,
+      cursor: query.cursor,
+    });
+    return {
+      ...toPaginatedResult(page.items, {
+        hasNext: page.hasNext,
+        nextCursor: page.nextCursor,
+        total: page.total,
+      }),
+      basis: 'engine',
+    };
+  }
+
+  private async conversationFromIndex(
+    user: AuthenticatedUser,
+    emailId: string,
+    limit: number,
+    after: ConversationPosition | null,
+  ): Promise<ConversationResult<MessageSummary>> {
+    await this.searchSync.syncBeforeRead(user.email);
+    const scope = await this.provider.conversationScope(user.email);
+    const page = await this.conversations.conversation(
+      user.email,
+      emailId,
+      scope,
+      { limit, after },
+    );
+    if (page === null) {
+      // 색인에 없다 — 첫 쪽이면 엔진의 스레드로(방금 온 메일), 이어 가는 쪽이면 그 메일이 그사이 사라졌다
+      if (after !== null) {
+        throw new BusinessException('RES_001', {
+          context: { reason: 'conversation-message-not-indexed' },
+        });
+      }
+      return this.conversationFromEngine(user, emailId, { limit });
+    }
+    const summaries =
+      page.ids.length > 0
+        ? await this.provider.getSummaries(user.email, page.ids)
+        : [];
+    const byId = new Map(summaries.map((summary) => [summary.id, summary]));
+    const items = page.ids.flatMap((id) => {
+      const summary = byId.get(id);
+      return summary ? [summary] : [];
+    });
+    return {
+      ...toPaginatedResult(items, {
+        hasNext: page.hasNext,
+        nextCursor: page.nextCursor,
+        total: page.total,
+      }),
+      basis: 'index',
+    };
+  }
+
+  private async listFromEngine(
+    user: AuthenticatedUser,
+    query: ConversationListQueryDto,
+  ): Promise<ConversationResult<ConversationSummary>> {
+    const page = await this.provider.listConversations(user.email, {
+      mailboxId: query.mailboxId,
+      limit: query.limit,
+      cursor: query.cursor,
+    });
+    return {
+      ...toPaginatedResult(page.items, {
+        hasNext: page.hasNext,
+        nextCursor: page.nextCursor,
+        total: page.total,
+      }),
+      basis: 'engine',
+    };
+  }
+
+  private async listFromIndex(
+    user: AuthenticatedUser,
+    query: ConversationListQueryDto,
+    after: ConversationPosition | null,
+  ): Promise<ConversationResult<ConversationSummary>> {
+    await this.searchSync.syncBeforeRead(user.email);
+    const scope = await this.provider.conversationScope(
+      user.email,
+      query.mailboxId,
+    );
+    const page = await this.conversations.mailboxConversations(
+      user.email,
+      query.mailboxId,
+      scope,
+      { limit: query.limit, after },
+    );
+    const latestIds = page.items.map((item) => item.latestId);
+    // 마지막 메일의 요약과 계정의 붙잡힌 메일 — 기다리는 제출은 이 쪽에서 한 번만 읽는다 (줄이 없으면 묻지 않는다)
+    const { summaries, heldIds } =
+      latestIds.length > 0
+        ? await this.provider.getSummariesWithHeld(user.email, latestIds)
+        : { summaries: [], heldIds: new Set<string>() };
+    const byId = new Map(summaries.map((summary) => [summary.id, summary]));
+    const items = page.items.flatMap((item): ConversationSummary[] => {
+      const latest = byId.get(item.latestId);
+      // 엔진에 없거나(그사이 지움) 그 메일함을 떠났다 — 맞추기가 곧 고친다
+      if (!latest || !latest.mailboxIds.includes(query.mailboxId)) return [];
+      const messageIds = [...item.mailboxMessageIds];
+      return [
+        {
+          id: item.key,
+          latest,
+          participants: [...item.participants],
+          messageCount: item.messageCount,
+          messageIds,
+          pendingSendIds: messageIds.filter((id) => heldIds.has(id)),
+          isRead: item.isRead,
+          isFlagged: item.isFlagged,
+          hasAttachment: item.hasAttachment,
+        },
+      ];
+    });
+    return {
+      ...toPaginatedResult(items, {
+        hasNext: page.hasNext,
+        nextCursor: page.nextCursor,
+        total: page.total,
+      }),
+      basis: 'index',
+    };
+  }
+
+  private warnFallback(user: AuthenticatedUser, error: unknown): void {
+    this.logger.warn(
+      `[SYS_001]${traceTag()} 검색 색인으로 대화를 읽지 못해 엔진의 스레드로 답합니다: user=${maskEmail(user.email)}, reason=${errorKind(error)}`,
+    );
+  }
+}
diff --git a/backend/src/modules/mail/dto/conversation-query.dto.ts b/backend/src/modules/mail/dto/conversation-query.dto.ts
new file mode 100644
index 0000000..2c4fe17
--- /dev/null
+++ b/backend/src/modules/mail/dto/conversation-query.dto.ts
@@ -0,0 +1,55 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import {
+  IsInt,
+  IsOptional,
+  IsString,
+  Matches,
+  Max,
+  Min,
+} from 'class-validator';
+
+import { CursorPaginationQueryDto } from '@/common/dto/pagination.dto';
+import { CONVERSATION_PAGE_LIMIT } from '@/modules/mail-search/mail-search.constants';
+import { MAIL_ID_PATTERN } from '@/modules/mail/mail.constants';
+
+/**
+ * GET /api/messages/{id}/conversation — 같은 대화의 쪽 (14단계). limit 의 처음 값이자 최대가 CONVERSATION_PAGE_LIMIT 다(화면은 한 번에 보인다)
+ */
+export class ConversationQueryDto {
+  @ApiPropertyOptional({
+    description:
+      '이전 응답의 nextCursor 값 — 그 메일의 대화에서만 쓴다(다르면 400 VAL_001). 첫 쪽은 생략한다',
+    example: 'eyJ2IjoxfQ',
+  })
+  @IsOptional()
+  @IsString({ message: '커서 값의 형식이 올바르지 않습니다.' })
+  cursor?: string;
+
+  @ApiPropertyOptional({
+    description: `한 번에 가져올 메일 수 (1~${CONVERSATION_PAGE_LIMIT})`,
+    default: CONVERSATION_PAGE_LIMIT,
+    example: CONVERSATION_PAGE_LIMIT,
+  })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt({ message: '조회 개수는 정수로 입력해 주세요.' })
+  @Min(1, { message: '조회 개수는 1 이상이어야 합니다.' })
+  @Max(CONVERSATION_PAGE_LIMIT, {
+    message: `조회 개수는 ${CONVERSATION_PAGE_LIMIT} 이하여야 합니다.`,
+  })
+  limit: number = CONVERSATION_PAGE_LIMIT;
+}
+
+/**
+ * GET /api/conversations — 대화로 묶은 목록 (14단계). 메일함이 꼭 있어야 한다(검색은 묶지 않는다)
+ */
+export class ConversationListQueryDto extends CursorPaginationQueryDto {
+  @ApiProperty({
+    description:
+      '메일함 id — 그 메일함의 대화를 묶는다. 없는 메일함은 404 RES_001',
+    example: 'a',
+  })
+  @Matches(MAIL_ID_PATTERN, { message: '메일함을 다시 선택해 주세요.' })
+  mailboxId!: string;
+}
diff --git a/backend/src/modules/mail/dto/mail-response.dto.ts b/backend/src/modules/mail/dto/mail-response.dto.ts
index e2d67c2..b6139bc 100644
--- a/backend/src/modules/mail/dto/mail-response.dto.ts
+++ b/backend/src/modules/mail/dto/mail-response.dto.ts
@@ -15,7 +15,18 @@ import {
   type ContactEmailLabel,
 } from '@/modules/contacts/contacts.types';
 import { MAX_BODY_VALUE_BYTES } from '@/modules/mail/mail.constants';
+import {
+  CONVERSATION_MESSAGE_IDS_MAX,
+  CONVERSATION_PARTICIPANTS_MAX,
+} from '@/modules/mail-search/mail-search.constants';
 import type {
+  ConversationBasis,
+  MessageDetailHighlight,
+  MessageListHighlight,
+  SearchRange,
+} from '@/modules/mail-search/mail-search.types';
+import type {
+  ConversationSummary,
   Draft,
   MailAddress,
   MailAttachment,
@@ -29,6 +40,7 @@ import type {
   MessageDeletionResult,
   MessageDetail,
   MessageLargeFile,
+  MessageListItem,
   MessagesPatchResult,
   MessageSummary,
   PendingSend,
@@ -311,6 +323,90 @@ export class MessageSummaryDto implements MessageSummary {
   pendingSend!: PendingSendDto | null;
 }
 
+/** 맞은 곳 [시작, 끝) — UTF-16, 끝은 들지 않는다 (14단계 검색 강조) */
+const RANGE_LIST_SCHEMA = {
+  type: 'array',
+  items: {
+    type: 'array',
+    items: { type: 'integer', minimum: 0 },
+    minItems: 2,
+    maxItems: 2,
+  },
+} as const;
+
+/** 목록 항목의 미리 보기 강조 */
+export class MessageListPreviewHighlightDto {
+  @ApiProperty({
+    description:
+      '보일 미리 보기 한 줄 — 본문에서 맞았으면 맞은 말 둘레(앞 20자 남짓 · 모두 80자 남짓, 말 경계에서 자르고 잘린 쪽에 "…"), 아니면 엔진의 미리 보기',
+    example: '…지난주 보내 드린 계약서를 다시 확인해 주세요',
+  })
+  text!: string;
+
+  @ApiProperty({
+    ...RANGE_LIST_SCHEMA,
+    description: 'text 안의 맞은 곳 [시작, 끝) — UTF-16',
+    example: [[12, 14]],
+  })
+  ranges!: SearchRange[];
+}
+
+/** 목록 항목의 검색 강조 (색인으로 찾았을 때만) */
+export class MessageListHighlightDto implements MessageListHighlight {
+  @ApiProperty({
+    ...RANGE_LIST_SCHEMA,
+    description:
+      '제목의 맞은 곳 [시작, 끝) — UTF-16. 강조가 있으면 subject 는 NFC 로 맞춘 글이다(위치가 그 글 기준)',
+    example: [[0, 2]],
+  })
+  subject!: SearchRange[];
+
+  @ApiProperty({ type: MessageListPreviewHighlightDto })
+  preview!: MessageListPreviewHighlightDto;
+}
+
+/** 목록 항목 (GET /api/messages) — 요약 + 검색 강조 */
+export class MessageListItemDto
+  extends MessageSummaryDto
+  implements MessageListItem
+{
+  @ApiProperty({
+    description:
+      '검색 강조 (14단계) — 색인으로 찾은 검색 결과에만, 목록 · 엔진 방식 검색(색인 준비 중)이면 null',
+    type: MessageListHighlightDto,
+    nullable: true,
+  })
+  searchHighlight!: MessageListHighlightDto | null;
+}
+
+/** 읽기 화면의 검색 강조 */
+export class MessageDetailHighlightDto implements MessageDetailHighlight {
+  @ApiProperty({
+    ...RANGE_LIST_SCHEMA,
+    description:
+      '제목의 맞은 곳 [시작, 끝) — UTF-16 (subject 는 NFC 로 맞춘 글이다)',
+    example: [[0, 2]],
+  })
+  subject!: SearchRange[];
+
+  @ApiProperty({
+    description:
+      '첨부 이름의 맞은 곳 — 첨부 id → [시작, 끝) 목록. 맞은 첨부만 든다 (이름은 NFC 로 맞춘 글이다)',
+    type: 'object',
+    additionalProperties: RANGE_LIST_SCHEMA,
+    example: { blob1: [[0, 3]] },
+  })
+  attachments!: Record<string, SearchRange[]>;
+
+  @ApiProperty({
+    ...RANGE_LIST_SCHEMA,
+    description:
+      'textBody 의 맞은 곳 [시작, 끝) — UTF-16 (textBody 는 NFC 로 맞춘 글이다). htmlBody 는 글 조각에 <mark> 가 들어 있다',
+    example: [[120, 122]],
+  })
+  textBody!: SearchRange[];
+}
+
 export class MessageDetailDto
   extends MessageSummaryDto
   implements MessageDetail
@@ -406,6 +502,14 @@ export class MessageDetailDto
     type: () => [MessageLargeFileDto],
   })
   largeFiles!: MessageLargeFileDto[];
+
+  @ApiProperty({
+    description:
+      '검색 강조 (14단계) — 검색 쿼리(q · subject · body)를 함께 보냈을 때만, 없으면 null. 강조가 있으면 subject · 첨부 이름 · textBody 는 NFC 로 맞춘 글이고 htmlBody 의 맞은 글 조각에 <mark> 가 있다',
+    type: MessageDetailHighlightDto,
+    nullable: true,
+  })
+  searchHighlight!: MessageDetailHighlightDto | null;
 }
 
 const SHARED_FILE_STATUSES: SharedFileStatus[] = [
@@ -475,13 +579,132 @@ export class MessageLargeFileDto implements MessageLargeFile {
 
 export class MessagePageDto {
   @ApiProperty({
-    type: [MessageSummaryDto],
+    type: [MessageListItemDto],
     description: '받은 시각 내림차순',
   })
+  items!: MessageListItemDto[];
+
+  @ApiProperty({
+    type: PageInfoDto,
+    description:
+      'total — 목록 · 엔진 방식 검색은 늘, 색인 방식 검색은 첫 쪽에서만 1,000 까지(넘거나 다 세지 못하면 null). 색인 방식은 쪽이 limit 보다 적거나 비어도 hasNext 일 수 있다(이어 찾기)',
+  })
+  pageInfo!: PageInfoDto;
+}
+
+/** 대화의 기준 — 우리 색인(답장 관계 + 말머리를 뗀 제목) 또는 엔진의 스레드(색인을 다 만들기 전) — 14단계 */
+const CONVERSATION_BASES: ConversationBasis[] = ['index', 'engine'];
+
+/** 같은 대화 (GET /api/messages/{id}/conversation — 14단계) */
+export class ConversationPageDto {
+  @ApiProperty({
+    type: [MessageSummaryDto],
+    description:
+      '그 메일의 대화 — 오래된 차례(받은 시각). 보낸편지함 포함, 휴지통 · 스팸메일함에만 든 메일과 발송 중인 내부 초안은 빼되 지금 메일은 넣는다. 한 통뿐이면 그 메일 하나',
+  })
   items!: MessageSummaryDto[];
 
-  @ApiProperty({ type: PageInfoDto, description: 'total 포함' })
+  @ApiProperty({
+    type: PageInfoDto,
+    description:
+      'total — 대화의 메일 수. 색인 방식은 첫 쪽에서만, 엔진 방식은 스레드를 모두 읽었을 때(상한 이하)만 쪽마다 — 넘으면 null (쪽이 limit 보다 적어도 hasNext 면 이어 읽는다)',
+  })
   pageInfo!: PageInfoDto;
+
+  @ApiProperty({
+    description:
+      '대화의 기준 — index 우리 색인(답장 관계 + 말머리를 뗀 제목이 같음) · engine 엔진의 스레드(그 직원의 색인을 다 만들기 전)',
+    enum: CONVERSATION_BASES,
+    example: 'index',
+  })
+  basis!: ConversationBasis;
+}
+
+/** 묶은 목록의 대화 하나 (GET /api/conversations — 14단계) */
+export class ConversationSummaryDto implements ConversationSummary {
+  @ApiProperty({
+    description:
+      '대화 — 불투명 문자열(색인이면 대화 키, 엔진이면 스레드 id). 한 목록 안에서 대화를 가리는 데만 쓴다',
+    example: 'eaaaaab',
+  })
+  id!: string;
+
+  @ApiProperty({
+    type: MessageSummaryDto,
+    description: '그 메일함 안 마지막 메일 — 줄을 누르면 연다',
+  })
+  latest!: MessageSummaryDto;
+
+  @ApiProperty({
+    type: [MailAddressDto],
+    description: `보낸 사람들 — 대화 전체에서 받은 차례, 주소마다 한 번, ${CONVERSATION_PARTICIPANTS_MAX}명까지 (화면은 내 주소를 "나"로). 엔진 방식에서 스레드가 상한을 넘으면 읽은 최신 메일에서만`,
+  })
+  participants!: MailAddressDto[];
+
+  @ApiProperty({
+    description:
+      '대화 전체의 메일 수 — 보낸편지함 포함, 휴지통 · 스팸메일함에만 든 메일은 빼고(그 메일함의 메일은 넣는다). 엔진 방식에서 상한 때문에 읽지 못한 오래된 메일은 거르지 않고 더한다',
+    example: 4,
+  })
+  messageCount!: number;
+
+  @ApiProperty({
+    type: [String],
+    description: `그 메일함 안 그 대화의 메일 — 최신부터 ${CONVERSATION_MESSAGE_IDS_MAX}통까지(넘는 오래된 메일은 빠진다). 고르기 · 읽음 · 중요 · 이동 · 삭제는 이 id 들로 여러 통 API(PATCH /api/messages 등)에 — pendingSendIds 는 뺀다`,
+    example: ['eaaaaab', 'eaaaaaa'],
+  })
+  messageIds!: string[];
+
+  @ApiProperty({
+    type: [String],
+    description:
+      'messageIds 가운데 붙잡힌 메일(보내기 취소 · 예약을 기다리는 — pendingSend 가 있는 메일)의 id — 없으면 빈 배열. 붙잡힌 메일은 취소로만 보낸편지함을 떠난다(여러 통 처리에서 뺀다)',
+    example: [],
+  })
+  pendingSendIds!: string[];
+
+  @ApiProperty({
+    description: '그 메일함 안 메일을 모두 읽었다',
+    example: false,
+  })
+  isRead!: boolean;
+
+  @ApiProperty({
+    description: '그 메일함 안 메일 가운데 하나라도 중요 표시',
+    example: false,
+  })
+  isFlagged!: boolean;
+
+  @ApiProperty({
+    description:
+      '그 메일함 안 메일 가운데 하나라도 첨부가 있다 (목록의 hasAttachment 와 같은 판정)',
+    example: true,
+  })
+  hasAttachment!: boolean;
+}
+
+/** 대화로 묶은 목록 (GET /api/conversations — 14단계) */
+export class ConversationListPageDto {
+  @ApiProperty({
+    type: [ConversationSummaryDto],
+    description: '그 메일함의 대화 — 그 메일함 안 마지막 받은 시각 최신부터',
+  })
+  items!: ConversationSummaryDto[];
+
+  @ApiProperty({
+    type: PageInfoDto,
+    description:
+      'total — 그 메일함의 대화 수(색인 방식은 첫 쪽에서만 · 엔진 방식은 엔진이 센 스레드 수)',
+  })
+  pageInfo!: PageInfoDto;
+
+  @ApiProperty({
+    description:
+      '묶은 기준 — index 우리 색인 · engine 엔진의 스레드(그 직원의 색인을 다 만들기 전 — 통 수 · 묶음이 엔진 규칙이다)',
+    enum: CONVERSATION_BASES,
+    example: 'index',
+  })
+  basis!: ConversationBasis;
 }
 
 const REJECTION_REASONS: RecipientRejectionReason[] = [
diff --git a/backend/src/modules/mail/dto/message-detail-query.dto.spec.ts b/backend/src/modules/mail/dto/message-detail-query.dto.spec.ts
index 0ef15c5..287854b 100644
--- a/backend/src/modules/mail/dto/message-detail-query.dto.spec.ts
+++ b/backend/src/modules/mail/dto/message-detail-query.dto.spec.ts
@@ -25,3 +25,72 @@ describe('메일 한 통 읽기 쿼리 (GET /api/messages/{id} — 9단계 image
     expect(await constraintsOf({ show: '1' })).toEqual(['whitelistValidation']);
   });
 });
+
+describe('메일 한 통 읽기 쿼리 — 검색 강조 (14단계 q · from · to · subject · body)', () => {
+  it('목록의 검색 칸과 같은 검사 — 앞뒤 공백을 지우고, 길이 · 낱말 수를 본다', async () => {
+    for (const field of ['q', 'from', 'to', 'subject', 'body']) {
+      expect(await constraintsOf({ [field]: ' 계약 ' })).toEqual([]);
+      expect(await constraintsOf({ [field]: '가'.repeat(201) })).toEqual([
+        'maxCodeUnits',
+      ]);
+      expect(
+        await constraintsOf({
+          [field]: Array.from({ length: 9 }, (_, i) => `w${i}`).join(' '),
+        }),
+      ).toEqual(['maxSearchWords', 'maxCombinedSearchWords']);
+      expect(await constraintsOf({ [field]: ['a', 'b'] })).toContain(
+        'isString',
+      );
+    }
+  });
+
+  it('images=show 와 함께 받는다 · 목록에만 있는 조건(after · hasAttachment)은 받지 않는다', async () => {
+    expect(await constraintsOf({ images: 'show', q: '계약' })).toEqual([]);
+    expect(await constraintsOf({ after: '2026-10-31T15:00:00.000Z' })).toEqual([
+      'whitelistValidation',
+    ]);
+    expect(await constraintsOf({ hasAttachment: 'true' })).toEqual([
+      'whitelistValidation',
+    ]);
+  });
+});
+
+describe('메일 한 통 읽기 쿼리 — 받는 칸은 계약과 같다 (14단계 리뷰 M2 · M3)', () => {
+  it('q · from · to · subject · body 의 낱말은 합쳐 8개까지 — 목록과 같다', async () => {
+    const words = (prefix: string, count: number) =>
+      Array.from({ length: count }, (_, index) => `${prefix}${index}`).join(
+        ' ',
+      );
+    expect(
+      await constraintsOf({ q: words('q', 4), subject: words('s', 4) }),
+    ).toEqual([]);
+    expect(
+      await constraintsOf({ q: words('q', 4), body: words('b', 5) }),
+    ).toEqual(['maxCombinedSearchWords']);
+  });
+
+  it('images · q · from · to · subject · body 밖의 이름(cursor · limit · mailboxId · after · before · hasAttachment)은 400', async () => {
+    expect(
+      await constraintsOf({
+        images: 'show',
+        q: '계약',
+        from: '이도윤',
+        to: 'ara',
+        subject: '견적',
+        body: '일정',
+      }),
+    ).toEqual([]);
+    for (const name of [
+      'cursor',
+      'limit',
+      'mailboxId',
+      'after',
+      'before',
+      'hasAttachment',
+    ]) {
+      expect(await constraintsOf({ [name]: '1' })).toEqual([
+        'whitelistValidation',
+      ]);
+    }
+  });
+});
diff --git a/backend/src/modules/mail/dto/message-detail-query.dto.ts b/backend/src/modules/mail/dto/message-detail-query.dto.ts
index 6c24fb1..aa00ca3 100644
--- a/backend/src/modules/mail/dto/message-detail-query.dto.ts
+++ b/backend/src/modules/mail/dto/message-detail-query.dto.ts
@@ -1,12 +1,23 @@
 import { ApiPropertyOptional } from '@nestjs/swagger';
 import { IsIn, IsOptional } from 'class-validator';
 
+import {
+  MAX_SEARCH_LENGTH,
+  MAX_SEARCH_WORDS,
+} from '@/modules/mail/mail.constants';
+import { SearchTextField } from './search-query-fields';
+
 /** 외부 이미지를 보이는 본문 (GET /api/messages/{id}?images=show) — 계약 2절 "외부 이미지 보기" (9단계) */
 export const SHOW_IMAGES = 'show';
 
+/** 강조에 쓰는 검색 칸의 설명 꼬리 */
+const HIGHLIGHT_RULE = `검색 결과에서 연 메일을 강조할 때 목록과 같은 값을 보낸다 — 검사는 목록의 검색어와 같다(다섯 칸의 낱말을 합쳐 ${MAX_SEARCH_WORDS}개까지)`;
+
 /**
  * GET /api/messages/{id} 의 쿼리 — `images=show` 면 외부 이미지를 중계 주소로 바꿔 넣는다(스팸메일함의 메일도).
- * 없으면 그 직원의 설정(externalImages)을 따른다. 모르는 값 · 모르는 쿼리는 400 VAL_001
+ * 없으면 그 직원의 설정(externalImages)을 따른다. 검색 칸(q · from · to · subject · body — 14단계)을 받으면 맞은 곳을 강조한다
+ * (searchHighlight · htmlBody 의 `<mark>`). from · to 는 받기만 하고 강조하지 않는다. 모르는 값 · 모르는 쿼리는 400 VAL_001 —
+ * 목록에만 있는 cursor · limit · mailboxId · after · before · hasAttachment 도 받지 않는다(계약 2절 "검색 — 14단계" — 화면은 다섯 칸만 넘긴다)
  */
 export class MessageDetailQueryDto {
   @ApiPropertyOptional({
@@ -18,4 +29,39 @@ export class MessageDetailQueryDto {
   @IsOptional()
   @IsIn([SHOW_IMAGES], { message: '이미지 보기 값이 올바르지 않습니다.' })
   images?: typeof SHOW_IMAGES;
+
+  @ApiPropertyOptional({
+    description: `검색어 — 제목 · 본문 · 첨부 이름의 맞은 곳을 강조한다. ${HIGHLIGHT_RULE}`,
+    maxLength: MAX_SEARCH_LENGTH,
+  })
+  @SearchTextField('검색어', '검색어는')
+  q?: string;
+
+  @ApiPropertyOptional({
+    description: `보낸 사람 조건 — 받기만 하고 강조하지 않는다. ${HIGHLIGHT_RULE}`,
+    maxLength: MAX_SEARCH_LENGTH,
+  })
+  @SearchTextField('보낸 사람', '보낸 사람은')
+  from?: string;
+
+  @ApiPropertyOptional({
+    description: `받는 사람 조건 — 받기만 하고 강조하지 않는다. ${HIGHLIGHT_RULE}`,
+    maxLength: MAX_SEARCH_LENGTH,
+  })
+  @SearchTextField('받는 사람', '받는 사람은')
+  to?: string;
+
+  @ApiPropertyOptional({
+    description: `제목 조건 — 제목의 맞은 곳을 강조한다. ${HIGHLIGHT_RULE}`,
+    maxLength: MAX_SEARCH_LENGTH,
+  })
+  @SearchTextField('제목', '제목은')
+  subject?: string;
+
+  @ApiPropertyOptional({
+    description: `내용 조건 — 본문의 맞은 곳을 강조한다. ${HIGHLIGHT_RULE}`,
+    maxLength: MAX_SEARCH_LENGTH,
+  })
+  @SearchTextField('내용', '내용은')
+  body?: string;
 }
diff --git a/backend/src/modules/mail/dto/message-list-query.dto.spec.ts b/backend/src/modules/mail/dto/message-list-query.dto.spec.ts
index 7bd7b15..21c3524 100644
--- a/backend/src/modules/mail/dto/message-list-query.dto.spec.ts
+++ b/backend/src/modules/mail/dto/message-list-query.dto.spec.ts
@@ -1,6 +1,9 @@
+import { BadRequestException } from '@nestjs/common';
 import { plainToInstance } from 'class-transformer';
 import { validate } from 'class-validator';
 
+import { startCpuTimer } from '@/../test/cpu-time';
+import { createValidationPipe } from '@/app.setup';
 import {
   MAX_SEARCH_LENGTH,
   MAX_SEARCH_WORDS,
@@ -63,10 +66,10 @@ describe('MessageListQueryDto (GET /api/messages)', () => {
     );
     expect(
       (await check({ q: words(MAX_SEARCH_WORDS + 1) })).constraints,
-    ).toEqual(['maxSearchWords']);
+    ).toEqual(['maxSearchWords', 'maxCombinedSearchWords']);
     expect(
       (await check({ q: `"${words(MAX_SEARCH_WORDS + 1)}"` })).constraints,
-    ).toEqual(['maxSearchWords']);
+    ).toEqual(['maxSearchWords', 'maxCombinedSearchWords']);
   });
 
   it('검색어가 문자열이 아니면(같은 이름을 두 번 보냄) 형식 오류', async () => {
@@ -75,3 +78,154 @@ describe('MessageListQueryDto (GET /api/messages)', () => {
     );
   });
 });
+
+describe('MessageListQueryDto — 조건 검색 (14단계)', () => {
+  const TEXT_FIELDS = ['from', 'to', 'subject', 'body'] as const;
+
+  it('글 조건(from · to · subject · body)은 검색어와 같다 — 앞뒤 공백을 지우고, 공백뿐이면 없는 것', async () => {
+    for (const field of TEXT_FIELDS) {
+      const trimmed = await check({ [field]: '  이도윤 계약 ' });
+      expect(trimmed.constraints).toEqual([]);
+      expect(trimmed.dto[field]).toBe('이도윤 계약');
+
+      const blank = await check({ [field]: ' \u3000 ' });
+      expect(blank.constraints).toEqual([]);
+      expect(blank.dto[field]).toBeUndefined();
+    }
+  });
+
+  it(`글 조건도 앞뒤 공백을 뺀 ${MAX_SEARCH_LENGTH}자 · 낱말 ${MAX_SEARCH_WORDS}개까지, 글이 아니면 형식 오류`, async () => {
+    const words = (count: number) =>
+      Array.from({ length: count }, (_, index) => `w${index}`).join(' ');
+    for (const field of TEXT_FIELDS) {
+      expect(
+        (await check({ [field]: '가'.repeat(MAX_SEARCH_LENGTH) })).constraints,
+      ).toEqual([]);
+      expect(
+        (await check({ [field]: '가'.repeat(MAX_SEARCH_LENGTH + 1) }))
+          .constraints,
+      ).toEqual(['maxCodeUnits']);
+      expect(
+        (await check({ [field]: words(MAX_SEARCH_WORDS) })).constraints,
+      ).toEqual([]);
+      expect(
+        (await check({ [field]: words(MAX_SEARCH_WORDS + 1) })).constraints,
+      ).toEqual(['maxSearchWords', 'maxCombinedSearchWords']);
+      expect((await check({ [field]: ['a', 'b'] })).constraints).toContain(
+        'isString',
+      );
+    }
+  });
+
+  it('기간(after · before)은 ISO 8601 UTC(Z)만 — 없는 날짜 · 시간대 표기 · 날짜만 · 빈 값은 형식 오류', async () => {
+    expect(
+      (
+        await check({
+          after: '2026-10-31T15:00:00.000Z',
+          before: '2026-11-30T15:00:00Z',
+        })
+      ).constraints,
+    ).toEqual([]);
+    for (const value of [
+      '',
+      '2026-11-01',
+      '2026-11-01T00:00:00+09:00',
+      '2026-02-30T00:00:00.000Z',
+      '2026-11-01T00:00:00.0000Z',
+      'yesterday',
+    ]) {
+      expect((await check({ after: value })).constraints).toEqual([
+        'isUtcDateTime',
+      ]);
+      expect((await check({ before: value })).constraints).toEqual([
+        'isUtcDateTime',
+      ]);
+    }
+  });
+
+  it('첨부 조건은 true 만 — false · 1 · 대문자 · 빈 값은 형식 오류, 모르는 쿼리는 받지 않는다', async () => {
+    expect((await check({ hasAttachment: 'true' })).constraints).toEqual([]);
+    for (const hasAttachment of ['false', '1', 'TRUE', '']) {
+      expect((await check({ hasAttachment })).constraints).toEqual(['isIn']);
+    }
+    expect((await check({ cc: 'ara' })).constraints).toEqual([
+      'whitelistValidation',
+    ]);
+  });
+
+  it('전역 검사 그대로(stopAtFirstError) — 긴 글은 길이에서 멈춘다: 낱말을 나누지 않고 싸게 400 (CPU 시간)', async () => {
+    const pipe = createValidationPipe();
+    // 낱말 10만 개 · 30만 자 — 길이(MaxCodeUnits — 길이만 본다)에서 걸려 낱말 수 검사(나누기)까지 가지 않는다
+    const huge = 'ab '.repeat(100_000);
+    for (const field of ['q', ...TEXT_FIELDS]) {
+      const cpuMs = startCpuTimer();
+      const error = await pipe
+        .transform(
+          { [field]: huge },
+          { type: 'query', metatype: MessageListQueryDto },
+        )
+        .then(
+          () => null,
+          (caught: unknown) => caught,
+        );
+      // 지금 수 ms — 부하를 견디게 10배 넘게
+      expect(cpuMs()).toBeLessThan(500);
+      expect(error).toBeInstanceOf(BadRequestException);
+      const { message } = (error as BadRequestException).getResponse() as {
+        message: string[];
+      };
+      expect(message).toHaveLength(1);
+      expect(message[0]).toContain(`${MAX_SEARCH_LENGTH}자 이하`);
+    }
+  });
+});
+
+describe('MessageListQueryDto — 검색어와 조건을 합친 낱말 수 (14단계 리뷰 M2)', () => {
+  const words = (prefix: string, count: number) =>
+    Array.from({ length: count }, (_, index) => `${prefix}${index}`).join(' ');
+
+  it(`q 와 조건 칸 넷(from · to · subject · body)의 낱말을 합쳐 ${MAX_SEARCH_WORDS}개까지 — 넘으면 한 번만 알린다`, async () => {
+    expect(
+      (
+        await check({
+          q: words('q', 2),
+          from: words('f', 2),
+          to: words('t', 2),
+          subject: words('s', 1),
+          body: words('b', 1),
+        })
+      ).constraints,
+    ).toEqual([]);
+    expect(
+      (await check({ q: words('q', 4), to: words('t', 5) })).constraints,
+    ).toEqual(['maxCombinedSearchWords']);
+    // 검색어 없이 조건만이어도 같다
+    expect(
+      (await check({ from: words('f', 5), body: words('b', 4) })).constraints,
+    ).toEqual(['maxCombinedSearchWords']);
+  });
+
+  it('기간 · 첨부 · 메일함은 세지 않는다 · 따옴표 안의 낱말은 센다', async () => {
+    expect(
+      (
+        await check({
+          q: words('q', MAX_SEARCH_WORDS),
+          after: '2026-10-31T15:00:00.000Z',
+          hasAttachment: 'true',
+          mailboxId: 'a',
+        })
+      ).constraints,
+    ).toEqual([]);
+    expect(
+      (await check({ q: `"${words('q', 5)}"`, subject: words('s', 4) }))
+        .constraints,
+    ).toEqual(['maxCombinedSearchWords']);
+  });
+
+  it('칸 하나가 길이를 넘으면 그 칸의 검사만 — 합친 수를 세려고 긴 글을 나누지 않는다', async () => {
+    // (이 검사는 stopAtFirstError 를 뺀 것이라 그 칸의 규칙이 모두 보인다 — 합친 수는 보지 않았다)
+    expect(
+      (await check({ q: '계약', to: 'ab '.repeat(100) })).constraints,
+    ).toEqual(['maxCodeUnits', 'maxSearchWords']);
+  });
+});
diff --git a/backend/src/modules/mail/dto/message-list-query.dto.ts b/backend/src/modules/mail/dto/message-list-query.dto.ts
index 8fa807a..c8e3b54 100644
--- a/backend/src/modules/mail/dto/message-list-query.dto.ts
+++ b/backend/src/modules/mail/dto/message-list-query.dto.ts
@@ -1,61 +1,29 @@
 import { ApiPropertyOptional } from '@nestjs/swagger';
-import { Transform, type TransformFnParams } from 'class-transformer';
-import {
-  IsOptional,
-  IsString,
-  Matches,
-  ValidateBy,
-  type ValidationOptions,
-} from 'class-validator';
+import { IsIn, IsOptional, Matches } from 'class-validator';
 
-import { MaxCodeUnits } from '@/common/decorators/code-units.decorator';
 import { CursorPaginationQueryDto } from '@/common/dto/pagination.dto';
 import {
   MAIL_ID_PATTERN,
   MAX_SEARCH_LENGTH,
   MAX_SEARCH_WORDS,
-  SEARCH_WORD_SEPARATOR,
 } from '@/modules/mail/mail.constants';
+import { IsUtcDateTime } from './mail-vacation.dto';
+import { SearchTextField } from './search-query-fields';
+
+/** 첨부 있음 조건의 값 — 이것만 받는다 (없으면 첨부와 상관없이) */
+export const HAS_ATTACHMENT_ONLY = 'true';
+
+/** 글 칸의 설명 꼬리 — 검사는 검색어와 같다 */
+const TEXT_FIELD_RULE = `앞뒤 공백을 뺀 1~${MAX_SEARCH_LENGTH}자 · 낱말 ${MAX_SEARCH_WORDS}개까지(검색어와 같은 검사 — q 와 조건 넷의 낱말을 합쳐서도 ${MAX_SEARCH_WORDS}개까지), 공백뿐이면 없는 것으로 본다. 큰따옴표 구절 · 앞뒤 문장부호 떼기 · NUL 을 U+FFFD 로 바꾸기도 검색어와 같다`;
 
 /**
- * 검색어 — 앞뒤 공백을 지우고, 공백뿐이면 없는 것으로 본다 (계약 2절 "검색").
- * 문자열이 아니면(같은 이름을 두 번 보낸 배열 등) 그대로 두어 IsString 이 막는다.
- */
-function normalizeSearchQuery({ value }: TransformFnParams): unknown {
-  const raw: unknown = value;
-  if (typeof raw !== 'string') return raw;
-  const trimmed = raw.trim();
-  return trimmed === '' ? undefined : trimmed;
-}
-
-/** 검색어의 낱말 수 — 띄어쓰기(공백 문자)로 나눈 조각 (따옴표와 상관없이 센다) */
-function countSearchWords(text: string): number {
-  return text.split(SEARCH_WORD_SEPARATOR).filter((word) => word !== '').length;
-}
-
-/** 최대 낱말 수 */
-function MaxSearchWords(max: number, options: ValidationOptions) {
-  return ValidateBy(
-    {
-      name: 'maxSearchWords',
-      constraints: [max],
-      validator: {
-        validate: (value: unknown) =>
-          typeof value === 'string' && countSearchWords(value) <= max,
-      },
-    },
-    options,
-  );
-}
-
-/**
- * GET /api/messages — 커서 페이지네이션 + 메일함 + 검색어.
- * mailboxId 와 q 중 하나는 있어야 한다 — 둘 다 없으면 서비스가 400 VAL_001 (mail.service.ts 의 listMessages)
+ * GET /api/messages — 커서 페이지네이션 + 메일함 + 검색어 + 조건(14단계).
+ * mailboxId 와 검색(q 나 조건 하나) 가운데 하나는 있어야 한다 — 둘 다 없으면 서비스가 400 VAL_001 (message-list.service.ts)
  */
 export class MessageListQueryDto extends CursorPaginationQueryDto {
   @ApiPropertyOptional({
     description:
-      '메일함 id — 없으면 q 가 있어야 하고, 휴지통·스팸메일함을 뺀 모든 메일함에서 찾는다 (mailboxId 와 q 가 둘 다 없으면 400 VAL_001)',
+      '메일함 id — 없으면 검색(q 나 조건)이 있어야 하고, 휴지통·스팸메일함을 뺀 모든 메일함에서 찾는다 (둘 다 없으면 400 VAL_001)',
     example: 'a',
   })
   @IsOptional()
@@ -64,21 +32,76 @@ export class MessageListQueryDto extends CursorPaginationQueryDto {
 
   @ApiPropertyOptional({
     description:
-      `검색어 — 앞뒤 공백을 뺀 1~${MAX_SEARCH_LENGTH}자(JS 문자열 길이), 낱말(띄어쓰기로 나눈 것) ${MAX_SEARCH_WORDS}개까지. 공백뿐이면 없는 것으로 본다. ` +
-      '보낸 사람·받는 사람·참조·제목·본문에서 찾고, 여러 낱말이면 모두 들어간 메일만. 큰따옴표로 감싼 부분은 그 구절 그대로 찾는다. ' +
-      '한글로 끝나는 낱말은 흔한 조사를 붙인 형태도 함께 찾는다(회의 → 회의를 · 회의에서 …). ' +
-      '낱말 앞뒤의 문장부호는 떼고(회의, → 회의), 문자·숫자가 없는 낱말(- · … 등)은 빼고, 찾을 낱말이 하나도 없으면 빈 목록. 커서는 같은 검색어·범위로만 쓴다',
+      `검색어 — 앞뒤 공백을 뺀 1~${MAX_SEARCH_LENGTH}자(JS 문자열 길이), 낱말(띄어쓰기로 나눈 것) ${MAX_SEARCH_WORDS}개까지(조건 from · to · subject · body 의 낱말과 합쳐서도 ${MAX_SEARCH_WORDS}개까지). 공백뿐이면 없는 것으로 본다. ` +
+      '보낸 사람·받는 사람·참조·제목·첨부 이름·본문에서 찾고, 여러 낱말이면 모두 들어간 메일만. 큰따옴표로 감싼 부분은 그 구절 그대로 찾는다. ' +
+      '색인이 준비됐으면(GET /api/search-index 의 ready) 부분 일치(붙여 쓴 말 · 앞부분 · 제목 맨 앞의 말머리까지, 영문 대소문자 없이), ' +
+      '준비 중이면 낱말이 통째로 같을 때만 맞고 한글로 끝나는 낱말은 흔한 조사를 붙인 형태도 함께 찾는다. ' +
+      '낱말 앞뒤의 문장부호는 떼고(회의, → 회의), 문자·숫자가 없는 낱말(- · … 등)은 빼고, 찾을 낱말이 하나도 없으면 빈 목록. 커서는 같은 검색어·조건·범위로만 쓴다',
     example: '서버 이전',
     maxLength: MAX_SEARCH_LENGTH,
   })
-  @Transform(normalizeSearchQuery)
-  @IsOptional()
-  @IsString({ message: '검색어 형식이 올바르지 않습니다.' })
-  @MaxCodeUnits(MAX_SEARCH_LENGTH, {
-    message: `검색어는 ${MAX_SEARCH_LENGTH}자 이하로 입력해 주세요.`,
-  })
-  @MaxSearchWords(MAX_SEARCH_WORDS, {
-    message: `검색어는 낱말 ${MAX_SEARCH_WORDS}개까지 입력해 주세요.`,
-  })
+  @SearchTextField('검색어', '검색어는')
   q?: string;
+
+  @ApiPropertyOptional({
+    description: `보낸 사람 조건 — 보낸 사람의 이름 · 주소에서 찾는다. ${TEXT_FIELD_RULE}`,
+    example: '이도윤',
+    maxLength: MAX_SEARCH_LENGTH,
+  })
+  @SearchTextField('보낸 사람', '보낸 사람은')
+  from?: string;
+
+  @ApiPropertyOptional({
+    description: `받는 사람 조건 — 받는 사람과 참조의 이름 · 주소에서 찾는다. ${TEXT_FIELD_RULE}`,
+    example: 'ara.kim',
+    maxLength: MAX_SEARCH_LENGTH,
+  })
+  @SearchTextField('받는 사람', '받는 사람은')
+  to?: string;
+
+  @ApiPropertyOptional({
+    description: `제목 조건. ${TEXT_FIELD_RULE}`,
+    example: '견적',
+    maxLength: MAX_SEARCH_LENGTH,
+  })
+  @SearchTextField('제목', '제목은')
+  subject?: string;
+
+  @ApiPropertyOptional({
+    description: `내용 조건 — 본문에서 찾는다(첨부 파일 안의 글은 찾지 않는다). ${TEXT_FIELD_RULE}`,
+    example: '계약',
+    maxLength: MAX_SEARCH_LENGTH,
+  })
+  @SearchTextField('내용', '내용은')
+  body?: string;
+
+  @ApiPropertyOptional({
+    description:
+      '받은 시각이 이 시각 이후(이상)인 메일만 — ISO 8601 UTC(Z). 화면은 브라우저 시간대의 시작 날짜 0시를 UTC 로 바꿔 보낸다',
+    example: '2026-10-31T15:00:00.000Z',
+  })
+  @IsOptional()
+  @IsUtcDateTime({ message: '시작 날짜 형식이 올바르지 않습니다.' })
+  after?: string;
+
+  @ApiPropertyOptional({
+    description:
+      '받은 시각이 이 시각 앞(미만)인 메일만 — ISO 8601 UTC(Z). 화면은 끝 날짜의 다음 날 0시를 보낸다',
+    example: '2026-11-30T15:00:00.000Z',
+  })
+  @IsOptional()
+  @IsUtcDateTime({ message: '끝 날짜 형식이 올바르지 않습니다.' })
+  before?: string;
+
+  @ApiPropertyOptional({
+    description:
+      'true 면 첨부 파일이 있는 메일만 (목록의 첨부 표시와 같은 판정 — 본문 그림만 있는 메일은 빠진다). 다른 값은 400 VAL_001',
+    enum: [HAS_ATTACHMENT_ONLY],
+    example: HAS_ATTACHMENT_ONLY,
+  })
+  @IsOptional()
+  @IsIn([HAS_ATTACHMENT_ONLY], {
+    message: '첨부 조건이 올바르지 않습니다.',
+  })
+  hasAttachment?: typeof HAS_ATTACHMENT_ONLY;
 }
diff --git a/backend/src/modules/mail/dto/search-query-fields.ts b/backend/src/modules/mail/dto/search-query-fields.ts
new file mode 100644
index 0000000..2ad2f53
--- /dev/null
+++ b/backend/src/modules/mail/dto/search-query-fields.ts
@@ -0,0 +1,121 @@
+import { applyDecorators } from '@nestjs/common';
+import { Transform, type TransformFnParams } from 'class-transformer';
+import {
+  IsOptional,
+  IsString,
+  ValidateBy,
+  type ValidationArguments,
+  type ValidationOptions,
+} from 'class-validator';
+
+import { MaxCodeUnits } from '@/common/decorators/code-units.decorator';
+import {
+  MAX_SEARCH_LENGTH,
+  MAX_SEARCH_WORDS,
+  SEARCH_WORD_SEPARATOR,
+} from '@/modules/mail/mail.constants';
+
+/**
+ * 검색 글 칸의 검사 (계약 2절 "검색" · "검색 — 14단계" — 검색어 q 와 조건 검색의 from · to · subject · body 가 같이 쓴다).
+ * 앞뒤 공백을 지우고 공백뿐이면 없는 것으로 본다. 앞뒤 공백을 뺀 1~MAX_SEARCH_LENGTH 자(JS 문자열 길이) · 낱말 MAX_SEARCH_WORDS 개까지,
+ * 그리고 **다섯 칸을 합친 낱말도 MAX_SEARCH_WORDS 개까지** — 색인을 채우는 동안의 엔진 방식이 낱말마다 조사 형태를 붙여 묻는다(3단계에서 잰 비용 안에 두려고).
+ * 검사는 적은 차례대로 돈다(applyDecorators — 8단계 DTO 와 같다): 형식 → 길이 → 낱말 수 → 합친 낱말 수. 길이에서 걸리면 낱말을 나누지 않는다
+ */
+
+/** 낱말 수를 합쳐 세는 검색 글 칸 — 목록(GET /api/messages)과 읽기(GET /api/messages/{id})의 같은 이름 */
+export const SEARCH_TEXT_FIELDS = [
+  'q',
+  'from',
+  'to',
+  'subject',
+  'body',
+] as const;
+
+/** 앞뒤 공백을 지우고, 공백뿐이면 없는 것으로 — 문자열이 아니면(같은 이름을 두 번 보낸 배열 등) 그대로 두어 IsString 이 막는다 */
+function normalizeSearchText({ value }: TransformFnParams): unknown {
+  const raw: unknown = value;
+  if (typeof raw !== 'string') return raw;
+  const trimmed = raw.trim();
+  return trimmed === '' ? undefined : trimmed;
+}
+
+/** 검색 글의 낱말 수 — 띄어쓰기(공백 문자)로 나눈 조각 (따옴표와 상관없이 센다) */
+export function countSearchWords(text: string): number {
+  return text.split(SEARCH_WORD_SEPARATOR).filter((word) => word !== '').length;
+}
+
+/** 최대 낱말 수 */
+function MaxSearchWords(max: number, options: ValidationOptions) {
+  return ValidateBy(
+    {
+      name: 'maxSearchWords',
+      constraints: [max],
+      validator: {
+        validate: (value: unknown) =>
+          typeof value === 'string' && countSearchWords(value) <= max,
+      },
+    },
+    options,
+  );
+}
+
+/**
+ * 다섯 칸을 합친 낱말 수 — 값이 있는 첫 칸에서만 센다(한 번만 알린다). 다른 칸이 글이 아니거나 길이를 넘으면 세지 않는다 —
+ * 그 칸의 검사가 막는다(긴 글을 나누지 않게)
+ */
+export function combinedSearchWords(
+  object: Readonly<Record<string, unknown>>,
+): number | null {
+  let total = 0;
+  for (const field of SEARCH_TEXT_FIELDS) {
+    const value = object[field];
+    if (value === undefined) continue;
+    if (typeof value !== 'string' || value.length > MAX_SEARCH_LENGTH) {
+      return null;
+    }
+    total += countSearchWords(value);
+  }
+  return total;
+}
+
+function MaxCombinedSearchWords(max: number, options: ValidationOptions) {
+  return ValidateBy(
+    {
+      name: 'maxCombinedSearchWords',
+      constraints: [max],
+      validator: {
+        validate: (_value: unknown, args?: ValidationArguments) => {
+          const object = (args?.object ?? {}) as Record<string, unknown>;
+          const first = SEARCH_TEXT_FIELDS.find(
+            (field) => object[field] !== undefined,
+          );
+          if (first !== args?.property) return true;
+          const total = combinedSearchWords(object);
+          return total === null || total <= max;
+        },
+      },
+    },
+    options,
+  );
+}
+
+/**
+ * 검색 글 칸 하나 — `label` 은 검사 글의 이름(검색어 · 보낸 사람 …), `topic` 은 조사를 붙인 꼴(검색어는 · 보낸 사람은 …).
+ * 검사 글은 로그 · 응답에 나가지 않는다(응답은 늘 VAL_001 의 사전 문구 — 계약 머리말)
+ */
+export function SearchTextField(label: string, topic: string) {
+  return applyDecorators(
+    Transform(normalizeSearchText),
+    IsOptional(),
+    IsString({ message: `${label} 형식이 올바르지 않습니다.` }),
+    MaxCodeUnits(MAX_SEARCH_LENGTH, {
+      message: `${topic} ${MAX_SEARCH_LENGTH}자 이하로 입력해 주세요.`,
+    }),
+    MaxSearchWords(MAX_SEARCH_WORDS, {
+      message: `${topic} 낱말 ${MAX_SEARCH_WORDS}개까지 입력해 주세요.`,
+    }),
+    MaxCombinedSearchWords(MAX_SEARCH_WORDS, {
+      message: `검색어와 조건은 낱말을 모두 합쳐 ${MAX_SEARCH_WORDS}개까지 입력해 주세요.`,
+    }),
+  );
+}
diff --git a/backend/src/modules/mail/html/html-mark.spec.ts b/backend/src/modules/mail/html/html-mark.spec.ts
new file mode 100644
index 0000000..4e22f13
--- /dev/null
+++ b/backend/src/modules/mail/html/html-mark.spec.ts
@@ -0,0 +1,176 @@
+import { startCpuTimer } from '@/../test/cpu-time';
+import { MAX_HTML_MARKS, markHtmlText } from './html-mark';
+import { sanitizeMailHtml } from './sanitize-mail-html';
+
+const marked = (html: string, ...terms: string[]) =>
+  markHtmlText(html, terms).html;
+
+const countMarks = (html: string) => html.split('<mark>').length - 1;
+
+describe('본문 HTML 강조 (html-mark — 14단계 설계 C2)', () => {
+  it('글 조각의 맞은 곳에 <mark> — 대소문자 · 전각은 접어서 맞추고 원래 글자는 그대로', () => {
+    expect(marked('<p>계약 갱신 안내</p>', '계약')).toBe(
+      '<p><mark>계약</mark> 갱신 안내</p>',
+    );
+    expect(marked('<p>ERP 와 Erp 와 ＥＲＰ</p>', 'erp')).toBe(
+      '<p><mark>ERP</mark> 와 <mark>Erp</mark> 와 <mark>ＥＲＰ</mark></p>',
+    );
+    expect(markHtmlText('<p>계약 계약</p>', ['계약']).marks).toBe(2);
+  });
+
+  it('겹치거나 맞닿은 맞은 곳은 하나로 — 여러 말이 한 자리에 맞아도 <mark> 는 겹치지 않는다', () => {
+    expect(marked('<p>계약서 갱신</p>', '계약', '약서')).toBe(
+      '<p><mark>계약서</mark> 갱신</p>',
+    );
+  });
+
+  it('태그 안(이름 · 속성 · style · 주소)은 건드리지 않는다', () => {
+    const html =
+      '<a href="https://example.com/계약?q=계약" title="계약 안내" style="font-family:계약">계약</a><img alt="계약" src="cid:x">';
+    expect(marked(html, '계약')).toBe(
+      '<a href="https://example.com/계약?q=계약" title="계약 안내" style="font-family:계약"><mark>계약</mark></a><img alt="계약" src="cid:x">',
+    );
+  });
+
+  it('주석 · 글을 그대로 두는 요소(style · script · textarea · title)의 안은 그대로', () => {
+    expect(
+      marked(
+        '<!-- 계약 --><style>.계약{color:red}</style><title>계약</title><p>계약</p><!-- 닫히지 않은 계약',
+        '계약',
+      ),
+    ).toBe(
+      '<!-- 계약 --><style>.계약{color:red}</style><title>계약</title><p><mark>계약</mark></p><!-- 닫히지 않은 계약',
+    );
+    expect(marked('<SCRIPT>계약</Script >계약', '계약')).toBe(
+      '<SCRIPT>계약</Script ><mark>계약</mark>',
+    );
+  });
+
+  it('문자 참조를 풀어 맞추고 다시 적는다 — &amp; · &lt; · &gt; · &nbsp; · 10진 · 16진', () => {
+    expect(marked('<p>A&amp;B 계약 &lt;중요&gt;</p>', 'a&b', '<중요>')).toBe(
+      '<p><mark>A&amp;B</mark> 계약 <mark>&lt;중요&gt;</mark></p>',
+    );
+    // &nbsp; 는 띄어쓰기와 같이 접힌다 — 구절이 맞는다 (다시 적을 때는 글자 그대로)
+    expect(marked('<p>계약&nbsp;갱신</p>', '계약 갱신')).toBe(
+      '<p><mark>계약\u00a0갱신</mark></p>',
+    );
+    expect(marked('<p>&#44228;&#xC57D; 건</p>', '계약')).toBe(
+      '<p><mark>계약</mark> 건</p>',
+    );
+    // 맞은 곳이 없는 조각은 원래 글자 그대로 (참조를 풀어 다시 적지 않는다)
+    expect(marked('<p>&#44228; &quot;x&quot;</p>', '없는말')).toBe(
+      '<p>&#44228; &quot;x&quot;</p>',
+    );
+  });
+
+  it('모르는 참조 · 닫히지 않은 & 가 있는 조각은 그대로 둔다 (정화 결과에는 나오지 않는다)', () => {
+    expect(marked('<p>&copy; 계약</p>', '계약')).toBe('<p>&copy; 계약</p>');
+    expect(marked('<p>R&D 계약</p><p>계약</p>', '계약')).toBe(
+      '<p>R&D 계약</p><p><mark>계약</mark></p>',
+    );
+  });
+
+  it('줄바꿈 · 탭으로 갈린 구절도 맞는다 — 태그를 건너는 말은 강조하지 않는다', () => {
+    expect(marked('<p>계약\n갱신</p>', '계약 갱신')).toBe(
+      '<p><mark>계약\n갱신</mark></p>',
+    );
+    expect(marked('<p>계<b>약</b></p>', '계약')).toBe('<p>계<b>약</b></p>');
+  });
+
+  it('NFD 로 적은 글도 맞춘다 — 맞은 조각은 NFC 로 다시 적는다', () => {
+    const nfd = '계약 안내'.normalize('NFD');
+    expect(marked(`<p>${nfd}</p>`, '계약')).toBe(
+      '<p><mark>계약</mark> 안내</p>',
+    );
+    expect(marked(`<p>${nfd}</p>`, '없는말')).toBe(`<p>${nfd}</p>`);
+  });
+
+  it('강조할 말이 없거나 빈 본문이면 그대로', () => {
+    expect(markHtmlText('<p>계약</p>', [])).toEqual({
+      html: '<p>계약</p>',
+      marks: 0,
+    });
+    expect(markHtmlText('<p>계약</p>', ['', ' '])).toEqual({
+      html: '<p>계약</p>',
+      marks: 0,
+    });
+    expect(markHtmlText('', ['계약'])).toEqual({ html: '', marks: 0 });
+  });
+
+  it(`<mark> 는 ${MAX_HTML_MARKS}개까지 — 흔한 말이 수만 번 나와도`, () => {
+    const html = `<p>${'가 '.repeat(5_000)}</p><p>${'가 '.repeat(5_000)}</p>`;
+    const result = markHtmlText(html, ['가']);
+    expect(result.marks).toBe(MAX_HTML_MARKS);
+    expect(countMarks(result.html)).toBe(MAX_HTML_MARKS);
+  });
+
+  it('정화한 HTML 그대로 — 속성 값의 > · 따옴표 · 링크가 깨지지 않고, 넣은 <mark> 는 받은 메일 정화를 다시 지나도 남는다', () => {
+    const { html } = sanitizeMailHtml(
+      '<div title="a > 계약 &quot;b&quot;"><a href="https://example.com/?q=계약&x=1">계약 바로가기</a> 계약&amp;견적 <b>중요</b></div>',
+    );
+    const result = markHtmlText(html, ['계약']);
+
+    expect(result.marks).toBe(2);
+    // 속성은 정화 결과 그대로
+    expect(result.html).toContain('title="a &gt; 계약 &quot;b&quot;"');
+    expect(result.html).toContain('href="https://example.com/?q=계약&amp;x=1"');
+    expect(result.html).toContain('<mark>계약</mark> 바로가기');
+    expect(result.html).toContain('<mark>계약</mark>&amp;견적');
+    // <mark> 는 받은 메일 정화의 허용 태그다 — 다시 정화해도 같다(클라이언트가 그대로 그린다)
+    expect(sanitizeMailHtml(result.html).html).toBe(result.html);
+  });
+
+  it('깊게 중첩된 HTML 도 한 번 훑는다 — 길이에 비례 (CPU 시간)', () => {
+    const depth = 100_000;
+    const html = `${'<div>'.repeat(depth)}계약 안내${'</div>'.repeat(depth)}`;
+    const cpuMs = startCpuTimer();
+
+    const result = markHtmlText(html, ['계약']);
+
+    // 지금 30ms 안팎 — 부하를 견디게 10배 넘게
+    expect(cpuMs()).toBeLessThan(1_000);
+    expect(result.marks).toBe(1);
+    expect(result.html.length).toBe(html.length + '<mark></mark>'.length);
+  });
+
+  it('긴 글(2MB · 조각 수만 개) · 낱말 8개도 길이에 비례한다 (CPU 시간)', () => {
+    const paragraph = `<p>이번 분기 계약 갱신과 단가 조정 일정을 공유합니다 &amp; 확인 부탁드립니다.</p>`;
+    const html = paragraph.repeat(Math.ceil(2_000_000 / paragraph.length));
+    const terms = [
+      '계약',
+      '갱신',
+      '단가',
+      '조정',
+      '일정',
+      '공유',
+      '확인',
+      '"부탁드립니다."',
+    ];
+    const cpuMs = startCpuTimer();
+
+    const result = markHtmlText(html, terms);
+
+    expect(cpuMs()).toBeLessThan(3_000);
+    expect(result.marks).toBe(MAX_HTML_MARKS);
+  });
+
+  it('맞는 말이 없는 2MB 도 한 번 훑고 원래 글 그대로 (CPU 시간 — 리뷰 L6)', () => {
+    const paragraph =
+      '<p>이번 분기 일정을 공유합니다 &amp; 확인 부탁드립니다.<br><b>굵게</b> <a href="https://example.com/a?b=1&amp;c=2">링크</a></p>';
+    const html = paragraph.repeat(Math.ceil(2_000_000 / paragraph.length));
+    const cpuMs = startCpuTimer();
+
+    const result = markHtmlText(html, ['없는말', '"계약 갱신"', 'zzz']);
+
+    // 지금 0.1초 안팎 — 부하를 견디게 10배 넘게
+    expect(cpuMs()).toBeLessThan(2_000);
+    expect(result).toEqual({ html, marks: 0 });
+  });
+
+  it('검색 글의 NUL(U+FFFD 로 바꾼 말)은 본문의 U+FFFD 에 맞는다 — 색인과 같은 글자 (리뷰 L2)', () => {
+    const FFFD = String.fromCharCode(0xfffd);
+    expect(marked(`<p>계${FFFD}약 건</p>`, `계${FFFD}약`)).toBe(
+      `<p><mark>계${FFFD}약</mark> 건</p>`,
+    );
+  });
+});
diff --git a/backend/src/modules/mail/html/html-mark.ts b/backend/src/modules/mail/html/html-mark.ts
new file mode 100644
index 0000000..ce3eaad
--- /dev/null
+++ b/backend/src/modules/mail/html/html-mark.ts
@@ -0,0 +1,175 @@
+import {
+  foldTerms,
+  foldText,
+  matchFoldedRanges,
+} from '@/shared/utils/search-text';
+
+/**
+ * 정화한 메일 HTML 의 글 조각에 `<mark>` 를 넣는다 (순수 함수 — 14단계 설계 C2, 읽기 화면의 검색 강조).
+ * **정화한 뒤에만** 부른다(sanitize-mail-html.ts 의 결과 — 태그가 닫혀 있고 속성 값의 `>` 는 `&gt;` 다). 다시 정화하지 않는다 — 넣는 것은 속성 없는 `<mark>` 뿐이다
+ * (mark 는 받은 메일 정화의 허용 태그다).
+ *
+ * - 태그 안(이름 · 속성 · style)은 건드리지 않는다 — `<` 부터 `>` 까지는 그대로 옮긴다. 주석(`<!-- … -->`)과 글을 그대로 두어야 하는 요소
+ *   (script · style · textarea · title · xmp — 정화가 이미 지우지만)도 그대로
+ * - 글 조각마다 문자 참조를 풀어(&amp; · &lt; · &gt; · &quot; · &apos; · &nbsp; · 10진 · 16진) NFC 로 맞춘 뒤 찾기와 같은 접기 · 부분 일치로 맞춘다
+ *   (search-text.ts — 목록 · 색인과 같은 규칙). 맞은 조각만 다시 적는다(&amp; · &lt; · &gt; 로) — 모르는 이름의 문자 참조가 있는 조각은 그대로 둔다
+ * - 태그를 건너는 말(`계<b>약</b>`)은 강조하지 않는다 — 글 조각 안에서만
+ * - 넣는 `<mark>` 는 `limit`(MAX_HTML_MARKS)개까지
+ * 입력을 한 번 훑는다 — 길이에 비례한다(중첩 깊이와 상관없다)
+ */
+
+/** 한 본문에 넣는 `<mark>` 의 수 */
+export const MAX_HTML_MARKS = 1_000;
+
+/** 문자 참조 이름 · 숫자의 최대 길이 — 넘으면 참조가 아니다 */
+const MAX_REFERENCE_LENGTH = 32;
+
+/** 푸는 이름 있는 참조 — 정화 결과에 나오는 것(sanitize-html 은 글을 풀어 &amp; · &lt; · &gt; 만 다시 적는다)과 흔한 것 */
+const NAMED_REFERENCES: Readonly<Record<string, string>> = {
+  amp: '&',
+  lt: '<',
+  gt: '>',
+  quot: '"',
+  apos: "'",
+  nbsp: '\u00a0',
+};
+
+/** 글을 그대로 두는 요소 — 정화가 지우지만 혹시 남으면 그 안은 건드리지 않는다 */
+const RAW_TEXT_TAGS: ReadonlySet<string> = new Set([
+  'script',
+  'style',
+  'textarea',
+  'title',
+  'xmp',
+]);
+
+const COMMENT_OPEN = '<!--';
+const COMMENT_CLOSE = '-->';
+const MAX_CODE_POINT = 0x10ffff;
+const REPLACEMENT_CHARACTER = '\ufffd';
+
+/** 태그 이름 (`<style …>` → style, 닫는 태그 · 이름 없음은 null) — 소문자 */
+const OPEN_TAG_NAME = /^<([A-Za-z][A-Za-z0-9-]*)/;
+
+function decodeReference(reference: string): string | null {
+  if (reference.startsWith('#')) {
+    const hex = reference[1] === 'x' || reference[1] === 'X';
+    const digits = reference.slice(hex ? 2 : 1);
+    if (!(hex ? /^[0-9A-Fa-f]{1,8}$/ : /^[0-9]{1,8}$/).test(digits)) {
+      return null;
+    }
+    const point = Number.parseInt(digits, hex ? 16 : 10);
+    if (
+      point <= 0 ||
+      point > MAX_CODE_POINT ||
+      (point >= 0xd800 && point <= 0xdfff)
+    ) {
+      return REPLACEMENT_CHARACTER;
+    }
+    return String.fromCodePoint(point);
+  }
+  return NAMED_REFERENCES[reference] ?? null;
+}
+
+/** 글 조각의 문자 참조를 푼다 — 모르는 참조 · 닫히지 않은 `&` 가 있으면 null(그 조각은 그대로 둔다) */
+function decodeText(text: string): string | null {
+  if (!text.includes('&')) return text;
+  let decoded = '';
+  let index = 0;
+  for (;;) {
+    const amp = text.indexOf('&', index);
+    if (amp < 0) return decoded + text.slice(index);
+    decoded += text.slice(index, amp);
+    const limit = Math.min(text.length, amp + 1 + MAX_REFERENCE_LENGTH + 1);
+    const semi = text.indexOf(';', amp + 1);
+    if (semi < 0 || semi >= limit) return null;
+    const value = decodeReference(text.slice(amp + 1, semi));
+    if (value === null) return null;
+    decoded += value;
+    index = semi + 1;
+  }
+}
+
+/** 글을 HTML 글 조각으로 — `&` · `<` · `>` 만 적는다 */
+function escapeText(text: string): string {
+  return text.replace(/[&<>]/g, (char) =>
+    char === '&' ? '&amp;' : char === '<' ? '&lt;' : '&gt;',
+  );
+}
+
+/** 글 조각 하나 — 맞은 곳에 `<mark>` 를 넣은 조각과 넣은 수 (맞은 곳이 없으면 원래 조각 그대로) */
+function markText(
+  source: string,
+  terms: readonly string[],
+  limit: number,
+): { readonly html: string; readonly marks: number } {
+  const decoded = decodeText(source);
+  if (decoded === null) return { html: source, marks: 0 };
+  const text = decoded.normalize('NFC');
+  const ranges = matchFoldedRanges(foldText(text), terms, limit);
+  if (ranges.length === 0) return { html: source, marks: 0 };
+  let html = '';
+  let last = 0;
+  for (const [start, end] of ranges) {
+    html += `${escapeText(text.slice(last, start))}<mark>${escapeText(text.slice(start, end))}</mark>`;
+    last = end;
+  }
+  return { html: html + escapeText(text.slice(last)), marks: ranges.length };
+}
+
+/** `name` 의 닫는 태그 자리 (대소문자 없이) — 없으면 끝 */
+function closingTagAt(html: string, name: string, from: number): number {
+  const pattern = new RegExp(`</${name}[\\s/>]`, 'gi');
+  pattern.lastIndex = from;
+  const found = pattern.exec(html);
+  return found ? found.index : html.length;
+}
+
+export function markHtmlText(
+  html: string,
+  terms: readonly string[],
+  limit: number = MAX_HTML_MARKS,
+): { readonly html: string; readonly marks: number } {
+  const folded = foldTerms(terms);
+  if (folded.length === 0 || html === '') return { html, marks: 0 };
+  const out: string[] = [];
+  let marks = 0;
+  let index = 0;
+  while (index < html.length) {
+    const lt = html.indexOf('<', index);
+    const textEnd = lt < 0 ? html.length : lt;
+    if (textEnd > index) {
+      const text = html.slice(index, textEnd);
+      if (marks < limit) {
+        const marked = markText(text, folded, limit - marks);
+        out.push(marked.html);
+        marks += marked.marks;
+      } else {
+        out.push(text);
+      }
+    }
+    if (lt < 0) break;
+    if (html.startsWith(COMMENT_OPEN, lt)) {
+      const close = html.indexOf(COMMENT_CLOSE, lt + COMMENT_OPEN.length);
+      const end = close < 0 ? html.length : close + COMMENT_CLOSE.length;
+      out.push(html.slice(lt, end));
+      index = end;
+      continue;
+    }
+    const gt = html.indexOf('>', lt + 1);
+    if (gt < 0) {
+      out.push(html.slice(lt));
+      break;
+    }
+    const tag = html.slice(lt, gt + 1);
+    out.push(tag);
+    index = gt + 1;
+    const name = OPEN_TAG_NAME.exec(tag)?.[1].toLowerCase();
+    if (name !== undefined && RAW_TEXT_TAGS.has(name)) {
+      const close = closingTagAt(html, name, index);
+      out.push(html.slice(index, close));
+      index = close;
+    }
+  }
+  return { html: out.join(''), marks };
+}
diff --git a/backend/src/modules/mail/jmap/jmap-conversations.spec.ts b/backend/src/modules/mail/jmap/jmap-conversations.spec.ts
new file mode 100644
index 0000000..fa08632
--- /dev/null
+++ b/backend/src/modules/mail/jmap/jmap-conversations.spec.ts
@@ -0,0 +1,909 @@
+import { Logger } from '@nestjs/common';
+
+import { BusinessException } from '@/common/errors/business.exception';
+import { firstSender } from '@/modules/mail-search/index-document';
+import {
+  CONVERSATION_ENGINE_LIST_SCAN_MAX,
+  CONVERSATION_ENGINE_SCAN_MAX,
+  CONVERSATION_ENGINE_THREAD_SCAN_MAX,
+  CONVERSATION_MESSAGE_IDS_MAX,
+  INDEX_FROM_NAME_MAX_CHARS,
+} from '@/modules/mail-search/mail-search.constants';
+import type { JmapClient } from './jmap.client';
+import { JmapConversations, shareScan } from './jmap-conversations';
+import { decodeCursor, encodeCursor } from './jmap-cursor';
+import type { JmapInvocation } from './jmap.types';
+
+const ARA = 'ara.kim@arasystem.test';
+/** 내보낼 메일만 읽어야 하는 요약 속성의 표 — 미리 보기 */
+const SUMMARY_ONLY = 'preview';
+const FUTURE = '2099-01-01T00:00:00Z';
+
+/** 호출 한 번이 시작될 때 — 손으로 돌리는 시계를 넘기거나, Error 를 돌려주면 그 호출을 그 오류로 끝낸다 */
+type CallHook = (
+  index: number,
+  options: { timeoutMs?: number } | undefined,
+) => unknown;
+
+/** 엔진 대역 — 받은 호출을 적고 준비한 응답을 차례로 */
+function fakeClient(responses: JmapInvocation[][], onCall?: CallHook) {
+  const recorded: {
+    calls: JmapInvocation[];
+    options: { timeoutMs?: number } | undefined;
+  }[] = [];
+  const queue = [...responses];
+  const call = jest.fn(
+    (
+      _user: string,
+      build: (accountId: string) => JmapInvocation[],
+      options?: { timeoutMs?: number },
+    ) => {
+      recorded.push({ calls: build('d'), options });
+      const failure = onCall?.(recorded.length - 1, options);
+      if (failure instanceof Error) return Promise.reject(failure);
+      const next = queue.shift();
+      if (!next) return Promise.reject(new Error('준비한 응답이 없습니다'));
+      return Promise.resolve(next);
+    },
+  );
+  return {
+    recorded,
+    call,
+    reader: new JmapConversations({ call } as unknown as JmapClient),
+  };
+}
+
+const MAILBOX_LIST = [
+  { id: 'a', role: 'inbox' },
+  { id: 'b', role: 'trash' },
+  { id: 'c', role: 'junk' },
+  { id: 'e', role: 'sent' },
+];
+const mailboxes: JmapInvocation = ['Mailbox/get', { list: MAILBOX_LIST }, 'm'];
+
+/** 메일 하나 (엔진이 주는 꼴 — 요청한 속성과 상관없이 다 싣는다) */
+function email(
+  id: string,
+  receivedAt: string,
+  extra: Record<string, unknown> = {},
+) {
+  return {
+    id,
+    threadId: 't1',
+    mailboxIds: { a: true },
+    keywords: { $seen: true },
+    from: [{ name: `보낸 ${id}`, email: `${id}@example.com` }],
+    to: [{ name: null, email: ARA }],
+    subject: `제목 ${id}`,
+    preview: '미리 보기',
+    receivedAt,
+    attachments: [],
+    size: 100,
+    ...extra,
+  };
+}
+
+const noHeld: JmapInvocation[] = [
+  ['EmailSubmission/query', { ids: [], total: 0, position: 0 }, 'pq'],
+  ['EmailSubmission/get', { list: [] }, 'pg'],
+];
+
+/** 한 요청에서 그 호출 id 의 인자 */
+function argsOf(calls: JmapInvocation[], id: string): Record<string, unknown> {
+  return calls.find(([, , callId]) => callId === id)?.[1] ?? {};
+}
+
+/** 그 요청의 Email/get 이 요약 속성(미리 보기)을 읽었나 */
+function readsSummary(calls: JmapInvocation[]): boolean {
+  return calls.some(
+    ([method, args]) =>
+      method === 'Email/get' &&
+      Array.isArray(args.properties) &&
+      (args.properties as string[]).includes(SUMMARY_ONLY),
+  );
+}
+
+/** 그 요청의 Email/get 이 묻는 id (back-reference 면 빈 배열) */
+function idsOf(calls: JmapInvocation[]): string[] {
+  return calls.flatMap(([method, args]) =>
+    method === 'Email/get' && Array.isArray(args.ids)
+      ? (args.ids as string[])
+      : [],
+  );
+}
+
+interface FakeMail {
+  readonly id: string;
+  readonly threadId: string;
+  readonly receivedAt: string;
+  readonly mailboxIds: Record<string, boolean>;
+  readonly keywords?: Record<string, boolean>;
+}
+
+/**
+ * 메일을 들고 요청마다 답하는 엔진 대역 (큰 스레드 — 3차 리뷰 H1). Email/get · Thread/get · Mailbox/get · collapseThreads 의 Email/query ·
+ * 제출 조회를 안다(back-reference 는 /ids · /list/[*]/threadId 만)
+ */
+function fakeEngine(mails: readonly FakeMail[], onCall?: CallHook) {
+  const byId = new Map(mails.map((mail) => [mail.id, mail]));
+  const threads = new Map<string, string[]>();
+  for (const mail of [...mails].sort((a, b) =>
+    a.receivedAt.localeCompare(b.receivedAt),
+  )) {
+    threads.set(mail.threadId, [
+      ...(threads.get(mail.threadId) ?? []),
+      mail.id,
+    ]);
+  }
+  const requests: JmapInvocation[][] = [];
+  /** 호출마다 받은 제한 시간 */
+  const timeouts: (number | undefined)[] = [];
+  const full = (mail: FakeMail) => email(mail.id, mail.receivedAt, { ...mail });
+  const call = jest.fn(
+    (
+      _user: string,
+      build: (accountId: string) => JmapInvocation[],
+      options?: { timeoutMs?: number },
+    ) => {
+      const invocations = build('d');
+      requests.push(invocations);
+      timeouts.push(options?.timeoutMs);
+      const failure = onCall?.(requests.length - 1, options);
+      if (failure instanceof Error) return Promise.reject(failure);
+      const results = new Map<string, Record<string, unknown>>();
+      const resolve = (args: Record<string, unknown>): string[] => {
+        const ref = args['#ids'] as
+          | { resultOf: string; path: string }
+          | undefined;
+        if (!ref) return (args.ids as string[] | null) ?? [];
+        const source = results.get(ref.resultOf) ?? {};
+        if (ref.path === '/ids') return (source.ids as string[]) ?? [];
+        return ((source.list as { threadId: string }[]) ?? []).map(
+          (item) => item.threadId,
+        );
+      };
+      const responses: JmapInvocation[] = invocations.map(
+        ([method, args, id]) => {
+          let result: Record<string, unknown>;
+          if (method === 'Email/get') {
+            const ids = resolve(args);
+            result = {
+              list: ids.flatMap((emailId) => {
+                const mail = byId.get(emailId);
+                return mail ? [full(mail)] : [];
+              }),
+              notFound: ids.filter((emailId) => !byId.has(emailId)),
+            };
+          } else if (method === 'Thread/get') {
+            result = {
+              list: resolve(args).map((threadId) => ({
+                id: threadId,
+                emailIds: threads.get(threadId) ?? [],
+              })),
+            };
+          } else if (method === 'Mailbox/get') {
+            result = { list: MAILBOX_LIST };
+          } else if (method === 'Email/query') {
+            const filter = args.filter as { inMailbox: string };
+            const seen = new Set<string>();
+            const ids = [...mails]
+              .filter((mail) => mail.mailboxIds[filter.inMailbox])
+              .sort((a, b) => b.receivedAt.localeCompare(a.receivedAt))
+              .filter((mail) => {
+                if (seen.has(mail.threadId)) return false;
+                seen.add(mail.threadId);
+                return true;
+              })
+              .map((mail) => mail.id);
+            const position = (args.position as number | undefined) ?? 0;
+            result = {
+              ids: ids.slice(position, position + (args.limit as number)),
+              position,
+              total: ids.length,
+            };
+          } else if (method === 'EmailSubmission/query') {
+            result = { ids: [], total: 0, position: 0 };
+          } else {
+            result = { list: [] };
+          }
+          results.set(id, result);
+          return [method, result, id];
+        },
+      );
+      return Promise.resolve(responses);
+    },
+  );
+  return {
+    requests,
+    timeouts,
+    call,
+    reader: new JmapConversations({ call } as unknown as JmapClient),
+  };
+}
+
+/** 받은 시각 — n 초 뒤 (차례가 id 차례와 같게) */
+const second = (n: number) =>
+  new Date(Date.UTC(2026, 10, 1) + n * 1000).toISOString();
+
+describe('엔진의 스레드로 본 대화 (JmapConversations — 14단계, 색인 전)', () => {
+  let warnSpy: jest.SpyInstance;
+  beforeEach(() => {
+    warnSpy = jest
+      .spyOn(Logger.prototype, 'warn')
+      .mockImplementation(() => undefined);
+  });
+  afterEach(() => jest.restoreAllMocks());
+
+  describe('같은 대화 (conversation)', () => {
+    const lookup = (emailIds: string[]): JmapInvocation[] => [
+      ['Email/get', { list: [{ id: 'm2', threadId: 't1' }] }, 'e'],
+      ['Thread/get', { list: [{ id: 't1', emailIds }] }, 't'],
+      mailboxes,
+    ];
+
+    it('그 메일의 스레드 → 값싼 속성으로 걸러 오래된 차례 — 휴지통 · 스팸에만 든 메일 · 내부 초안은 빼되 지금 메일은 넣고, 요약 속성은 내보낼 메일만', async () => {
+      const { reader, recorded } = fakeClient([
+        lookup(['m1', 'm2', 'm3', 'm4', 'm5']),
+        [
+          [
+            'Email/get',
+            {
+              list: [
+                email('m1', '2026-11-01T00:00:00Z', {
+                  mailboxIds: { e: true },
+                }),
+                email('m2', '2026-11-02T00:00:00Z', {
+                  mailboxIds: { c: true },
+                }),
+                email('m3', '2026-11-03T00:00:00Z', {
+                  mailboxIds: { b: true },
+                }),
+                email('m4', '2026-11-04T00:00:00Z', {
+                  keywords: { $draft: true, '$ara-sending': true },
+                }),
+                email('m5', '2026-11-05T00:00:00Z', {
+                  mailboxIds: { b: true, a: true },
+                }),
+              ],
+            },
+            'g',
+          ],
+        ],
+        [
+          [
+            'Email/get',
+            {
+              list: ['m1', 'm2', 'm5'].map((id, index) =>
+                email(id, `2026-11-0${index + 1}T00:00:00Z`),
+              ),
+            },
+            'g',
+          ],
+          ...noHeld,
+        ],
+      ]);
+
+      const page = await reader.conversation(ARA, 'm2', { limit: 100 });
+
+      // m3(휴지통에만) · m4(내부 초안) 빠짐, m2(스팸이지만 지금 메일) · m5(휴지통과 받은편지함) 듦
+      expect(page.items.map((item) => item.id)).toEqual(['m1', 'm2', 'm5']);
+      expect(page.total).toBe(3);
+      expect(page.hasNext).toBe(false);
+      expect(recorded[0].options).toEqual({
+        invalidRequestCode: 'RES_001',
+        timeoutMs: expect.any(Number) as number,
+      });
+      expect(recorded[0].calls.map(([method]) => method)).toEqual([
+        'Email/get',
+        'Thread/get',
+        'Mailbox/get',
+      ]);
+      // 거르기는 값싼 속성만, 요약은 내보낼 세 통만 (기다리는 발송과 함께)
+      expect(argsOf(recorded[1].calls, 'g').properties).toEqual([
+        'id',
+        'mailboxIds',
+        'keywords',
+        'receivedAt',
+      ]);
+      expect(readsSummary(recorded[1].calls)).toBe(false);
+      expect(idsOf(recorded[2].calls)).toEqual(['m1', 'm2', 'm5']);
+      expect(recorded[2].calls.map(([method]) => method)).toEqual([
+        'Email/get',
+        'EmailSubmission/query',
+        'EmailSubmission/get',
+      ]);
+    });
+
+    it('쪽을 넘긴다 — 커서는 그 메일의 대화에서만(다른 메일의 커서는 엔진에 묻기 전에 VAL_001), 스레드 안 위치 · 마지막 메일이 빠졌으면 위치로', async () => {
+      const cheap: JmapInvocation[] = [
+        [
+          'Email/get',
+          {
+            list: ['m1', 'm2', 'm3'].map((id, index) =>
+              email(id, `2026-11-0${index + 1}T00:00:00Z`),
+            ),
+          },
+          'g',
+        ],
+      ];
+      const summaries = (ids: string[]): JmapInvocation[] => [
+        [
+          'Email/get',
+          { list: ids.map((id) => email(id, '2026-11-01T00:00:00Z')) },
+          'g',
+        ],
+        ...noHeld,
+      ];
+      const first = fakeClient([
+        lookup(['m1', 'm2', 'm3']),
+        cheap,
+        summaries(['m1', 'm2']),
+      ]);
+      const page = await first.reader.conversation(ARA, 'm2', { limit: 2 });
+      expect(page.items.map((item) => item.id)).toEqual(['m1', 'm2']);
+      expect(page.hasNext).toBe(true);
+      expect(page.total).toBe(3);
+      expect(
+        decodeCursor(page.nextCursor!, { conditions: ['conversation', 'm2'] }),
+      ).toEqual({ anchor: 'm2', position: 2 });
+
+      const next = fakeClient([
+        lookup(['m1', 'm2', 'm3']),
+        cheap,
+        summaries(['m3']),
+      ]);
+      const second = await next.reader.conversation(ARA, 'm2', {
+        limit: 2,
+        cursor: page.nextCursor!,
+      });
+      expect(second.items.map((item) => item.id)).toEqual(['m3']);
+      expect(second.hasNext).toBe(false);
+      expect(idsOf(next.recorded[2].calls)).toEqual(['m3']);
+
+      const other = fakeClient([]);
+      await expect(
+        other.reader.conversation(ARA, 'm9', {
+          limit: 2,
+          cursor: page.nextCursor!,
+        }),
+      ).rejects.toMatchObject({ code: 'VAL_001' });
+      expect(other.call).not.toHaveBeenCalled();
+
+      const gone = encodeCursor(
+        { anchor: 'm-gone', position: 1 },
+        { conditions: ['conversation', 'm2'] },
+      );
+      const resumed = fakeClient([
+        lookup(['m1', 'm2', 'm3']),
+        cheap,
+        summaries(['m2', 'm3']),
+      ]);
+      const fromPosition = await resumed.reader.conversation(ARA, 'm2', {
+        limit: 5,
+        cursor: gone,
+      });
+      expect(fromPosition.items.map((item) => item.id)).toEqual(['m2', 'm3']);
+    });
+
+    it('그 메일이 없으면(남의 메일 · 지움) 404 RES_001', async () => {
+      const { reader } = fakeClient([
+        [
+          ['Email/get', { list: [], notFound: ['zz'] }, 'e'],
+          ['Thread/get', { list: [] }, 't'],
+          mailboxes,
+        ],
+      ]);
+      const error = await reader
+        .conversation(ARA, 'zz', { limit: 100 })
+        .catch((caught: unknown) => caught);
+      expect(error).toBeInstanceOf(BusinessException);
+      expect((error as BusinessException).code).toBe('RES_001');
+    });
+
+    it('메일함 역할을 읽지 못하면 빼지 않고 이어 간다 — 경고는 코드 · 가린 주소만 (리뷰 L5)', async () => {
+      const { reader } = fakeClient([
+        [
+          ['Email/get', { list: [{ id: 'm2', threadId: 't1' }] }, 'e'],
+          ['Thread/get', { list: [{ id: 't1', emailIds: ['m2'] }] }, 't'],
+          ['error', { type: 'serverFail' }, 'm'],
+        ],
+        [['Email/get', { list: [email('m2', '2026-11-02T00:00:00Z')] }, 'g']],
+        [
+          ['Email/get', { list: [email('m2', '2026-11-02T00:00:00Z')] }, 'g'],
+          // 기다리는 제출을 다 주지 못했다 — 목록과 같은 경고
+          [
+            'EmailSubmission/query',
+            { ids: ['s1'], total: 600, position: 0 },
+            'pq',
+          ],
+          ['EmailSubmission/get', { list: [] }, 'pg'],
+        ],
+      ]);
+      const page = await reader.conversation(ARA, 'm2', { limit: 100 });
+      expect(page.items.map((item) => item.id)).toEqual(['m2']);
+      const lines = warnSpy.mock.calls.map(([line]) => String(line));
+      expect(lines).toHaveLength(2);
+      for (const line of lines) {
+        expect(line).toMatch(/^\[MAIL_001\]/);
+        expect(line).toContain('user=a***@arasystem.test');
+        expect(line).not.toContain(ARA);
+      }
+    });
+
+    it('2,000통짜리 스레드 — 거르기는 커서 자리부터 상한까지만, 요약 속성은 한 쪽(100통)만 · total 은 null (리뷰 H1)', async () => {
+      const mails: FakeMail[] = Array.from({ length: 2_000 }, (_, index) => ({
+        id: `m${String(index).padStart(4, '0')}`,
+        threadId: 't1',
+        receivedAt: second(index),
+        mailboxIds: { a: true },
+      }));
+      const engine = fakeEngine(mails);
+
+      const page = await engine.reader.conversation(ARA, 'm1999', {
+        limit: 100,
+      });
+
+      expect(page.items).toHaveLength(100);
+      expect(page.items[0].id).toBe('m0000');
+      expect(page.total).toBeNull();
+      expect(page.hasNext).toBe(true);
+      expect(
+        decodeCursor(page.nextCursor!, {
+          conditions: ['conversation', 'm1999'],
+        }),
+      ).toEqual({ anchor: 'm0099', position: 100 });
+      // 엔진 요청: 찾기 · 거르기 한 번(500통) · 요약 한 번
+      expect(engine.call).toHaveBeenCalledTimes(3);
+      const summaryIds = engine.requests.filter(readsSummary).flatMap(idsOf);
+      expect(summaryIds).toHaveLength(100);
+      const scanned = engine.requests
+        .filter((request) => !readsSummary(request))
+        .flatMap(idsOf)
+        .filter((id) => id !== 'm1999');
+      expect(scanned.length).toBeLessThanOrEqual(CONVERSATION_ENGINE_SCAN_MAX);
+    });
+
+    it('거를 메일이 많은 큰 스레드 — 한 요청은 상한까지만 훑고 빈 쪽이어도 이어 갈 자리를 준다, 다음 요청에서 지금 메일이 든다', async () => {
+      const mails: FakeMail[] = Array.from({ length: 2_000 }, (_, index) => ({
+        id: `m${String(index).padStart(4, '0')}`,
+        threadId: 't1',
+        receivedAt: second(index),
+        // 지금 메일(맨 끝) 말고는 모두 휴지통에만
+        mailboxIds: { [index === 1_999 ? 'a' : 'b']: true },
+      }));
+      const engine = fakeEngine(mails);
+
+      const page = await engine.reader.conversation(ARA, 'm1999', {
+        limit: 100,
+      });
+      expect(page.items).toEqual([]);
+      expect(page.hasNext).toBe(true);
+      expect(page.total).toBeNull();
+      expect(
+        decodeCursor(page.nextCursor!, {
+          conditions: ['conversation', 'm1999'],
+        }),
+      ).toEqual({
+        anchor: 'm0999',
+        position: CONVERSATION_ENGINE_SCAN_MAX,
+      });
+      // 찾기 · 거르기 두 번(500 + 500) — 요약은 읽지 않는다
+      expect(engine.call).toHaveBeenCalledTimes(3);
+      expect(engine.requests.some(readsSummary)).toBe(false);
+
+      const next = await engine.reader.conversation(ARA, 'm1999', {
+        limit: 100,
+        cursor: page.nextCursor!,
+      });
+      expect(next.items.map((item) => item.id)).toEqual(['m1999']);
+      expect(next.hasNext).toBe(false);
+    });
+  });
+
+  describe('묶은 목록 (list)', () => {
+    it('collapseThreads 로 그 메일함 안 스레드마다 마지막 메일(요약은 이것만) → 스레드의 나머지 메일을 값싼 속성으로 — 통 수 · 참여자 · 그 메일함 안 id · 읽음 · 붙잡힌 메일 (리뷰 L6)', async () => {
+      const { reader, recorded } = fakeClient([
+        [
+          mailboxes,
+          ['Email/query', { ids: ['m3', 'x1'], position: 0, total: 2 }, 'q'],
+          [
+            'Email/get',
+            {
+              list: [
+                email('m3', '2026-11-03T00:00:00Z', {
+                  keywords: {},
+                  threadId: 't1',
+                }),
+                email('x1', '2026-11-02T00:00:00Z', { threadId: 't2' }),
+              ],
+            },
+            'g',
+          ],
+          [
+            'Thread/get',
+            {
+              list: [
+                { id: 't1', emailIds: ['m1', 'm2', 'm3', 'm4'] },
+                { id: 't2', emailIds: ['x1'] },
+              ],
+            },
+            't',
+          ],
+          [
+            'EmailSubmission/query',
+            { ids: ['s1'], total: 1, position: 0 },
+            'pq',
+          ],
+          [
+            'EmailSubmission/get',
+            {
+              list: [
+                {
+                  id: 's1',
+                  emailId: 'm2',
+                  undoStatus: 'pending',
+                  sendAt: FUTURE,
+                },
+              ],
+            },
+            'pg',
+          ],
+        ],
+        [
+          [
+            'Email/get',
+            {
+              list: [
+                email('m1', '2026-11-01T00:00:00Z', {
+                  mailboxIds: { e: true },
+                  from: [{ name: '김아라', email: ARA }],
+                }),
+                email('m2', '2026-11-02T00:00:00Z', {
+                  attachments: [
+                    {
+                      type: 'application/pdf',
+                      disposition: 'attachment',
+                      size: 10,
+                    },
+                  ],
+                }),
+                email('m4', '2026-11-04T00:00:00Z', {
+                  mailboxIds: { b: true },
+                }),
+              ],
+            },
+            'g',
+          ],
+        ],
+      ]);
+
+      const page = await reader.list(ARA, { mailboxId: 'a', limit: 20 });
+
+      expect(argsOf(recorded[0].calls, 'q')).toMatchObject({
+        filter: { inMailbox: 'a', notKeyword: '$ara-sending' },
+        collapseThreads: true,
+        calculateTotal: true,
+        sort: [{ property: 'receivedAt', isAscending: false }],
+      });
+      // 마지막 메일(m3 · x1)은 다시 읽지 않는다 — 나머지는 값싼 속성 + 보낸 사람 · 첨부 부분
+      expect(recorded).toHaveLength(2);
+      expect(idsOf(recorded[1].calls)).toEqual(['m1', 'm2', 'm4']);
+      expect(readsSummary(recorded[1].calls)).toBe(false);
+      expect(argsOf(recorded[1].calls, 'g').properties).toEqual([
+        'id',
+        'mailboxIds',
+        'keywords',
+        'receivedAt',
+        'from',
+        'attachments',
+      ]);
+      expect(page.total).toBe(2);
+      const [thread, single] = page.items;
+      expect(thread).toMatchObject({
+        id: 't1',
+        messageCount: 3, // m4 는 휴지통에만
+        messageIds: ['m3', 'm2'], // 받은편지함 안 — 최신부터
+        pendingSendIds: ['m2'],
+        isRead: false,
+        isFlagged: false,
+        hasAttachment: true,
+      });
+      expect(thread.latest.id).toBe('m3');
+      expect(thread.participants.map((p) => p.email)).toEqual([
+        ARA,
+        'm2@example.com',
+        'm3@example.com',
+      ]);
+      expect(single).toMatchObject({
+        id: 't2',
+        messageCount: 1,
+        messageIds: ['x1'],
+        pendingSendIds: [],
+        isRead: true,
+      });
+    });
+
+    it('메일함 목록을 엔진이 거절하면(메서드 오류) 503 MAIL_001 — 없는 메일함 404 와 가른다 (리뷰 M1)', async () => {
+      const { reader } = fakeClient([
+        [
+          ['error', { type: 'serverFail' }, 'm'],
+          ['Email/query', { ids: [], position: 0, total: 0 }, 'q'],
+          ['Email/get', { list: [] }, 'g'],
+          ['Thread/get', { list: [] }, 't'],
+          ...noHeld,
+        ],
+      ]);
+      await expect(
+        reader.list(ARA, { mailboxId: 'a', limit: 20 }),
+      ).rejects.toMatchObject({ code: 'MAIL_001' });
+    });
+
+    it('없는 메일함이면 404 RES_001 · 커서는 그 메일함의 묶은 목록에서만', async () => {
+      const missing = fakeClient([
+        [
+          mailboxes,
+          ['Email/query', { ids: [], position: 0, total: 0 }, 'q'],
+          ['Email/get', { list: [] }, 'g'],
+          ['Thread/get', { list: [] }, 't'],
+          ...noHeld,
+        ],
+      ]);
+      await expect(
+        missing.reader.list(ARA, { mailboxId: 'zz', limit: 20 }),
+      ).rejects.toMatchObject({ code: 'RES_001' });
+
+      const cursor = encodeCursor(
+        { anchor: 'm3', position: 20 },
+        { mailboxId: 'a', conditions: ['conversations'] },
+      );
+      const other = fakeClient([]);
+      for (const query of [
+        { mailboxId: 'e', limit: 20, cursor },
+        // 메일 목록의 커서는 쓸 수 없다
+        {
+          mailboxId: 'a',
+          limit: 20,
+          cursor: encodeCursor(
+            { anchor: 'm3', position: 20 },
+            { mailboxId: 'a' },
+          ),
+        },
+      ]) {
+        await expect(other.reader.list(ARA, query)).rejects.toMatchObject({
+          code: 'VAL_001',
+        });
+      }
+      expect(other.call).not.toHaveBeenCalled();
+    });
+
+    it('2,000통짜리 스레드가 든 쪽 — 스레드마다 최신 상한까지 · 요약 속성은 줄마다 마지막 메일만, 상한에 걸린 줄의 통 수는 읽지 못한 메일을 거르지 않고 더한다 (리뷰 H1)', async () => {
+      const big: FakeMail[] = Array.from({ length: 2_000 }, (_, index) => ({
+        id: `g${String(index).padStart(4, '0')}`,
+        threadId: 'tg',
+        receivedAt: second(index),
+        // 오래된 절반은 휴지통에만 — 읽지 못한 쪽이라 통 수에는 그대로 든다
+        mailboxIds: { [index < 1_000 ? 'b' : 'a']: true },
+      }));
+      const small: FakeMail[] = ['s1', 's2'].map((id, index) => ({
+        id,
+        threadId: 'ts',
+        receivedAt: second(5_000 + index),
+        mailboxIds: { a: true },
+      }));
+      const engine = fakeEngine([...big, ...small]);
+
+      const page = await engine.reader.list(ARA, {
+        mailboxId: 'a',
+        limit: 20,
+      });
+
+      expect(page.items.map((row) => row.id)).toEqual(['ts', 'tg']);
+      // 엔진 요청: 목록 한 번 · 스레드 메일 한 번
+      expect(engine.call).toHaveBeenCalledTimes(2);
+      const summaryIds = engine.requests.filter(readsSummary).flatMap(idsOf);
+      expect(summaryIds).toEqual([]); // 마지막 메일은 back-reference 로 — 다시 읽지 않는다
+      const memberIds = engine.requests.slice(1).flatMap(idsOf);
+      expect(memberIds).toHaveLength(
+        CONVERSATION_ENGINE_THREAD_SCAN_MAX - 1 + 1,
+      );
+      expect(memberIds.length).toBeLessThanOrEqual(
+        CONVERSATION_ENGINE_LIST_SCAN_MAX,
+      );
+      const [smallRow, bigRow] = page.items;
+      expect(smallRow).toMatchObject({
+        messageCount: 2,
+        messageIds: ['s2', 's1'],
+      });
+      // 최신 500통을 읽었고(모두 받은편지함) 오래된 1,500통은 읽지 않고 센다
+      expect(bigRow.messageCount).toBe(2_000);
+      expect(bigRow.messageIds).toHaveLength(
+        CONVERSATION_ENGINE_THREAD_SCAN_MAX,
+      );
+      expect(bigRow.messageIds[0]).toBe('g1999');
+      expect(bigRow.messageIds.length).toBeLessThanOrEqual(
+        CONVERSATION_MESSAGE_IDS_MAX,
+      );
+    });
+  });
+
+  describe('한 요청의 시간 (3차 재확인 N1 · N2 — Date.now 를 손으로 돌린다)', () => {
+    const START = Date.UTC(2026, 10, 6, 1, 0, 0);
+    let clock = START;
+    beforeEach(() => {
+      clock = START;
+      jest.spyOn(Date, 'now').mockImplementation(() => clock);
+    });
+
+    /** 스레드 하나 — `mailbox(i)` 메일함에 든 메일 `count` 통 (받은 시각 차례) */
+    const thread = (
+      count: number,
+      mailbox: (index: number) => string = () => 'a',
+    ): FakeMail[] =>
+      Array.from({ length: count }, (_, index) => ({
+        id: `m${String(index).padStart(4, '0')}`,
+        threadId: 't1',
+        receivedAt: second(index),
+        mailboxIds: { [mailbox(index)]: true },
+      }));
+
+    it('1,000통 이하 스레드를 시간 안에 다 읽지 못하면 503 MAIL_001 — 요약은 읽지 않는다', async () => {
+      // 찾기 7초 · 첫 묶음은 제한 시간(5초 — 남은 8초에서 요약 몫 3초를 뺀)을 다 쓰고 돌아온다 → 남은 3초는 더 훑지 않는다
+      const engine = fakeEngine(thread(800), (index, options) => {
+        clock += index === 0 ? 7_000 : (options?.timeoutMs ?? 0);
+      });
+      await expect(
+        engine.reader.conversation(ARA, 'm0799', { limit: 100 }),
+      ).rejects.toMatchObject({ code: 'MAIL_001' });
+      expect(engine.timeouts).toEqual([10_000, 5_000]);
+      expect(engine.requests.some(readsSummary)).toBe(false);
+    });
+
+    it('1,000통이 넘는 스레드에서 한 묶음 뒤 시간이 끝나면 읽은 데까지 답하고 앞으로 간 커서를 준다 — 요약 읽기는 남은 3초를 받는다', async () => {
+      // 앞 세 통만 받은편지함, 나머지는 휴지통에만(지금 메일은 맨 끝) — 첫 묶음으로는 쪽이 차지 않는다
+      const engine = fakeEngine(
+        thread(2_000, (index) => (index < 3 || index === 1_999 ? 'a' : 'b')),
+        (index, options) => {
+          clock += index === 0 ? 2_000 : (options?.timeoutMs ?? 0);
+        },
+      );
+      const page = await engine.reader.conversation(ARA, 'm1999', {
+        limit: 100,
+      });
+      expect(page.items.map((item) => item.id)).toEqual([
+        'm0000',
+        'm0001',
+        'm0002',
+      ]);
+      expect(page.hasNext).toBe(true);
+      expect(page.total).toBeNull();
+      expect(
+        decodeCursor(page.nextCursor!, {
+          conditions: ['conversation', 'm1999'],
+        }),
+      ).toEqual({ anchor: 'm0499', position: 500 });
+      // 찾기 10초 · 묶음 10초(남은 13초 − 3초) · 요약 3초(남은 시간을 다)
+      expect(engine.timeouts).toEqual([10_000, 10_000, 3_000]);
+    });
+
+    it('훑는 호출은 마지막 요약 읽기 몫을 빼고 받는다 — 3.5초 남아 시작한 느린 묶음 뒤에도 요약 읽기가 3초를 받는다 (N1)', async () => {
+      const engine = fakeEngine(thread(2_000), (index, options) => {
+        clock += index === 0 ? 11_500 : (options?.timeoutMs ?? 0);
+      });
+      const page = await engine.reader.conversation(ARA, 'm1999', {
+        limit: 100,
+      });
+      expect(page.items).toHaveLength(100);
+      // 남은 3.5초에서 시작한 묶음은 0.5초만 받고(전에는 3.5초를 받아 요약 읽기가 1ms 였다), 요약 읽기는 3초
+      expect(engine.timeouts).toEqual([10_000, 500, 3_000]);
+    });
+
+    describe('묶은 목록 — 시간이 끝나면 어림 줄로 답한다(503 이 아니다)', () => {
+      const first: JmapInvocation[] = [
+        mailboxes,
+        ['Email/query', { ids: ['m3'], position: 0, total: 1 }, 'q'],
+        [
+          'Email/get',
+          { list: [email('m3', '2026-11-03T00:00:00Z', { keywords: {} })] },
+          'g',
+        ],
+        [
+          'Thread/get',
+          { list: [{ id: 't1', emailIds: ['m1', 'm2', 'm3', 'm4'] }] },
+          't',
+        ],
+        ...noHeld,
+      ];
+      /** 스레드의 다른 메일을 읽지 못한 줄 — 통 수는 읽지 못한 세 통을 거르지 않고 더하고, 나머지는 마지막 메일로만 */
+      const approximate = {
+        id: 't1',
+        messageCount: 4,
+        messageIds: ['m3'],
+        pendingSendIds: [],
+        participants: [{ name: '보낸 m3', email: 'm3@example.com' }],
+        isRead: false,
+        isFlagged: false,
+        hasAttachment: false,
+      };
+
+      it('첫 요청이 늦어 남은 시간이 요약 몫뿐이면 스레드 메일을 읽지 않는다', async () => {
+        const { reader, recorded } = fakeClient([first], () => {
+          clock += 13_000;
+        });
+        const page = await reader.list(ARA, { mailboxId: 'a', limit: 20 });
+        expect(recorded).toHaveLength(1);
+        expect(recorded[0].options?.timeoutMs).toBe(10_000);
+        expect(page.items).toHaveLength(1);
+        expect(page.items[0]).toMatchObject(approximate);
+      });
+
+      it('스레드 메일 읽기가 시간 때문에 끊기면 그 메일은 읽지 못한 것으로 — 시간이 남았는데 엔진이 실패하면 그대로 503', async () => {
+        const cut = fakeClient([first], (index, options) => {
+          if (index === 0) {
+            clock += 2_000;
+            return undefined;
+          }
+          // 제한 시간(남은 13초 − 요약 몫 3초)을 다 쓰고 끊겼다
+          clock += options?.timeoutMs ?? 0;
+          return new BusinessException('MAIL_001', {
+            context: { reason: 'timeout' },
+          });
+        });
+        const page = await cut.reader.list(ARA, { mailboxId: 'a', limit: 20 });
+        expect(cut.recorded).toHaveLength(2);
+        expect(cut.recorded[1].options?.timeoutMs).toBe(10_000);
+        expect(page.items[0]).toMatchObject(approximate);
+
+        const broken = fakeClient([first], (index) =>
+          index === 0 ? undefined : new BusinessException('MAIL_001'),
+        );
+        await expect(
+          broken.reader.list(ARA, { mailboxId: 'a', limit: 20 }),
+        ).rejects.toMatchObject({ code: 'MAIL_001' });
+      });
+    });
+  });
+
+  it('엔진 방식 참여자의 이름도 색인과 같은 상한 · 같은 자르기 (INDEX_FROM_NAME_MAX_CHARS 코드 포인트 — N3)', async () => {
+    const longName = `${'가'.repeat(INDEX_FROM_NAME_MAX_CHARS - 1)}😀😀 끝`;
+    const { reader } = fakeClient([
+      [
+        mailboxes,
+        ['Email/query', { ids: ['x1'], position: 0, total: 1 }, 'q'],
+        [
+          'Email/get',
+          {
+            list: [
+              email('x1', '2026-11-02T00:00:00Z', {
+                threadId: 't2',
+                from: [{ name: longName, email: 'long@example.com' }],
+              }),
+            ],
+          },
+          'g',
+        ],
+        ['Thread/get', { list: [{ id: 't2', emailIds: ['x1'] }] }, 't'],
+        ...noHeld,
+      ],
+    ]);
+    const page = await reader.list(ARA, { mailboxId: 'a', limit: 20 });
+    const [participant] = page.items[0].participants;
+    expect([...(participant.name ?? '')]).toHaveLength(
+      INDEX_FROM_NAME_MAX_CHARS,
+    );
+    expect(participant.name).toBe(
+      firstSender([{ name: longName, email: 'long@example.com' }]).name,
+    );
+    expect(participant.name?.endsWith('😀')).toBe(true);
+    // 목록의 마지막 메일 요약(보낸 사람)은 자르지 않는다
+    expect(page.items[0].latest.from?.name).toBe(longName);
+  });
+
+  it('읽을 몫 나누기 — 작은 스레드는 다 주고 남는 몫을 큰 스레드끼리 똑같이 (모두 상한 안)', () => {
+    expect(shareScan([3, 500, 1, 500], 600)).toEqual([3, 298, 1, 298]);
+    expect(shareScan([2, 2], 2_000)).toEqual([2, 2]);
+    expect(shareScan([500, 500, 500, 500, 500], 2_000)).toEqual([
+      400, 400, 400, 400, 400,
+    ]);
+    expect(shareScan([], 2_000)).toEqual([]);
+  });
+});
diff --git a/backend/src/modules/mail/jmap/jmap-conversations.ts b/backend/src/modules/mail/jmap/jmap-conversations.ts
new file mode 100644
index 0000000..f27fbad
--- /dev/null
+++ b/backend/src/modules/mail/jmap/jmap-conversations.ts
@@ -0,0 +1,622 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+import { BusinessException } from '@/common/errors/business.exception';
+import {
+  CONVERSATION_ENGINE_BUDGET_MS,
+  CONVERSATION_ENGINE_LIST_SCAN_MAX,
+  CONVERSATION_ENGINE_RESERVE_MS,
+  CONVERSATION_ENGINE_SCAN_MAX,
+  CONVERSATION_ENGINE_THREAD_SCAN_MAX,
+  CONVERSATION_MESSAGE_IDS_MAX,
+  CONVERSATION_PARTICIPANTS_MAX,
+} from '@/modules/mail-search/mail-search.constants';
+import { participantName } from '@/modules/mail-search/index-document';
+import { hasRealAttachment } from '@/modules/mail/html/inline-images';
+import type {
+  ConversationListQuery,
+  ConversationSummary,
+  ConversationSummaryPage,
+  MailAddress,
+  MessagePage,
+} from '@/modules/mail/mail.types';
+import { traceTag } from '@/shared/logger/request-context';
+import { maskEmail } from '@/shared/utils/mask';
+import {
+  JMAP_REQUEST_TIMEOUT_MS,
+  JmapClient,
+  type JmapCallOptions,
+} from './jmap.client';
+import { decodeCursor, encodeCursor, type CursorScope } from './jmap-cursor';
+import { expectResult, findResult } from './jmap-results';
+import {
+  SUMMARY_BODY_PART_PROPERTIES,
+  SUMMARY_PROPERTIES,
+  toAddress,
+  toSummary,
+} from './jmap.mapper';
+import type {
+  JmapEmail,
+  JmapGetResult,
+  JmapInvocation,
+  JmapMailbox,
+  JmapQueryResult,
+} from './jmap.types';
+import { excludedMailboxIdsOf, INTERNAL_SEND_KEYWORD } from './mail-scope';
+import {
+  heldSubmissionFilter,
+  pendingSendOf,
+  readHeldSendTimes,
+  submissionCalls,
+  warnIfHeldQueryFull,
+} from './pending-send';
+
+/** 한 번에 읽는 대화의 메일 수 — 엔진의 한 번 처리 한도(maxObjectsInGet 500) 안 */
+const MEMBER_BATCH_SIZE = 500;
+/** 기다리는 발송을 묻는 호출 id 앞머리 (pending-send.ts) */
+const HELD_CALLS = 'p';
+
+/** 같은 대화에서 거르기에 읽는 값싼 속성 — 요약 속성(미리 보기 · 첨부 부분 …)은 내보낼 메일만 읽는다 */
+const FILTER_PROPERTIES = ['id', 'mailboxIds', 'keywords', 'receivedAt'];
+/** 묶은 목록에서 스레드의 메일마다 읽는 속성 — 거르기 + 참여자(보낸 사람) · 첨부 판정(부분은 SUMMARY_BODY_PART_PROPERTIES 만) */
+const MEMBER_PROPERTIES = [...FILTER_PROPERTIES, 'from', 'attachments'];
+
+/** 엔진의 스레드 — emailIds 는 받은 시각 오래된 차례(RFC 8621 §3.1 — 같은 시각이면 엔진이 정한 차례 그대로) */
+interface JmapThread {
+  readonly id: string;
+  readonly emailIds?: string[];
+}
+
+/** 시간 때문에 끊긴 훑기로 볼 여유 — 제한 시간이 다 된 호출이 끝난 뒤 남은 시간이 마지막 요약 읽기 몫을 조금 넘을 수 있다 */
+const CUT_OFF_SLACK_MS = 100;
+
+/** 엔진 호출 한 번의 제한 시간 — 기본 제한 시간과 `ms` 중 짧은 쪽 (1ms 이상) */
+function timeoutOf(ms: number): number {
+  return Math.max(1, Math.min(JMAP_REQUEST_TIMEOUT_MS, ms));
+}
+
+/**
+ * 한 요청의 시간 (CONVERSATION_ENGINE_BUDGET_MS — 메일함 처리의 BulkRun 과 같은 결).
+ * - 훑는 호출(같은 대화의 찾기 · 거르기, 묶은 목록의 스레드 메일)은 기본 제한 시간과 "남은 시간 − CONVERSATION_ENGINE_RESERVE_MS" 중 짧은 쪽 —
+ *   마지막 요약 읽기 몫을 늘 남긴다(3차 재확인 N1 — 3.5초 남아 시작한 느린 묶음이 요약 읽기를 1ms 로 만들지 않게)
+ * - 마지막 읽기(같은 대화의 요약 · 묶은 목록의 첫 요청)만 남은 시간을 다 쓴다
+ * - 남은 시간이 그 몫보다 적으면 더 훑지 않는다. 훑던 호출이 시간 때문에 끊겼으면(cutOff) 거기까지로 답한다
+ * 시계는 Date.now 다 (시험은 spy 로 돌린다)
+ */
+class ReadBudget {
+  private readonly deadline = Date.now() + CONVERSATION_ENGINE_BUDGET_MS;
+
+  canScan(): boolean {
+    return this.left() > CONVERSATION_ENGINE_RESERVE_MS;
+  }
+
+  scanOptions(options: JmapCallOptions = {}): JmapCallOptions {
+    return {
+      ...options,
+      timeoutMs: timeoutOf(this.left() - CONVERSATION_ENGINE_RESERVE_MS),
+    };
+  }
+
+  finalOptions(options: JmapCallOptions = {}): JmapCallOptions {
+    return { ...options, timeoutMs: timeoutOf(this.left()) };
+  }
+
+  /** 훑던 호출이 시간 때문에 끊겼나 — 엔진 장애(MAIL_001)이고 남은 시간이 마지막 요약 읽기 몫 남짓뿐이다 */
+  cutOff(error: unknown): boolean {
+    return (
+      error instanceof BusinessException &&
+      error.code === 'MAIL_001' &&
+      this.left() <= CONVERSATION_ENGINE_RESERVE_MS + CUT_OFF_SLACK_MS
+    );
+  }
+
+  private left(): number {
+    return this.deadline - Date.now();
+  }
+}
+
+function chunks<T>(items: readonly T[], size: number): T[][] {
+  const out: T[][] = [];
+  for (let index = 0; index < items.length; index += size) {
+    out.push(items.slice(index, index + size));
+  }
+  return out;
+}
+
+/** 대화에 드는 메일인가 — 발송 중인 내부 초안이 아니고, 빼는 메일함(휴지통 · 스팸메일함)에만 들어 있지 않다 (`keep` 이면 늘 든다) */
+function inConversation(
+  email: JmapEmail,
+  excluded: ReadonlySet<string>,
+  keep: (email: JmapEmail) => boolean,
+): boolean {
+  if (keep(email)) return true;
+  if (email.keywords?.[INTERNAL_SEND_KEYWORD]) return false;
+  const mailboxes = Object.keys(email.mailboxIds ?? {});
+  return mailboxes.length === 0 || mailboxes.some((id) => !excluded.has(id));
+}
+
+/** 보낸 사람들 — 주어진 차례(받은 차례), 주소마다 한 번, `max` 명까지 · 이름은 INDEX_FROM_NAME_MAX_CHARS 코드 포인트까지 */
+function participantsOf(
+  emails: readonly JmapEmail[],
+  max: number,
+): MailAddress[] {
+  const seen = new Set<string>();
+  const participants: MailAddress[] = [];
+  for (const email of emails) {
+    if (participants.length >= max) break;
+    const from = toAddress(email.from?.[0]);
+    if (!from) continue;
+    const key = from.email.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    // 이름은 색인 방식의 참여자와 같은 상한 · 같은 자르기 (index-document.ts 의 participantName)
+    participants.push({ email: from.email, name: participantName(from.name) });
+  }
+  return participants;
+}
+
+/**
+ * 한 요청에 읽을 몫 — 스레드마다 `needs[i]` 까지, 모두 `budget` 까지. 작은 스레드부터 다 주고 남는 몫을 큰 스레드끼리 똑같이 나눈다
+ * (큰 스레드 하나가 쪽의 다른 줄을 비우지 않게)
+ */
+export function shareScan(needs: readonly number[], budget: number): number[] {
+  const shares = needs.map(() => 0);
+  const order = needs
+    .map((need, index) => ({ need: Math.max(0, need), index }))
+    .sort((a, b) => a.need - b.need);
+  let left = Math.max(0, budget);
+  order.forEach(({ need, index }, position) => {
+    const give = Math.min(need, Math.floor(left / (order.length - position)));
+    shares[index] = give;
+    left -= give;
+  });
+  return shares;
+}
+
+/**
+ * 엔진의 스레드로 본 대화 (14단계 — 자체 색인을 다 만들기 전 · 첫 쪽 DB 장애의 대신, 설계 C3 · C4). 스레드는 엔진의 규칙(답장 관계 + 엔진이 정규화한 제목)이다.
+ * 거르기는 값싼 속성만 읽고 요약 속성은 내보낼 메일만 읽는다. 상한 · 시간은 mail-search.constants.ts 의 CONVERSATION_ENGINE_* (3차 리뷰 H1).
+ * - 같은 대화: 그 메일의 스레드(오래된 차례) — 스레드가 CONVERSATION_ENGINE_SCAN_MAX 통 이하면 모두 읽어 total 을 세고, 넘으면 커서 자리부터 쪽이 찰 때까지만
+ *   (한 요청 그 상한까지 · 시간 안 — 쪽이 limit 보다 적어도 이어 갈 자리가 있으면 hasNext, total 은 null). 쪽은 스레드 안 위치(anchor · position) 커서
+ * - 묶은 목록: `Email/query` 의 collapseThreads(그 메일함 안 스레드마다 마지막 메일 — 요약 속성은 이것만) → 스레드마다 최신 CONVERSATION_ENGINE_THREAD_SCAN_MAX 통
+ *   (한 요청 모두 CONVERSATION_ENGINE_LIST_SCAN_MAX 통 — shareScan)으로 통 수 · 참여자 · 그 메일함 안 id · 읽음 · 붙잡힌 메일.
+ *   **상한에 걸린 줄**(읽지 못한 오래된 메일이 있는 스레드 — 몫 · 시간): 통 수는 읽은 메일 가운데 대화에 드는 것 + 읽지 못한 메일 수(거르지 않고 더한다),
+ *   참여자 · messageIds · 읽음 · 중요 · 첨부 · pendingSendIds 는 읽은 메일(최신 쪽)로만 정한다
+ * 커서는 jmap-cursor.ts 의 모양(1판)에 범위를 따로 둔다 — 목록 · 검색의 커서와 섞이지 않게
+ */
+@Injectable()
+export class JmapConversations {
+  private readonly logger = new Logger(JmapConversations.name);
+
+  constructor(private readonly jmap: JmapClient) {}
+
+  async conversation(
+    user: string,
+    emailId: string,
+    page: { readonly limit: number; readonly cursor?: string },
+  ): Promise<MessagePage> {
+    const scope: CursorScope = { conditions: ['conversation', emailId] };
+    // 커서는 엔진에 묻기 전에 본다 — 다른 대화의 커서면 VAL_001
+    const resume = page.cursor ? decodeCursor(page.cursor, scope) : null;
+    const budget = new ReadBudget();
+    const lookup = await this.jmap.call(
+      user,
+      (accountId) => [
+        [
+          'Email/get',
+          { accountId, ids: [emailId], properties: ['id', 'threadId'] },
+          'e',
+        ],
+        [
+          'Thread/get',
+          {
+            accountId,
+            '#ids': {
+              resultOf: 'e',
+              name: 'Email/get',
+              path: '/list/*/threadId',
+            },
+          },
+          't',
+        ],
+        [
+          'Mailbox/get',
+          { accountId, ids: null, properties: ['id', 'role'] },
+          'm',
+        ],
+      ],
+      budget.scanOptions({ invalidRequestCode: 'RES_001' }),
+    );
+    const { list: found = [] } = expectResult<JmapGetResult<JmapEmail>>(
+      lookup,
+      'e',
+      'Email/get',
+    );
+    if (found.length === 0) {
+      throw new BusinessException('RES_001', {
+        context: { reason: 'conversation-message-not-found' },
+      });
+    }
+    const thread = expectResult<JmapGetResult<JmapThread>>(
+      lookup,
+      't',
+      'Thread/get',
+    ).list?.[0];
+    const excluded = new Set(
+      excludedMailboxIdsOf(this.mailboxesOf(lookup, user)),
+    );
+    const order = thread?.emailIds?.length ? thread.emailIds : [emailId];
+
+    // 이어 갈 자리 — 스레드 안 위치. 마지막으로 본 메일이 그사이 빠졌으면 위치로
+    let start = 0;
+    if (resume) {
+      const anchorAt = order.indexOf(resume.anchor);
+      start =
+        anchorAt >= 0 ? anchorAt + 1 : Math.min(resume.position, order.length);
+    }
+    // 상한 이하면 모두 읽어 센다(total), 넘으면 이어 갈 자리부터 쪽이 찰 때까지만
+    const countAll = order.length <= CONVERSATION_ENGINE_SCAN_MAX;
+    const scanEnd = countAll
+      ? order.length
+      : Math.min(order.length, start + CONVERSATION_ENGINE_SCAN_MAX);
+    const keep = (email: JmapEmail) => email.id === emailId;
+    /** 대화에 드는 메일의 스레드 안 위치 */
+    const kept: number[] = [];
+    let scanned = countAll ? 0 : start;
+    let shownCount = 0;
+    while (scanned < scanEnd && (countAll || shownCount <= page.limit)) {
+      if (!budget.canScan()) break;
+      const batch = order.slice(
+        scanned,
+        Math.min(scanEnd, scanned + MEMBER_BATCH_SIZE),
+      );
+      let byId: Map<string, JmapEmail>;
+      try {
+        byId = await this.readEmails(user, batch, FILTER_PROPERTIES, budget);
+      } catch (error) {
+        // 시간 때문에 끊긴 묶음 — 읽은 데까지로 답한다(아래에서 다 읽어야 하는 작은 스레드 · 아무것도 못 읽음은 MAIL_001)
+        if (budget.cutOff(error)) break;
+        throw error;
+      }
+      batch.forEach((id, offset) => {
+        const email = byId.get(id);
+        if (!email || !inConversation(email, excluded, keep)) return;
+        kept.push(scanned + offset);
+        if (scanned + offset >= start) shownCount += 1;
+      });
+      scanned += batch.length;
+    }
+    const readAll = countAll && scanned >= order.length;
+    if (countAll && !readAll) {
+      // 작은 스레드를 시간 안에 다 읽지 못했다 — 엔진이 느리다
+      throw new BusinessException('MAIL_001', {
+        context: { reason: 'conversation-budget', scanned },
+      });
+    }
+    if (!countAll && scanned === start && start < order.length) {
+      throw new BusinessException('MAIL_001', {
+        context: { reason: 'conversation-budget', scanned },
+      });
+    }
+
+    const candidates = kept.filter((index) => index >= start);
+    const shown = candidates.slice(0, page.limit);
+    let next: number | null = null;
+    if (candidates.length > page.limit) {
+      next = shown[shown.length - 1] + 1;
+    } else if (scanned < order.length && !readAll) {
+      next = scanned;
+    }
+    const items = await this.summaries(
+      user,
+      shown.map((index) => order[index]),
+      budget,
+    );
+    return {
+      items,
+      hasNext: next !== null,
+      nextCursor:
+        next !== null
+          ? encodeCursor({ anchor: order[next - 1], position: next }, scope)
+          : null,
+      total: readAll ? kept.length : null,
+    };
+  }
+
+  async list(
+    user: string,
+    query: ConversationListQuery,
+  ): Promise<ConversationSummaryPage> {
+    const scope: CursorScope = {
+      mailboxId: query.mailboxId,
+      conditions: ['conversations'],
+    };
+    const resume = query.cursor ? decodeCursor(query.cursor, scope) : null;
+    const budget = new ReadBudget();
+    const now = Date.now();
+    const ask = (start: { anchor: string } | { position: number }) =>
+      this.jmap.call(
+        user,
+        (accountId) => [
+          [
+            'Mailbox/get',
+            { accountId, ids: null, properties: ['id', 'role'] },
+            'm',
+          ],
+          [
+            'Email/query',
+            {
+              accountId,
+              filter: {
+                inMailbox: query.mailboxId,
+                notKeyword: INTERNAL_SEND_KEYWORD,
+              },
+              sort: [{ property: 'receivedAt', isAscending: false }],
+              collapseThreads: true,
+              ...('anchor' in start
+                ? { anchor: start.anchor, anchorOffset: 1 }
+                : { position: start.position }),
+              limit: query.limit,
+              calculateTotal: true,
+            },
+            'q',
+          ],
+          [
+            'Email/get',
+            {
+              accountId,
+              '#ids': { resultOf: 'q', name: 'Email/query', path: '/ids' },
+              properties: SUMMARY_PROPERTIES,
+              bodyProperties: SUMMARY_BODY_PART_PROPERTIES,
+            },
+            'g',
+          ],
+          [
+            'Thread/get',
+            {
+              accountId,
+              '#ids': {
+                resultOf: 'g',
+                name: 'Email/get',
+                path: '/list/*/threadId',
+              },
+            },
+            't',
+          ],
+          ...submissionCalls(accountId, heldSubmissionFilter(now), HELD_CALLS),
+        ],
+        budget.finalOptions({ invalidRequestCode: 'RES_001' }),
+      );
+    let responses = await ask(
+      resume ? { anchor: resume.anchor } : { position: 0 },
+    );
+    // 마지막으로 본 메일이 그사이 지워지거나 옮겨졌으면 위치로 이어 읽는다
+    const first = findResult(responses, 'q', 'Email/query');
+    if (resume && !first.ok && first.error.type === 'anchorNotFound') {
+      responses = await ask({ position: resume.position });
+    }
+
+    // 메일함 목록은 꼭 읽는다 — 엔진 장애(메서드 오류)는 503 MAIL_001, 없는 메일함은 404 RES_001 (3차 리뷰 M1)
+    const { list: mailboxes = [] } = expectResult<JmapGetResult<JmapMailbox>>(
+      responses,
+      'm',
+      'Mailbox/get',
+    );
+    if (!mailboxes.some((mailbox) => mailbox.id === query.mailboxId)) {
+      throw new BusinessException('RES_001', {
+        context: { reason: 'mailbox-not-found' },
+      });
+    }
+    const excluded = new Set(excludedMailboxIdsOf(mailboxes));
+    const result = expectResult<JmapQueryResult>(responses, 'q', 'Email/query');
+    const { list: latestEmails = [] } = expectResult<JmapGetResult<JmapEmail>>(
+      responses,
+      'g',
+      'Email/get',
+    );
+    const { list: threads = [] } = expectResult<JmapGetResult<JmapThread>>(
+      responses,
+      't',
+      'Thread/get',
+    );
+    const held = readHeldSendTimes(responses, HELD_CALLS, now);
+    warnIfHeldQueryFull(this.logger, responses, HELD_CALLS, user);
+
+    const latestById = new Map(latestEmails.map((email) => [email.id, email]));
+    const threadById = new Map(threads.map((thread) => [thread.id, thread]));
+    const ids = result.ids ?? [];
+    const rows = ids.flatMap((id) => {
+      const latest = latestById.get(id);
+      if (!latest) return [];
+      const members = latest.threadId
+        ? threadById.get(latest.threadId)?.emailIds
+        : undefined;
+      return [{ latest, order: members?.length ? members : [latest.id] }];
+    });
+    // 스레드마다 최신 쪽의 몫 — 한 요청 상한 안에서 작은 스레드부터
+    const shares = shareScan(
+      rows.map((row) =>
+        Math.min(row.order.length, CONVERSATION_ENGINE_THREAD_SCAN_MAX),
+      ),
+      CONVERSATION_ENGINE_LIST_SCAN_MAX,
+    );
+    const windows = rows.map(
+      (row, index) =>
+        new Set(row.order.slice(row.order.length - shares[index])),
+    );
+    const toRead = [
+      ...new Set(windows.flatMap((window) => [...window])),
+    ].filter((id) => !latestById.has(id));
+    const { emails: members, attempted } = await this.readMembers(
+      user,
+      toRead,
+      budget,
+    );
+
+    const items = rows.map(({ latest, order }, index): ConversationSummary => {
+      const window = windows[index];
+      /** 읽은 메일 — 몫 안에서 엔진에 물은 것(그사이 지운 것은 빠진다)과 마지막 메일 */
+      const wasRead = (id: string) =>
+        id === latest.id || (window.has(id) && attempted.has(id));
+      const readEmails = order.flatMap((id) => {
+        if (!wasRead(id)) return [];
+        const email = id === latest.id ? latest : members.get(id);
+        return email ? [email] : [];
+      });
+      if (!order.includes(latest.id)) readEmails.push(latest);
+      const notRead = order.filter((id) => !wasRead(id)).length;
+      const inMailbox = (email: JmapEmail) =>
+        Boolean(email.mailboxIds?.[query.mailboxId]) &&
+        !email.keywords?.[INTERNAL_SEND_KEYWORD];
+      const kept = readEmails.filter((email) =>
+        inConversation(email, excluded, inMailbox),
+      );
+      const here = kept.filter(inMailbox);
+      const messageIds = (
+        here.length > 0 ? here.map((email) => email.id).reverse() : [latest.id]
+      ).slice(0, CONVERSATION_MESSAGE_IDS_MAX);
+      const shownHere = here.length > 0 ? here : [latest];
+      return {
+        id: latest.threadId ?? latest.id,
+        latest: toSummary(latest, pendingSendOf(latest, held)),
+        participants: participantsOf(kept, CONVERSATION_PARTICIPANTS_MAX),
+        messageCount: Math.max(kept.length + notRead, 1),
+        messageIds,
+        pendingSendIds: messageIds.filter((id) => held.has(id)),
+        isRead: shownHere.every((email) => email.keywords?.$seen === true),
+        isFlagged: shownHere.some((email) => email.keywords?.$flagged === true),
+        hasAttachment: shownHere.some((email) =>
+          hasRealAttachment(email.attachments ?? []),
+        ),
+      };
+    });
+
+    const start = result.position ?? 0;
+    const total = typeof result.total === 'number' ? result.total : null;
+    const hasNext =
+      total !== null ? start + ids.length < total : ids.length === query.limit;
+    const lastId = ids.at(-1);
+    return {
+      items,
+      hasNext,
+      nextCursor:
+        hasNext && lastId
+          ? encodeCursor(
+              { anchor: lastId, position: start + ids.length },
+              scope,
+            )
+          : null,
+      total,
+    };
+  }
+
+  /** 메일함 목록(역할) — 같은 대화에서만: 읽지 못하면 빈 목록(빼는 메일함 없이 — 대화가 넓어질 뿐, 경고를 남긴다) */
+  private mailboxesOf(
+    responses: JmapInvocation[],
+    user: string,
+  ): JmapMailbox[] {
+    const found = findResult(responses, 'm', 'Mailbox/get');
+    if (!found.ok) {
+      this.logger.warn(
+        `[MAIL_001]${traceTag()} 대화의 메일함 역할을 읽지 못해 휴지통 · 스팸메일함을 빼지 못했습니다: user=${maskEmail(user)}, type=${found.error.type}`,
+      );
+      return [];
+    }
+    return (found.args as JmapGetResult<JmapMailbox>).list ?? [];
+  }
+
+  /** 메일 여러 통을 값싼 속성으로 — 훑는 호출(마지막 요약 읽기 몫을 남긴 제한 시간), 엔진 장애는 그대로 던진다 */
+  private async readEmails(
+    user: string,
+    ids: readonly string[],
+    properties: readonly string[],
+    budget: ReadBudget,
+  ): Promise<Map<string, JmapEmail>> {
+    const responses = await this.jmap.call(
+      user,
+      (accountId) => [
+        [
+          'Email/get',
+          {
+            accountId,
+            ids: [...ids],
+            properties: [...properties],
+            ...(properties.includes('attachments')
+              ? { bodyProperties: SUMMARY_BODY_PART_PROPERTIES }
+              : {}),
+          },
+          'g',
+        ],
+      ],
+      budget.scanOptions(),
+    );
+    const { list = [] } = expectResult<JmapGetResult<JmapEmail>>(
+      responses,
+      'g',
+      'Email/get',
+    );
+    return new Map(list.map((email) => [email.id, email]));
+  }
+
+  /** 묶은 목록의 스레드 메일 — 500통씩, 시간이 남은 동안만(물은 id 를 함께 준다 — 묻지 못한 것은 상한에 걸린 줄의 읽지 못한 메일이다) */
+  private async readMembers(
+    user: string,
+    ids: readonly string[],
+    budget: ReadBudget,
+  ): Promise<{ emails: Map<string, JmapEmail>; attempted: Set<string> }> {
+    const emails = new Map<string, JmapEmail>();
+    const attempted = new Set<string>();
+    for (const batch of chunks(ids, MEMBER_BATCH_SIZE)) {
+      if (!budget.canScan()) break;
+      let read: Map<string, JmapEmail>;
+      try {
+        read = await this.readEmails(user, batch, MEMBER_PROPERTIES, budget);
+      } catch (error) {
+        // 시간 때문에 끊긴 묶음 — 그 메일은 읽지 못한 것으로(어림 줄 — 503 이 아니다)
+        if (budget.cutOff(error)) break;
+        throw error;
+      }
+      for (const id of batch) attempted.add(id);
+      for (const [id, email] of read) emails.set(id, email);
+    }
+    return { emails, attempted };
+  }
+
+  /** 내보낼 메일의 요약 — 마지막 읽기(남은 시간을 다 쓴다). 요약 속성은 이 메일들만, 같은 요청에서 기다리는 발송도 (주어진 차례 · 없는 메일은 빠진다) */
+  private async summaries(
+    user: string,
+    ids: readonly string[],
+    budget: ReadBudget,
+  ): Promise<MessagePage['items']> {
+    if (ids.length === 0) return [];
+    const now = Date.now();
+    const responses = await this.jmap.call(
+      user,
+      (accountId) => [
+        [
+          'Email/get',
+          {
+            accountId,
+            ids: [...ids],
+            properties: SUMMARY_PROPERTIES,
+            bodyProperties: SUMMARY_BODY_PART_PROPERTIES,
+          },
+          'g',
+        ],
+        ...submissionCalls(accountId, heldSubmissionFilter(now), HELD_CALLS),
+      ],
+      budget.finalOptions(),
+    );
+    const { list = [] } = expectResult<JmapGetResult<JmapEmail>>(
+      responses,
+      'g',
+      'Email/get',
+    );
+    const held = readHeldSendTimes(responses, HELD_CALLS, now);
+    warnIfHeldQueryFull(this.logger, responses, HELD_CALLS, user);
+    const byId = new Map(list.map((email) => [email.id, email]));
+    return ids.flatMap((id) => {
+      const email = byId.get(id);
+      return email ? [toSummary(email, pendingSendOf(email, held))] : [];
+    });
+  }
+}
diff --git a/backend/src/modules/mail/jmap/jmap-cursor.spec.ts b/backend/src/modules/mail/jmap/jmap-cursor.spec.ts
index e1d4f1d..d4a662f 100644
--- a/backend/src/modules/mail/jmap/jmap-cursor.spec.ts
+++ b/backend/src/modules/mail/jmap/jmap-cursor.spec.ts
@@ -85,4 +85,56 @@ describe('메일 목록 커서', () => {
       expect(codeOf(() => decodeCursor(cursor, inbox))).toBe('VAL_001');
     }
   });
+
+  it('조건 검색(14단계)의 조건도 범위다 — 조건이 다르면 다른 목록, 조건이 없으면 지문은 예전과 같다', () => {
+    const position = { anchor: 'eaaaaab', position: 20 };
+    const conditions = ['이도윤', '', '', '', '', '', false];
+    const withConditions = encodeCursor(position, { text: '회의', conditions });
+
+    expect(
+      decodeCursor(withConditions, {
+        text: '회의',
+        conditions: [...conditions],
+      }),
+    ).toEqual(position);
+    for (const scope of [
+      { text: '회의' },
+      { text: '회의', conditions: ['김아라', '', '', '', '', '', false] },
+      { text: '회의', conditions: ['이도윤', '', '', '', '', '', true] },
+    ]) {
+      expect(codeOf(() => decodeCursor(withConditions, scope))).toBe('VAL_001');
+    }
+    // 조건이 없으면 예전 지문 — 3단계의 커서가 그대로 쓰인다
+    const plain = encodeCursor(position, { text: '회의' });
+    expect(decodeCursor(plain, { text: '회의' })).toEqual(position);
+  });
+
+  it('조건의 지문은 JSON 으로 잇는다 — 글 칸에 줄바꿈을 넣어 다른 칸 · 검색어를 흉내 내도 다른 목록이다', () => {
+    const position = { anchor: 'eaaaaab', position: 20 };
+    const NL = String.fromCharCode(10);
+    const fromTwoLines = encodeCursor(position, {
+      text: '회의',
+      conditions: [`a${NL}b`, '', '', '', '', '', false],
+    });
+    expect(
+      codeOf(() =>
+        decodeCursor(fromTwoLines, {
+          text: '회의',
+          conditions: ['a', 'b', '', '', '', '', false],
+        }),
+      ),
+    ).toBe('VAL_001');
+    // 검색어 끝에 줄바꿈 + 조건처럼 보이는 글을 넣어도 조건이 있는 검색과 섞이지 않는다
+    const textOnly = encodeCursor(position, {
+      text: `회의${NL}${JSON.stringify(['a', '', '', '', '', '', false])}`,
+    });
+    expect(
+      codeOf(() =>
+        decodeCursor(textOnly, {
+          text: '회의',
+          conditions: ['a', '', '', '', '', '', false],
+        }),
+      ),
+    ).toBe('VAL_001');
+  });
 });
diff --git a/backend/src/modules/mail/jmap/jmap-cursor.ts b/backend/src/modules/mail/jmap/jmap-cursor.ts
index cc03e69..5889fc5 100644
--- a/backend/src/modules/mail/jmap/jmap-cursor.ts
+++ b/backend/src/modules/mail/jmap/jmap-cursor.ts
@@ -30,6 +30,11 @@ export interface CursorScope {
   /** 메일함 — 없으면 휴지통·스팸메일함을 뺀 모든 메일함 */
   readonly mailboxId?: string;
   readonly text?: string;
+  /**
+   * 조건 검색의 조건(14단계 — 정해진 차례의 값들). 없으면(조건 없는 검색 · 목록) 지문은 예전과 같다 — 배포 전에 받은 커서도 그대로 쓴다.
+   * 있으면 지문은 [메일함, 검색어, 조건] 의 JSON 이다 — 글 칸에 줄바꿈이 들어도 칸의 경계가 섞이지 않는다
+   */
+  readonly conditions?: readonly (string | boolean)[];
 }
 
 export interface CursorPosition {
@@ -47,8 +52,15 @@ interface EncodedCursor {
 }
 
 function scopeHash(scope: CursorScope): string {
+  const mailbox = scope.mailboxId ?? ALL_MAILBOXES_SCOPE;
+  const text = scope.text ?? '';
+  // 조건이 없으면 예전 모양("<메일함>\n<검색어>") — 메일함 id 에는 줄바꿈이 없어 섞이지 않는다. 조건이 있으면 JSON(늘 "[" 로 시작 — 메일함 id 와 겹치지 않는다)
+  const material =
+    scope.conditions === undefined
+      ? `${mailbox}\n${text}`
+      : JSON.stringify([mailbox, text, scope.conditions]);
   return createHash('sha256')
-    .update(`${scope.mailboxId ?? ALL_MAILBOXES_SCOPE}\n${scope.text ?? ''}`)
+    .update(material)
     .digest('base64url')
     .slice(0, SCOPE_HASH_LENGTH);
 }
diff --git a/backend/src/modules/mail/jmap/jmap-filter-run.ts b/backend/src/modules/mail/jmap/jmap-filter-run.ts
index 1e2243e..0a5dbb9 100644
--- a/backend/src/modules/mail/jmap/jmap-filter-run.ts
+++ b/backend/src/modules/mail/jmap/jmap-filter-run.ts
@@ -71,8 +71,11 @@ const BODY_ROUND_SIZE = 100;
 export const FILTER_RUN_BODY_VALUE_BYTES = 262_144;
 export const FILTER_RUN_MESSAGE_BODY_BYTES = 1_048_576;
 
-/** 본문을 한 번에 읽는 양의 어림 상한 — 부분의 크기로 어림해 넘으면 나눠 읽는다 (응답 하나가 수십 MB 가 되지 않게) */
-const BODY_FETCH_BUDGET_BYTES = 4_000_000;
+/**
+ * 본문을 한 번에 읽는 양의 어림 상한 — 부분의 크기로 어림해 넘으면 나눠 읽는다 (응답 하나가 수십 MB 가 되지 않게).
+ * 검색 색인의 본문 읽기(jmap-index-source.ts — 14단계)도 같은 상한을 쓴다
+ */
+export const BODY_FETCH_BUDGET_BYTES = 4_000_000;
 
 /** 엔진의 한 번 읽기 한도 (maxObjectsInGet) */
 const MAX_IDS_PER_GET = 500;
diff --git a/backend/src/modules/mail/jmap/jmap-index-source.spec.ts b/backend/src/modules/mail/jmap/jmap-index-source.spec.ts
new file mode 100644
index 0000000..78923ed
--- /dev/null
+++ b/backend/src/modules/mail/jmap/jmap-index-source.spec.ts
@@ -0,0 +1,434 @@
+import { BusinessException } from '@/common/errors/business.exception';
+import { IndexDeadlineError } from '@/modules/mail-search/mail-index-source';
+import {
+  BODY_READ_BATCH_MESSAGE_BYTES,
+  BODY_READ_SOLO_MESSAGE_BYTES,
+  INDEX_CALL_MIN_MS,
+  INDEX_CALL_TIMEOUT_MS,
+} from '@/modules/mail-search/mail-search.constants';
+import type { JmapClient, JmapCallOptions } from './jmap.client';
+import {
+  JmapIndexSource,
+  indexAttachmentNames,
+  indexBodyBatches,
+} from './jmap-index-source';
+import type { JmapEmail, JmapInvocation } from './jmap.types';
+
+const ARA = 'ara.kim@arasystem.test';
+
+type Responder = (
+  method: string,
+  args: Record<string, unknown>,
+  callId: string,
+) => JmapInvocation;
+
+/** 대역 엔진 — 메서드마다 답을 정한다. 받은 요청을 모은다 */
+class FakeJmap {
+  readonly requests: { calls: JmapInvocation[]; options: JmapCallOptions }[] =
+    [];
+  responders = new Map<string, Responder>();
+  /** 요청 전체를 이 예외로 거절한다 (한 번) */
+  rejectNext: Error | null = null;
+
+  readonly client = {
+    call: jest.fn(
+      (
+        _user: string,
+        build: (accountId: string) => JmapInvocation[],
+        options: JmapCallOptions = {},
+      ) => {
+        const calls = build('acc');
+        this.requests.push({ calls, options });
+        if (this.rejectNext) {
+          const error = this.rejectNext;
+          this.rejectNext = null;
+          return Promise.reject(error);
+        }
+        return Promise.resolve(
+          calls.map(([method, args, callId]) => {
+            const responder = this.responders.get(method);
+            if (!responder) throw new Error(`답이 없는 메서드: ${method}`);
+            return responder(method, args, callId);
+          }),
+        );
+      },
+    ),
+  };
+
+  on(method: string, responder: Responder): void {
+    this.responders.set(method, responder);
+  }
+}
+
+describe('JmapIndexSource (검색 색인의 엔진 읽기)', () => {
+  let engine: FakeJmap;
+  let source: JmapIndexSource;
+  const options = () => ({ deadline: Date.now() + 30_000 });
+
+  beforeEach(() => {
+    engine = new FakeJmap();
+    source = new JmapIndexSource(engine.client as unknown as JmapClient);
+  });
+
+  describe('changes', () => {
+    it('만든 · 바꾼 · 없어진 id 와 새 state · 더 있는지', async () => {
+      engine.on('Email/changes', (method, args, callId) => {
+        expect(args).toMatchObject({ sinceState: 's1', maxChanges: 100 });
+        return [
+          method,
+          {
+            newState: 's2',
+            hasMoreChanges: true,
+            created: ['a'],
+            updated: ['b'],
+            destroyed: ['c', 7],
+          },
+          callId,
+        ];
+      });
+      expect(await source.changes(ARA, 's1', 100, options())).toEqual({
+        kind: 'changes',
+        created: ['a'],
+        updated: ['b'],
+        destroyed: ['c'],
+        newState: 's2',
+        hasMore: true,
+      });
+      // 호출마다 남은 시간을 넘긴다 (한 번은 15초까지)
+      expect(engine.requests[0].options.timeoutMs).toBeLessThanOrEqual(15_000);
+    });
+
+    it.each(['cannotCalculateChanges', 'invalidArguments'])(
+      '엔진이 셀 수 없다(%s) → cannotCalculate',
+      async (type) => {
+        engine.on('Email/changes', (_method, _args, callId) => [
+          'error',
+          { type, description: '엔진 문장' },
+          callId,
+        ]);
+        expect(await source.changes(ARA, 'old', 100, options())).toEqual({
+          kind: 'cannotCalculate',
+        });
+      },
+    );
+
+    it('요청 전체를 거절해도(모르는 state 모양) cannotCalculate — 그 밖의 오류는 코드로 던진다', async () => {
+      engine.rejectNext = new BusinessException('VAL_001', {
+        context: { reason: 'request-rejected', jmapType: 'notRequest' },
+      });
+      expect(await source.changes(ARA, '###', 100, options())).toEqual({
+        kind: 'cannotCalculate',
+      });
+
+      engine.on('Email/changes', (_method, _args, callId) => [
+        'error',
+        { type: 'serverFail', description: '엔진 문장' },
+        callId,
+      ]);
+      const error = (await source
+        .changes(ARA, 's1', 100, options())
+        .catch((caught: unknown) => caught)) as BusinessException;
+      expect(error.code).toBe('MAIL_001');
+      expect(JSON.stringify(error.context)).not.toContain('엔진 문장');
+    });
+
+    it('끝 시각까지 INDEX_CALL_MIN_MS 보다 적게 남았으면 엔진에 묻지 않고 IndexDeadlineError (실패가 아니라 이어 하기)', async () => {
+      for (const deadline of [
+        Date.now() - 1,
+        Date.now() + INDEX_CALL_MIN_MS - 500,
+      ]) {
+        await expect(
+          source.changes(ARA, 's1', 100, { deadline }),
+        ).rejects.toBeInstanceOf(IndexDeadlineError);
+      }
+      expect(engine.requests).toHaveLength(0);
+    });
+
+    it('남은 시간으로 줄인 기다림이 끝나 끊기면 IndexDeadlineError — 끝 시각이 멀어 줄이지 않았으면 엔진 장애(MAIL_001) 그대로', async () => {
+      const timeout = () =>
+        new BusinessException('MAIL_001', {
+          context: { reason: 'timeout', call: 'api' },
+        });
+      engine.rejectNext = timeout();
+      await expect(
+        source.changes(ARA, 's1', 100, { deadline: Date.now() + 5_000 }),
+      ).rejects.toBeInstanceOf(IndexDeadlineError);
+      expect(engine.requests[0].options.timeoutMs).toBeLessThanOrEqual(5_000);
+
+      engine.rejectNext = timeout();
+      await expect(
+        source.changes(ARA, 's1', 100, {
+          deadline: Date.now() + INDEX_CALL_TIMEOUT_MS * 2,
+        }),
+      ).rejects.toMatchObject({ code: 'MAIL_001' });
+      expect(engine.requests[1].options.timeoutMs).toBe(INDEX_CALL_TIMEOUT_MS);
+    });
+  });
+
+  describe('documents', () => {
+    const emails: JmapEmail[] = [
+      {
+        id: 'e1',
+        threadId: 't1',
+        mailboxIds: { inbox: true, old: false },
+        keywords: { $seen: true, $flagged: false },
+        receivedAt: '2026-11-05T01:00:00Z',
+        size: 900,
+        messageId: ['m1@x'],
+        inReplyTo: ['p@x'],
+        references: ['r@x', 'p@x'],
+        subject: '계약서',
+        from: [{ name: '이도윤', email: 'doyun.lee@arasystem.test' }],
+        to: [{ email: ARA }],
+        cc: null,
+        preview: '미리 보기',
+        textBody: [{ partId: '1', type: 'text/html', size: 100 }],
+        attachments: [
+          // 진짜 첨부 — 이름이 있음 · 이름 없음
+          {
+            partId: '2',
+            type: 'application/pdf',
+            name: ' 계약서.pdf ',
+            size: 10,
+          },
+          { partId: '3', type: 'application/zip', size: 10 },
+          // 본문 그림(서명 로고) — 첨부가 아니다
+          {
+            partId: '4',
+            type: 'image/png',
+            name: 'logo.png',
+            cid: 'logo',
+            disposition: 'inline',
+            size: 1000,
+          },
+          // 텍스트 첨부 — 안의 글은 읽지 않는다
+          { partId: '5', type: 'text/plain', name: '메모.txt', size: 10 },
+        ],
+      },
+      {
+        id: 'e2',
+        mailboxIds: { inbox: true },
+        receivedAt: '2026-11-05T02:00:00Z',
+        subject: null,
+        textBody: [
+          { partId: '1', type: 'text/plain', size: 20 },
+          { partId: '2', type: 'image/jpeg', size: 20 },
+        ],
+        attachments: [],
+      },
+    ];
+
+    it('머리글을 읽고 textBody 의 글자 부분만 값을 읽는다 — HTML 은 글자만, 첨부 이름은 진짜 첨부만', async () => {
+      engine.on('Email/get', (method, args, callId) => {
+        const ids = args.ids as string[];
+        if (args.fetchTextBodyValues === true) {
+          // 몫 — 글자 부분 하나면 256KiB
+          expect(args.maxBodyValueBytes).toBe(262_144);
+          expect(args.fetchAllBodyValues).toBeUndefined();
+          return [
+            method,
+            {
+              list: ids.map((id) =>
+                id === 'e1'
+                  ? {
+                      id,
+                      textBody: [{ partId: '1', type: 'text/html' }],
+                      bodyValues: {
+                        '1': {
+                          value:
+                            '<p>계약서를<b>보내</b> 드립니다</p><style>x{}</style>',
+                        },
+                      },
+                    }
+                  : {
+                      id,
+                      textBody: [{ partId: '1', type: 'text/plain' }],
+                      bodyValues: { '1': { value: '글 본문' } },
+                    },
+              ),
+            },
+            callId,
+          ];
+        }
+        return [
+          method,
+          { list: emails.filter((email) => ids.includes(email.id)) },
+          callId,
+        ];
+      });
+
+      const documents = await source.documents(
+        ARA,
+        ['e1', 'e2', 'gone'],
+        options(),
+      );
+
+      expect(documents).toHaveLength(2);
+      expect(documents[0]).toEqual({
+        id: 'e1',
+        threadId: 't1',
+        mailboxIds: ['inbox'],
+        keywords: ['$seen'],
+        receivedAt: '2026-11-05T01:00:00Z',
+        size: 900,
+        messageIds: ['m1@x'],
+        inReplyTo: ['p@x'],
+        references: ['r@x', 'p@x'],
+        subject: '계약서',
+        from: [{ name: '이도윤', email: 'doyun.lee@arasystem.test' }],
+        to: [{ name: null, email: ARA }],
+        cc: [],
+        attachmentNames: ['계약서.pdf', '메모.txt'],
+        hasAttachment: true,
+        preview: '미리 보기',
+        bodyText: '계약서를보내 드립니다\n',
+      });
+      expect(documents[1]).toMatchObject({
+        id: 'e2',
+        subject: '',
+        threadId: null,
+        bodyText: '글 본문',
+        hasAttachment: false,
+        attachmentNames: [],
+      });
+    });
+  });
+
+  it('indexBodyBatches — 메일 전체 크기의 합이 BODY_READ_BATCH_MESSAGE_BYTES 를 넘으면 나누고, BODY_READ_SOLO_MESSAGE_BYTES 를 넘는 메일은 혼자', () => {
+    const part = { partId: '1', type: 'text/plain', size: 1_000 };
+    const third = Math.floor(BODY_READ_BATCH_MESSAGE_BYTES / 3);
+    const batches = indexBodyBatches([
+      // 큰 첨부가 든 메일 넷 — 크기 합이 상한을 넘기 전에 나눈다
+      { id: 'a', parts: [part], size: third },
+      { id: 'b', parts: [part], size: third },
+      { id: 'c', parts: [part], size: third },
+      { id: 'd', parts: [part], size: third },
+      // 혼자 읽는 메일 — 그 앞뒤 묶음과 섞지 않는다
+      { id: 'huge', parts: [part], size: BODY_READ_SOLO_MESSAGE_BYTES + 1 },
+      { id: 'small', parts: [part], size: 10 },
+    ]);
+    expect(batches.map((batch) => batch.ids)).toEqual([
+      ['a', 'b', 'c'],
+      ['huge'],
+      ['d', 'small'],
+    ]);
+  });
+
+  it('indexBodyBatches — 몫이 같은 메일끼리, 어림 크기가 상한을 넘으면 나눈다 · 글자 부분이 없으면 읽지 않는다', () => {
+    const big = { partId: '1', type: 'text/plain', size: 1_000_000 };
+    const batches = indexBodyBatches([
+      { id: 'a', parts: [big], size: 1_000_000 },
+      { id: 'b', parts: [big], size: 1_000_000 },
+      { id: 'c', parts: [big, { ...big, partId: '2' }], size: 2_000_000 },
+      { id: 'none', parts: [], size: 0 },
+    ]);
+    // 한 부분 몫 256KiB — 어림 256KiB 씩이라 a · b 는 한 묶음, c 는 부분이 둘이라 몫이 같은(256KiB) 묶음에
+    expect(batches.flatMap((batch) => batch.ids).sort()).toEqual([
+      'a',
+      'b',
+      'c',
+    ]);
+    expect(batches.every((batch) => batch.quota === 262_144)).toBe(true);
+  });
+
+  it('indexAttachmentNames — 본문 그림을 빼고 이름이 있는 것만, 경로 · 제어 문자는 다듬는다', () => {
+    expect(
+      indexAttachmentNames([
+        { name: '../보고서.hwp', type: 'application/octet-stream' },
+        { name: 'logo.png', type: 'image/png', cid: 'c1', size: 10 },
+        { name: '', type: 'application/pdf' },
+      ]),
+    ).toEqual(['보고서.hwp']);
+  });
+
+  describe('pageIds · allIds · snapshot', () => {
+    it('anchor 다음부터 최신 차례 — anchor 가 지워졌으면 위치로', async () => {
+      const seen: Record<string, unknown>[] = [];
+      engine.on('Email/query', (method, args, callId) => {
+        seen.push(args);
+        if (args.anchor === 'gone') {
+          return ['error', { type: 'anchorNotFound' }, callId];
+        }
+        return [method, { ids: ['x', 'y'], position: 50, total: 120 }, callId];
+      });
+      expect(
+        await source.pageIds(
+          ARA,
+          { anchor: 'gone', position: 50 },
+          2,
+          options(),
+        ),
+      ).toEqual({ ids: ['x', 'y'], position: 50, total: 120 });
+      expect(seen[0]).toMatchObject({
+        anchor: 'gone',
+        anchorOffset: 1,
+        sort: [{ property: 'receivedAt', isAscending: false }],
+        calculateTotal: true,
+      });
+      expect(seen[1]).toMatchObject({ position: 50, limit: 2 });
+      expect(seen[1]).not.toHaveProperty('anchor');
+    });
+
+    it('전체 대조는 오래된 차례로 anchor 로 이어 묻고 빈 쪽에서 끝난다 — anchor 가 지워지면 처음부터', async () => {
+      const pages = [
+        { anchor: undefined, ids: ['a', 'b'] },
+        { anchor: 'b', error: 'anchorNotFound' },
+        { anchor: undefined, ids: ['a', 'c'] },
+        { anchor: 'c', ids: ['d'] },
+        { anchor: 'd', ids: [] },
+      ];
+      engine.on('Email/get', (method, _args, callId) => [
+        method,
+        { state: 'st', list: [] },
+        callId,
+      ]);
+      engine.on('Email/query', (method, args, callId) => {
+        if (args.limit === 1) return [method, { ids: [], total: 3 }, callId];
+        const page = pages.shift()!;
+        expect(args.anchor).toBe(page.anchor);
+        expect(args.sort).toEqual([
+          { property: 'receivedAt', isAscending: true },
+        ]);
+        if (page.error) return ['error', { type: page.error }, callId];
+        return [method, { ids: page.ids, total: 3 }, callId];
+      });
+      expect(await source.allIds(ARA, options())).toEqual({
+        state: 'st',
+        ids: ['a', 'c', 'd'],
+      });
+      expect(pages).toEqual([]);
+    });
+
+    it('snapshot — 빈 ids 의 Email/get 으로 state, 조회의 total 로 메일 수', async () => {
+      engine.on('Email/get', (method, args, callId) => {
+        expect(args.ids).toEqual([]);
+        return [method, { state: 'st9', list: [] }, callId];
+      });
+      engine.on('Email/query', (method, _args, callId) => [
+        method,
+        { ids: ['z'], total: 42 },
+        callId,
+      ]);
+      expect(await source.snapshot(ARA, options())).toEqual({
+        state: 'st9',
+        total: 42,
+      });
+    });
+
+    it('state 가 없으면 MAIL_001', async () => {
+      engine.on('Email/get', (method, _args, callId) => [
+        method,
+        { list: [] },
+        callId,
+      ]);
+      engine.on('Email/query', (method, _args, callId) => [
+        method,
+        { ids: [] },
+        callId,
+      ]);
+      await expect(source.snapshot(ARA, options())).rejects.toMatchObject({
+        code: 'MAIL_001',
+      });
+    });
+  });
+});
diff --git a/backend/src/modules/mail/jmap/jmap-index-source.ts b/backend/src/modules/mail/jmap/jmap-index-source.ts
new file mode 100644
index 0000000..fcdb222
--- /dev/null
+++ b/backend/src/modules/mail/jmap/jmap-index-source.ts
@@ -0,0 +1,622 @@
+import { Injectable } from '@nestjs/common';
+
+import { BusinessException } from '@/common/errors/business.exception';
+import { sanitizeFileName } from '@/modules/mail/attachment.policy';
+import { htmlToText } from '@/modules/mail/html/html-text';
+import {
+  hasRealAttachment,
+  isBodyImagePart,
+} from '@/modules/mail/html/inline-images';
+import {
+  IndexDeadlineError,
+  type IndexAddress,
+  type IndexAllIds,
+  type IndexChanges,
+  type IndexDocument,
+  type IndexIdPage,
+  type IndexMutable,
+  type IndexReadOptions,
+  type MailIndexSource,
+} from '@/modules/mail-search/mail-index-source';
+import {
+  ALL_IDS_PAGE,
+  BODY_READ_BATCH_MESSAGE_BYTES,
+  BODY_READ_SOLO_MESSAGE_BYTES,
+  INDEX_CALL_MIN_MS,
+  INDEX_CALL_TIMEOUT_MS,
+} from '@/modules/mail-search/mail-search.constants';
+import { BODY_FETCH_BUDGET_BYTES, bodyValueQuota } from './jmap-filter-run';
+import { JmapClient, type JmapCallOptions } from './jmap.client';
+import { jmapFailure } from './jmap.errors';
+import { expectResult, findResult, isState } from './jmap-results';
+import type {
+  JmapBodyPart,
+  JmapChangesResult,
+  JmapEmail,
+  JmapEmailAddress,
+  JmapGetResult,
+  JmapInvocation,
+  JmapQueryResult,
+} from './jmap.types';
+
+/**
+ * 메일 검색 색인이 엔진에서 읽는 것 — Stalwart(JMAP) 어댑터 (14단계 설계 B2, 포트는 modules/mail-search/mail-index-source.ts).
+ * 직원 자격(게이트웨이 대리 접근 — JmapClient.call)으로 읽기만 한다 — 이 파일에는 Email/set 이 없다.
+ *
+ * - 글: 머리글 · 받는 사람 · 첨부 부분은 한 번에(MAX_IDS_PER_GET 씩), 본문 값은 textBody 의 글자 부분만 따로 읽는다(fetchTextBodyValues).
+ *   textBody 는 엔진이 고른 글자 쪽 표현(text/plain, 없으면 text/html)이라 같은 글을 두 번 담지 않는다. 첨부 파일 안의 글은 읽지 않는다(설계 — 첨부 이름만 찾는다).
+ *   본문 값은 부분마다 256KiB · 한 통 1MiB 까지(이미 받은 메일에 필터 적용과 같은 몫 — jmap-filter-run.ts 의 bodyValueQuota),
+ *   몫이 같은 메일끼리 어림 크기 BODY_FETCH_BUDGET_BYTES 로 나눠 읽는다 — 바깥 메일 한 통으로 서버 · 엔진 메모리를 크게 쓰지 않게.
+ *   묶음은 메일 **전체** 크기(size)의 합도 BODY_READ_BATCH_MESSAGE_BYTES 까지, BODY_READ_SOLO_MESSAGE_BYTES 를 넘는 메일은 혼자 읽는다 —
+ *   엔진은 값을 만들며 원문을 읽으므로 큰 첨부 메일 여럿이 한 요청에 들면 엔진(1g) 메모리가 한꺼번에 튄다
+ * - 시간: 엔진 읽기마다 차례의 끝 시각까지 남은 시간을 본다 — INDEX_CALL_MIN_MS 보다 적으면 시작하지 않고, 남은 시간으로 줄인 기다림이
+ *   끝나 끊긴 것도 IndexDeadlineError(실패가 아니라 이어 하기)로 알린다. 한 번은 INDEX_CALL_TIMEOUT_MS 까지만 기다린다
+ * - 지난 메일 쪽: 받은 시각 최신부터 anchor 다음 — anchor 가 지워졌으면(anchorNotFound) 위치로
+ * - 전체 대조: 받은 시각 오래된 것부터 anchor 로 이어 묻는다(위치로 넘기면 그사이 지운 메일만큼 건너뛴다) — anchor 가 지워지면 처음부터 다시
+ * 엔진 오류의 설명 문장은 남기지 않는다(jmapFailure — type · 속성 이름만)
+ */
+
+/** 엔진의 한 번 읽기 한도 (maxObjectsInGet) */
+const MAX_IDS_PER_GET = 500;
+
+/** 전체 대조에서 anchor 가 지워져 처음부터 다시 묻는 횟수 */
+const ALL_IDS_RESTARTS = 3;
+
+/** 머리글을 읽을 때의 속성 · 부분 속성 (본문 값은 따로) */
+const DOCUMENT_PROPERTIES = [
+  'id',
+  'threadId',
+  'mailboxIds',
+  'keywords',
+  'receivedAt',
+  'size',
+  'messageId',
+  'inReplyTo',
+  'references',
+  'subject',
+  'from',
+  'to',
+  'cc',
+  'preview',
+  'attachments',
+  'textBody',
+];
+const DOCUMENT_PART_PROPERTIES = [
+  'partId',
+  'type',
+  'size',
+  'name',
+  'disposition',
+  'cid',
+];
+
+const NEWEST_FIRST = [{ property: 'receivedAt', isAscending: false }];
+const OLDEST_FIRST = [{ property: 'receivedAt', isAscending: true }];
+
+/** JMAP 메서드 오류 — 그 state 부터의 변화를 셀 수 없다 · 인자가 맞지 않는다(모르는 state 모양) · anchor 가 결과에 없다 */
+const CANNOT_CALCULATE_CHANGES = 'cannotCalculateChanges';
+const INVALID_ARGUMENTS = 'invalidArguments';
+const ANCHOR_NOT_FOUND = 'anchorNotFound';
+
+const HTML_TYPE = 'text/html';
+
+function chunks<T>(items: readonly T[], size: number): T[][] {
+  const out: T[][] = [];
+  for (let index = 0; index < items.length; index += size) {
+    out.push(items.slice(index, index + size));
+  }
+  return out;
+}
+
+function trueKeys(record: Record<string, boolean> | undefined): string[] {
+  return Object.entries(record ?? {})
+    .filter(([, value]) => value === true)
+    .map(([key]) => key);
+}
+
+function strings(value: unknown): string[] {
+  return Array.isArray(value)
+    ? value.filter((item): item is string => typeof item === 'string')
+    : [];
+}
+
+function toAddresses(
+  addresses: JmapEmailAddress[] | null | undefined,
+): IndexAddress[] {
+  return (addresses ?? []).map((address) => ({
+    name: typeof address.name === 'string' ? address.name : null,
+    email: typeof address.email === 'string' ? address.email : null,
+  }));
+}
+
+/** textBody 의 글자 부분 (text/* — 같은 partId 는 한 번) */
+export function indexTextParts(email: JmapEmail): JmapBodyPart[] {
+  const seen = new Set<string>();
+  return (email.textBody ?? []).filter((part) => {
+    const { partId } = part;
+    if (!partId || seen.has(partId)) return false;
+    seen.add(partId);
+    return (part.type ?? '').toLowerCase().startsWith('text/');
+  });
+}
+
+/** 본문 글 — 글자 부분마다(HTML 은 글자만), 줄바꿈으로 잇는다. 값을 받지 못한 부분은 뺀다 */
+export function indexBodyText(
+  parts: readonly JmapBodyPart[],
+  values: JmapEmail['bodyValues'],
+): string {
+  return parts
+    .flatMap((part) => {
+      const value = values?.[part.partId ?? '']?.value;
+      if (typeof value !== 'string') return [];
+      return [
+        (part.type ?? '').toLowerCase() === HTML_TYPE
+          ? htmlToText(value)
+          : value,
+      ];
+    })
+    .join('\n');
+}
+
+/** 진짜 첨부(본문 그림이 아닌 것)의 이름 — 이름이 없는 첨부는 뺀다 (목록 · 읽기 화면과 같은 이름 다듬기) */
+export function indexAttachmentNames(
+  attachments: readonly JmapBodyPart[],
+): string[] {
+  return attachments
+    .filter((part) => !isBodyImagePart(part))
+    .flatMap((part) => {
+      const name = part.name?.trim();
+      return name ? [sanitizeFileName(name)] : [];
+    });
+}
+
+/** 본문 값을 받을 때 응답 크기의 어림 (바이트) — 부분마다 몫까지, UTF-8 로 바꾸며 늘 수 있어 두 배 (크기를 모르면 몫) */
+function estimatedBytes(parts: readonly JmapBodyPart[], quota: number): number {
+  return parts.reduce(
+    (sum, part) =>
+      sum +
+      (typeof part.size === 'number' && part.size >= 0
+        ? Math.min(quota, part.size * 2)
+        : quota),
+    0,
+  );
+}
+
+/** 본문 값을 한 번에 읽을 메일 — 부분마다의 몫이 같은 메일끼리 */
+interface BodyBatch {
+  readonly quota: number;
+  readonly ids: string[];
+}
+
+/** 본문 값을 읽을 메일 한 통 — 글자 부분 · 메일 전체 크기(엔진의 size, 모르면 0) */
+export interface BodyReadCandidate {
+  readonly id: string;
+  readonly parts: readonly JmapBodyPart[];
+  readonly size: number;
+}
+
+/**
+ * 본문 값을 읽을 묶음 — 몫(bodyValueQuota)이 같은 메일끼리. 이럴 때 나눈다: 값의 어림 크기가 BODY_FETCH_BUDGET_BYTES 를 넘는다 ·
+ * 한 번 읽기 한도(MAX_IDS_PER_GET)에 닿는다 · 메일 전체 크기의 합이 BODY_READ_BATCH_MESSAGE_BYTES 를 넘는다.
+ * 전체 크기가 BODY_READ_SOLO_MESSAGE_BYTES 를 넘는 메일은 혼자 읽는다. 글자 부분이 없는 메일은 읽지 않는다
+ */
+export function indexBodyBatches(
+  emails: readonly BodyReadCandidate[],
+): BodyBatch[] {
+  const groups = new Map<number, BodyReadCandidate[]>();
+  for (const email of emails) {
+    if (email.parts.length === 0) continue;
+    const quota = bodyValueQuota(email.parts.length);
+    const group = groups.get(quota);
+    if (group) group.push(email);
+    else groups.set(quota, [email]);
+  }
+  const batches: BodyBatch[] = [];
+  for (const [quota, group] of groups) {
+    let ids: string[] = [];
+    let valueBytes = 0;
+    let messageBytes = 0;
+    for (const email of group) {
+      const size = Number.isFinite(email.size) ? Math.max(0, email.size) : 0;
+      if (size > BODY_READ_SOLO_MESSAGE_BYTES) {
+        batches.push({ quota, ids: [email.id] });
+        continue;
+      }
+      const estimate = estimatedBytes(email.parts, quota);
+      if (
+        ids.length > 0 &&
+        (valueBytes + estimate > BODY_FETCH_BUDGET_BYTES ||
+          messageBytes + size > BODY_READ_BATCH_MESSAGE_BYTES ||
+          ids.length >= MAX_IDS_PER_GET)
+      ) {
+        batches.push({ quota, ids });
+        ids = [];
+        valueBytes = 0;
+        messageBytes = 0;
+      }
+      ids.push(email.id);
+      valueBytes += estimate;
+      messageBytes += size;
+    }
+    if (ids.length > 0) batches.push({ quota, ids });
+  }
+  return batches;
+}
+
+/** 엔진 호출이 기다림 끝(시간 초과)으로 끊겼나 — JmapClient 가 붙이는 사유 */
+function isTimeout(error: unknown): boolean {
+  return (
+    error instanceof BusinessException &&
+    error.code === 'MAIL_001' &&
+    error.context?.reason === 'timeout'
+  );
+}
+
+@Injectable()
+export class JmapIndexSource implements MailIndexSource {
+  constructor(private readonly jmap: JmapClient) {}
+
+  async snapshot(
+    user: string,
+    options: IndexReadOptions,
+  ): Promise<{ state: string; total: number | null }> {
+    const responses = await this.call(
+      user,
+      (accountId) => [
+        ['Email/get', { accountId, ids: [], properties: ['id'] }, 's'],
+        [
+          'Email/query',
+          { accountId, position: 0, limit: 1, calculateTotal: true },
+          'q',
+        ],
+      ],
+      options,
+    );
+    const { state } = expectResult<JmapGetResult<JmapEmail>>(
+      responses,
+      's',
+      'Email/get',
+    );
+    const query = expectResult<JmapQueryResult>(responses, 'q', 'Email/query');
+    return {
+      state: this.requireState(state),
+      total: typeof query.total === 'number' ? query.total : null,
+    };
+  }
+
+  async changes(
+    user: string,
+    sinceState: string,
+    maxChanges: number,
+    options: IndexReadOptions,
+  ): Promise<IndexChanges> {
+    let responses: JmapInvocation[];
+    try {
+      responses = await this.call(
+        user,
+        (accountId) => [
+          ['Email/changes', { accountId, sinceState, maxChanges }, 'c'],
+        ],
+        options,
+        // 엔진이 state 모양을 받지 않아 요청 전체를 거절해도 셀 수 없는 것으로 본다 (아래 catch)
+        { invalidRequestCode: 'VAL_001' },
+      );
+    } catch (error) {
+      if (
+        error instanceof BusinessException &&
+        error.code === 'VAL_001' &&
+        error.context?.reason === 'request-rejected'
+      ) {
+        return { kind: 'cannotCalculate' };
+      }
+      throw error;
+    }
+    const result = findResult(responses, 'c', 'Email/changes');
+    if (!result.ok) {
+      const type = result.error.type;
+      if (type === CANNOT_CALCULATE_CHANGES || type === INVALID_ARGUMENTS) {
+        return { kind: 'cannotCalculate' };
+      }
+      throw jmapFailure(result.error, { method: 'Email/changes' });
+    }
+    const changes = result.args as JmapChangesResult;
+    return {
+      kind: 'changes',
+      created: strings(changes.created),
+      updated: strings(changes.updated),
+      destroyed: strings(changes.destroyed),
+      newState: this.requireState(changes.newState),
+      hasMore: changes.hasMoreChanges === true,
+    };
+  }
+
+  async documents(
+    user: string,
+    ids: readonly string[],
+    options: IndexReadOptions,
+  ): Promise<IndexDocument[]> {
+    const documents: IndexDocument[] = [];
+    for (const chunk of chunks(ids, MAX_IDS_PER_GET)) {
+      const emails = await this.readEmails(
+        user,
+        chunk,
+        DOCUMENT_PROPERTIES,
+        DOCUMENT_PART_PROPERTIES,
+        options,
+      );
+      const withParts = emails.map((email) => ({
+        id: email.id,
+        parts: indexTextParts(email),
+        size: typeof email.size === 'number' ? email.size : 0,
+      }));
+      const bodies = new Map<string, string>();
+      for (const batch of indexBodyBatches(withParts)) {
+        for (const email of await this.readBodies(user, batch, options)) {
+          bodies.set(
+            email.id,
+            indexBodyText(indexTextParts(email), email.bodyValues),
+          );
+        }
+      }
+      for (const email of emails) {
+        documents.push(this.toDocument(email, bodies.get(email.id) ?? ''));
+      }
+    }
+    return documents;
+  }
+
+  async mutable(
+    user: string,
+    ids: readonly string[],
+    options: IndexReadOptions,
+  ): Promise<IndexMutable[]> {
+    const found: IndexMutable[] = [];
+    for (const chunk of chunks(ids, MAX_IDS_PER_GET)) {
+      const emails = await this.readEmails(
+        user,
+        chunk,
+        ['id', 'mailboxIds', 'keywords'],
+        null,
+        options,
+      );
+      for (const email of emails) {
+        found.push({
+          id: email.id,
+          mailboxIds: trueKeys(email.mailboxIds),
+          keywords: trueKeys(email.keywords),
+        });
+      }
+    }
+    return found;
+  }
+
+  async pageIds(
+    user: string,
+    from: { anchor: string | null; position: number },
+    limit: number,
+    options: IndexReadOptions,
+  ): Promise<IndexIdPage> {
+    if (from.anchor !== null) {
+      const anchored = await this.query(
+        user,
+        NEWEST_FIRST,
+        { anchor: from.anchor },
+        limit,
+        options,
+      );
+      if (anchored !== null) return anchored;
+    }
+    // anchor 가 없거나 그사이 지워졌다 — 위치로
+    const page = await this.query(
+      user,
+      NEWEST_FIRST,
+      { position: Math.max(0, from.position) },
+      limit,
+      options,
+    );
+    return page ?? { ids: [], position: from.position, total: null };
+  }
+
+  async allIds(user: string, options: IndexReadOptions): Promise<IndexAllIds> {
+    for (let attempt = 0; attempt <= ALL_IDS_RESTARTS; attempt += 1) {
+      const { state } = await this.snapshot(user, options);
+      const ids: string[] = [];
+      let anchor: string | null = null;
+      let restarted = false;
+      for (;;) {
+        const page = await this.query(
+          user,
+          OLDEST_FIRST,
+          anchor === null ? { position: 0 } : { anchor },
+          ALL_IDS_PAGE,
+          options,
+        );
+        if (page === null) {
+          restarted = true;
+          break;
+        }
+        if (page.ids.length === 0) break;
+        ids.push(...page.ids);
+        anchor = page.ids[page.ids.length - 1];
+      }
+      if (!restarted) return { state, ids };
+    }
+    throw new BusinessException('MAIL_001', {
+      context: { reason: 'index-all-ids-anchor-lost' },
+    });
+  }
+
+  /**
+   * 받은 시각 차례로 한 쪽 — anchor 가 결과에 없으면(anchorNotFound) null (부른 쪽이 위치로 · 처음부터).
+   * 위치 · anchor 둘 다 total 을 센다
+   */
+  private async query(
+    user: string,
+    sort: readonly { property: string; isAscending: boolean }[],
+    start: { anchor: string } | { position: number },
+    limit: number,
+    options: IndexReadOptions,
+  ): Promise<IndexIdPage | null> {
+    const responses = await this.call(
+      user,
+      (accountId) => [
+        [
+          'Email/query',
+          {
+            accountId,
+            sort,
+            ...('anchor' in start
+              ? { anchor: start.anchor, anchorOffset: 1 }
+              : { position: start.position }),
+            limit,
+            calculateTotal: true,
+          },
+          'q',
+        ],
+      ],
+      options,
+    );
+    const result = findResult(responses, 'q', 'Email/query');
+    if (!result.ok) {
+      if (result.error.type === ANCHOR_NOT_FOUND && 'anchor' in start) {
+        return null;
+      }
+      throw jmapFailure(result.error, { method: 'Email/query' });
+    }
+    const query = result.args as JmapQueryResult;
+    return {
+      ids: strings(query.ids),
+      position:
+        typeof query.position === 'number'
+          ? query.position
+          : 'position' in start
+            ? start.position
+            : 0,
+      total: typeof query.total === 'number' ? query.total : null,
+    };
+  }
+
+  private async readEmails(
+    user: string,
+    ids: readonly string[],
+    properties: readonly string[],
+    bodyProperties: readonly string[] | null,
+    options: IndexReadOptions,
+  ): Promise<JmapEmail[]> {
+    if (ids.length === 0) return [];
+    const responses = await this.call(
+      user,
+      (accountId) => [
+        [
+          'Email/get',
+          {
+            accountId,
+            ids: [...ids],
+            properties: [...properties],
+            ...(bodyProperties ? { bodyProperties: [...bodyProperties] } : {}),
+          },
+          'g',
+        ],
+      ],
+      options,
+    );
+    const { list = [] } = expectResult<JmapGetResult<JmapEmail>>(
+      responses,
+      'g',
+      'Email/get',
+    );
+    return list.filter(
+      (email): email is JmapEmail =>
+        typeof email?.id === 'string' && email.id !== '',
+    );
+  }
+
+  /** 본문 값 — textBody 의 글자 부분, 부분마다 그 몫까지 */
+  private async readBodies(
+    user: string,
+    batch: BodyBatch,
+    options: IndexReadOptions,
+  ): Promise<JmapEmail[]> {
+    const responses = await this.call(
+      user,
+      (accountId) => [
+        [
+          'Email/get',
+          {
+            accountId,
+            ids: batch.ids,
+            properties: ['id', 'textBody', 'bodyValues'],
+            bodyProperties: ['partId', 'type'],
+            fetchTextBodyValues: true,
+            maxBodyValueBytes: batch.quota,
+          },
+          'b',
+        ],
+      ],
+      options,
+    );
+    const { list = [] } = expectResult<JmapGetResult<JmapEmail>>(
+      responses,
+      'b',
+      'Email/get',
+    );
+    return list.filter((email) => typeof email?.id === 'string');
+  }
+
+  private toDocument(email: JmapEmail, bodyText: string): IndexDocument {
+    const attachments = email.attachments ?? [];
+    return {
+      id: email.id,
+      threadId: typeof email.threadId === 'string' ? email.threadId : null,
+      mailboxIds: trueKeys(email.mailboxIds),
+      keywords: trueKeys(email.keywords),
+      receivedAt: typeof email.receivedAt === 'string' ? email.receivedAt : '',
+      size: typeof email.size === 'number' ? email.size : 0,
+      messageIds: strings(email.messageId),
+      inReplyTo: strings(email.inReplyTo),
+      references: strings(email.references),
+      subject: typeof email.subject === 'string' ? email.subject : '',
+      from: toAddresses(email.from),
+      to: toAddresses(email.to),
+      cc: toAddresses(email.cc),
+      attachmentNames: indexAttachmentNames(attachments),
+      hasAttachment: hasRealAttachment(attachments),
+      preview: typeof email.preview === 'string' ? email.preview : '',
+      bodyText,
+    };
+  }
+
+  /**
+   * 엔진 읽기 한 번 — 차례의 끝 시각까지 남은 시간이 INDEX_CALL_MIN_MS 보다 적으면 시작하지 않는다(IndexDeadlineError).
+   * 기다림은 남은 시간 · INDEX_CALL_TIMEOUT_MS 가운데 짧은 쪽이다 — 남은 시간으로 줄인 기다림이 끝나 끊겼으면 그것도 IndexDeadlineError
+   * (엔진이 느린 것이 아니라 차례가 끝난 것이다). 그 밖의 실패는 그대로 던진다
+   */
+  private async call(
+    user: string,
+    build: (accountId: string) => JmapInvocation[],
+    options: IndexReadOptions,
+    extra: Omit<JmapCallOptions, 'timeoutMs'> = {},
+  ): Promise<JmapInvocation[]> {
+    const remaining = options.deadline - Date.now();
+    if (remaining < INDEX_CALL_MIN_MS) throw new IndexDeadlineError();
+    const cappedByDeadline = remaining < INDEX_CALL_TIMEOUT_MS;
+    try {
+      return await this.jmap.call(user, build, {
+        ...extra,
+        timeoutMs: Math.min(remaining, INDEX_CALL_TIMEOUT_MS),
+      });
+    } catch (error) {
+      if (cappedByDeadline && isTimeout(error)) throw new IndexDeadlineError();
+      throw error;
+    }
+  }
+
+  private requireState(state: unknown): string {
+    if (!isState(state)) {
+      throw new BusinessException('MAIL_001', {
+        context: { reason: 'index-state-missing' },
+      });
+    }
+    return state;
+  }
+}
diff --git a/backend/src/modules/mail/jmap/jmap-mail.provider.spec.ts b/backend/src/modules/mail/jmap/jmap-mail.provider.spec.ts
index cf213ac..6578061 100644
--- a/backend/src/modules/mail/jmap/jmap-mail.provider.spec.ts
+++ b/backend/src/modules/mail/jmap/jmap-mail.provider.spec.ts
@@ -9,6 +9,7 @@ import { BusinessException } from '@/common/errors/business.exception';
 import {
   MAX_BODY_VALUE_BYTES,
   MAX_ENVELOPE_RESUBMITS,
+  MAX_SEARCH_WORDS,
 } from '@/modules/mail/mail.constants';
 import { SendNotStartedException } from '@/modules/mail/mail.provider';
 import type { MailSettings } from '@/modules/mail/mail.settings';
@@ -29,6 +30,7 @@ import {
 } from './jmap.client';
 import type { JmapClient, JmapSession } from './jmap.client';
 import { decodeCursor, encodeCursor } from './jmap-cursor';
+import { JmapConversations } from './jmap-conversations';
 import { JmapFilterRunner } from './jmap-filter-run';
 import { JmapFilterScriptStore } from './jmap-filter-script';
 import { WATCH_DEBOUNCE_MS, WATCH_START_TIMEOUT_MS } from './jmap-mail-watch';
@@ -38,7 +40,8 @@ import {
   parseLargeFileIds,
 } from './jmap-mail.provider';
 import { MAILBOX_PROPERTIES } from './jmap.mapper';
-import type { JmapInvocation } from './jmap.types';
+import type { JmapEmailFilter, JmapInvocation } from './jmap.types';
+import { particleForms } from './search-terms';
 
 const ARA = 'ara.kim@arasystem.test';
 const DOYUN = 'doyun.lee@arasystem.test';
@@ -194,6 +197,7 @@ function fakeClient(
       overrides.settings ?? settings,
       new JmapFilterScriptStore(client as unknown as JmapClient),
       new JmapFilterRunner(client as unknown as JmapClient),
+      new JmapConversations(client as unknown as JmapClient),
     ),
   };
 }
@@ -871,6 +875,298 @@ describe('JmapMailProvider', () => {
     });
   });
 
+  describe('조건 검색 · 색인 검색의 엔진 쪽 (14단계)', () => {
+    const searchResponses = (
+      ids: string[],
+      total: number,
+    ): JmapInvocation[] => [
+      ['Email/query', { ids, position: 0, total, queryState: 's' }, 'q'],
+      [
+        'Email/get',
+        {
+          list: ids.map((id) => summaryEmail(id, '2026-10-26T09:00:00Z')),
+          notFound: [],
+        },
+        'g',
+      ],
+    ];
+    const mailboxRoles: JmapInvocation[] = [
+      [
+        'Mailbox/get',
+        { list: stalwartMailboxes.map(({ id, role }) => ({ id, role })) },
+        'm',
+      ],
+    ];
+
+    it('조건은 칸마다 엔진 필터로 — 받는 사람은 to · cc 가운데 하나, 기간은 받은 시각(after 이상 · before 미만), 첨부는 hasAttachment', async () => {
+      const { provider, recorded } = fakeClient([
+        mailboxRoles,
+        searchResponses(['m1'], 1),
+      ]);
+
+      const page = await provider.listMessages(ARA, {
+        limit: 20,
+        conditions: {
+          from: '이도윤',
+          to: 'ara',
+          subject: '"계약 갱신"',
+          body: '견적',
+          after: '2026-10-31T15:00:00.000Z',
+          before: '2026-11-30T15:00:00.000Z',
+          hasAttachment: true,
+        },
+      });
+
+      const { filter } = argsOf(recorded[1]) as {
+        filter: { operator: string; conditions: unknown[] };
+      };
+      expect(filter.operator).toBe('AND');
+      expect(filter.conditions[0]).toEqual({
+        inMailboxOtherThan: ['b', 'c'],
+        notKeyword: '$ara-sending',
+      });
+      expect(filter.conditions.slice(1)).toEqual([
+        {
+          operator: 'OR',
+          conditions: particleForms('이도윤').map((from) => ({ from })),
+        },
+        {
+          operator: 'OR',
+          conditions: particleForms('ara').flatMap((form) => [
+            { to: form },
+            { cc: form },
+          ]),
+        },
+        { subject: '"계약 갱신"' },
+        {
+          operator: 'OR',
+          conditions: particleForms('견적').map((body) => ({ body })),
+        },
+        { after: '2026-10-31T15:00:00Z' },
+        { before: '2026-11-30T15:00:00Z' },
+        { hasAttachment: true },
+      ]);
+      expect(page.items.map((item) => item.id)).toEqual(['m1']);
+    });
+
+    it('검색어와 조건은 함께 AND — 커서 지문에 조건이 들어가 조건이 다른 검색의 커서는 엔진에 묻기 전에 VAL_001', async () => {
+      const conditions = { from: '이도윤', hasAttachment: true as const };
+      const first = fakeClient([
+        mailboxRoles,
+        searchResponses(['m1', 'm2'], 3),
+      ]);
+      const page = await first.provider.listMessages(ARA, {
+        limit: 2,
+        text: '회의',
+        conditions,
+      });
+      const { filter } = argsOf(first.recorded[1]) as {
+        filter: { conditions: unknown[] };
+      };
+      // 범위 · 검색어 · 보낸 사람 · 첨부
+      expect(filter.conditions).toHaveLength(4);
+      const cursor = page.nextCursor as string;
+      expect(cursor).not.toBeNull();
+
+      for (const query of [
+        { limit: 2, text: '회의', cursor },
+        { limit: 2, text: '회의', cursor, conditions: { from: '이도윤' } },
+        {
+          limit: 2,
+          text: '회의',
+          cursor,
+          conditions: { ...conditions, before: '2026-11-30T15:00:00.000Z' },
+        },
+      ]) {
+        const other = fakeClient([]);
+        expect(await codeOf(other.provider.listMessages(ARA, query))).toBe(
+          'VAL_001',
+        );
+        expect(other.client.call).not.toHaveBeenCalled();
+      }
+      const next = fakeClient([mailboxRoles, searchResponses(['m3'], 3)]);
+      await next.provider.listMessages(ARA, {
+        limit: 2,
+        text: '회의',
+        cursor,
+        conditions,
+      });
+      expect(argsOf(next.recorded[1])).toMatchObject({ anchor: 'm2' });
+    });
+
+    it('조건만 있는 검색(검색어 없음)도 모든 메일함에서 · 조건 없는 검색의 커서 지문은 예전과 같다', async () => {
+      const { provider, recorded } = fakeClient([
+        mailboxRoles,
+        searchResponses([], 0),
+      ]);
+      await provider.listMessages(ARA, {
+        limit: 20,
+        conditions: { hasAttachment: true },
+      });
+      const { filter } = argsOf(recorded[1]) as {
+        filter: { conditions: unknown[] };
+      };
+      expect(filter.conditions).toEqual([
+        { inMailboxOtherThan: ['b', 'c'], notKeyword: '$ara-sending' },
+        { hasAttachment: true },
+      ]);
+
+      const plainCursor = encodeCursor(
+        { anchor: 'm2', position: 2 },
+        { text: '회의' },
+      );
+      const plain = fakeClient([mailboxRoles, searchResponses([], 0)]);
+      await expect(
+        plain.provider.listMessages(ARA, {
+          limit: 2,
+          text: '회의',
+          cursor: plainCursor,
+          conditions: {},
+        }),
+      ).resolves.toMatchObject({ items: [] });
+    });
+
+    it(`엔진 방식의 가장 큰 필터를 고정한다 — 합친 낱말 ${MAX_SEARCH_WORDS}개가 모두 받는 사람(to · cc 둘로 묻는다)이고 영문 · 숫자로 끝나면(형태가 가장 많다) 잎 948개 (리뷰 M2)`, async () => {
+      /** 필터의 잎(연산자가 아닌 조건) 수 */
+      const leaves = (filter: JmapEmailFilter): number =>
+        'operator' in filter
+          ? filter.conditions.reduce((sum, child) => sum + leaves(child), 0)
+          : 1;
+      const words = Array.from(
+        { length: MAX_SEARCH_WORDS },
+        (_, index) => `word${index}`,
+      ).join(' ');
+      const filterOf = async (query: {
+        text?: string;
+        conditions?: Record<string, unknown>;
+      }) => {
+        const { provider, recorded } = fakeClient([
+          mailboxRoles,
+          searchResponses([], 0),
+        ]);
+        await provider.listMessages(ARA, { limit: 20, ...query });
+        return (argsOf(recorded[1]) as { filter: JmapEmailFilter }).filter;
+      };
+      const forms = particleForms('word0').length;
+      expect(forms).toBe(59);
+
+      const worst = await filterOf({
+        conditions: {
+          to: words,
+          after: '2026-10-31T15:00:00.000Z',
+          before: '2026-11-30T15:00:00.000Z',
+          hasAttachment: true,
+        },
+      });
+      // 낱말 8 × 형태 59 × 칸 2(to · cc) + 범위 1 + 기간 2 + 첨부 1
+      expect(leaves(worst)).toBe(MAX_SEARCH_WORDS * forms * 2 + 4);
+      expect(leaves(worst)).toBe(948);
+      // 같은 낱말을 검색어로 두면 칸이 하나 — 3단계에서 잰 472 + 범위
+      expect(leaves(await filterOf({ text: words }))).toBe(
+        MAX_SEARCH_WORDS * forms + 1,
+      );
+    });
+
+    it('글 조건에 찾을 낱말이 하나도 없으면(문장부호뿐) 엔진에 묻지 않고 빈 결과', async () => {
+      for (const conditions of [{ from: '…' }, { body: '""' }, { to: '-' }]) {
+        const { provider, client } = fakeClient([]);
+        await expect(
+          provider.listMessages(ARA, { limit: 20, conditions }),
+        ).resolves.toEqual({
+          items: [],
+          hasNext: false,
+          nextCursor: null,
+          total: 0,
+        });
+        expect(client.call).not.toHaveBeenCalled();
+      }
+    });
+
+    it('색인 검색의 범위 (searchScope) — 모든 메일함이면 휴지통 · 스팸메일함을 빼는 메일함으로, 내부 초안 키워드는 늘 뺀다', async () => {
+      const { provider, recorded } = fakeClient([mailboxRoles]);
+
+      await expect(provider.searchScope(ARA)).resolves.toEqual({
+        mailboxId: null,
+        excludedMailboxIds: ['b', 'c'],
+        excludedKeywords: ['$ara-sending'],
+      });
+      expect(argsOf(recorded[0])).toEqual({
+        accountId: 'd',
+        ids: null,
+        properties: ['id', 'role'],
+      });
+      expect(recorded[0].options).toEqual({ invalidRequestCode: 'MAIL_001' });
+    });
+
+    it('색인 검색의 범위 — 메일함 범위면 그 메일함이 있는지만 본다(없으면 404 RES_001 · 엔진이 해석하지 못하는 id 도 RES_001)', async () => {
+      const found = fakeClient([
+        [['Mailbox/get', { list: [{ id: 'a', role: 'inbox' }] }, 'm']],
+      ]);
+      await expect(found.provider.searchScope(ARA, 'a')).resolves.toEqual({
+        mailboxId: 'a',
+        excludedMailboxIds: [],
+        excludedKeywords: ['$ara-sending'],
+      });
+      expect(argsOf(found.recorded[0])).toMatchObject({ ids: ['a'] });
+      expect(found.recorded[0].options).toEqual({
+        invalidRequestCode: 'RES_001',
+      });
+
+      const missing = fakeClient([
+        [['Mailbox/get', { list: [], notFound: ['zz'] }, 'm']],
+      ]);
+      expect(await codeOf(missing.provider.searchScope(ARA, 'zz'))).toBe(
+        'RES_001',
+      );
+    });
+
+    it('찾은 쪽의 요약 (getSummaries) — 목록과 같은 속성 · 기다리는 발송을 한 요청에, 준 차례대로 · 없는 메일 · 형식이 틀린 id 는 빠진다', async () => {
+      const { provider, recorded } = fakeClient([
+        [
+          [
+            'Email/get',
+            {
+              list: [
+                summaryEmail('m2', '2026-10-26T08:00:00Z'),
+                summaryEmail('m1', '2026-10-26T09:00:00Z'),
+              ],
+              notFound: ['m3'],
+            },
+            'g',
+          ],
+          ...heldGuard(),
+        ],
+      ]);
+
+      const summaries = await provider.getSummaries(ARA, [
+        'm1',
+        'm3',
+        '../x',
+        'm2',
+        'm1',
+      ]);
+
+      expect(summaries.map((summary) => summary.id)).toEqual(['m1', 'm2']);
+      expect(summaries[0]).toMatchObject({
+        subject: '제목 m1',
+        pendingSend: null,
+      });
+      expect(recorded[0].calls.map(([method]) => method)).toEqual([
+        'Email/get',
+        'EmailSubmission/query',
+        'EmailSubmission/get',
+      ]);
+      expect(argsOf(recorded[0])).toMatchObject({ ids: ['m1', 'm3', 'm2'] });
+    });
+
+    it('요약할 id 가 없으면 엔진에 묻지 않는다', async () => {
+      const { provider, client } = fakeClient([]);
+      await expect(provider.getSummaries(ARA, [])).resolves.toEqual([]);
+      await expect(provider.getSummaries(ARA, ['../x'])).resolves.toEqual([]);
+      expect(client.call).not.toHaveBeenCalled();
+    });
+  });
+
   describe('메일 상세 (getMessage)', () => {
     const detailEmail = {
       ...summaryEmail('m1', '2026-10-26T05:12:00Z', { hasAttachment: true }),
diff --git a/backend/src/modules/mail/jmap/jmap-mail.provider.ts b/backend/src/modules/mail/jmap/jmap-mail.provider.ts
index bbfbfac..1079181 100644
--- a/backend/src/modules/mail/jmap/jmap-mail.provider.ts
+++ b/backend/src/modules/mail/jmap/jmap-mail.provider.ts
@@ -16,9 +16,15 @@ import {
   type MailProvider,
 } from '@/modules/mail/mail.provider';
 import { MAIL_SETTINGS, type MailSettings } from '@/modules/mail/mail.settings';
+import type {
+  SearchConditions,
+  SearchScope,
+} from '@/modules/mail-search/mail-search.types';
 import type {
   AttachmentContent,
   BlockedSender,
+  ConversationListQuery,
+  ConversationSummaryPage,
   Correspondence,
   CredentialCheck,
   DraftContent,
@@ -62,6 +68,7 @@ import type {
   SendHold,
   SentMessage,
   SentMessageRecord,
+  SummariesWithHeld,
   TwoFactorLoginResult,
   UploadedFile,
 } from '@/modules/mail/mail.types';
@@ -91,6 +98,7 @@ import {
   submissionEnvelope,
 } from './envelope';
 import { decodeCursor, encodeCursor } from './jmap-cursor';
+import { JmapConversations } from './jmap-conversations';
 import { JmapFilterRunner } from './jmap-filter-run';
 import { JmapFilterScriptStore } from './jmap-filter-script';
 import {
@@ -126,6 +134,7 @@ import {
   selectAccountQuota,
   toAddresses,
   toDetailSource,
+  toJmapUtcDate,
   toMailbox,
   toSummary,
   toUsage,
@@ -148,14 +157,13 @@ import type {
   JmapSetResult,
 } from './jmap.types';
 import { NEW_MAIL_PROPERTIES, selectNewMail } from './new-mail';
+import { INTERNAL_SEND_KEYWORD, excludedMailboxIdsOf } from './mail-scope';
 import {
   CANCELED_SEND_KEYWORD,
-  HELD_SUBMISSIONS_MAX,
   SCHEDULED_SEND_KEYWORD,
   heldAmong,
   heldEmailsFilter,
   heldOverLimit,
-  heldQueryFull,
   heldSendTimes,
   heldSubmissionFilter,
   holdParameters,
@@ -164,11 +172,17 @@ import {
   readHeldEmails,
   readHeldSendTimes,
   submissionCalls,
+  warnIfHeldQueryFull,
   submittedPendingSend,
   type HeldEmails,
   type HeldLookup,
 } from './pending-send';
-import { searchTextConditions, withSearchConditions } from './search-terms';
+import {
+  searchFieldConditions,
+  searchTextConditions,
+  withSearchConditions,
+  type SearchFieldProperty,
+} from './search-terms';
 
 const QUOTA_CAPABILITY = 'urn:ietf:params:jmap:quota';
 /** Blob/get (RFC 9404) — 첨부 합계 크기를 발송 전에 잰다 */
@@ -182,15 +196,6 @@ const BLOB_CAPABILITY = 'urn:ietf:params:jmap:blob';
 const FINGERPRINT_HEADER = 'X-Ara-Payload-Hash';
 const FINGERPRINT_PROPERTY = `header:${FINGERPRINT_HEADER}:asText`;
 
-/**
- * 발송 중인 내부 초안 표시 (JMAP 키워드) — 발송 경로가 임시보관함에 잠깐 만드는 초안에 붙이고, 제출에 성공하면
- * 보낸편지함으로 옮기면서 뗀다(onSuccessUpdateEmail). 메일 목록은 이 키워드가 있는 메일을 보이지 않는다 —
- * 사용자의 임시 저장본과 섞이지 않게 (계약 2절 "임시 저장").
- * 헤더(X-Ara-Payload-Hash)로 거르지 않는 이유: Stalwart 는 헤더가 있는지로 거르는 필터(`header`)를 지원하지 않는다
- * (2026-10-27 개발 엔진으로 확인 — 아무것도 맞지 않는다). 이 표시 전에 생긴 내부 초안은 지문 헤더로 알아본다(isUserDraft).
- */
-const INTERNAL_SEND_KEYWORD = '$ara-sending';
-
 /**
  * 임시 저장본이 답장하는 메일 id — 쓰기 화면이 이어 쓸 때 inReplyTo 로 돌려준다 (계약 2절 "임시 저장").
  * 초안 자체는 보내지 않으므로(보낼 때는 새 메일을 만든다) 이 헤더가 받는 사람에게 가지 않는다.
@@ -273,8 +278,60 @@ const BULK_BATCH_SIZE = 500;
 const SOURCE_TYPE = 'message/rfc822';
 const SOURCE_DOWNLOAD_NAME = 'message.eml';
 
-/** 메일함을 정하지 않은 검색에서 빼는 메일함 역할 — 휴지통 · 스팸메일함 (계약 2절 "검색") */
-const SEARCH_EXCLUDED_ROLES: ReadonlySet<string> = new Set(['trash', 'junk']);
+/** 조건 검색의 글 칸 → 엔진 필터 칸 (받는 사람은 참조도 — 둘 가운데 하나) — 14단계, 색인 준비 전의 엔진 방식 */
+const CONDITION_PROPERTIES: readonly (readonly [
+  keyof Pick<SearchConditions, 'from' | 'to' | 'subject' | 'body'>,
+  readonly SearchFieldProperty[],
+])[] = [
+  ['from', ['from']],
+  ['to', ['to', 'cc']],
+  ['subject', ['subject']],
+  ['body', ['body']],
+];
+
+/** 조건 → 커서 지문에 넣는 값들 (정해진 차례 — jmap-cursor.ts 가 JSON 으로 잇는다) — 조건이 없으면 undefined (지문이 예전과 같다) */
+function conditionsKey(
+  conditions: SearchConditions | undefined,
+): (string | boolean)[] | undefined {
+  if (!conditions) return undefined;
+  const parts = [
+    conditions.from ?? '',
+    conditions.to ?? '',
+    conditions.subject ?? '',
+    conditions.body ?? '',
+    conditions.after ?? '',
+    conditions.before ?? '',
+    conditions.hasAttachment === true,
+  ];
+  return parts.some((part) => part !== '' && part !== false)
+    ? parts
+    : undefined;
+}
+
+/**
+ * 조건 → 엔진 필터 조건들 (AND 로 묶어 쓴다) — 글 칸은 검색어와 같은 낱말 · 구절 · 조사 형태, 기간은 받은 시각(after 이상 · before 미만), 첨부는 엔진의 판정.
+ * 글을 준 칸에 찾을 낱말이 하나도 없으면 null — 아무것도 맞지 않는다(묻지 않고 빈 결과)
+ */
+function conditionFilters(
+  conditions: SearchConditions | undefined,
+): JmapEmailFilter[] | null {
+  if (!conditions) return [];
+  const filters: JmapEmailFilter[] = [];
+  for (const [name, properties] of CONDITION_PROPERTIES) {
+    const value = conditions[name];
+    if (!value) continue;
+    const found = searchFieldConditions(value, properties);
+    if (found.length === 0) return null;
+    filters.push(...found);
+  }
+  if (conditions.after)
+    filters.push({ after: toJmapUtcDate(conditions.after) });
+  if (conditions.before) {
+    filters.push({ before: toJmapUtcDate(conditions.before) });
+  }
+  if (conditions.hasAttachment === true) filters.push({ hasAttachment: true });
+  return filters;
+}
 
 /**
  * 발송 요청 하나가 엔진을 기다리는 전체 시간 — 클라이언트의 발송 시간 한도(60초)보다 짧게 둔다
@@ -807,6 +864,8 @@ export class JmapMailProvider implements MailProvider {
     private readonly filterScripts: JmapFilterScriptStore,
     /** 이미 받은 메일에 필터 적용 (jmap-filter-run.ts — 7단계) */
     private readonly filterRuns: JmapFilterRunner,
+    /** 엔진의 스레드로 본 대화 (jmap-conversations.ts — 14단계, 자체 색인을 다 만들기 전) */
+    private readonly conversations: JmapConversations,
   ) {}
 
   verifyCredentials(email: string, password: string): Promise<CredentialCheck> {
@@ -1419,15 +1478,23 @@ export class JmapMailProvider implements MailProvider {
     user: string,
     query: MessageListQuery,
   ): Promise<MessagePage> {
-    const scope = { mailboxId: query.mailboxId, text: query.text };
-    // 커서는 엔진에 묻기 전에 본다 — 다른 메일함·검색어의 커서면 VAL_001
+    const scope = {
+      mailboxId: query.mailboxId,
+      text: query.text,
+      conditions: conditionsKey(query.conditions),
+    };
+    // 커서는 엔진에 묻기 전에 본다 — 다른 메일함·검색어·조건의 커서면 VAL_001
     const resume = query.cursor ? decodeCursor(query.cursor, scope) : null;
 
-    // 검색어에 찾을 낱말(문자·숫자)이 하나도 없으면(`-` · `…` 등) 엔진에 묻지 않고 빈 결과 — 범위 전체를 돌려주지 않는다.
+    // 검색어 · 조건의 글에 찾을 낱말(문자·숫자)이 하나도 없으면(`-` · `…` 등) 엔진에 묻지 않고 빈 결과 — 범위 전체를 돌려주지 않는다.
     // 메일함 범위여도 그 메일함을 확인하지 않는다 (계약 2절 "검색")
     const textConditions =
       query.text !== undefined ? searchTextConditions(query.text) : [];
-    if (query.text !== undefined && textConditions.length === 0) {
+    const fieldConditions = conditionFilters(query.conditions);
+    if (
+      (query.text !== undefined && textConditions.length === 0) ||
+      fieldConditions === null
+    ) {
       return { items: [], hasNext: false, nextCursor: null, total: 0 };
     }
 
@@ -1439,7 +1506,7 @@ export class JmapMailProvider implements MailProvider {
         : await this.searchableMailboxes(user);
     const filter = withSearchConditions(
       { ...range, notKeyword: INTERNAL_SEND_KEYWORD },
-      textConditions,
+      [...textConditions, ...fieldConditions],
     );
 
     // 기다리는 발송(보내기 취소 · 예약 — 9단계)은 같은 요청에서 보낼 시각이 지금 뒤인 제출로 묻는다 (pending-send.ts)
@@ -1489,7 +1556,7 @@ export class JmapMailProvider implements MailProvider {
     const start = result.position ?? 0;
     const total = typeof result.total === 'number' ? result.total : null;
     const held = readHeldSendTimes(responses, HELD_CALLS, now);
-    this.warnIfHeldQueryFull(responses, user);
+    warnIfHeldQueryFull(this.logger, responses, HELD_CALLS, user);
 
     // Email/get 의 결과 순서는 보장되지 않으므로 query 순서(받은 시각 내림차순)로 다시 놓는다
     const byId = new Map(list.map((email) => [email.id, email]));
@@ -1516,6 +1583,160 @@ export class JmapMailProvider implements MailProvider {
     };
   }
 
+  /**
+   * 자체 색인으로 찾을 범위 (14단계) — 메일함 범위면 그 메일함이 있는지(없으면 RES_001 — 엔진이 해석하지 못하는 id 도), 모든 메일함이면 빼는 메일함(휴지통 · 스팸메일함).
+   * 발송 중인 내부 초안의 키워드는 늘 뺀다 (목록과 같다). 엔진 요청 한 번
+   */
+  async searchScope(user: string, mailboxId?: string): Promise<SearchScope> {
+    const responses = await this.jmap.call(
+      user,
+      (accountId) => [
+        [
+          'Mailbox/get',
+          {
+            accountId,
+            ids: mailboxId === undefined ? null : [mailboxId],
+            properties: ['id', 'role'],
+          },
+          'm',
+        ],
+      ],
+      { invalidRequestCode: mailboxId === undefined ? 'MAIL_001' : 'RES_001' },
+    );
+    const { list: mailboxes = [] } = expectResult<JmapGetResult<JmapMailbox>>(
+      responses,
+      'm',
+      'Mailbox/get',
+    );
+    if (mailboxId !== undefined) {
+      if (!mailboxes.some((mailbox) => mailbox.id === mailboxId)) {
+        throw new BusinessException('RES_001', {
+          context: { reason: 'mailbox-not-found' },
+        });
+      }
+      return {
+        mailboxId,
+        excludedMailboxIds: [],
+        excludedKeywords: [INTERNAL_SEND_KEYWORD],
+      };
+    }
+    return {
+      mailboxId: null,
+      excludedMailboxIds: excludedMailboxIdsOf(mailboxes),
+      excludedKeywords: [INTERNAL_SEND_KEYWORD],
+    };
+  }
+
+  /**
+   * 대화의 범위 (14단계 — 색인 방식의 같은 대화 · 묶은 목록) — 늘 휴지통 · 스팸메일함을 빼는 메일함으로 준다(대화의 통 수 · 같은 대화).
+   * `mailboxId` 를 주면 그 메일함이 있는지 본다(없으면 RES_001 — 엔진이 해석하지 못하는 id 도). 엔진 요청 한 번
+   */
+  async conversationScope(
+    user: string,
+    mailboxId?: string,
+  ): Promise<SearchScope> {
+    const responses = await this.jmap.call(
+      user,
+      (accountId) => [
+        [
+          'Mailbox/get',
+          { accountId, ids: null, properties: ['id', 'role'] },
+          'm',
+        ],
+      ],
+      { invalidRequestCode: 'MAIL_001' },
+    );
+    const { list: mailboxes = [] } = expectResult<JmapGetResult<JmapMailbox>>(
+      responses,
+      'm',
+      'Mailbox/get',
+    );
+    if (
+      mailboxId !== undefined &&
+      !mailboxes.some((mailbox) => mailbox.id === mailboxId)
+    ) {
+      throw new BusinessException('RES_001', {
+        context: { reason: 'mailbox-not-found' },
+      });
+    }
+    return {
+      mailboxId: mailboxId ?? null,
+      excludedMailboxIds: excludedMailboxIdsOf(mailboxes),
+      excludedKeywords: [INTERNAL_SEND_KEYWORD],
+    };
+  }
+
+  getConversation(
+    user: string,
+    emailId: string,
+    page: { readonly limit: number; readonly cursor?: string },
+  ): Promise<MessagePage> {
+    return this.conversations.conversation(user, emailId, page);
+  }
+
+  listConversations(
+    user: string,
+    query: ConversationListQuery,
+  ): Promise<ConversationSummaryPage> {
+    return this.conversations.list(user, query);
+  }
+
+  /**
+   * 요약 여러 통 (14단계 — 색인으로 찾은 쪽) — 목록과 같은 속성 · 기다리는 발송. `ids` 차례대로, 없는 메일은 빠진다.
+   * 엔진이 해석하지 못하는 id 는 받지 않는다(색인의 id 는 엔진이 준 것이다 — 형식이 틀리면 건너뛴다)
+   */
+  async getSummaries(
+    user: string,
+    ids: readonly string[],
+  ): Promise<MessageSummary[]> {
+    if (!ids.some((id) => MAIL_ID_PATTERN.test(id))) return [];
+    return (await this.getSummariesWithHeld(user, ids)).summaries;
+  }
+
+  /**
+   * 요약 여러 통 + 지금 붙잡힌 메일 id (14단계 3차 — 묶은 목록의 색인 방식) — 같은 요청에서 계정의 기다리는 제출을 한 번 읽는다(보이기 경로 —
+   * readHeldSendTimes, 읽지 못하면 빈 표). 요약이 없어도(ids 가 비거나 모두 형식이 틀림) 기다리는 제출은 읽는다
+   */
+  async getSummariesWithHeld(
+    user: string,
+    ids: readonly string[],
+  ): Promise<SummariesWithHeld> {
+    const valid = [...new Set(ids)].filter((id) => MAIL_ID_PATTERN.test(id));
+    const now = Date.now();
+    const responses = await this.jmap.call(user, (accountId) => [
+      ...(valid.length > 0
+        ? ([
+            [
+              'Email/get',
+              {
+                accountId,
+                ids: valid,
+                properties: SUMMARY_PROPERTIES,
+                bodyProperties: SUMMARY_BODY_PART_PROPERTIES,
+              },
+              'g',
+            ],
+          ] satisfies JmapInvocation[])
+        : []),
+      ...submissionCalls(accountId, heldSubmissionFilter(now), HELD_CALLS),
+    ]);
+    const list =
+      valid.length > 0
+        ? (expectResult<JmapGetResult<JmapEmail>>(responses, 'g', 'Email/get')
+            .list ?? [])
+        : [];
+    const held = readHeldSendTimes(responses, HELD_CALLS, now);
+    warnIfHeldQueryFull(this.logger, responses, HELD_CALLS, user);
+    const byId = new Map(list.map((email) => [email.id, email]));
+    return {
+      summaries: valid.flatMap((id) => {
+        const email = byId.get(id);
+        return email ? [toSummary(email, pendingSendOf(email, held))] : [];
+      }),
+      heldIds: new Set(held.keys()),
+    };
+  }
+
   /**
    * 상세 — 같은 요청에서 메일함 역할(스팸메일함에 들었는지 — 외부 이미지 설정)과 그 메일의 제출(기다리는 발송 — 9단계)을 함께 묻는다.
    * 메일함 · 제출을 읽지 못하면 스팸메일함이 아니고 기다리는 발송이 없는 것으로 본다 — 상세를 실패로 만들지 않는다
@@ -2605,7 +2826,7 @@ export class JmapMailProvider implements MailProvider {
       'g',
       'Email/get',
     );
-    this.warnIfHeldQueryFull(responses, user);
+    warnIfHeldQueryFull(this.logger, responses, HELD_CALLS, user);
     const times = heldSendTimes(submissions, now);
     return emails
       .flatMap((email) => {
@@ -3615,11 +3836,7 @@ export class JmapMailProvider implements MailProvider {
       'm',
       'Mailbox/get',
     );
-    const excluded = mailboxes
-      .filter((mailbox) =>
-        SEARCH_EXCLUDED_ROLES.has(mailbox.role?.toLowerCase() ?? ''),
-      )
-      .map((mailbox) => mailbox.id);
+    const excluded = excludedMailboxIdsOf(mailboxes);
     return excluded.length > 0 ? { inMailboxOtherThan: excluded } : {};
   }
 
@@ -3878,17 +4095,6 @@ export class JmapMailProvider implements MailProvider {
     );
   }
 
-  /**
-   * 보이기 경로(목록 · 예약 목록)의 계정 전체 제출 조회가 다 주지 못했다(상한 500 · 엔진이 줄인 limit · total 보다 적음 — pending-send.ts 의 heldQueryFull)
-   * — 보낼 시각이 늦은 기다리는 발송은 표시가 빠질 수 있다 (경고만). 취소한 예약도 보낼 시각이 7일 안이면 조회에 든다 (HELD_SUBMISSIONS_MAX)
-   */
-  private warnIfHeldQueryFull(responses: JmapInvocation[], user: string): void {
-    if (!heldQueryFull(responses, HELD_CALLS)) return;
-    this.logger.warn(
-      `[MAIL_001]${traceTag()} 보낼 시각이 지금 뒤인 제출을 엔진이 다 주지 않아(한 번에 ${HELD_SUBMISSIONS_MAX}개까지 · 엔진의 한도) 보낼 시각이 이른 것부터 받은 만큼만 봅니다 — 늦은 기다리는 발송은 표시가 빠질 수 있습니다: user=${maskEmail(user)}`,
-    );
-  }
-
   /** 이 메일로 만든 제출(EmailSubmission) — 상태 · 보낼 시각 (메일 id 조건은 엔진의 색인을 탄다) */
   private async submissionsOf(
     user: string,
diff --git a/backend/src/modules/mail/jmap/jmap.types.ts b/backend/src/modules/mail/jmap/jmap.types.ts
index c848242..ebfeb40 100644
--- a/backend/src/modules/mail/jmap/jmap.types.ts
+++ b/backend/src/modules/mail/jmap/jmap.types.ts
@@ -221,8 +221,18 @@ export interface JmapEmailFilterCondition {
   notKeyword?: string;
   /** 받은 시각이 이보다 앞선(미만) 메일 — UTCDate. 엔진은 받은 시각을 초 단위로 둔다 (2026-10-29 확인) */
   before?: string;
+  /** 받은 시각이 이 이후(이상)인 메일 — UTCDate (14단계 조건 검색의 기간) */
+  after?: string;
   /** 보낸 사람·받는 사람·참조·제목·본문 전문 검색 — 큰따옴표로 감싼 값은 구절로 찾는다 */
   text?: string;
+  /** 칸마다의 전문 검색 (14단계 조건 검색 — 색인 준비 전의 엔진 방식) — 낱말 통째 일치는 text 와 같다 */
+  from?: string;
+  to?: string;
+  cc?: string;
+  subject?: string;
+  body?: string;
+  /** 엔진의 첨부 판정 (본문 그림만 있어도 true 일 수 있다 — 색인 방식과 조금 다르다) */
+  hasAttachment?: boolean;
 }
 
 /** FilterOperator (RFC 8620 §5.5) — 조건들을 AND · OR · NOT 으로 묶는다 */
diff --git a/backend/src/modules/mail/jmap/mail-scope.ts b/backend/src/modules/mail/jmap/mail-scope.ts
new file mode 100644
index 0000000..cdf9662
--- /dev/null
+++ b/backend/src/modules/mail/jmap/mail-scope.ts
@@ -0,0 +1,27 @@
+import type { JmapMailbox } from './jmap.types';
+
+/**
+ * 발송 중인 내부 초안 표시 (JMAP 키워드) — 발송 경로가 임시보관함에 잠깐 만드는 초안에 붙이고, 제출에 성공하면
+ * 보낸편지함으로 옮기면서 뗀다(onSuccessUpdateEmail). 메일 목록 · 검색 · 대화는 이 키워드가 있는 메일을 보이지 않는다 —
+ * 사용자의 임시 저장본과 섞이지 않게 (계약 2절 "임시 저장").
+ * 헤더(X-Ara-Payload-Hash)로 거르지 않는 이유: Stalwart 는 헤더가 있는지로 거르는 필터(`header`)를 지원하지 않는다
+ * (2026-10-27 개발 엔진으로 확인 — 아무것도 맞지 않는다). 이 표시 전에 생긴 내부 초안은 지문 헤더로 알아본다(isUserDraft).
+ */
+export const INTERNAL_SEND_KEYWORD = '$ara-sending';
+
+/** 메일함을 정하지 않은 검색 · 같은 대화 · 대화의 통 수에서 빼는 메일함 역할 — 휴지통 · 스팸메일함 (계약 2절 "검색") */
+export const SEARCH_EXCLUDED_ROLES: ReadonlySet<string> = new Set([
+  'trash',
+  'junk',
+]);
+
+/** 빼는 역할(휴지통 · 스팸메일함)의 메일함 id */
+export function excludedMailboxIdsOf(
+  mailboxes: readonly Pick<JmapMailbox, 'id' | 'role'>[],
+): string[] {
+  return mailboxes
+    .filter((mailbox) =>
+      SEARCH_EXCLUDED_ROLES.has(mailbox.role?.toLowerCase() ?? ''),
+    )
+    .map((mailbox) => mailbox.id);
+}
diff --git a/backend/src/modules/mail/jmap/pending-send.ts b/backend/src/modules/mail/jmap/pending-send.ts
index 5024eff..33e1d01 100644
--- a/backend/src/modules/mail/jmap/pending-send.ts
+++ b/backend/src/modules/mail/jmap/pending-send.ts
@@ -1,5 +1,9 @@
+import type { Logger } from '@nestjs/common';
+
 import { BusinessException } from '@/common/errors/business.exception';
 import type { PendingSend, SendHold } from '@/modules/mail/mail.types';
+import { traceTag } from '@/shared/logger/request-context';
+import { maskEmail } from '@/shared/utils/mask';
 import { toJmapUtcDate, toUtcIso } from './jmap.mapper';
 import { expectResult, findResult } from './jmap-results';
 import type {
@@ -212,6 +216,22 @@ export function heldQueryFull(
   }
 }
 
+/**
+ * 보이기 경로(목록 · 예약 목록 · 대화)의 계정 전체 제출 조회가 다 주지 못했으면(heldQueryFull) 경고만 남긴다 — 보낼 시각이 늦은 기다리는 발송은 표시가 빠질 수 있다.
+ * 취소한 예약도 보낼 시각이 7일 안이면 조회에 든다 (HELD_SUBMISSIONS_MAX). 로그는 코드 · 추적 ID · 가린 주소만
+ */
+export function warnIfHeldQueryFull(
+  logger: Logger,
+  responses: JmapInvocation[],
+  prefix: string,
+  user: string,
+): void {
+  if (!heldQueryFull(responses, prefix)) return;
+  logger.warn(
+    `[MAIL_001]${traceTag()} 보낼 시각이 지금 뒤인 제출을 엔진이 다 주지 않아(한 번에 ${HELD_SUBMISSIONS_MAX}개까지 · 엔진의 한도) 보낼 시각이 이른 것부터 받은 만큼만 봅니다 — 늦은 기다리는 발송은 표시가 빠질 수 있습니다: user=${maskEmail(user)}`,
+  );
+}
+
 /** 붙잡힌 메일 — 막기 경로의 판정 (readHeldEmails · heldAmong) */
 export interface HeldEmails {
   /** 붙잡힌 제출이 있는 메일 id (보낼 시각을 읽지 못한 기다리는 제출도 — holdsForGuard) */
diff --git a/backend/src/modules/mail/jmap/search-terms.spec.ts b/backend/src/modules/mail/jmap/search-terms.spec.ts
index af40546..9251f60 100644
--- a/backend/src/modules/mail/jmap/search-terms.spec.ts
+++ b/backend/src/modules/mail/jmap/search-terms.spec.ts
@@ -2,6 +2,7 @@ import {
   SEARCH_PARTICLES,
   parseSearchTerms,
   particleForms,
+  searchFieldConditions,
   searchTextConditions,
   withSearchConditions,
 } from './search-terms';
@@ -365,4 +366,57 @@ describe('검색어 → 엔진 조건 (search-terms)', () => {
       );
     });
   });
+
+  describe('칸 조건 (searchFieldConditions — 14단계 조건 검색의 엔진 방식)', () => {
+    it('칸 하나 — 낱말은 그 칸의 형태 OR, 구절은 그 칸의 따옴표 구절', () => {
+      const [word, phrase] = searchFieldConditions('계약 "갱신 일정"', [
+        'subject',
+      ]);
+      expect(word).toEqual({
+        operator: 'OR',
+        conditions: particleForms('계약').map((subject) => ({ subject })),
+      });
+      expect(phrase).toEqual({ subject: '"갱신 일정"' });
+    });
+
+    it('칸이 여럿(받는 사람 = to · cc)이면 형태마다 두 칸의 OR — 낱말끼리는 AND(목록의 차례)', () => {
+      const conditions = searchFieldConditions('ara 東京', ['to', 'cc']);
+      expect(conditions).toHaveLength(2);
+      expect(conditions[0]).toEqual({
+        operator: 'OR',
+        conditions: particleForms('ara').flatMap((form) => [
+          { to: form },
+          { cc: form },
+        ]),
+      });
+      // 형태가 하나뿐이어도 칸이 둘이면 OR
+      expect(conditions[1]).toEqual({
+        operator: 'OR',
+        conditions: [{ to: '東京' }, { cc: '東京' }],
+      });
+    });
+
+    it('검색어 조건(searchTextConditions)은 text 칸 하나의 칸 조건과 같다 · 찾을 낱말이 없으면 빈 목록', () => {
+      expect(searchTextConditions('서버 "이전 계획"')).toEqual(
+        searchFieldConditions('서버 "이전 계획"', ['text']),
+      );
+      expect(searchFieldConditions('… -', ['body'])).toEqual([]);
+    });
+  });
+
+  it('검색 글의 NUL 은 U+FFFD 로 1:1 바꾼다 — 색인의 저장과 같고 엔진 방식도 같은 낱말로 묻는다 (리뷰 L2)', () => {
+    const NUL = String.fromCharCode(0);
+    const FFFD = String.fromCharCode(0xfffd);
+    expect(parseSearchTerms(`계${NUL}약 "a${NUL}b"`)).toEqual([
+      { kind: 'word', text: `계${FFFD}약` },
+      { kind: 'phrase', text: `a${FFFD}b` },
+    ]);
+    // 엔진에 보내는 조건(JSON)에 NUL 이 없다 — 이스케이프한 꼴도 없다
+    const sent = JSON.stringify(searchTextConditions(`계${NUL}약`));
+    expect(sent.includes(NUL)).toBe(false);
+    expect(sent).not.toContain(`${String.fromCharCode(92)}u0000`);
+    expect(sent).toContain(`계${FFFD}약`);
+    // NUL 만이면 찾을 글자가 없다 — 빈 목록
+    expect(parseSearchTerms(NUL.repeat(3))).toEqual([]);
+  });
 });
diff --git a/backend/src/modules/mail/jmap/search-terms.ts b/backend/src/modules/mail/jmap/search-terms.ts
index 258f7fa..fa5b8d3 100644
--- a/backend/src/modules/mail/jmap/search-terms.ts
+++ b/backend/src/modules/mail/jmap/search-terms.ts
@@ -1,4 +1,4 @@
-import { SEARCH_WORD_SEPARATOR } from '@/modules/mail/mail.constants';
+import { parseSearchTerms } from '@/shared/utils/search-query';
 import type { JmapEmailFilter, JmapEmailFilterCondition } from './jmap.types';
 
 /**
@@ -14,6 +14,9 @@ import type { JmapEmailFilter, JmapEmailFilterCondition } from './jmap.types';
  * 제목 맨 앞의 말머리('[공지]' · 'Re:' — 엔진이 제목을 정규화하며 색인에서 뺀다)는 찾지 못한다.
  */
 
+/** 검색어 나누기는 엔진과 상관없어 shared/utils/search-query.ts 로 옮겼다(14단계 — 색인 찾기와 함께 쓴다) */
+export { parseSearchTerms, type SearchTerm } from '@/shared/utils/search-query';
+
 /**
  * 낱말 뒤에 붙여 함께 찾는 조사 — 서버 상수는 이 표 하나다 (계약 2절).
  * 한글로 끝나는 낱말 하나가 형태 44개(낱말 그대로 + 28 + 15), 영문·숫자로 끝나면 59개가 된다
@@ -89,6 +92,9 @@ export const SEARCH_PARTICLES = {
   ],
 } as const;
 
+/** 큰따옴표 — 구절 조건(`{ text: '"…"' }`)을 감싼다 */
+const QUOTE = '"';
+
 /** 한글 음절(가~힣) — 받침은 (코드 − 첫 음절) % 28 (0 = 받침 없음) */
 const HANGUL_SYLLABLE_FIRST = 0xac00;
 const HANGUL_SYLLABLE_LAST = 0xd7a3;
@@ -102,29 +108,6 @@ const EURO = '으로';
 /** 영문·숫자로 끝나는 낱말 — 읽는 법(받침)을 알 수 없어 두 가지 조사를 다 붙인다 (ERP가 · ERP이) */
 const ASCII_ALNUM_END = /[A-Za-z0-9]$/;
 
-/** 큰따옴표 — 감싼 부분은 구절로 찾는다 */
-const QUOTE = '"';
-
-/**
- * 찾을 수 있는 글자 — 문자(\p{L}: 한글·자모·영문 등)나 숫자(\p{N}).
- * 이것이 하나도 없는 낱말·구절(`-` · `…` · 그림 문자뿐)은 버린다 — 엔진은 문장부호를 낱말로 색인하지 않는다
- */
-const SEARCHABLE_CHARACTER = /[\p{L}\p{N}]/u;
-
-/**
- * 낱말 앞뒤에 붙은, 문자·숫자가 아닌 글자 — 엔진은 문장부호에서 낱말을 나누므로 떼고 가운데 낱말로 찾는다
- * ('회의,' · '(회의)' · '회의.' · '“회의”' → '회의' — 그래야 받침을 읽어 '회의를' 도 찾는다). 낱말 가운데의 문장부호('서버-이전')는 그대로 둔다.
- * 뒤쪽은 "문자·숫자·결합 문자가 아닌 글자 + 그 뒤의 결합 문자" 를 뗀다 — 글자에 붙은 결합 문자(태국어 성조 등)는 남기고,
- * 그림 문자와 그 이체 선택자(❤️ = U+2764 U+FE0F)는 함께 뗀다.
- */
-const WORD_EDGE_PUNCTUATION =
-  /^[^\p{L}\p{N}]+|(?:[^\p{L}\p{N}\p{M}]\p{M}*)+$/gu;
-
-/** 낱말 앞뒤의 문장부호·기호를 뗀 가운데 낱말 — 문자·숫자가 없으면 빈 문자열 */
-function coreWord(word: string): string {
-  return word.replace(WORD_EDGE_PUNCTUATION, '');
-}
-
 /** 낱말 끝의 종류 — 어떤 조사를 붙일지 정한다 */
 type WordEnding =
   /** 받침 없는 한글 */
@@ -186,61 +169,46 @@ export function particleForms(word: string): string[] {
   ]);
 }
 
-/** 검색어를 나눈 조각 — 낱말(조사를 붙여 찾는다) · 구절(큰따옴표 안, 그대로 찾는다) */
-export interface SearchTerm {
-  readonly kind: 'word' | 'phrase';
-  readonly text: string;
-}
-
-function splitWords(text: string): string[] {
-  return text.split(SEARCH_WORD_SEPARATOR).filter((word) => word !== '');
-}
-
-/**
- * 검색어를 낱말·구절로 나눈다 — 나온 순서대로, 같은 낱말·같은 구절은 한 번만.
- * - 큰따옴표 한 쌍 안은 구절이다 (안의 여러 칸 공백은 한 칸으로)
- * - 짝이 없는 마지막 큰따옴표는 없는 것으로 본다 — 그 뒤는 따옴표 밖처럼 낱말로 나눈다
- * - 낱말은 띄어쓰기(공백 문자)로 나눈다 — DTO 가 세는 "낱말 수"와 같은 기준 (SEARCH_WORD_SEPARATOR)
- * - 낱말 앞뒤의 문장부호·기호는 떼고 가운데 낱말로 찾는다 ('회의,' → '회의', WORD_EDGE_PUNCTUATION). 구절은 그대로 둔다
- * - 문자·숫자가 하나도 없는 낱말·구절(비어 있음 · `-` · `…` 등)은 버린다 (SEARCHABLE_CHARACTER) —
- *   남는 것이 없으면 빈 목록이고, 목록 조회는 엔진에 묻지 않고 빈 결과를 돌려준다 (범위 전체를 돌려주지 않는다)
- * - 유니코드 NFC(완성형)로 정규화한다 — 자모를 풀어 쓴(NFD) 한글을 붙여 넣어도 받침을 읽는다
- */
-export function parseSearchTerms(query: string): SearchTerm[] {
-  const segments = query.normalize('NFC').split(QUOTE);
-  const terms: SearchTerm[] = [];
-  const seen = new Set<string>();
-  const add = (kind: SearchTerm['kind'], text: string) => {
-    const key = `${kind}\n${text}`;
-    if (!SEARCHABLE_CHARACTER.test(text) || seen.has(key)) return;
-    seen.add(key);
-    terms.push({ kind, text });
-  };
-
-  segments.forEach((segment, index) => {
-    // 홀수 번째 조각은 따옴표 안이다 — 뒤에 닫는 따옴표가 있을 때만 (마지막 조각이면 짝이 없다)
-    const isPhrase = index % 2 === 1 && index < segments.length - 1;
-    if (isPhrase) {
-      add('phrase', splitWords(segment).join(' '));
-      return;
-    }
-    for (const word of splitWords(segment)) add('word', coreWord(word));
-  });
-  return terms;
-}
-
 /**
  * 검색어의 text 조건들 — 모두 맞아야 한다(AND 로 묶어 쓴다).
  * 구절은 `{ text: '"…"' }` 하나, 낱말은 형태들의 OR (형태가 하나뿐이면 그 조건 하나).
  * 찾을 낱말이 하나도 없으면(문장부호뿐 · 빈 따옴표 등) 빈 목록 — 호출한 쪽은 아무것도 찾지 않는다.
  */
 export function searchTextConditions(query: string): JmapEmailFilter[] {
+  return searchFieldConditions(query, ['text']);
+}
+
+/** 글로 찾는 엔진 필터 칸 — text(모든 칸) · 보낸 사람 · 받는 사람 · 참조 · 제목 · 본문 */
+export type SearchFieldProperty =
+  | 'text'
+  | 'from'
+  | 'to'
+  | 'cc'
+  | 'subject'
+  | 'body';
+
+/**
+ * 칸 조건 (14단계 조건 검색 — 색인 준비 전의 엔진 방식) — searchTextConditions 와 같은 낱말 · 구절 · 조사 형태를 그 칸에서 찾는다.
+ * 칸이 여럿이면(받는 사람 = to · cc) 그 가운데 하나에 있으면 된다 — 낱말마다 (형태 × 칸)의 OR, 낱말끼리는 AND.
+ * 찾을 낱말이 하나도 없으면 빈 목록
+ */
+export function searchFieldConditions(
+  query: string,
+  properties: readonly SearchFieldProperty[],
+): JmapEmailFilter[] {
   return parseSearchTerms(query).map((term): JmapEmailFilter => {
-    if (term.kind === 'phrase') return { text: `${QUOTE}${term.text}${QUOTE}` };
-    const forms = particleForms(term.text);
-    return forms.length === 1
-      ? { text: forms[0] }
-      : { operator: 'OR', conditions: forms.map((text) => ({ text })) };
+    const forms =
+      term.kind === 'phrase'
+        ? [`${QUOTE}${term.text}${QUOTE}`]
+        : particleForms(term.text);
+    const conditions = forms.flatMap((form) =>
+      properties.map(
+        (property): JmapEmailFilterCondition => ({ [property]: form }),
+      ),
+    );
+    return conditions.length === 1
+      ? conditions[0]
+      : { operator: 'OR', conditions };
   });
 }
 
diff --git a/backend/src/modules/mail/mail-events.service.spec.ts b/backend/src/modules/mail/mail-events.service.spec.ts
index 72fcc91..b306bec 100644
--- a/backend/src/modules/mail/mail-events.service.spec.ts
+++ b/backend/src/modules/mail/mail-events.service.spec.ts
@@ -15,6 +15,7 @@ import {
   type MailEventSink,
 } from './mail-events.service';
 import type { RevokedSessions } from '@/modules/auth/revoked-sessions';
+import type { MailSearchSyncService } from '@/modules/mail-search/mail-search-sync.service';
 import type { MailProvider } from './mail.provider';
 import type {
   MailLiveState,
@@ -132,6 +133,8 @@ describe('MailEventsService (실시간 알림의 연결 관리)', () => {
   let service: MailEventsService;
   /** 끊은 세션 기억 대역 — 테스트가 넣는다 */
   let revokedIds: Set<string>;
+  /** 검색 색인 맞추기 대역 (14단계) — 맞춰 달라는 직원을 모은다 */
+  let searchSync: { requestSync: jest.Mock };
 
   const connect = (
     user: string,
@@ -171,9 +174,11 @@ describe('MailEventsService (실시간 알림의 연결 관리)', () => {
     const revoked = {
       isRevoked: (sessionId: string) => revokedIds.has(sessionId),
     };
+    searchSync = { requestSync: jest.fn() };
     service = new MailEventsService(
       fake.provider,
       revoked as unknown as RevokedSessions,
+      searchSync as unknown as MailSearchSyncService,
     );
   });
 
@@ -207,6 +212,9 @@ describe('MailEventsService (실시간 알림의 연결 관리)', () => {
     }
     expect(other.events).toHaveLength(1);
 
+    // 메일이 바뀐 소식 — 그 직원의 검색 색인을 맞춰 달라고 한다 (14단계 — 직원마다 한 번, 모으기는 맞추기 쪽이 한다)
+    expect(searchSync.requestSync.mock.calls).toEqual([[ARA]]);
+
     // 나중에 들어온 연결은 마지막으로 알게 된 상태로 시작한다 (엔진에 다시 묻지 않는다)
     const late = await connected(ARA);
     expect(late.events).toEqual([
diff --git a/backend/src/modules/mail/mail-events.service.ts b/backend/src/modules/mail/mail-events.service.ts
index 484be6c..8a14ae0 100644
--- a/backend/src/modules/mail/mail-events.service.ts
+++ b/backend/src/modules/mail/mail-events.service.ts
@@ -8,6 +8,7 @@ import {
 import { BusinessException } from '@/common/errors/business.exception';
 import { ACCESS_TTL_MAX_SECONDS } from '@/modules/auth/auth.constants';
 import { RevokedSessions } from '@/modules/auth/revoked-sessions';
+import { MailSearchSyncService } from '@/modules/mail-search/mail-search-sync.service';
 import {
   runOutsideRequestContext,
   traceTag,
@@ -149,6 +150,8 @@ export class MailEventsService implements BeforeApplicationShutdown {
   constructor(
     @Inject(MAIL_PROVIDER) private readonly provider: MailProvider,
     private readonly revokedSessions: RevokedSessions,
+    /** 14단계 — 엔진의 state 소식이 오면 그 직원의 검색 색인을 맞춘다 (300ms 모아서 — 던지지 않는다) */
+    private readonly searchSync: MailSearchSyncService,
   ) {}
 
   /**
@@ -312,6 +315,8 @@ export class MailEventsService implements BeforeApplicationShutdown {
       state: (live) => {
         hub.live = live;
         this.broadcast(hub, { type: 'state', data: live });
+        // 메일이 바뀌었다 — 검색 색인도 맞춘다 (연결이 있는 동안만 오는 소식이다 — 없을 때는 5분 맞추기가 한다)
+        this.searchSync.requestSync(hub.user);
       },
       newMail: (notice) =>
         this.broadcast(hub, { type: 'new-mail', data: notice }),
diff --git a/backend/src/modules/mail/mail.constants.ts b/backend/src/modules/mail/mail.constants.ts
index b355b15..a412474 100644
--- a/backend/src/modules/mail/mail.constants.ts
+++ b/backend/src/modules/mail/mail.constants.ts
@@ -56,8 +56,8 @@ export const MAX_SEARCH_LENGTH = 200;
 /** 검색어의 낱말(띄어쓰기로 나눈 것) 최대 개수 — 낱말마다 조사를 붙인 형태 수십 개로 찾으므로 엔진 비용을 묶어 둔다 */
 export const MAX_SEARCH_WORDS = 8;
 
-/** 검색어의 낱말을 나누는 기준 — 공백 문자(전각 공백·줄바꿈 포함). DTO 의 낱말 수와 엔진 조건(jmap/search-terms.ts)이 같이 쓴다 */
-export const SEARCH_WORD_SEPARATOR = /\s+/u;
+/** 검색어의 낱말을 나누는 기준 — 공백 문자(전각 공백·줄바꿈 포함). DTO 의 낱말 수 · 엔진 조건 · 색인 찾기가 같이 쓴다 (shared/utils/search-query.ts) */
+export { SEARCH_WORD_SEPARATOR } from '@/shared/utils/search-query';
 
 /**
  * 여러 통을 한꺼번에 다루는 요청(PATCH /api/messages · POST /api/message-deletions)의 id 최대 개수 —
diff --git a/backend/src/modules/mail/mail.module.ts b/backend/src/modules/mail/mail.module.ts
index 46f83be..d97c3ae 100644
--- a/backend/src/modules/mail/mail.module.ts
+++ b/backend/src/modules/mail/mail.module.ts
@@ -10,6 +10,7 @@ import { AuthSessionModule } from '@/modules/auth/auth-session.module';
 import { ContactsModule } from '@/modules/contacts/contacts.module';
 import { FileSharingModule } from '@/modules/file-sharing/file-sharing.module';
 import { MailDirectoryModule } from '@/modules/mail-directory/mail-directory.module';
+import { MailSearchModule } from '@/modules/mail-search/mail-search.module';
 import { MailSignatureModule } from '@/modules/mail-signature/mail-signature.module';
 import { MailUserSettingsModule } from '@/modules/mail-user-settings/mail-user-settings.module';
 import { SystemMailModule } from '@/modules/system-mail/system-mail.module';
@@ -27,6 +28,7 @@ import {
   DnsMailImageResolver,
   NodeMailImageTransport,
 } from './images/node-image-transport';
+import { JmapConversations } from './jmap/jmap-conversations';
 import { JmapFilterRunner } from './jmap/jmap-filter-run';
 import { JmapFilterScriptStore } from './jmap/jmap-filter-script';
 import { JmapMailProvider } from './jmap/jmap-mail.provider';
@@ -55,6 +57,9 @@ import {
   MailVacationController,
 } from './mailbox.controller';
 import { MessageDeletionController } from './message-deletion.controller';
+import { MessageListService } from './message-list.service';
+import { ConversationController } from './conversation.controller';
+import { MailConversationService } from './conversation.service';
 import { MessageController } from './message.controller';
 import { RecipientSuggestionController } from './recipient-suggestion.controller';
 import { RecipientSuggestionService } from './recipient-suggestions.service';
@@ -127,6 +132,8 @@ function attachmentUploadOptions(config: ConfigService): MulterModuleOptions {
     AuthSessionModule,
     // 받은편지함 알림 메일 (13단계) — 위험 파일 판정을 그 직원의 받은편지함에. 이 모듈은 메일을 가져오지 않는다
     SystemMailModule,
+    // 검색 색인 (14단계) — 실시간 소식이 오면 맞춘다. 이 모듈은 메일을 가져오지 않는다(엔진 연결 MailEngineModule 만)
+    MailSearchModule,
   ],
   controllers: [
     MailboxController,
@@ -138,6 +145,8 @@ function attachmentUploadOptions(config: ConfigService): MulterModuleOptions {
     MailFilterRunController,
     MailBlockController,
     MessageController,
+    // 같은 대화 · 대화로 묶은 목록 (14단계)
+    ConversationController,
     MessageDeletionController,
     ScheduledMessageController,
     MailAttachmentController,
@@ -162,8 +171,12 @@ function attachmentUploadOptions(config: ConfigService): MulterModuleOptions {
     JmapFilterScriptStore,
     // 이미 받은 메일에 필터 적용(받은편지함을 차례로 판정 · 표시 · 옮기기 — 7단계) — 어댑터 안에서만 쓴다
     JmapFilterRunner,
+    JmapConversations,
     { provide: MAIL_PROVIDER, useClass: JmapMailProvider },
     MailService,
+    // 메일 목록 · 검색 (14단계 — 색인 방식 · 엔진 방식을 고르고 강조를 단다)
+    MessageListService,
+    MailConversationService,
     // 실시간 알림 — 직원마다 엔진 연결 하나를 나눠 쓰고, 서버 종료 때 열린 연결을 먼저 닫는다 (beforeApplicationShutdown)
     MailEventsService,
     // 대용량 첨부(11단계) — 발송의 덩이 · 링크, 임시 저장의 파일, 읽기의 덩이 알아보기, 위험 판정 알림(large-file)
diff --git a/backend/src/modules/mail/mail.provider.ts b/backend/src/modules/mail/mail.provider.ts
index 36150a8..76cc46a 100644
--- a/backend/src/modules/mail/mail.provider.ts
+++ b/backend/src/modules/mail/mail.provider.ts
@@ -1,7 +1,10 @@
 import { BusinessException } from '@/common/errors/business.exception';
+import type { SearchScope } from '@/modules/mail-search/mail-search.types';
 import type {
   AttachmentContent,
   BlockedSender,
+  ConversationListQuery,
+  ConversationSummaryPage,
   Correspondence,
   CredentialCheck,
   DraftContent,
@@ -40,6 +43,7 @@ import type {
   SavedDraft,
   SentMessage,
   SentMessageRecord,
+  SummariesWithHeld,
   TwoFactorLoginResult,
   UploadedFile,
 } from './mail.types';
@@ -254,6 +258,51 @@ export interface MailProvider {
    */
   listMessages(user: string, query: MessageListQuery): Promise<MessagePage>;
 
+  /**
+   * 자체 색인으로 찾을 범위 (14단계 — 색인 방식 검색) — 메일함 하나(없으면 RES_001), 또는 휴지통 · 스팸메일함만 뺀 모든 메일함과
+   * 목록에서 빼는 키워드(발송 중인 내부 초안). 엔진의 메일함 역할 · 키워드 이름은 어댑터만 안다
+   */
+  searchScope(user: string, mailboxId?: string): Promise<SearchScope>;
+
+  /**
+   * 대화의 범위 (14단계 — 색인 방식의 같은 대화 · 묶은 목록) — 늘 휴지통 · 스팸메일함을 빼는 메일함으로 준다.
+   * `mailboxId` 를 주면 그 메일함이 있는지 본다(없으면 RES_001)
+   */
+  conversationScope(user: string, mailboxId?: string): Promise<SearchScope>;
+
+  /**
+   * 요약 여러 통 — `ids` 차례대로, 없는 메일(그사이 지움)은 빠진다. 기다리는 발송(pendingSend)도 목록과 같이 (14단계 — 색인으로 찾은 쪽을 보일 때)
+   */
+  getSummaries(user: string, ids: readonly string[]): Promise<MessageSummary[]>;
+
+  /**
+   * 요약 여러 통 + 지금 붙잡힌 메일 id (14단계 3차 — 묶은 목록의 색인 방식: 줄의 messageIds 가운데 붙잡힌 메일 pendingSendIds).
+   * getSummaries 와 같은 요청 하나 — 기다리는 제출은 한 번만 읽는다
+   */
+  getSummariesWithHeld(
+    user: string,
+    ids: readonly string[],
+  ): Promise<SummariesWithHeld>;
+
+  /**
+   * 같은 대화 — 엔진의 스레드로 (14단계 — 색인을 다 만들기 전). 오래된 차례, 휴지통 · 스팸메일함에만 든 메일과 발송 중인 내부 초안은 빼되
+   * 지금 보는 메일(`emailId`)은 넣는다. 그 메일이 없으면 RES_001. 커서는 이 메일의 대화에서만 쓴다(다르면 VAL_001)
+   */
+  getConversation(
+    user: string,
+    emailId: string,
+    page: { readonly limit: number; readonly cursor?: string },
+  ): Promise<MessagePage>;
+
+  /**
+   * 대화로 묶은 목록 — 엔진의 스레드로 (14단계 — 색인을 다 만들기 전). 그 메일함 안 마지막 받은 시각 최신부터. 없는 메일함은 RES_001.
+   * 커서는 그 메일함의 묶은 목록에서만 쓴다(다르면 VAL_001)
+   */
+  listConversations(
+    user: string,
+    query: ConversationListQuery,
+  ): Promise<ConversationSummaryPage>;
+
   /**
    * 조회만 한다 — 읽음 처리하지 않는다. 기다리는 발송(pendingSend — 9단계)과 스팸메일함에 들었는지(isInJunkMailbox)를 함께 준다
    */
diff --git a/backend/src/modules/mail/mail.service.spec.ts b/backend/src/modules/mail/mail.service.spec.ts
index 035dbf8..f55a7f1 100644
--- a/backend/src/modules/mail/mail.service.spec.ts
+++ b/backend/src/modules/mail/mail.service.spec.ts
@@ -99,6 +99,12 @@ function fakeProvider(): ProviderMocks {
     getMailState: mockOf<'getMailState'>(),
     watchMail: mockOf<'watchMail'>(),
     listMessages: mockOf<'listMessages'>(),
+    searchScope: mockOf<'searchScope'>(),
+    conversationScope: mockOf<'conversationScope'>(),
+    getSummaries: mockOf<'getSummaries'>(),
+    getSummariesWithHeld: mockOf<'getSummariesWithHeld'>(),
+    getConversation: mockOf<'getConversation'>(),
+    listConversations: mockOf<'listConversations'>(),
     getMessage: mockOf<'getMessage'>(),
     updateMessage: mockOf<'updateMessage'>(),
     updateMessages: mockOf<'updateMessages'>(),
@@ -281,9 +287,11 @@ interface NinthStepMocks {
 function fakeNinthStep(): NinthStepMocks {
   return {
     userSettings: {
-      get: jest
-        .fn<Promise<MailUserSettings>, [string]>()
-        .mockResolvedValue({ undoSendSeconds: 0, externalImages: 'ask' }),
+      get: jest.fn<Promise<MailUserSettings>, [string]>().mockResolvedValue({
+        undoSendSeconds: 0,
+        externalImages: 'ask',
+        groupByConversation: false,
+      }),
     },
     contacts: {
       hasEmail: jest
@@ -452,59 +460,7 @@ describe('MailService', () => {
     expect(await codeOf(() => service.getQuota(user))).toBe('MAIL_001');
   });
 
-  it('검색어 앞뒤 공백을 지우고, 비면 검색하지 않는다', async () => {
-    provider.listMessages.mockResolvedValue({
-      items: [],
-      hasNext: false,
-      nextCursor: null,
-      total: 0,
-    });
-
-    await service.listMessages(user, { mailboxId: 'a', limit: 20, q: '   ' });
-    await service.listMessages(user, {
-      mailboxId: 'a',
-      limit: 20,
-      q: ' 이전 ',
-    });
-
-    expect(provider.listMessages.mock.calls[0][1]).toMatchObject({
-      text: undefined,
-    });
-    expect(provider.listMessages.mock.calls[1][1]).toMatchObject({
-      text: '이전',
-    });
-  });
-
-  describe('검색 · 새 메일 확인 · 여러 통 (3단계)', () => {
-    const emptyPage = {
-      items: [],
-      hasNext: false,
-      nextCursor: null,
-      total: 0,
-    };
-
-    it('메일함 없이 검색어만 있으면 모든 메일함 검색으로 넘긴다 (휴지통·스팸메일함 제외는 어댑터)', async () => {
-      provider.listMessages.mockResolvedValue(emptyPage);
-
-      await service.listMessages(user, { limit: 20, q: ' 회의 ' });
-
-      expect(provider.listMessages).toHaveBeenCalledWith(user.email, {
-        mailboxId: undefined,
-        limit: 20,
-        cursor: undefined,
-        text: '회의',
-      });
-    });
-
-    it('메일함도 검색어도 없으면(공백뿐인 검색어 포함) 엔진에 묻지 않고 VAL_001', async () => {
-      for (const query of [{ limit: 20 }, { limit: 20, q: '   ' }]) {
-        expect(await codeOf(() => service.listMessages(user, query))).toBe(
-          'VAL_001',
-        );
-      }
-      expect(provider.listMessages).not.toHaveBeenCalled();
-    });
-
+  describe('새 메일 확인 · 여러 통 (3단계 — 목록 · 검색은 message-list.service.spec.ts)', () => {
     it('새 메일 확인은 어댑터의 상태 값을 그대로 — 요청마다 로그를 남기지 않는다', async () => {
       provider.getMailState.mockResolvedValue({ state: 'c2Iy.c2Fq' });
 
@@ -2866,6 +2822,7 @@ describe('MailService', () => {
         ninth.userSettings.get.mockResolvedValue({
           undoSendSeconds: 20,
           externalImages: 'ask',
+          groupByConversation: false,
         });
         await service.sendMessage(user, sendDto());
         expect(sentMessage()?.hold).toEqual({ kind: 'undo', seconds: 20 });
@@ -2876,6 +2833,7 @@ describe('MailService', () => {
         ninth.userSettings.get.mockResolvedValue({
           undoSendSeconds: 0,
           externalImages: 'ask',
+          groupByConversation: false,
         });
         await service.sendMessage(user, sendDto());
         expect(sentMessage()).not.toHaveProperty('hold');
@@ -2901,6 +2859,7 @@ describe('MailService', () => {
         ninth.userSettings.get.mockResolvedValue({
           undoSendSeconds: 10,
           externalImages: 'ask',
+          groupByConversation: false,
         });
         await service.sendMessage(user, sendDto(), IDEMPOTENCY_KEY);
         const first = sentMessage();
@@ -2983,6 +2942,7 @@ describe('MailService', () => {
         ninth.userSettings.get.mockResolvedValue({
           undoSendSeconds: 10,
           externalImages,
+          groupByConversation: false,
         });
       /** 본문의 중계 주소 → 표를 푼 원래 주소 */
       const proxied = (html: string | null) =>
diff --git a/backend/src/modules/mail/mail.service.ts b/backend/src/modules/mail/mail.service.ts
index 2062d9c..40ef947 100644
--- a/backend/src/modules/mail/mail.service.ts
+++ b/backend/src/modules/mail/mail.service.ts
@@ -42,7 +42,6 @@ import {
   SHOW_IMAGES,
   type MessageDetailQueryDto,
 } from './dto/message-detail-query.dto';
-import type { MessageListQueryDto } from './dto/message-list-query.dto';
 import type {
   ComposeContentDto,
   DraftBodyDto,
@@ -58,6 +57,7 @@ import {
   selectInlineImages,
   toDataUri,
 } from './html/inline-images';
+import { highlightTermsOf } from '@/modules/mail-search/search-plan';
 import { checkHtmlParseBudget } from './html/html-parse-budget';
 import { sanitizeMailHtml } from './html/sanitize-mail-html';
 import { sanitizeOutgoingHtml } from './html/sanitize-outgoing-html';
@@ -118,6 +118,7 @@ import type {
   SentMessage,
 } from './mail.types';
 import { presentMailbox, presentMailboxes } from './mailbox.presenter';
+import { highlightDetail } from './message-highlight';
 import { RecipientSuggestionService } from './recipient-suggestions.service';
 import {
   idempotentMessageId,
@@ -660,34 +661,6 @@ export class MailService {
     };
   }
 
-  /**
-   * 메일 목록 · 검색 — mailboxId 와 검색어(q) 중 하나는 있어야 한다 (둘 다 없으면 VAL_001).
-   * mailboxId 가 없으면 휴지통·스팸메일함을 뺀 모든 메일함에서 찾는다 (계약 2절 "검색"). 검색어는 어떤 로그에도 남기지 않는다.
-   */
-  async listMessages(
-    user: AuthenticatedUser,
-    query: MessageListQueryDto,
-  ): Promise<PaginatedResult<MessageSummary>> {
-    const text = query.q?.trim() || undefined;
-    if (query.mailboxId === undefined && text === undefined) {
-      throw new BusinessException('VAL_001', {
-        context: { reason: 'mailbox-or-search-required' },
-      });
-    }
-    const page = await this.provider.listMessages(user.email, {
-      mailboxId: query.mailboxId,
-      limit: query.limit,
-      cursor: query.cursor,
-      text,
-    });
-
-    return toPaginatedResult(page.items, {
-      hasNext: page.hasNext,
-      nextCursor: page.nextCursor,
-      total: page.total,
-    });
-  }
-
   /**
    * 상세 — 조회만 한다(읽음 처리 없음). HTML 은 정화한 뒤에만 내보낸다.
    * 정화가 이벤트 루프를 오래 붙잡을 HTML(너무 길거나 깊게 중첩된 것)은 정화하지 않고 htmlBody 를 비운다 —
@@ -705,6 +678,26 @@ export class MailService {
     id: string,
     query: MessageDetailQueryDto = {},
   ): Promise<MessageDetail> {
+    // 검색 강조(14단계) — 같은 검색 쿼리로 열었으면 정화한 뒤의 본문 · 제목 · 첨부 이름에 맞은 곳을 단다 (검색 글은 로그에 남기지 않는다).
+    // 보낸 사람 · 받는 사람 조건은 강조하지 않지만 넘긴다 — 본문에 강조할 말(한 글자 낱말)을 목록과 같게 고른다
+    return highlightDetail(
+      await this.readMessage(user, id, query),
+      highlightTermsOf({
+        text: query.q,
+        from: query.from,
+        to: query.to,
+        subject: query.subject,
+        body: query.body,
+      }),
+    );
+  }
+
+  /** getMessage 의 본체 — 강조 전의 상세 */
+  private async readMessage(
+    user: AuthenticatedUser,
+    id: string,
+    query: MessageDetailQueryDto,
+  ): Promise<Omit<MessageDetail, 'searchHighlight'>> {
     const {
       rawHtmlBody,
       isRawHtmlBodyTruncated,
@@ -724,7 +717,9 @@ export class MailService {
       }));
 
     /** HTML 없이 텍스트 본문을 보여 줄 때 (HTML 이 없거나, 있었지만 정화 한도를 넘어 비웠을 때) */
-    const withoutHtml = (isHtmlBodyOmitted: boolean): MessageDetail => ({
+    const withoutHtml = (
+      isHtmlBodyOmitted: boolean,
+    ): Omit<MessageDetail, 'searchHighlight'> => ({
       ...detail,
       attachments: markInline(NO_INLINE_ATTACHMENTS),
       htmlBody: null,
diff --git a/backend/src/modules/mail/mail.types.ts b/backend/src/modules/mail/mail.types.ts
index e4ead21..3ba5a07 100644
--- a/backend/src/modules/mail/mail.types.ts
+++ b/backend/src/modules/mail/mail.types.ts
@@ -6,6 +6,11 @@ import type {
   LargeFile,
   MissingLargeFile,
 } from '@/modules/file-storage/file-storage.types';
+import type {
+  MessageDetailHighlight,
+  MessageListHighlight,
+  SearchConditions,
+} from '@/modules/mail-search/mail-search.types';
 
 /**
  * 메일 도메인 타입 — API 계약(docs/mail/api-contract.md 2절)과 같은 모양이다.
@@ -49,6 +54,11 @@ export interface PendingSend {
   readonly kind: PendingSendKind;
 }
 
+/** 목록 항목 (GET /api/messages — 14단계) — 요약 + 검색 강조. 색인으로 찾았을 때만 강조가 있고, 목록 · 엔진 방식 검색이면 null */
+export interface MessageListItem extends MessageSummary {
+  readonly searchHighlight: MessageListHighlight | null;
+}
+
 export interface MessageSummary {
   readonly id: string;
   readonly threadId: string;
@@ -137,6 +147,11 @@ export interface MessageDetail extends MessageSummary {
    * 그때 htmlBody 안 그 덩이의 바깥 요소에 `data-ara-large-files` 가 붙는다
    */
   readonly largeFiles: MessageLargeFile[];
+  /**
+   * 검색 강조 (14단계 — 같은 검색 쿼리로 열었을 때) — 제목 · 첨부 이름(맞은 것만) · 글 본문의 맞은 곳. htmlBody 는 글 조각에 `<mark>` 를 넣어 준다.
+   * 검색 쿼리가 없으면 null
+   */
+  readonly searchHighlight: MessageDetailHighlight | null;
 }
 
 /** 본문이 `cid:` 로 참조할 수 있는 내장 부분 (첨부 목록에 있는 것 중 Content-ID 가 있는 것) */
@@ -165,6 +180,7 @@ export interface MessageDetailSource extends Omit<
   | 'isBodyTruncated'
   | 'attachments'
   | 'largeFiles'
+  | 'searchHighlight'
 > {
   /** 첨부 — 본문에 넣었는지(isInline)는 정화한 뒤 서비스 계층이 정한다 */
   readonly attachments: MailAttachment[];
@@ -189,6 +205,8 @@ export interface MessageListQuery {
   readonly cursor?: string;
   /** 자유 텍스트 검색어 (앞뒤 공백을 뺀 값) */
   readonly text?: string;
+  /** 조건 검색의 조건 (14단계 — 엔진 방식은 JMAP 필터로 · 낱말 통째 일치) */
+  readonly conditions?: SearchConditions;
 }
 
 export interface MessagePage {
@@ -198,6 +216,55 @@ export interface MessagePage {
   readonly total: number | null;
 }
 
+/**
+ * 묶은 목록의 대화 하나 (14단계 — GET /api/conversations). 고르기 · 읽음 · 중요 · 이동 · 삭제는 `messageIds`(그 메일함 안)에 여러 통 API 로 한다
+ */
+export interface ConversationSummary {
+  /** 대화 — 불투명 (색인이면 대화 키, 엔진이면 스레드 id) */
+  readonly id: string;
+  /** 그 메일함 안 마지막 메일 */
+  readonly latest: MessageSummary;
+  /**
+   * 보낸 사람들 — 받은 차례, 주소마다 한 번, CONVERSATION_PARTICIPANTS_MAX 명까지 (대화 전체 — 엔진 방식에서 스레드가 상한을 넘으면 읽은 최신 메일에서만)
+   */
+  readonly participants: MailAddress[];
+  /**
+   * 대화 전체의 메일 수 — 휴지통 · 스팸메일함에만 든 메일은 빼고(그 메일함의 메일은 넣는다). 엔진 방식에서 상한 때문에 읽지 못한 오래된 메일은 거르지 않고 더한다
+   */
+  readonly messageCount: number;
+  /** 그 메일함 안 그 대화의 메일 — 최신부터 CONVERSATION_MESSAGE_IDS_MAX 통까지 (엔진 방식에서 상한을 넘은 스레드는 읽은 최신 메일에서만) */
+  readonly messageIds: string[];
+  /** messageIds 가운데 붙잡힌 메일(보내기 취소 · 예약을 기다리는 — pendingSend 가 있는 메일) — 없으면 빈 배열. 화면은 여러 통 처리에서 뺀다 */
+  readonly pendingSendIds: string[];
+  /** 그 메일함 안 메일을 모두 읽었다 */
+  readonly isRead: boolean;
+  /** 그 메일함 안 메일 가운데 하나라도 중요 표시 */
+  readonly isFlagged: boolean;
+  /** 그 메일함 안 메일 가운데 하나라도 첨부가 있다 (목록의 첨부 표시와 같은 판정) */
+  readonly hasAttachment: boolean;
+}
+
+/** 요약 여러 통과 계정의 붙잡힌 메일 (14단계 3차 — 묶은 목록의 색인 방식, 기다리는 제출은 한 번만 읽는다) */
+export interface SummariesWithHeld {
+  readonly summaries: MessageSummary[];
+  /** 지금 붙잡힌 메일 id — 보이기 경로의 판정(보낼 시각이 아직 · pendingSend 와 같다), 계정 전체에서 보낼 시각이 이른 것부터 HELD_SUBMISSIONS_MAX 개까지 */
+  readonly heldIds: ReadonlySet<string>;
+}
+
+export interface ConversationSummaryPage {
+  readonly items: ConversationSummary[];
+  readonly hasNext: boolean;
+  readonly nextCursor: string | null;
+  readonly total: number | null;
+}
+
+/** 묶은 목록 쿼리 (엔진 방식) */
+export interface ConversationListQuery {
+  readonly mailboxId: string;
+  readonly limit: number;
+  readonly cursor?: string;
+}
+
 export interface MessageUpdate {
   readonly isRead?: boolean;
   readonly isFlagged?: boolean;
diff --git a/backend/src/modules/mail/message-highlight.spec.ts b/backend/src/modules/mail/message-highlight.spec.ts
new file mode 100644
index 0000000..3908d46
--- /dev/null
+++ b/backend/src/modules/mail/message-highlight.spec.ts
@@ -0,0 +1,175 @@
+import { highlightTermsOf } from '@/modules/mail-search/search-plan';
+import type { MessageDetail } from './mail.types';
+import { highlightDetail } from './message-highlight';
+
+type Detail = Omit<MessageDetail, 'searchHighlight'>;
+
+function detail(overrides: Partial<Detail> = {}): Detail {
+  return {
+    id: 'm1',
+    threadId: 't1',
+    mailboxIds: ['inbox'],
+    from: { name: '이도윤', email: 'doyun.lee@arasystem.test' },
+    to: [{ name: '김아라', email: 'ara.kim@arasystem.test' }],
+    cc: [],
+    bcc: [],
+    replyTo: [],
+    subject: '[공지] 계약 갱신 안내',
+    preview: '계약 갱신 일정',
+    receivedAt: '2026-11-02T01:00:00.000Z',
+    sentAt: '2026-11-02T01:00:00.000Z',
+    messageId: 'x@example.com',
+    references: [],
+    isRead: true,
+    isFlagged: false,
+    hasAttachment: true,
+    size: 2048,
+    pendingSend: null,
+    htmlBody: '<p>이번 달 <b>계약</b> 갱신 일정입니다.</p>',
+    textBody: '이번 달 계약 갱신 일정입니다.',
+    hasBlockedImages: false,
+    imagesShown: false,
+    isHtmlBodyOmitted: false,
+    isBodyTruncated: false,
+    attachments: [
+      {
+        id: 'p1',
+        name: '계약서_초안.pdf',
+        type: 'application/pdf',
+        size: 100,
+        isInline: false,
+      },
+      {
+        id: 'p2',
+        name: '견적.xlsx',
+        type: 'application/vnd.ms-excel',
+        size: 100,
+        isInline: false,
+      },
+    ],
+    largeFiles: [],
+    ...overrides,
+  };
+}
+
+const slices = (text: string, ranges: readonly (readonly [number, number])[]) =>
+  ranges.map(([start, end]) => text.slice(start, end));
+
+describe('읽기 화면의 검색 강조 (message-highlight — 14단계 설계 C2)', () => {
+  it('검색 쿼리가 없으면 searchHighlight 는 null 이고 나머지는 그대로', () => {
+    const source = detail();
+    expect(highlightDetail(source, highlightTermsOf({}))).toEqual({
+      ...source,
+      searchHighlight: null,
+    });
+  });
+
+  it('검색어는 제목 · 본문(textBody 위치 · htmlBody 의 <mark>) · 맞은 첨부 이름에', () => {
+    const result = highlightDetail(
+      detail(),
+      highlightTermsOf({ text: '계약' }),
+    );
+
+    expect(slices(result.subject, result.searchHighlight!.subject)).toEqual([
+      '계약',
+    ]);
+    expect(result.searchHighlight!.attachments).toEqual({ p1: [[0, 2]] });
+    expect(slices(result.textBody!, result.searchHighlight!.textBody)).toEqual([
+      '계약',
+    ]);
+    expect(result.htmlBody).toBe(
+      '<p>이번 달 <b><mark>계약</mark></b> 갱신 일정입니다.</p>',
+    );
+  });
+
+  it('제목 조건은 제목에만, 내용 조건은 본문에만 — 첨부 이름은 검색어로만', () => {
+    const subjectOnly = highlightDetail(
+      detail(),
+      highlightTermsOf({ subject: '갱신' }),
+    );
+    expect(subjectOnly.searchHighlight).toEqual({
+      subject: [[8, 10]],
+      attachments: {},
+      textBody: [],
+    });
+    expect(subjectOnly.htmlBody).toBe(detail().htmlBody);
+
+    const bodyOnly = highlightDetail(
+      detail(),
+      highlightTermsOf({ body: '일정' }),
+    );
+    expect(bodyOnly.searchHighlight!.subject).toEqual([]);
+    expect(bodyOnly.searchHighlight!.attachments).toEqual({});
+    expect(
+      slices(bodyOnly.textBody!, bodyOnly.searchHighlight!.textBody),
+    ).toEqual(['일정']);
+    expect(bodyOnly.htmlBody).toContain('<mark>일정</mark>');
+  });
+
+  it('한 글자 낱말뿐이면 본문은 강조하지 않는다 — 본문을 찾지 않았다, 제목 · 첨부 이름은 그대로 (2026-11-06 실사용 시험)', () => {
+    const source = detail({
+      subject: '견적 안내',
+      htmlBody: '<p>이번 달 견적 안내</p>',
+      textBody: '이번 달 견적 안내',
+    });
+    // '견' 은 제목 · 첨부 이름(견적.xlsx) · 본문에, '달' 은 본문에만 있다
+    const single = highlightDetail(source, highlightTermsOf({ text: '달 견' }));
+    expect(single.searchHighlight).toEqual({
+      subject: [[0, 1]],
+      attachments: { p2: [[0, 1]] },
+      textBody: [],
+    });
+    expect(single.htmlBody).toBe('<p>이번 달 견적 안내</p>');
+
+    // 두 글자 이상 낱말과 섞이면 그 낱말만 본문에 — 한 글자 낱말은 제목 · 첨부 이름에만
+    const mixed = highlightDetail(
+      source,
+      highlightTermsOf({ text: '달 견적' }),
+    );
+    expect(slices(mixed.textBody!, mixed.searchHighlight!.textBody)).toEqual([
+      '견적',
+    ]);
+    expect(mixed.htmlBody).toBe('<p>이번 달 <mark>견적</mark> 안내</p>');
+    expect(mixed.searchHighlight!.subject).toEqual([[0, 2]]);
+    expect(mixed.searchHighlight!.attachments).toEqual({ p2: [[0, 2]] });
+  });
+
+  it('강조가 있으면 제목 · 첨부 이름 · textBody 를 NFC 로 싣는다 — 위치의 기준', () => {
+    const nfd = (text: string) => text.normalize('NFD');
+    const result = highlightDetail(
+      detail({
+        subject: nfd('계약 안내'),
+        textBody: nfd('계약 내용'),
+        attachments: [
+          {
+            id: 'p1',
+            name: nfd('계약서.pdf'),
+            type: 'application/pdf',
+            size: 1,
+            isInline: false,
+          },
+        ],
+      }),
+      highlightTermsOf({ text: '계약' }),
+    );
+
+    expect(result.subject).toBe('계약 안내');
+    expect(result.textBody).toBe('계약 내용');
+    expect(result.attachments[0].name).toBe('계약서.pdf');
+    expect(result.searchHighlight).toEqual({
+      subject: [[0, 2]],
+      attachments: { p1: [[0, 2]] },
+      textBody: [[0, 2]],
+    });
+  });
+
+  it('본문이 없거나 HTML 을 비웠으면(isHtmlBodyOmitted) 있는 쪽에만', () => {
+    const result = highlightDetail(
+      detail({ htmlBody: null, isHtmlBodyOmitted: true, textBody: null }),
+      highlightTermsOf({ text: '계약' }),
+    );
+    expect(result.htmlBody).toBeNull();
+    expect(result.textBody).toBeNull();
+    expect(result.searchHighlight!.textBody).toEqual([]);
+  });
+});
diff --git a/backend/src/modules/mail/message-highlight.ts b/backend/src/modules/mail/message-highlight.ts
new file mode 100644
index 0000000..68e7c26
--- /dev/null
+++ b/backend/src/modules/mail/message-highlight.ts
@@ -0,0 +1,62 @@
+import type {
+  MessageDetailHighlight,
+  SearchRange,
+} from '@/modules/mail-search/mail-search.types';
+import type { HighlightTerms } from '@/modules/mail-search/search-plan';
+import { matchRanges } from '@/shared/utils/search-text';
+import { markHtmlText } from './html/html-mark';
+import type { MessageDetail } from './mail.types';
+
+/**
+ * 읽기 화면의 검색 강조 (순수 함수 — 14단계 설계 C2) — 검색에서 연 메일을 같은 검색 쿼리로 받으면 맞은 곳을 알려 준다.
+ * - 제목: 검색어 · 제목 조건의 말 / 본문(textBody 위치 · htmlBody 의 `<mark>`): 검색어 · 내용 조건의 말 / 첨부 이름: 검색어의 말(맞은 첨부만)
+ * - 위치는 NFC 로 맞춘 글 기준이라 강조가 있으면 subject · 첨부 이름 · textBody 를 NFC 로 바꿔 싣는다(화면에는 같게 보인다)
+ * - htmlBody 는 **정화한 뒤** 의 HTML 에만 `<mark>` 를 넣는다(html/html-mark.ts — 태그 · 속성은 건드리지 않는다)
+ * 강조할 말이 없으면 searchHighlight 는 null 이고 나머지는 그대로다
+ */
+export function highlightDetail(
+  detail: Omit<MessageDetail, 'searchHighlight'>,
+  terms: HighlightTerms | null,
+): MessageDetail {
+  if (terms === null) return { ...detail, searchHighlight: null };
+  const subject = detail.subject.normalize('NFC');
+  const attachments = detail.attachments.map((attachment) => ({
+    ...attachment,
+    name: attachment.name.normalize('NFC'),
+  }));
+  const attachmentRanges: Record<string, SearchRange[]> = {};
+  if (terms.attachment.length > 0) {
+    for (const attachment of attachments) {
+      const ranges = matchRanges(attachment.name, terms.attachment);
+      if (ranges.length > 0) {
+        attachmentRanges[attachment.id] = ranges.map(
+          ([start, end]) => [start, end] as const,
+        );
+      }
+    }
+  }
+  const textBody = detail.textBody?.normalize('NFC') ?? null;
+  const highlight: MessageDetailHighlight = {
+    subject: matchRanges(subject, terms.subject).map(
+      ([start, end]) => [start, end] as const,
+    ),
+    attachments: attachmentRanges,
+    textBody:
+      textBody !== null && terms.body.length > 0
+        ? matchRanges(textBody, terms.body).map(
+            ([start, end]) => [start, end] as const,
+          )
+        : [],
+  };
+  return {
+    ...detail,
+    subject,
+    attachments,
+    textBody,
+    htmlBody:
+      detail.htmlBody === null || terms.body.length === 0
+        ? detail.htmlBody
+        : markHtmlText(detail.htmlBody, terms.body).html,
+    searchHighlight: highlight,
+  };
+}
diff --git a/backend/src/modules/mail/message-list.service.spec.ts b/backend/src/modules/mail/message-list.service.spec.ts
new file mode 100644
index 0000000..39fe63c
--- /dev/null
+++ b/backend/src/modules/mail/message-list.service.spec.ts
@@ -0,0 +1,442 @@
+import { Logger } from '@nestjs/common';
+
+import { BusinessException } from '@/common/errors/business.exception';
+import type { MailSearchIndexService } from '@/modules/mail-search/mail-search-index.service';
+import type {
+  IndexHighlightText,
+  IndexSearchPage,
+  MailSearchQueryService,
+} from '@/modules/mail-search/mail-search-query.service';
+import type { MailSearchSyncService } from '@/modules/mail-search/mail-search-sync.service';
+import type { SearchScope } from '@/modules/mail-search/mail-search.types';
+import { encodeIndexCursor } from '@/modules/mail-search/search-cursor';
+import { encodeCursor } from './jmap/jmap-cursor';
+import type { MailProvider } from './mail.provider';
+import type { MessagePage, MessageSummary } from './mail.types';
+import { MessageListService } from './message-list.service';
+
+const user = { email: 'ara.kim@arasystem.test', name: '김아라' };
+
+const ALL_SCOPE: SearchScope = {
+  mailboxId: null,
+  excludedMailboxIds: ['trash', 'junk'],
+  excludedKeywords: ['$ara-sending'],
+};
+
+function summary(
+  id: string,
+  extra: Partial<MessageSummary> = {},
+): MessageSummary {
+  return {
+    id,
+    threadId: `t-${id}`,
+    mailboxIds: ['inbox'],
+    from: { name: '이도윤', email: 'doyun.lee@arasystem.test' },
+    to: [{ name: '김아라', email: user.email }],
+    subject: `${id} 계약 갱신`,
+    preview: '계약 갱신 일정을 알려 드립니다',
+    receivedAt: '2026-11-02T01:00:00.000Z',
+    isRead: false,
+    isFlagged: false,
+    hasAttachment: false,
+    size: 1200,
+    pendingSend: null,
+    ...extra,
+  };
+}
+
+const emptyEnginePage: MessagePage = {
+  items: [],
+  hasNext: false,
+  nextCursor: null,
+  total: 0,
+};
+
+function setup(options: { ready?: boolean } = {}) {
+  const provider = {
+    listMessages: jest.fn().mockResolvedValue(emptyEnginePage),
+    searchScope: jest.fn().mockResolvedValue(ALL_SCOPE),
+    getSummaries: jest.fn().mockResolvedValue([]),
+  };
+  const searchIndex = {
+    isSearchReady: jest.fn().mockResolvedValue(options.ready ?? true),
+  };
+  const searchSync = { syncBeforeRead: jest.fn().mockResolvedValue(true) };
+  const indexPage: IndexSearchPage = {
+    hits: [],
+    hasNext: false,
+    nextCursor: null,
+    total: 0,
+  };
+  const searchQuery = {
+    search: jest.fn().mockResolvedValue(indexPage),
+    highlightTexts: jest
+      .fn()
+      .mockResolvedValue(new Map<string, IndexHighlightText>()),
+  };
+  const service = new MessageListService(
+    provider as unknown as MailProvider,
+    searchIndex as unknown as MailSearchIndexService,
+    searchSync as unknown as MailSearchSyncService,
+    searchQuery as unknown as MailSearchQueryService,
+  );
+  return { service, provider, searchIndex, searchSync, searchQuery };
+}
+
+async function codeOf(run: () => Promise<unknown>): Promise<string | null> {
+  try {
+    await run();
+    return null;
+  } catch (error) {
+    return error instanceof BusinessException ? error.code : 'NOT_BUSINESS';
+  }
+}
+
+describe('MessageListService (GET /api/messages — 목록 · 검색, 14단계)', () => {
+  let warnSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    warnSpy = jest.spyOn(Logger.prototype, 'warn').mockImplementation();
+  });
+
+  afterEach(() => {
+    warnSpy.mockRestore();
+  });
+
+  it('메일함도 검색도 없으면(공백뿐인 검색어 포함) 엔진 · 색인에 묻지 않고 VAL_001', async () => {
+    const { service, provider, searchIndex } = setup();
+    for (const query of [
+      { limit: 20 },
+      { limit: 20, q: '   ' },
+      { limit: 20, from: ' ', subject: '' },
+    ]) {
+      expect(await codeOf(() => service.list(user, query))).toBe('VAL_001');
+    }
+    expect(provider.listMessages).not.toHaveBeenCalled();
+    expect(searchIndex.isSearchReady).not.toHaveBeenCalled();
+  });
+
+  it('검색이 아닌 목록은 늘 엔진 — 색인 상태를 묻지 않고, 항목의 searchHighlight 는 null', async () => {
+    const { service, provider, searchIndex } = setup();
+    provider.listMessages.mockResolvedValue({
+      items: [summary('m1')],
+      hasNext: true,
+      nextCursor: 'next',
+      total: 9,
+    });
+
+    const page = await service.list(user, {
+      mailboxId: 'inbox',
+      limit: 20,
+      q: '   ',
+    });
+
+    expect(provider.listMessages).toHaveBeenCalledWith(user.email, {
+      mailboxId: 'inbox',
+      limit: 20,
+      cursor: undefined,
+      text: undefined,
+      conditions: undefined,
+    });
+    expect(searchIndex.isSearchReady).not.toHaveBeenCalled();
+    expect(page.items).toEqual([{ ...summary('m1'), searchHighlight: null }]);
+    expect(page.pageInfo).toEqual({
+      hasNext: true,
+      nextCursor: 'next',
+      total: 9,
+    });
+  });
+
+  it('색인이 준비되지 않았으면 엔진 방식 — 검색어 앞뒤 공백을 지우고, 준 조건만 넘긴다', async () => {
+    const { service, provider, searchQuery } = setup({ ready: false });
+
+    await service.list(user, { limit: 20, q: ' 이전 ' });
+    await service.list(user, {
+      limit: 20,
+      from: ' 이도윤 ',
+      hasAttachment: 'true',
+      after: '2026-10-31T15:00:00.000Z',
+    });
+
+    expect(provider.listMessages).toHaveBeenNthCalledWith(1, user.email, {
+      mailboxId: undefined,
+      limit: 20,
+      cursor: undefined,
+      text: '이전',
+      conditions: undefined,
+    });
+    expect(provider.listMessages).toHaveBeenNthCalledWith(2, user.email, {
+      mailboxId: undefined,
+      limit: 20,
+      cursor: undefined,
+      text: undefined,
+      conditions: {
+        from: '이도윤',
+        after: '2026-10-31T15:00:00.000Z',
+        hasAttachment: true,
+      },
+    });
+    expect(searchQuery.search).not.toHaveBeenCalled();
+  });
+
+  it('색인이 준비됐으면 색인 방식 — 바로 전 맞추기 → 엔진의 범위 → 색인 찾기 → 찾은 쪽의 요약은 엔진에서, 찾은 차례대로', async () => {
+    const { service, provider, searchSync, searchQuery } = setup();
+    const order: string[] = [];
+    searchSync.syncBeforeRead.mockImplementation(() => {
+      order.push('sync');
+      return Promise.resolve(true);
+    });
+    provider.searchScope.mockImplementation(() => {
+      order.push('scope');
+      return Promise.resolve(ALL_SCOPE);
+    });
+    searchQuery.search.mockImplementation(() => {
+      order.push('search');
+      return Promise.resolve({
+        hits: [
+          { id: 'm2', receivedAt: new Date('2026-11-02T02:00:00Z') },
+          { id: 'm1', receivedAt: new Date('2026-11-02T01:00:00Z') },
+        ],
+        hasNext: true,
+        nextCursor: 'index-next',
+        total: 42,
+      });
+    });
+    // 엔진은 차례를 보장하지 않는다
+    provider.getSummaries.mockResolvedValue([summary('m1'), summary('m2')]);
+
+    const page = await service.list(user, { limit: 2, q: '계약' });
+
+    expect(order).toEqual(['sync', 'scope', 'search']);
+    expect(searchSync.syncBeforeRead).toHaveBeenCalledWith(user.email);
+    expect(provider.searchScope).toHaveBeenCalledWith(user.email, undefined);
+    const [, scope, criteria, plan, pageOptions] = searchQuery.search.mock
+      .calls[0] as unknown[];
+    expect(scope).toBe(ALL_SCOPE);
+    expect(criteria).toMatchObject({ text: '계약', hasAttachment: false });
+    expect(plan).toMatchObject({ grams: ['계약'] });
+    expect(pageOptions).toEqual({ limit: 2, cursor: undefined });
+    expect(provider.getSummaries).toHaveBeenCalledWith(user.email, [
+      'm2',
+      'm1',
+    ]);
+    expect(page.items.map((item) => item.id)).toEqual(['m2', 'm1']);
+    expect(page.pageInfo).toEqual({
+      hasNext: true,
+      nextCursor: 'index-next',
+      total: 42,
+    });
+    expect(provider.listMessages).not.toHaveBeenCalled();
+  });
+
+  it('색인 방식의 강조 — 제목의 맞은 곳 · 본문에서 맞은 곳 둘레의 미리 보기(색인의 본문), 본문이 없으면 엔진의 미리 보기', async () => {
+    const { service, provider, searchQuery } = setup();
+    searchQuery.search.mockResolvedValue({
+      hits: [
+        { id: 'm1', receivedAt: new Date() },
+        { id: 'm2', receivedAt: new Date() },
+      ],
+      hasNext: false,
+      nextCursor: null,
+      total: 2,
+    });
+    provider.getSummaries.mockResolvedValue([
+      summary('m1', { subject: '계약 갱신 안내' }),
+      summary('m2', { subject: '안내', preview: '갱신 계약서 초안' }),
+    ]);
+    searchQuery.highlightTexts.mockResolvedValue(
+      new Map([
+        [
+          'm1',
+          {
+            subject: '계약 갱신 안내',
+            bodyText: '안녕하세요. 이번 달 계약 갱신 일정입니다.',
+            preview: '안녕하세요.',
+            otherFields: ['', '', '계약 갱신 안내', ''],
+          },
+        ],
+      ]),
+    );
+
+    const page = await service.list(user, { limit: 20, q: '계약' });
+
+    expect(page.items[0].searchHighlight).toEqual({
+      subject: [[0, 2]],
+      preview: {
+        text: '안녕하세요. 이번 달 계약 갱신 일정입니다.',
+        ranges: [[12, 14]],
+      },
+    });
+    expect(page.items[1].searchHighlight).toEqual({
+      subject: [],
+      preview: { text: '갱신 계약서 초안', ranges: [[3, 5]] },
+    });
+  });
+
+  it('색인 방식의 미리 보기는 답장의 원문 인용(> 줄)을 피한다 — 인용 안에서만 맞고 색인의 다른 칸(제목)에서도 맞으면 인용 앞의 글 (2026-11-06 사용자 관점 점검)', async () => {
+    const { service, provider, searchQuery } = setup();
+    searchQuery.search.mockResolvedValue({
+      hits: [{ id: 'm1', receivedAt: new Date() }],
+      hasNext: false,
+      nextCursor: null,
+      total: 1,
+    });
+    provider.getSummaries.mockResolvedValue([
+      summary('m1', {
+        subject: 'RE: 해오름 견적',
+        preview: '네, 확인했습니다. > 견적서를 보내 드립니다.',
+      }),
+    ]);
+    searchQuery.highlightTexts.mockResolvedValue(
+      new Map([
+        [
+          'm1',
+          {
+            subject: 'RE: 해오름 견적',
+            bodyText: '네, 확인했습니다.\n\n> 견적서를 보내 드립니다.',
+            preview: '네, 확인했습니다.',
+            otherFields: ['', '', 're: 해오름 견적', ''],
+          },
+        ],
+      ]),
+    );
+
+    const page = await service.list(user, { limit: 20, q: '견적' });
+
+    expect(page.items[0].searchHighlight).toEqual({
+      subject: [[8, 10]],
+      preview: { text: '네, 확인했습니다.…', ranges: [] },
+    });
+  });
+
+  it('엔진이 범위 밖에 둔 메일(그사이 휴지통으로 옮김) · 엔진에 없는 메일은 뺀다 — 메일함 범위면 그 메일함에 든 것만', async () => {
+    const { service, provider, searchQuery } = setup();
+    searchQuery.search.mockResolvedValue({
+      hits: ['m1', 'm2', 'm3'].map((id) => ({ id, receivedAt: new Date() })),
+      hasNext: false,
+      nextCursor: null,
+      total: 3,
+    });
+    provider.getSummaries.mockResolvedValue([
+      summary('m1', { mailboxIds: ['trash'] }),
+      summary('m2', { mailboxIds: ['trash', 'project'] }),
+    ]);
+
+    const all = await service.list(user, { limit: 20, q: '계약' });
+    expect(all.items.map((item) => item.id)).toEqual(['m2']);
+
+    provider.searchScope.mockResolvedValue({
+      mailboxId: 'project',
+      excludedMailboxIds: [],
+      excludedKeywords: ['$ara-sending'],
+    });
+    provider.getSummaries.mockResolvedValue([
+      summary('m1', { mailboxIds: ['inbox'] }),
+      summary('m2', { mailboxIds: ['project'] }),
+    ]);
+    const inProject = await service.list(user, {
+      mailboxId: 'project',
+      limit: 20,
+      q: '계약',
+    });
+    expect(provider.searchScope).toHaveBeenLastCalledWith(
+      user.email,
+      'project',
+    );
+    expect(inProject.items.map((item) => item.id)).toEqual(['m2']);
+  });
+
+  it('찾은 것이 없으면 엔진에 요약을 묻지 않는다', async () => {
+    const { service, provider, searchQuery } = setup();
+    const page = await service.list(user, { limit: 20, subject: '없는말' });
+    expect(provider.getSummaries).not.toHaveBeenCalled();
+    expect(searchQuery.highlightTexts).not.toHaveBeenCalled();
+    expect(page).toEqual({
+      items: [],
+      pageInfo: { hasNext: false, nextCursor: null, total: 0 },
+    });
+  });
+
+  it('쪽을 넘기는 중에는 커서의 방식대로 — 색인 커서는 색인으로(준비 전이어도), 엔진 커서는 엔진으로(준비됐어도). 색인 상태를 묻지 않는다', async () => {
+    const indexCursor = encodeIndexCursor(
+      { receivedAt: new Date('2026-11-02T01:00:00Z'), emailId: 'm9' },
+      'scope',
+    );
+    const engineCursor = encodeCursor(
+      { anchor: 'm9', position: 20 },
+      { text: '계약' },
+    );
+
+    const notReady = setup({ ready: false });
+    await notReady.service.list(user, {
+      limit: 20,
+      q: '계약',
+      cursor: indexCursor,
+    });
+    expect(notReady.searchQuery.search).toHaveBeenCalledTimes(1);
+    expect(notReady.provider.listMessages).not.toHaveBeenCalled();
+
+    const ready = setup({ ready: true });
+    await ready.service.list(user, {
+      limit: 20,
+      q: '계약',
+      cursor: engineCursor,
+    });
+    expect(ready.provider.listMessages).toHaveBeenCalledTimes(1);
+    expect(ready.searchQuery.search).not.toHaveBeenCalled();
+
+    expect(notReady.searchIndex.isSearchReady).not.toHaveBeenCalled();
+    expect(ready.searchIndex.isSearchReady).not.toHaveBeenCalled();
+  });
+
+  it('첫 쪽의 색인 찾기가 실패하면(DB 장애) 엔진 방식으로 찾는다 — 경고에 검색 글 · 주소 원문을 남기지 않는다', async () => {
+    const { service, provider, searchQuery } = setup();
+    searchQuery.search.mockRejectedValue(
+      Object.assign(new Error('connection terminated'), { code: '57P01' }),
+    );
+    provider.listMessages.mockResolvedValue({
+      items: [summary('m1')],
+      hasNext: false,
+      nextCursor: null,
+      total: 1,
+    });
+
+    const page = await service.list(user, { limit: 20, q: '비밀 계약' });
+
+    expect(page.items.map((item) => item.searchHighlight)).toEqual([null]);
+    expect(provider.listMessages).toHaveBeenCalledTimes(1);
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    const [line] = warnSpy.mock.calls[0] as [string];
+    expect(line).toContain('[SYS_001]');
+    expect(line).toContain('Error/57P01');
+    expect(line).not.toContain('비밀');
+    expect(line).not.toContain('계약');
+    expect(line).not.toContain(user.email);
+  });
+
+  it('코드가 있는 실패(없는 메일함 RES_001 · 엔진 장애 MAIL_001)는 그대로 — 엔진 방식으로 다시 찾지 않는다', async () => {
+    for (const code of ['RES_001', 'MAIL_001'] as const) {
+      const { service, provider } = setup();
+      provider.searchScope.mockRejectedValue(new BusinessException(code));
+      expect(
+        await codeOf(() =>
+          service.list(user, { mailboxId: 'zz', limit: 20, q: '계약' }),
+        ),
+      ).toBe(code);
+      expect(provider.listMessages).not.toHaveBeenCalled();
+    }
+  });
+
+  it('다음 쪽(색인 커서)의 색인 찾기가 실패하면 그대로 실패한다 — 엔진 커서와 섞지 않는다', async () => {
+    const { service, provider, searchQuery } = setup();
+    searchQuery.search.mockRejectedValue(new Error('db down'));
+    const cursor = encodeIndexCursor(
+      { receivedAt: new Date('2026-11-02T01:00:00Z'), emailId: 'm9' },
+      'scope',
+    );
+    expect(
+      await codeOf(() => service.list(user, { limit: 20, q: '계약', cursor })),
+    ).toBe('NOT_BUSINESS');
+    expect(provider.listMessages).not.toHaveBeenCalled();
+  });
+});
diff --git a/backend/src/modules/mail/message-list.service.ts b/backend/src/modules/mail/message-list.service.ts
new file mode 100644
index 0000000..fe8df08
--- /dev/null
+++ b/backend/src/modules/mail/message-list.service.ts
@@ -0,0 +1,214 @@
+import { Inject, Injectable, Logger } from '@nestjs/common';
+
+import type { AuthenticatedUser } from '@/common/decorators/current-user.decorator';
+import {
+  type PaginatedResult,
+  toPaginatedResult,
+} from '@/common/dto/pagination.dto';
+import { BusinessException } from '@/common/errors/business.exception';
+import { MailSearchIndexService } from '@/modules/mail-search/mail-search-index.service';
+import {
+  MailSearchQueryService,
+  type IndexHighlightText,
+} from '@/modules/mail-search/mail-search-query.service';
+import { MailSearchSyncService } from '@/modules/mail-search/mail-search-sync.service';
+import type {
+  SearchConditions,
+  SearchCriteria,
+  SearchScope,
+} from '@/modules/mail-search/mail-search.types';
+import { cursorMethod } from '@/modules/mail-search/search-cursor';
+import {
+  highlightedSubject,
+  listHighlight,
+} from '@/modules/mail-search/search-highlight';
+import {
+  isSearchCriteria,
+  planSearch,
+} from '@/modules/mail-search/search-plan';
+import { traceTag } from '@/shared/logger/request-context';
+import { maskEmail } from '@/shared/utils/mask';
+import {
+  HAS_ATTACHMENT_ONLY,
+  type MessageListQueryDto,
+} from './dto/message-list-query.dto';
+import { MAIL_PROVIDER, type MailProvider } from './mail.provider';
+import type { MessageListItem, MessageSummary } from './mail.types';
+
+/** 앞뒤 공백을 지운 글 — 비면 없는 것 (DTO 가 이미 지우지만 HTTP 를 거치지 않는 호출도 같게) */
+function trimmed(value: string | undefined): string | undefined {
+  return value?.trim() || undefined;
+}
+
+/** 검색 쿼리 → 검색 조건 */
+export function criteriaOf(query: MessageListQueryDto): SearchCriteria {
+  return {
+    text: trimmed(query.q),
+    from: trimmed(query.from),
+    to: trimmed(query.to),
+    subject: trimmed(query.subject),
+    body: trimmed(query.body),
+    after: query.after,
+    before: query.before,
+    hasAttachment: query.hasAttachment === HAS_ATTACHMENT_ONLY,
+  };
+}
+
+/** 검색어 밖의 조건 — 하나도 없으면 undefined (엔진 방식 검색의 필터 · 커서 지문이 예전과 같다) */
+function conditionsOf(criteria: SearchCriteria): SearchConditions | undefined {
+  const conditions: SearchConditions = {
+    ...(criteria.from ? { from: criteria.from } : {}),
+    ...(criteria.to ? { to: criteria.to } : {}),
+    ...(criteria.subject ? { subject: criteria.subject } : {}),
+    ...(criteria.body ? { body: criteria.body } : {}),
+    ...(criteria.after ? { after: criteria.after } : {}),
+    ...(criteria.before ? { before: criteria.before } : {}),
+    ...(criteria.hasAttachment === true ? { hasAttachment: true } : {}),
+  };
+  return Object.keys(conditions).length > 0 ? conditions : undefined;
+}
+
+/** 엔진이 지금 그 메일을 범위 안에 두나 — 색인이 몇 초 늦을 수 있어 보이기 전에 엔진의 메일함으로 한 번 더 본다 */
+function inScope(summary: MessageSummary, scope: SearchScope): boolean {
+  if (scope.mailboxId !== null) {
+    return summary.mailboxIds.includes(scope.mailboxId);
+  }
+  const excluded = new Set(scope.excludedMailboxIds);
+  return summary.mailboxIds.some((mailboxId) => !excluded.has(mailboxId));
+}
+
+function errorKind(error: unknown): string {
+  const name = error instanceof Error ? error.name : typeof error;
+  const code = (error as { code?: unknown } | null)?.code;
+  return typeof code === 'string' ? `${name}/${code}` : name;
+}
+
+/**
+ * 메일 목록 · 검색 (GET /api/messages — 계약 2절 "검색", 14단계 설계 C1).
+ * - mailboxId 와 검색(검색어 q · 조건 하나라도) 가운데 하나는 있어야 한다 — 둘 다 없으면 VAL_001. 검색 글 · 조건은 어떤 로그에도 남기지 않는다
+ * - 검색 방식: 커서가 있으면 그 커서의 방식(쪽을 넘기는 중에 색인이 준비되거나 다시 채우기에 들어가도 처음 방식대로), 없으면 색인이 준비됐을 때(ready · 지금 판) 색인,
+ *   아니면 엔진(낱말 통째 일치 · 조건은 JMAP 필터)
+ * - 색인 방식: 바로 전 맞추기(PRE_READ_SYNC_WAIT_MS 안 — 넘으면 지금 색인으로) → 엔진에 범위(메일함 · 빼는 메일함) → 색인 찾기 → 찾은 쪽의 요약은 엔진에서
+ *   (목록과 같은 모양 · 지금 상태) → 엔진이 범위 밖으로 둔 메일(그사이 옮김)은 뺀다 → 제목 · 미리 보기 강조. 첫 쪽의 색인 찾기가 DB 장애로 실패하면 엔진 방식으로 찾는다
+ * 목록 항목은 늘 searchHighlight 를 싣는다 — 색인 방식 검색에서만 값이 있고 그 밖에는 null
+ */
+@Injectable()
+export class MessageListService {
+  private readonly logger = new Logger(MessageListService.name);
+
+  constructor(
+    @Inject(MAIL_PROVIDER) private readonly provider: MailProvider,
+    private readonly searchIndex: MailSearchIndexService,
+    private readonly searchSync: MailSearchSyncService,
+    private readonly searchQuery: MailSearchQueryService,
+  ) {}
+
+  async list(
+    user: AuthenticatedUser,
+    query: MessageListQueryDto,
+  ): Promise<PaginatedResult<MessageListItem>> {
+    const criteria = criteriaOf(query);
+    const searching = isSearchCriteria(criteria);
+    if (query.mailboxId === undefined && !searching) {
+      throw new BusinessException('VAL_001', {
+        context: { reason: 'mailbox-or-search-required' },
+      });
+    }
+    if (!searching) return this.fromEngine(user, query, criteria);
+    if (query.cursor) {
+      return cursorMethod(query.cursor) === 'index'
+        ? this.fromIndex(user, query, criteria)
+        : this.fromEngine(user, query, criteria);
+    }
+    if (!(await this.searchIndex.isSearchReady(user.email))) {
+      return this.fromEngine(user, query, criteria);
+    }
+    try {
+      return await this.fromIndex(user, query, criteria);
+    } catch (error) {
+      // 코드가 있는 실패(없는 메일함 RES_001 · 엔진 장애 MAIL_001 등)는 그대로 — 색인(DB)이 실패했으면 엔진으로 찾는다
+      if (error instanceof BusinessException) throw error;
+      this.logger.warn(
+        `[SYS_001]${traceTag()} 검색 색인으로 찾지 못해 엔진 방식으로 찾습니다: user=${maskEmail(user.email)}, reason=${errorKind(error)}`,
+      );
+      return this.fromEngine(user, query, criteria);
+    }
+  }
+
+  /** 엔진 방식 — 목록 · 색인 준비 전의 검색 (강조 없음) */
+  private async fromEngine(
+    user: AuthenticatedUser,
+    query: MessageListQueryDto,
+    criteria: SearchCriteria,
+  ): Promise<PaginatedResult<MessageListItem>> {
+    const page = await this.provider.listMessages(user.email, {
+      mailboxId: query.mailboxId,
+      limit: query.limit,
+      cursor: query.cursor,
+      text: criteria.text,
+      conditions: conditionsOf(criteria),
+    });
+    return toPaginatedResult(
+      page.items.map((item) => ({ ...item, searchHighlight: null })),
+      {
+        hasNext: page.hasNext,
+        nextCursor: page.nextCursor,
+        total: page.total,
+      },
+    );
+  }
+
+  /** 색인 방식 — 부분 일치 · 조건 · 강조 */
+  private async fromIndex(
+    user: AuthenticatedUser,
+    query: MessageListQueryDto,
+    criteria: SearchCriteria,
+  ): Promise<PaginatedResult<MessageListItem>> {
+    // 방금 온 메일도 찾게 — 기다리는 시간을 넘으면 지금 색인으로 답한다 (맞추기는 뒤에서 이어 한다)
+    await this.searchSync.syncBeforeRead(user.email);
+    const scope = await this.provider.searchScope(user.email, query.mailboxId);
+    const plan = planSearch(criteria);
+    const found = await this.searchQuery.search(
+      user.email,
+      scope,
+      criteria,
+      plan,
+      { limit: query.limit, cursor: query.cursor },
+    );
+    const ids = found.hits.map((hit) => hit.id);
+    const [summaries, texts] =
+      ids.length > 0
+        ? await Promise.all([
+            this.provider.getSummaries(user.email, ids),
+            this.searchQuery.highlightTexts(user.email, ids),
+          ])
+        : [[], new Map<string, IndexHighlightText>()];
+    const byId = new Map(summaries.map((summary) => [summary.id, summary]));
+    const items = ids.flatMap((id): MessageListItem[] => {
+      const summary = byId.get(id);
+      if (!summary || !inScope(summary, scope)) return [];
+      const subject = highlightedSubject(summary.subject);
+      const text = texts.get(id);
+      return [
+        {
+          ...summary,
+          subject,
+          searchHighlight: listHighlight(
+            {
+              subject,
+              preview: summary.preview,
+              bodyText: text?.bodyText ?? null,
+              otherFields: text?.otherFields ?? null,
+            },
+            plan.highlight,
+          ),
+        },
+      ];
+    });
+    return toPaginatedResult(items, {
+      hasNext: found.hasNext,
+      nextCursor: found.nextCursor,
+      total: found.total,
+    });
+  }
+}
diff --git a/backend/src/modules/mail/message.controller.ts b/backend/src/modules/mail/message.controller.ts
index e1d22b1..4f81c29 100644
--- a/backend/src/modules/mail/message.controller.ts
+++ b/backend/src/modules/mail/message.controller.ts
@@ -68,6 +68,7 @@ import { UpdateMessageDto } from './dto/update-message.dto';
 import { MailIdPipe } from './mail-id.pipe';
 import { MailLargeFilesService } from './mail-large-files.service';
 import { MailService } from './mail.service';
+import { MessageListService } from './message-list.service';
 import type { AttachmentContent } from './mail.types';
 import { IDEMPOTENCY_KEY_HEADER } from './send-idempotency';
 
@@ -94,24 +95,27 @@ export class MessageController {
   constructor(
     private readonly mail: MailService,
     private readonly largeFiles: MailLargeFilesService,
+    private readonly messageList: MessageListService,
   ) {}
 
   @Get()
   @ApiOperation({
     summary: '메일 목록 · 검색 (커서 페이지네이션, 받은 시각 내림차순)',
     description:
-      'mailboxId 와 q 중 하나는 있어야 한다. q 만 있으면 휴지통·스팸메일함을 뺀 모든 메일함에서 찾는다. ' +
-      '엔진의 전문 검색은 낱말이 통째로 같을 때만 맞으므로, 한글로 끝나는 낱말은 흔한 조사를 받침에 맞게 붙인 형태도 함께 찾는다 ' +
-      '(낱말 안은 OR · 낱말끼리는 AND, 영문·숫자로 끝나면 두 가지를 다, 큰따옴표 구절에는 붙이지 않는다). ' +
-      '낱말 앞뒤의 문장부호는 떼고 찾는다(회의, → 회의). 문자·숫자가 없는 낱말·구절(- · … 등)은 빼고 찾으며, 찾을 낱말이 하나도 없으면 빈 목록이다(범위 전체를 돌려주지 않는다). ' +
-      '붙여 쓴 말의 일부 · 앞부분만 친 말 · 제목 맨 앞의 말머리([공지] · Re:)는 찾지 못한다. 발송 중인 내부 초안은 빠진다.',
+      'mailboxId 와 검색(q 나 조건 from · to · subject · body · after · before · hasAttachment 하나라도) 가운데 하나는 있어야 한다. 메일함 없이 검색하면 휴지통·스팸메일함을 뺀 모든 메일함에서 찾는다. ' +
+      '검색 방식(14단계): 그 직원의 색인이 준비됐으면(GET /api/search-index 의 ready) 자체 색인으로 부분 일치(붙여 쓴 말 · 앞부분 · 제목 맨 앞의 말머리까지, 영문 대소문자 · 전각 없이, 줄바꿈으로 갈린 구절도) — 항목에 searchHighlight 가 있다. ' +
+      '한 글자 낱말뿐이면 제목 · 보낸 사람 · 받는 사람 · 참조 · 첨부 이름에서만 찾는다(본문은 훑지 않는다 — 두 글자 넘는 낱말과 함께면 본문도). ' +
+      '색인 방식은 한 요청이 확인하는 메일 수에 상한이 있어, 쪽이 limit 보다 적거나 비어도 hasNext · nextCursor 가 있으면 이어 찾는다. total 은 첫 쪽에서만 1,000 까지(넘거나 다 세지 못하면 null). ' +
+      '준비 중이면 엔진 검색 — 낱말이 통째로 같을 때만 맞고, 한글로 끝나는 낱말은 흔한 조사를 받침에 맞게 붙인 형태도 함께 찾는다(조건 칸도 같다), searchHighlight 는 null. ' +
+      '커서에는 방식이 실려 쪽을 넘기는 중에 준비가 끝나도 처음 방식대로 이어 간다. 낱말 앞뒤의 문장부호는 떼고 찾는다(회의, → 회의). ' +
+      '문자·숫자가 없는 낱말·구절(- · … 등)은 빼고 찾으며, 글을 준 칸에 찾을 낱말이 하나도 없으면 빈 목록이다(범위 전체를 돌려주지 않는다). 발송 중인 내부 초안은 빠진다.',
   })
   @ApiStandardResponse(MessagePageDto, {
     description: '메일 목록 (total 포함)',
   })
   @ApiErrorResponse(
     'VAL_001',
-    `mailboxId 와 q 가 둘 다 없음 · q 가 ${MAX_SEARCH_LENGTH}자 초과 또는 낱말 ${MAX_SEARCH_WORDS}개 초과 · 다른 메일함·검색어의 커서 · limit 범위 초과`,
+    `mailboxId 와 검색이 둘 다 없음 · 검색 글 칸(q · from · to · subject · body)이 ${MAX_SEARCH_LENGTH}자 초과 또는 낱말 ${MAX_SEARCH_WORDS}개 초과 · 다섯 칸을 합친 낱말이 ${MAX_SEARCH_WORDS}개 초과 · after · before 가 ISO 8601 UTC 가 아님 · hasAttachment 가 true 가 아님 · 다른 메일함·검색어·조건의 커서 · limit 범위 초과`,
   )
   @ApiErrorResponse(
     'RES_001',
@@ -122,7 +126,7 @@ export class MessageController {
     @CurrentUser() user: AuthenticatedUser,
     @Query() query: MessageListQueryDto,
   ) {
-    return this.mail.listMessages(user, query);
+    return this.messageList.list(user, query);
   }
 
   @Patch()
@@ -162,10 +166,15 @@ export class MessageController {
       '정화 한도(너무 길거나 깊게 중첩된 HTML)를 넘으면 htmlBody 는 null, isHtmlBodyOmitted 는 true 다 — textBody 를 보여 준다. ' +
       `보여 줄 본문(htmlBody — null 이거나 공백뿐이면 textBody)이 읽기 한도(본문 한 부분 UTF-8 ${MAX_BODY_VALUE_BYTES.toLocaleString('ko-KR')}바이트)에서 잘렸으면 isBodyTruncated 가 true 다. ` +
       'images=show 면 외부 이미지(<img> 의 http · https · // 주소, 한 통에 100개 · 주소 2,048자까지)를 중계 주소(/api/mail-images/{token} — 1시간)로 바꿔 넣는다(imagesShown: true · hasBlockedImages: false). ' +
-      '없으면 그 직원의 외부 이미지 설정을 따른다 — 스팸메일함의 메일은 설정과 상관없이 지운다. srcset · 배경 그림(url())은 늘 지운다. pendingSend 는 아직 보내지 않은 내 메일의 발송이다(9단계).',
+      '없으면 그 직원의 외부 이미지 설정을 따른다 — 스팸메일함의 메일은 설정과 상관없이 지운다. srcset · 배경 그림(url())은 늘 지운다. pendingSend 는 아직 보내지 않은 내 메일의 발송이다(9단계). ' +
+      '검색 쿼리(q · subject · body — 14단계)를 함께 보내면 searchHighlight 에 제목 · 첨부 이름 · textBody 의 맞은 곳을 싣고, htmlBody 의 맞은 글 조각에 <mark> 를 넣는다(목록과 같은 접기 · 부분 일치, 태그를 건너는 말은 강조하지 않는다). ' +
+      '검색 쿼리의 검사는 목록과 같다 — from · to 는 받기만 하고 강조하지 않는다.',
   })
   @ApiStandardResponse(MessageDetailDto, { description: '메일 상세' })
-  @ApiErrorResponse('VAL_001', '모르는 images 값 · 모르는 쿼리')
+  @ApiErrorResponse(
+    'VAL_001',
+    `모르는 images 값 · 모르는 쿼리(cursor · limit · after · before · hasAttachment 포함) · 검색 글 칸이 ${MAX_SEARCH_LENGTH}자 초과 또는 낱말 ${MAX_SEARCH_WORDS}개 초과 · 다섯 칸을 합친 낱말이 ${MAX_SEARCH_WORDS}개 초과`,
+  )
   @ApiErrorResponse('RES_001', '없는 메일')
   @ApiErrorResponse('MAIL_001', '메일 엔진 장애')
   get(
diff --git a/backend/src/modules/ops/lock-commands.ts b/backend/src/modules/ops/lock-commands.ts
index 38e7a52..cca3993 100644
--- a/backend/src/modules/ops/lock-commands.ts
+++ b/backend/src/modules/ops/lock-commands.ts
@@ -52,6 +52,8 @@ const ROW_LABELS: Record<keyof AddressRows, string> = {
   directory: '사내 목록 기록',
   files: '대용량 파일',
   shareLinks: '대용량 첨부 링크',
+  searchStates: '검색 색인 상태',
+  searchMessages: '검색 색인(메일)',
 };
 
 /** 남은 줄을 보이는 글 */
diff --git a/backend/src/modules/ops/ops-commands.spec.ts b/backend/src/modules/ops/ops-commands.spec.ts
index d0f4c02..e2e6230 100644
--- a/backend/src/modules/ops/ops-commands.spec.ts
+++ b/backend/src/modules/ops/ops-commands.spec.ts
@@ -55,6 +55,8 @@ const NO_ROWS: AddressRows = {
   directory: 0,
   files: 0,
   shareLinks: 0,
+  searchStates: 0,
+  searchMessages: 0,
 };
 
 function employee(overrides: Partial<EngineEmployee> = {}): EngineEmployee {
diff --git a/backend/src/modules/ops/ops-data.service.ts b/backend/src/modules/ops/ops-data.service.ts
index 5df7b84..aaa25cc 100644
--- a/backend/src/modules/ops/ops-data.service.ts
+++ b/backend/src/modules/ops/ops-data.service.ts
@@ -16,6 +16,8 @@ import {
 } from '@/modules/file-storage/file-blob-store';
 import { StoredFileEntity } from '@/modules/file-storage/stored-file.entity';
 import { MailDirectoryEntryEntity } from '@/modules/mail-directory/mail-directory.entity';
+import { MailSearchMessageEntity } from '@/modules/mail-search/mail-search-message.entity';
+import { MailSearchStateEntity } from '@/modules/mail-search/mail-search-state.entity';
 import { MailSignatureImageEntity } from '@/modules/mail-signature/mail-signature-image.entity';
 import { MailSignatureEntity } from '@/modules/mail-signature/mail-signature.entity';
 import { SignatureImageStorage } from '@/modules/mail-signature/signature-image-storage';
@@ -48,6 +50,9 @@ export interface AddressRows {
   readonly directory: number;
   readonly files: number;
   readonly shareLinks: number;
+  /** 14단계 — 검색 색인의 상태 줄 · 메일 줄 (메일 글이 한 벌 더 든다) */
+  readonly searchStates: number;
+  readonly searchMessages: number;
 }
 
 /** 지운 결과 — 줄 수 · 2단계 필수의 예외 주소에서 뺐는지 · 끊은 세션 수 · 지우지 못해 정리 작업에 맡긴 디스크 파일 수 */
@@ -255,7 +260,7 @@ export class OpsDataService {
 
   /**
    * 퇴사 마무리 — 살아 있는 세션을 끊고(행은 남긴다), 그 주소의 줄을 한 트랜잭션에 지운다
-   * (로그인 기록 · 앱 비밀번호 사용 · 2단계 기록 · 서명 · 서명 그림 · 설정 · 사내 목록 기록 · 대용량 파일 · 링크 + 2단계 필수의 예외 주소에서 빼기).
+   * (로그인 기록 · 앱 비밀번호 사용 · 2단계 기록 · 서명 · 서명 그림 · 설정 · 사내 목록 기록 · 대용량 파일 · 링크 · 검색 색인 + 2단계 필수의 예외 주소에서 빼기).
    * 지운 뒤 디스크의 파일(대용량 파일 · 서명 그림)도 지운다 — 지우지 못한 것은 정리 작업이 표에 없는 파일로 지운다
    */
   async purgeAddress(email: string): Promise<AddressPurge> {
@@ -378,7 +383,9 @@ export class OpsDataService {
         | typeof MailUserSettingsEntity
         | typeof MailDirectoryEntryEntity
         | typeof StoredFileEntity
-        | typeof ShareLinkEntity,
+        | typeof ShareLinkEntity
+        | typeof MailSearchStateEntity
+        | typeof MailSearchMessageEntity,
       where: Record<string, string>,
     ): Promise<number> => {
       if (mode === 'count') return manager.countBy(entity, where);
@@ -402,6 +409,10 @@ export class OpsDataService {
       files: await run(StoredFileEntity, { ownerEmail: email }),
       // 링크의 파일 줄은 외래 키(CASCADE)로 함께 지워진다
       shareLinks: await run(ShareLinkEntity, { ownerEmail: email }),
+      // 검색 색인(14단계) — 상태 줄을 먼저 지운다: 서버의 색인 쓰기는 상태 줄을 잠그고 하므로(없으면 쓰지 않는다) 그사이 끝난 쓰기가
+      // 메일 줄을 되살리지 않는다 (지우기는 잠금이 풀릴 때까지 기다리고, 다음 문장은 그 쓰기가 넣은 줄까지 본다)
+      searchStates: await run(MailSearchStateEntity, { userEmail: email }),
+      searchMessages: await run(MailSearchMessageEntity, { userEmail: email }),
     };
   }
 }
diff --git a/backend/src/shared/config/database.config.spec.ts b/backend/src/shared/config/database.config.spec.ts
new file mode 100644
index 0000000..a55808f
--- /dev/null
+++ b/backend/src/shared/config/database.config.spec.ts
@@ -0,0 +1,17 @@
+import { databaseLogging } from './database.config';
+
+describe('databaseLogging (TypeORM 로그)', () => {
+  it('운영 · 시험은 끈다', () => {
+    expect(databaseLogging(true, 'production')).toBe(false);
+    expect(databaseLogging(true, 'development')).toBe(false);
+    expect(databaseLogging(false, 'test')).toBe(false);
+  });
+
+  it('개발은 오류 · 경고 · 마이그레이션만 — 쿼리(매개변수에 메일 글 · 주소가 든다)는 남기지 않는다 (14단계)', () => {
+    for (const nodeEnv of ['development', undefined]) {
+      const logging = databaseLogging(false, nodeEnv);
+      expect(logging).toEqual(['error', 'warn', 'migration']);
+      expect(logging).not.toContain('query');
+    }
+  });
+});
diff --git a/backend/src/shared/config/database.config.ts b/backend/src/shared/config/database.config.ts
index d72be10..f95b619 100644
--- a/backend/src/shared/config/database.config.ts
+++ b/backend/src/shared/config/database.config.ts
@@ -57,6 +57,19 @@ function resolvePaths(baseDir: string) {
   };
 }
 
+/**
+ * TypeORM 로그 — 운영 · 시험은 끄고, 개발은 오류 · 경고 · 마이그레이션만 남긴다(쿼리는 남기지 않는다).
+ * 쿼리 로그는 매개변수째 찍는다 — 14단계부터 DB 에 메일 글 · 제목 · 주소(검색 색인)가 있어 개발 로그에도 남기지 않는다 (.claude/rules/logging.md).
+ * ⚠️ 'error' 는 실패한 쿼리를 매개변수째 찍는다(TypeORM 의 logQueryError) — 실패한 색인 쓰기는 개발 로그에 글이 남을 수 있다
+ */
+export function databaseLogging(
+  isProduction: boolean,
+  nodeEnv: string | undefined,
+): DataSourceOptions['logging'] {
+  if (isProduction || nodeEnv === 'test') return false;
+  return ['error', 'warn', 'migration'];
+}
+
 export function buildDatabaseOptions(): DataSourceOptions {
   const isProduction = isProductionEnv();
   const paths = resolvePaths(__dirname);
@@ -71,8 +84,8 @@ export function buildDatabaseOptions(): DataSourceOptions {
     synchronize: shouldSynchronize(),
     // 운영 배포 시 미적용 마이그레이션을 자동 실행한다
     migrationsRun: isProduction,
-    // SQL 로그는 개발에서만 — 테스트(e2e·CI)는 수천 줄의 쿼리·파라미터(주소 등)가 출력을 덮는다
-    logging: !isProduction && process.env.NODE_ENV !== 'test',
+    // 개발도 쿼리는 남기지 않는다(매개변수에 메일 글 · 주소가 든다) — 오류 · 경고 · 마이그레이션만. 운영 · 시험은 끈다
+    logging: databaseLogging(isProduction, process.env.NODE_ENV),
     extra: { ...POOL_OPTIONS },
     entities: paths.entities,
     migrations: paths.migrations,
diff --git a/backend/src/shared/utils/kst-date.spec.ts b/backend/src/shared/utils/kst-date.spec.ts
index c362734..2fb404a 100644
--- a/backend/src/shared/utils/kst-date.spec.ts
+++ b/backend/src/shared/utils/kst-date.spec.ts
@@ -5,6 +5,7 @@ import {
   formatKstDate,
   formatKstDateEnglish,
   kstEndOfDayAfter,
+  kstMinuteOfDay,
 } from './kst-date';
 
 describe('kstEndOfDayAfter — 한국 날짜 + n일의 끝', () => {
@@ -99,3 +100,13 @@ describe('formatKstDateTime — 알림 메일의 시각 (디자인 README 13단
     );
   });
 });
+
+describe('kstMinuteOfDay — 한국 시각의 하루 몇 분째 (14단계 밤 채우기 창)', () => {
+  it('UTC 에 9시간을 더한 시각의 분이다 — 날이 바뀌어도', () => {
+    expect(kstMinuteOfDay(new Date('2026-11-05T13:00:00Z'))).toBe(22 * 60);
+    expect(kstMinuteOfDay(new Date('2026-11-05T15:00:00Z'))).toBe(0);
+    expect(kstMinuteOfDay(new Date('2026-11-05T17:45:30Z'))).toBe(2 * 60 + 45);
+    expect(kstMinuteOfDay(new Date('2026-11-05T14:59:59.999Z'))).toBe(1439);
+    expect(kstMinuteOfDay(new Date('1969-12-31T14:59:00Z'))).toBe(1439);
+  });
+});
diff --git a/backend/src/shared/utils/kst-date.ts b/backend/src/shared/utils/kst-date.ts
index fbd889a..6bc6643 100644
--- a/backend/src/shared/utils/kst-date.ts
+++ b/backend/src/shared/utils/kst-date.ts
@@ -108,3 +108,13 @@ export function formatKstDateTime(at: Date): string {
   const hour12 = hours % 12 === 0 ? 12 : hours % 12;
   return `${year}년 ${month}월 ${day}일 (${WEEKDAYS_KO[weekday]}) ${period} ${hour12}:${minutes}`;
 }
+
+/** 하루의 분 */
+const MINUTES_PER_DAY = 24 * 60;
+const MS_PER_MINUTE = 60 * 1000;
+
+/** `at` 의 한국 시각이 하루의 몇 분째인가 (0 ~ 1439) — 14단계 검색 색인의 밤 채우기 창 */
+export function kstMinuteOfDay(at: Date): number {
+  const minutes = Math.floor((at.getTime() + KST_OFFSET_MS) / MS_PER_MINUTE);
+  return ((minutes % MINUTES_PER_DAY) + MINUTES_PER_DAY) % MINUTES_PER_DAY;
+}
diff --git a/backend/src/shared/utils/mask.spec.ts b/backend/src/shared/utils/mask.spec.ts
index 4f2f4e7..9713a07 100644
--- a/backend/src/shared/utils/mask.spec.ts
+++ b/backend/src/shared/utils/mask.spec.ts
@@ -15,6 +15,23 @@ describe('maskUrlForLog (로그에 남길 요청 주소)', () => {
     ).toBe('/api/messages?mailboxId=a&q=<26자>');
   });
 
+  it('조건 검색의 칸(from · to · subject · body — 14단계)도 검색어처럼 길이만 남긴다 — 날짜 · 첨부 조건은 그대로', () => {
+    expect(
+      maskUrlForLog(
+        '/api/messages?in=all&from=%EC%9D%B4%EB%8F%84%EC%9C%A4&to=ara.kim%40example.com&subject=%EA%B2%AC%EC%A0%81&body=%EA%B3%84%EC%95%BD&after=2026-10-01T00%3A00%3A00Z&hasAttachment=true',
+      ),
+    ).toBe(
+      '/api/messages?in=all&from=<3자>&to=<19자>&subject=<2자>&body=<2자>&after=2026-10-01T00%3A00%3A00Z&hasAttachment=true',
+    );
+    // 대소문자 · 배열 표기도 같은 이름 · 비슷한 다른 이름은 그대로
+    expect(
+      maskUrlForLog('/api/x?FROM=a&To[]=bb&Subject%5B0%5D=ccc&BODY=dddd'),
+    ).toBe('/api/x?FROM=<1자>&To[]=<2자>&Subject%5B0%5D=<3자>&BODY=<4자>');
+    expect(
+      maskUrlForLog('/api/x?fromDate=1&toDate=2&subjects=3&bodyHtml=4'),
+    ).toBe('/api/x?fromDate=1&toDate=2&subjects=3&bodyHtml=4');
+  });
+
   it('커서는 검색어의 해시(범위 해시)를 담으므로 검색 없는 목록의 커서도 가린다 — 메일함 id 는 그대로', () => {
     expect(
       maskUrlForLog(
diff --git a/backend/src/shared/utils/mask.ts b/backend/src/shared/utils/mask.ts
index 5aa1720..0480d70 100644
--- a/backend/src/shared/utils/mask.ts
+++ b/backend/src/shared/utils/mask.ts
@@ -9,13 +9,15 @@
 const MASK = '***';
 
 /**
- * 값을 남기지 않는 쿼리 이름 — 검색어(q)와 목록 커서(cursor).
+ * 값을 남기지 않는 쿼리 이름 — 검색어(q) · 조건 검색의 칸(from · to · subject · body — 14단계)과 목록 커서(cursor).
  * - q: 메일 검색어 · 받는 사람 추천의 거르는 글자 — 사람 이름·주소가 들어간다 (계약 2절 "검색" · "로그에는 개수만")
+ * - from · to · subject · body: 조건 검색의 보낸 사람 · 받는 사람 · 제목 · 내용 — 검색어와 같다 (14단계 설계 C1)
  * - cursor: 다른 목록의 커서를 막으려고 검색어의 해시(범위 해시)를 담는다 — 로그를 읽는 사람이 후보 검색어를 대입해 맞춰 볼 수 있다
  *   (modules/mail/jmap/jmap-cursor.ts · recipient-suggestion-cursor.ts)
  * 대소문자와 배열 표기(`q[]`·`q[0]`)도 같은 이름으로 본다 — 형식 오류(VAL_001)로 거절된 요청도 로그에는 남는다.
  */
-const REDACTED_QUERY_NAME = /^(?:q|cursor)(?:\[[^\]]*\])*$/i;
+const REDACTED_QUERY_NAME =
+  /^(?:q|from|to|subject|body|cursor)(?:\[[^\]]*\])*$/i;
 
 /** UUID 모양의 경로 조각 — 공개 링크의 파일 id 는 남긴다 */
 const UUID_SEGMENT =
diff --git a/backend/src/shared/utils/search-query.ts b/backend/src/shared/utils/search-query.ts
new file mode 100644
index 0000000..cfa17c8
--- /dev/null
+++ b/backend/src/shared/utils/search-query.ts
@@ -0,0 +1,84 @@
+/**
+ * 검색어 나누기 (순수 함수 — 계약 2절 "검색") — 엔진 검색(modules/mail/jmap/search-terms.ts)과 자체 색인 찾기(modules/mail-search — 14단계)가 함께 쓴다.
+ * 낱말 · 구절로 나누고 앞뒤 문장부호를 뗀다. 엔진 쪽은 여기에 조사 형태를 붙이고, 색인 쪽은 접기(search-text.ts) 뒤 부분 일치로 찾는다.
+ */
+
+/** 검색어의 낱말을 나누는 기준 — 공백 문자(전각 공백·줄바꿈 포함). DTO 의 낱말 수 · 엔진 조건 · 색인 찾기가 같이 쓴다 */
+export const SEARCH_WORD_SEPARATOR = /\s+/u;
+
+/** 큰따옴표 — 감싼 부분은 구절로 찾는다 */
+const QUOTE = '"';
+
+/**
+ * NUL(U+0000) — PostgreSQL 글에 넣을 수 없다(22021). 색인은 저장할 때 U+FFFD 로 1:1 바꾸므로(index-document.ts 의 storableText)
+ * 검색 글도 같게 바꿔 찾는다 (계약 2절 "검색 — 14단계") — 엔진 방식 · 강조도 같은 낱말을 쓴다
+ */
+const NUL = String.fromCharCode(0);
+const REPLACEMENT_CHARACTER = String.fromCharCode(0xfffd);
+
+/**
+ * 찾을 수 있는 글자 — 문자(\p{L}: 한글·자모·영문 등)나 숫자(\p{N}).
+ * 이것이 하나도 없는 낱말·구절(`-` · `…` · 그림 문자뿐)은 버린다 — 엔진은 문장부호를 낱말로 색인하지 않는다
+ */
+const SEARCHABLE_CHARACTER = /[\p{L}\p{N}]/u;
+
+/**
+ * 낱말 앞뒤에 붙은, 문자·숫자가 아닌 글자 — 엔진은 문장부호에서 낱말을 나누므로 떼고 가운데 낱말로 찾는다
+ * ('회의,' · '(회의)' · '회의.' · '“회의”' → '회의' — 그래야 받침을 읽어 '회의를' 도 찾는다). 낱말 가운데의 문장부호('서버-이전')는 그대로 둔다.
+ * 뒤쪽은 "문자·숫자·결합 문자가 아닌 글자 + 그 뒤의 결합 문자" 를 뗀다 — 글자에 붙은 결합 문자(태국어 성조 등)는 남기고,
+ * 그림 문자와 그 이체 선택자(❤️ = U+2764 U+FE0F)는 함께 뗀다.
+ */
+const WORD_EDGE_PUNCTUATION =
+  /^[^\p{L}\p{N}]+|(?:[^\p{L}\p{N}\p{M}]\p{M}*)+$/gu;
+
+/** 낱말 앞뒤의 문장부호·기호를 뗀 가운데 낱말 — 문자·숫자가 없으면 빈 문자열 */
+function coreWord(word: string): string {
+  return word.replace(WORD_EDGE_PUNCTUATION, '');
+}
+
+/** 검색어를 나눈 조각 — 낱말(조사를 붙여 찾는다) · 구절(큰따옴표 안, 그대로 찾는다) */
+export interface SearchTerm {
+  readonly kind: 'word' | 'phrase';
+  readonly text: string;
+}
+
+function splitWords(text: string): string[] {
+  return text.split(SEARCH_WORD_SEPARATOR).filter((word) => word !== '');
+}
+
+/**
+ * 검색어를 낱말·구절로 나눈다 — 나온 순서대로, 같은 낱말·같은 구절은 한 번만.
+ * - 큰따옴표 한 쌍 안은 구절이다 (안의 여러 칸 공백은 한 칸으로)
+ * - 짝이 없는 마지막 큰따옴표는 없는 것으로 본다 — 그 뒤는 따옴표 밖처럼 낱말로 나눈다
+ * - 낱말은 띄어쓰기(공백 문자)로 나눈다 — DTO 가 세는 "낱말 수"와 같은 기준 (SEARCH_WORD_SEPARATOR)
+ * - 낱말 앞뒤의 문장부호·기호는 떼고 가운데 낱말로 찾는다 ('회의,' → '회의', WORD_EDGE_PUNCTUATION). 구절은 그대로 둔다
+ * - 문자·숫자가 하나도 없는 낱말·구절(비어 있음 · `-` · `…` 등)은 버린다 (SEARCHABLE_CHARACTER) —
+ *   남는 것이 없으면 빈 목록이고, 목록 조회는 엔진에 묻지 않고 빈 결과를 돌려준다 (범위 전체를 돌려주지 않는다)
+ * - 유니코드 NFC(완성형)로 정규화한다 — 자모를 풀어 쓴(NFD) 한글을 붙여 넣어도 받침을 읽는다
+ * - NUL 은 U+FFFD 로 1:1 바꾼다 (색인의 저장과 같다 — 위치 · 길이는 그대로)
+ */
+export function parseSearchTerms(query: string): SearchTerm[] {
+  const segments = query
+    .normalize('NFC')
+    .replaceAll(NUL, REPLACEMENT_CHARACTER)
+    .split(QUOTE);
+  const terms: SearchTerm[] = [];
+  const seen = new Set<string>();
+  const add = (kind: SearchTerm['kind'], text: string) => {
+    const key = `${kind}\n${text}`;
+    if (!SEARCHABLE_CHARACTER.test(text) || seen.has(key)) return;
+    seen.add(key);
+    terms.push({ kind, text });
+  };
+
+  segments.forEach((segment, index) => {
+    // 홀수 번째 조각은 따옴표 안이다 — 뒤에 닫는 따옴표가 있을 때만 (마지막 조각이면 짝이 없다)
+    const isPhrase = index % 2 === 1 && index < segments.length - 1;
+    if (isPhrase) {
+      add('phrase', splitWords(segment).join(' '));
+      return;
+    }
+    for (const word of splitWords(segment)) add('word', coreWord(word));
+  });
+  return terms;
+}
diff --git a/backend/src/shared/utils/search-text.spec.ts b/backend/src/shared/utils/search-text.spec.ts
new file mode 100644
index 0000000..e444a9d
--- /dev/null
+++ b/backend/src/shared/utils/search-text.spec.ts
@@ -0,0 +1,130 @@
+import { startCpuTimer } from '@/../test/cpu-time';
+import {
+  FOLD_SAMPLES,
+  GRAM_SAMPLES,
+  MATCH_SAMPLES,
+} from '@/../test/search-text-samples';
+import {
+  MAX_MATCH_RANGES,
+  foldText,
+  gramsOf,
+  isSpaceCode,
+  matchRanges,
+} from './search-text';
+
+describe('foldText (검색의 접기)', () => {
+  it.each(FOLD_SAMPLES)('%j → %j', (input, folded) => {
+    expect(foldText(input)).toBe(folded);
+  });
+
+  it('접은 글은 NFC 원문과 UTF-16 길이가 늘 같다 — 위치를 원문에 그대로 쓴다', () => {
+    for (const [input] of FOLD_SAMPLES) {
+      expect(foldText(input).length).toBe(input.normalize('NFC').length);
+    }
+    // 글자 범위를 훑어 본다 — 소문자가 길이를 바꾸는 글자(İ 등)도 그대로라 길이가 같다
+    const changedLength: number[] = [];
+    for (let code = 0; code <= 0xffff; code += 1) {
+      if (code >= 0xd800 && code <= 0xdfff) continue;
+      const char = String.fromCharCode(code).normalize('NFC');
+      if (foldText(char).length !== char.length) changedLength.push(code);
+    }
+    expect(changedLength).toEqual([]);
+  });
+
+  it('두 번 접어도 같다', () => {
+    for (const [input, folded] of FOLD_SAMPLES) {
+      expect(foldText(folded)).toBe(folded);
+      expect(foldText(foldText(input))).toBe(folded);
+    }
+  });
+
+  it('짝이 없는 서로게이트도 그대로 둔다 (길이가 같다)', () => {
+    expect(foldText('a\ud800B')).toBe('a\ud800b');
+    expect(foldText('\udc00A')).toBe('\udc00a');
+  });
+
+  it('긴 글도 길이에 비례해 접는다', () => {
+    const unit = '계약서 Project ＡＢＣ 회의록 ÀÉÎ ';
+    const small = unit.repeat(2_000);
+    const large = unit.repeat(40_000);
+    const smallCpu = startCpuTimer();
+    foldText(small);
+    const smallMs = smallCpu();
+    const largeCpu = startCpuTimer();
+    expect(foldText(large).length).toBe(large.length);
+    const largeMs = largeCpu();
+    // 20배 입력 — 제곱이면 400배다. 지금 값의 10배쯤을 한도로 둔다 (test/cpu-time.ts)
+    expect(largeMs).toBeLessThan(Math.max(smallMs, 20) * 20 * 10);
+    expect(largeMs).toBeLessThan(5_000);
+  });
+});
+
+describe('gramsOf (글자 두 개 묶음)', () => {
+  it.each(GRAM_SAMPLES)('%j → %j', (fold, grams) => {
+    expect([...gramsOf(fold)]).toEqual(grams);
+  });
+
+  it('주어진 모음에 더한다 — 칸 경계를 넘지 않는다', () => {
+    const into = new Set<string>();
+    gramsOf('회의', into);
+    gramsOf('일정', into);
+    expect([...into]).toEqual(['회의', '일정']);
+    expect(into.has('의일')).toBe(false);
+  });
+
+  it('공백은 정규식 \\s 와 같은 글자다 (검색어 낱말 나누기와 같다)', () => {
+    const differ: number[] = [];
+    for (let code = 0; code <= 0xffff; code += 1) {
+      if (isSpaceCode(code) !== /\s/u.test(String.fromCharCode(code))) {
+        differ.push(code);
+      }
+    }
+    expect(differ).toEqual([]);
+  });
+
+  it('20,000자 본문도 길이에 비례해 묶는다', () => {
+    const body = '계약서를 보내 드립니다 Project plan 회의록 '.repeat(800);
+    const cpu = startCpuTimer();
+    const grams = gramsOf(foldText(body));
+    expect(grams.size).toBeGreaterThan(10);
+    expect(cpu()).toBeLessThan(2_000);
+  });
+});
+
+describe('matchRanges (맞은 곳)', () => {
+  it.each(MATCH_SAMPLES)('%j 에서 %j → %j', (original, terms, ranges) => {
+    expect(matchRanges(original, terms)).toEqual(ranges);
+  });
+
+  it('맞은 곳은 limit 개까지만 모은다 (한 글자 낱말이 흔해도)', () => {
+    // 찾은 자리를 말마다 limit 개까지 모은 뒤 합친다 — 이어진 글이면 앞 limit 자리만큼
+    const text = '가'.repeat(5_000);
+    expect(matchRanges(text, ['가'])).toEqual([[0, MAX_MATCH_RANGES]]);
+    const spaced = '가 '.repeat(5_000);
+    const ranges = matchRanges(spaced, ['가']);
+    expect(ranges).toHaveLength(MAX_MATCH_RANGES);
+    expect(ranges[0]).toEqual([0, 1]);
+    expect(matchRanges(spaced, ['가'], 3)).toEqual([
+      [0, 1],
+      [2, 3],
+      [4, 5],
+    ]);
+  });
+
+  it('긴 글 · 낱말 여럿도 오래 걸리지 않는다', () => {
+    const body = '계약서를 보내 드립니다 Project plan 회의록 '.repeat(800);
+    const cpu = startCpuTimer();
+    const ranges = matchRanges(body, [
+      '계약',
+      'project',
+      '회의',
+      '드립',
+      'plan',
+      '보내',
+      '없는말',
+      '록',
+    ]);
+    expect(ranges.length).toBeGreaterThan(0);
+    expect(cpu()).toBeLessThan(2_000);
+  });
+});
diff --git a/backend/src/shared/utils/search-text.ts b/backend/src/shared/utils/search-text.ts
new file mode 100644
index 0000000..498b512
--- /dev/null
+++ b/backend/src/shared/utils/search-text.ts
@@ -0,0 +1,234 @@
+/**
+ * 메일 검색의 접기(정규화) · 글자 두 개 묶음 · 맞은 곳 (순수 함수 — 14단계 설계 B1).
+ * ⚠️ frontend `shared/utils/search-match.ts` 와 **짝**이다 — 같은 접기 · 같은 위치 규칙, 같은 표본 표(backend `test/search-text-samples.ts` ·
+ *    frontend `src/test-utils/search-text-samples.ts`)를 두 쪽 테스트에 둔다. 한쪽을 고치면 둘 다 고친다.
+ *
+ * 접기(foldText)는 먼저 NFC 로 맞춘 뒤 **코드 포인트 하나씩** 바꾼다 — 전각 ASCII(！ ~ ～) → 반각, 소문자(결과가 코드 포인트 하나이고
+ * UTF-16 길이가 같을 때만 — 'İ' 처럼 늘어나면 그대로), 공백류(줄바꿈 · 탭 · NBSP · U+3000 등 정규식 `\s` 의 글자) → 띄어쓰기(U+0020) 하나.
+ * 그래서 NFC 원문과 접은 글은 코드 포인트 · UTF-16 위치가 같다 → 접은 글에서 찾은 위치를 원문에 그대로 쓴다(강조 · 미리 보기).
+ * NFKC 는 쓰지 않는다 — ㈜ → (주) 처럼 길이를 바꿔 위치를 잃는다. 공백은 1:1 로만 바꾼다(이어진 공백을 하나로 줄이지 않는다) —
+ * 구절 "계약 갱신" 은 줄바꿈으로 갈린 글에도 맞지만, 띄어쓰기 두 칸으로 갈린 글에는 맞지 않는다(알려진 한계).
+ * ⚠️ 접기 · 묶음 규칙을 바꾸면 색인 판(mail-search.constants.ts 의 INDEX_FORMAT)을 올린다 — 옛 판으로 만든 색인은 다시 채운다
+ *
+ * 모든 함수는 입력을 한 번(맞은 곳은 낱말마다 한 번) 훑는다 — 길이에 비례한다.
+ */
+
+/** 전각 ASCII 의 범위와 반각과의 차이 (U+FF01 ！ ~ U+FF5E ～ → U+0021 ~ U+007E) */
+const FULLWIDTH_FIRST = 0xff01;
+const FULLWIDTH_LAST = 0xff5e;
+const FULLWIDTH_OFFSET = 0xfee0;
+
+const ASCII_UPPER_A = 0x41;
+const ASCII_UPPER_Z = 0x5a;
+const ASCII_CASE_OFFSET = 0x20;
+const ASCII_LIMIT = 0x80;
+
+/** 소문자가 따로 없는 큰 묶음 — 한글 음절 · 자모, CJK 한자 · 기호 (toLowerCase 를 부르지 않고 건너뛴다) */
+const HANGUL_JAMO_FIRST = 0x1100;
+const HANGUL_JAMO_LAST = 0x11ff;
+const CJK_FIRST = 0x2e80;
+const CJK_LAST = 0x9fff;
+const HANGUL_SYLLABLE_FIRST = 0xac00;
+const HANGUL_SYLLABLE_LAST = 0xd7a3;
+
+const HIGH_SURROGATE_FIRST = 0xd800;
+const HIGH_SURROGATE_LAST = 0xdbff;
+const LOW_SURROGATE_FIRST = 0xdc00;
+const LOW_SURROGATE_LAST = 0xdfff;
+
+/** 맞은 곳을 이만큼까지만 모은다 — 글이 길고 낱말이 흔하면(한 글자) 끝없이 늘지 않게 */
+export const MAX_MATCH_RANGES = 500;
+
+/** 맞은 곳 — [시작, 끝) UTF-16 위치 */
+export type MatchRange = readonly [start: number, end: number];
+
+function isHighSurrogate(code: number): boolean {
+  return code >= HIGH_SURROGATE_FIRST && code <= HIGH_SURROGATE_LAST;
+}
+
+function isLowSurrogate(code: number): boolean {
+  return code >= LOW_SURROGATE_FIRST && code <= LOW_SURROGATE_LAST;
+}
+
+/** 소문자가 따로 없는 글자인가 (빠른 길 — 한글 · 한자) */
+function hasNoCase(code: number): boolean {
+  return (
+    (code >= HANGUL_SYLLABLE_FIRST && code <= HANGUL_SYLLABLE_LAST) ||
+    (code >= CJK_FIRST && code <= CJK_LAST) ||
+    (code >= HANGUL_JAMO_FIRST && code <= HANGUL_JAMO_LAST)
+  );
+}
+
+/** 공백류를 바꾼 글자 — 띄어쓰기 하나 */
+const SPACE = ' ';
+const SPACE_CODE = 0x20;
+
+/** ASCII 한 글자(코드)의 접기 — 대문자만 소문자로 */
+function foldAsciiCode(code: number): number {
+  return code >= ASCII_UPPER_A && code <= ASCII_UPPER_Z
+    ? code + ASCII_CASE_OFFSET
+    : code;
+}
+
+/**
+ * ASCII 밖 한 코드 포인트의 접기 — 바뀌지 않으면 null.
+ * `char` 는 그 코드 포인트의 글(UTF-16 한두 단위)이다
+ */
+function foldCodePoint(code: number, char: string): string | null {
+  if (code >= FULLWIDTH_FIRST && code <= FULLWIDTH_LAST) {
+    return String.fromCharCode(foldAsciiCode(code - FULLWIDTH_OFFSET));
+  }
+  if (hasNoCase(code)) return null;
+  const lower = char.toLowerCase();
+  if (lower === char || lower.length !== char.length) return null;
+  // 같은 UTF-16 길이여도 코드 포인트가 둘이 될 수 있다(BMP 두 글자) — 하나일 때만
+  const first = lower.codePointAt(0) ?? 0;
+  const firstWidth = first > 0xffff ? 2 : 1;
+  return firstWidth === lower.length ? lower : null;
+}
+
+/**
+ * 찾기 · 색인의 접기 글 — NFC 뒤 코드 포인트 하나씩: 전각 ASCII → 반각, 소문자, 공백류 → 띄어쓰기.
+ * 결과는 `text.normalize('NFC')` 와 UTF-16 길이 · 위치가 같다
+ */
+export function foldText(text: string): string {
+  const source = text.normalize('NFC');
+  let folded = '';
+  let runStart = 0;
+  for (let index = 0; index < source.length; ) {
+    const code = source.charCodeAt(index);
+    let width = 1;
+    let point = code;
+    if (
+      isHighSurrogate(code) &&
+      index + 1 < source.length &&
+      isLowSurrogate(source.charCodeAt(index + 1))
+    ) {
+      width = 2;
+      point = source.codePointAt(index) ?? code;
+    }
+    let replacement: string | null;
+    if (isSpaceCode(code)) {
+      // 공백류는 모두 BMP 의 한 단위다 — 띄어쓰기 하나로 1:1
+      replacement = code === SPACE_CODE ? null : SPACE;
+    } else if (code < ASCII_LIMIT) {
+      const folded = foldAsciiCode(code);
+      replacement = folded === code ? null : String.fromCharCode(folded);
+    } else {
+      replacement = foldCodePoint(point, source.slice(index, index + width));
+    }
+    if (replacement !== null) {
+      folded += source.slice(runStart, index) + replacement;
+      runStart = index + width;
+    }
+    index += width;
+  }
+  return runStart === 0 ? source : folded + source.slice(runStart);
+}
+
+/**
+ * 공백 글자인가 — 낱말 나누기 · 묶음의 경계 (JS 정규식 `\s` 와 같은 글자들: 띄어쓰기 · 탭 · 줄바꿈 · NBSP · 전각 공백 · U+2000~U+200A 등).
+ * 검색어를 낱말로 나누는 기준(SEARCH_WORD_SEPARATOR — `\s+`)과 같다
+ */
+export function isSpaceCode(code: number): boolean {
+  if (code <= 0x20) {
+    return code === 0x20 || (code >= 0x09 && code <= 0x0d);
+  }
+  if (code < 0xa0) return false;
+  return (
+    code === 0xa0 ||
+    code === 0x1680 ||
+    (code >= 0x2000 && code <= 0x200a) ||
+    code === 0x2028 ||
+    code === 0x2029 ||
+    code === 0x202f ||
+    code === 0x205f ||
+    code === 0x3000 ||
+    code === 0xfeff
+  );
+}
+
+/**
+ * 글자 두 개 묶음 — 공백이 아닌 이웃한 코드 포인트 둘을 한 묶음으로, 나온 차례대로 겹치지 않게(같은 묶음은 한 번).
+ * 접은 글(foldText)에 쓴다. 공백을 넘지 않는다 — "회의 일정" → 회의 · 일정. 한 글자 낱말은 묶음이 없다.
+ * `into` 를 주면 거기에 더한다 (색인의 다섯 칸을 한 모음으로 — 칸 경계를 넘지 않는다)
+ */
+export function gramsOf(
+  fold: string,
+  into: Set<string> = new Set(),
+): Set<string> {
+  let previous: string | null = null;
+  for (let index = 0; index < fold.length; ) {
+    const code = fold.charCodeAt(index);
+    const width =
+      isHighSurrogate(code) &&
+      index + 1 < fold.length &&
+      isLowSurrogate(fold.charCodeAt(index + 1))
+        ? 2
+        : 1;
+    if (isSpaceCode(code)) {
+      previous = null;
+    } else {
+      const char = width === 1 ? fold[index] : fold.slice(index, index + 2);
+      if (previous !== null) into.add(previous + char);
+      previous = char;
+    }
+    index += width;
+  }
+  return into;
+}
+
+/** 맞은 곳들을 시작 차례로 놓고 겹치거나 맞닿은 것을 합친다 */
+function mergeRanges(ranges: MatchRange[]): MatchRange[] {
+  ranges.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+  const merged: [number, number][] = [];
+  for (const [start, end] of ranges) {
+    const last = merged[merged.length - 1];
+    if (last && start <= last[1]) {
+      if (end > last[1]) last[1] = end;
+    } else {
+      merged.push([start, end]);
+    }
+  }
+  return merged;
+}
+
+/**
+ * 맞은 곳 — 원문(`original` — NFC 여야 위치가 맞는다)에서 찾는 말들(`terms` — 낱말 · 구절, 접기 전 글)이 나오는 자리를 모두 찾아
+ * 겹치거나 맞닿은 것을 합친 [시작, 끝) 목록(UTF-16, 시작 차례). 같은 접기 · 부분 일치다(찾기와 같다 — 'aa' 는 'aaa' 의 [0, 3)).
+ * 빈 말은 건너뛴다. 찾은 자리는 말마다 `limit`(기본 MAX_MATCH_RANGES)개까지 모으고, 합친 목록도 앞쪽부터 그만큼이다
+ */
+export function matchRanges(
+  original: string,
+  terms: readonly string[],
+  limit: number = MAX_MATCH_RANGES,
+): MatchRange[] {
+  return matchFoldedRanges(foldText(original), foldTerms(terms), limit);
+}
+
+/** 찾는 말들을 접는다 — 같은 말은 한 번, 빈 말은 뺀다 (여러 글에 같은 말을 맞출 때 한 번만 접게) */
+export function foldTerms(terms: readonly string[]): string[] {
+  return [...new Set(terms.map(foldText))].filter((term) => term !== '');
+}
+
+/** matchRanges 의 접은 글 판 — `haystack` 은 foldText 한 글, `terms` 는 foldTerms 한 말 */
+export function matchFoldedRanges(
+  haystack: string,
+  terms: readonly string[],
+  limit: number = MAX_MATCH_RANGES,
+): MatchRange[] {
+  const found: MatchRange[] = [];
+  for (const term of terms) {
+    if (term === '') continue;
+    let count = 0;
+    for (
+      let at = haystack.indexOf(term);
+      at >= 0 && count < limit;
+      at = haystack.indexOf(term, at + 1)
+    ) {
+      found.push([at, at + term.length]);
+      count += 1;
+    }
+  }
+  return mergeRanges(found).slice(0, limit);
+}
diff --git a/backend/src/shared/utils/subject-base.spec.ts b/backend/src/shared/utils/subject-base.spec.ts
new file mode 100644
index 0000000..529c35d
--- /dev/null
+++ b/backend/src/shared/utils/subject-base.spec.ts
@@ -0,0 +1,30 @@
+import { startCpuTimer } from '@/../test/cpu-time';
+import { SUBJECT_BASE_SAMPLES } from '@/../test/search-text-samples';
+import { subjectBase } from './subject-base';
+
+describe('subjectBase (말머리를 뗀 제목)', () => {
+  it.each(SUBJECT_BASE_SAMPLES)('%j → %j', (subject, base) => {
+    expect(subjectBase(subject)).toBe(base);
+  });
+
+  it('답장 · 전달 제목과 원본이 같은 글이 된다', () => {
+    const original = '[공지] 11월 회의 일정';
+    for (const reply of [
+      'Re: [공지] 11월 회의 일정',
+      '회신: [공지] 11월 회의 일정',
+      'RE: 전달: [공지] 11월 회의 일정',
+      'Fwd:[공지]  11월 회의 일정',
+    ]) {
+      expect(subjectBase(reply)).toBe(subjectBase(original));
+    }
+  });
+
+  it('말머리가 아주 많아도 · 닫히지 않은 대괄호가 길어도 길이에 비례한다', () => {
+    const prefixes = 'Re: [a] '.repeat(20_000) + '회의';
+    const open = '['.repeat(100_000);
+    const cpu = startCpuTimer();
+    expect(subjectBase(prefixes)).toBe('회의');
+    expect(subjectBase(open)).toBe(open);
+    expect(cpu()).toBeLessThan(3_000);
+  });
+});
diff --git a/backend/src/shared/utils/subject-base.ts b/backend/src/shared/utils/subject-base.ts
new file mode 100644
index 0000000..d6baeea
--- /dev/null
+++ b/backend/src/shared/utils/subject-base.ts
@@ -0,0 +1,49 @@
+import { foldText, isSpaceCode } from './search-text';
+
+/**
+ * 말머리를 뗀 제목의 접기 글 (순수 함수 — 14단계 설계 B4) — 같은 대화인지 볼 때 제목을 견주는 글이다.
+ * ⚠️ frontend `shared/utils/search-match.ts` 와 짝 — 같은 표본 표(`test/search-text-samples.ts` 의 SUBJECT_BASE_SAMPLES)를 두 쪽에 둔다.
+ *
+ * 차례: 접기(foldText — 소문자 · 전각 → 반각이라 `ＲＥ：` · `［공지］` 도 같다) → 공백을 하나로 · 앞뒤 공백 빼기 →
+ * 앞의 말머리를 여러 겹 뗀다 → 다시 공백 정리.
+ * - 답장 · 전달 말머리: `re` · `fw` · `fwd` · `aw` · `wg` · `회신` · `답장` · `전달` (대소문자 없이) — 뒤에 `[2]` · `(2)` 같은 수가 붙어도,
+ *   쌍점 앞에 공백이 있어도 된다. 쌍점은 꼭 있어야 한다(`Reply to` 는 떼지 않는다)
+ * - 대괄호 꼬리표: `[…]` (첫 `]` 까지)
+ * 엔진(Stalwart 0.16.27)은 `회신:` · `답장:` · `전달:` 을 떼지 않아 한국어 Outlook 의 답장이 따로 떨어진다(2026-11-03 실측) — 우리 규칙은 이것도 뗀다.
+ * 다 떼어 빈 글이 되어도 그대로 빈 글이다(빈 제목의 답장과 원본이 같다).
+ *
+ * 한 번 훑는다 — 말머리를 떼는 고리는 늘 앞으로만 간다(길이에 비례).
+ */
+
+/** 앞의 말머리 하나 — 답장 · 전달 말머리 또는 대괄호 꼬리표, 뒤의 공백까지 (접은 글 — 소문자 · 반각) */
+const LEADING_PREFIX =
+  /(?:(?:re|fwd|fw|aw|wg|회신|답장|전달) ?(?:\[\d{1,4}\]|\(\d{1,4}\))? ?:|\[[^\]]*\]) ?/uy;
+
+/** 공백 글자의 이어짐을 띄어쓰기 하나로 · 앞뒤 공백 빼기 (search-text.ts 의 isSpaceCode — 낱말 나누기와 같은 공백) */
+function collapseSpaces(text: string): string {
+  let collapsed = '';
+  let pendingSpace = false;
+  for (let index = 0; index < text.length; index += 1) {
+    if (isSpaceCode(text.charCodeAt(index))) {
+      pendingSpace = collapsed !== '';
+      continue;
+    }
+    if (pendingSpace) collapsed += ' ';
+    pendingSpace = false;
+    collapsed += text[index];
+  }
+  return collapsed;
+}
+
+export function subjectBase(subject: string): string {
+  const text = collapseSpaces(foldText(subject));
+  // 붙은 자리(sticky)에서만 맞춘다 — 뗄 때마다 글을 자르지 않고 자리만 옮긴다
+  let position = 0;
+  for (;;) {
+    LEADING_PREFIX.lastIndex = position;
+    const prefix = LEADING_PREFIX.exec(text);
+    if (!prefix || prefix[0] === '') break;
+    position += prefix[0].length;
+  }
+  return text.slice(position).trim();
+}
diff --git a/backend/test/app.e2e-spec.ts b/backend/test/app.e2e-spec.ts
index 517c3b5..12fe445 100644
--- a/backend/test/app.e2e-spec.ts
+++ b/backend/test/app.e2e-spec.ts
@@ -12,6 +12,7 @@ import request from 'supertest';
 import type { Response, Test as HttpTest } from 'supertest';
 import { App } from 'supertest/types';
 import { DataSource } from 'typeorm';
+import { SchedulerRegistry } from '@nestjs/schedule';
 
 import { AppModule } from '@/app.module';
 import { configureApp, createHttpAdapter } from '@/app.setup';
@@ -122,6 +123,22 @@ import {
   SIGNATURE_IMAGE_MAX_BYTES,
 } from '@/modules/mail-signature/mail-signature.constants';
 import { MailSignatureRepository } from '@/modules/mail-signature/mail-signature.repository';
+import {
+  MAIL_INDEX_SOURCE,
+  type IndexDocument,
+  type MailIndexSource,
+} from '@/modules/mail-search/mail-index-source';
+import { MailSearchBuildService } from '@/modules/mail-search/mail-search-build.service';
+import type { SearchScope } from '@/modules/mail-search/mail-search.types';
+import { MailSearchIndexRepository } from '@/modules/mail-search/mail-search-index.repository';
+import { PLANNER_SETTINGS } from '@/modules/mail-search/mail-search-query.service';
+import {
+  INDEX_FORMAT,
+  SEARCH_CHECK_ROWS_LIMIT,
+} from '@/modules/mail-search/mail-search.constants';
+import { toIndexRow } from '@/modules/mail-search/index-document';
+import { planSearch } from '@/modules/mail-search/search-plan';
+import { candidatesSql } from '@/modules/mail-search/search-sql';
 import {
   SystemSettingsService,
   type SystemSettingsPatch,
@@ -212,6 +229,8 @@ const MAIL_STATE = 'c2Iy.c2Fq';
 
 /** 대역 메일 엔진이 "없는 메일함"으로 답하는 이동 대상 (404 RES_001 경로) */
 const MISSING_MAILBOX = 'nomailbox';
+/** 대역 엔진에 없는 메일 (14단계 3차 — 같은 대화의 404) */
+const MISSING_MESSAGE = 'nosuchmail';
 
 /** 대역 메일 엔진이 "그사이 지워졌다"고 답하는 메일 id (failedIds · skippedIds 경로) */
 const GONE_MESSAGE = 'gonemessage';
@@ -533,6 +552,139 @@ const testFileStorageSettings = (dir: string): FileStorageSettings => ({
   clamav: null,
 });
 
+/**
+ * 14단계 — 검색 색인의 대역 엔진: 직원마다 메일 글과 state. 실제 엔진 읽기(JMAP)는 jmap-index-source.spec.ts 가 본다.
+ * 넣지 않은 직원은 엔진 장애(MAIL_001)로 답한다 — 개발 DB 를 함께 쓰는 실제 직원의 줄을 대역으로 채우지 않게
+ */
+class FakeIndexSource implements MailIndexSource {
+  readonly mailboxes = new Map<
+    string,
+    { state: string; emails: IndexDocument[] }
+  >();
+
+  private mailbox(user: string) {
+    const found = this.mailboxes.get(user);
+    if (!found) {
+      throw new BusinessException('MAIL_001', {
+        context: { reason: 'e2e-unknown-index-user' },
+      });
+    }
+    return found;
+  }
+
+  snapshot(user: string) {
+    const { state, emails } = this.mailbox(user);
+    return Promise.resolve({ state, total: emails.length });
+  }
+
+  changes(user: string, sinceState: string) {
+    const { state } = this.mailbox(user);
+    // 같은 state 면 변화 없음, 다르면 셀 수 없음(전체 대조로)
+    return Promise.resolve(
+      sinceState === state
+        ? {
+            kind: 'changes' as const,
+            created: [],
+            updated: [],
+            destroyed: [],
+            newState: state,
+            hasMore: false,
+          }
+        : { kind: 'cannotCalculate' as const },
+    );
+  }
+
+  documents(user: string, ids: readonly string[]) {
+    const { emails } = this.mailbox(user);
+    return Promise.resolve(emails.filter((email) => ids.includes(email.id)));
+  }
+
+  mutable(user: string, ids: readonly string[]) {
+    return this.documents(user, ids);
+  }
+
+  pageIds(
+    user: string,
+    from: { anchor: string | null; position: number },
+    limit: number,
+  ) {
+    const ids = this.newestFirst(user);
+    const anchorAt = from.anchor === null ? -1 : ids.indexOf(from.anchor);
+    const start = anchorAt >= 0 ? anchorAt + 1 : from.position;
+    return Promise.resolve({
+      ids: ids.slice(start, start + limit),
+      position: start,
+      total: ids.length,
+    });
+  }
+
+  allIds(user: string) {
+    const { state } = this.mailbox(user);
+    return Promise.resolve({ state, ids: this.newestFirst(user) });
+  }
+
+  private newestFirst(user: string): string[] {
+    return [...this.mailbox(user).emails]
+      .sort((a, b) => Date.parse(b.receivedAt) - Date.parse(a.receivedAt))
+      .map((email) => email.id);
+  }
+}
+
+/** 14단계 — 색인에 넣을 메일 한 통 (대역) */
+function indexDocument(overrides: Partial<IndexDocument>): IndexDocument {
+  return {
+    id: 'e2e-mail',
+    threadId: 'e2e-thread',
+    mailboxIds: ['inbox'],
+    keywords: [],
+    receivedAt: '2026-11-05T01:00:00Z',
+    size: 100,
+    messageIds: [],
+    inReplyTo: [],
+    references: [],
+    subject: '',
+    from: [{ name: '이도윤', email: 'doyun.lee@e2e.arasystem.test' }],
+    to: [],
+    cc: [],
+    attachmentNames: [],
+    hasAttachment: false,
+    preview: '',
+    bodyText: '',
+    ...overrides,
+  };
+}
+
+/** 대역 엔진이 색인 검색에서 빼는 메일함 (휴지통 · 스팸메일함 역할 — 14단계 2차) */
+const SEARCH_EXCLUDED_MAILBOX = 'idxtrash';
+
+/** 색인 문서의 주소 → 요약의 주소 (주소가 없는 것은 뺀다) */
+function mailAddressesOf(
+  addresses: readonly { name: string | null; email: string | null }[],
+): { name: string | null; email: string }[] {
+  return addresses.flatMap(({ name, email }) =>
+    email === null ? [] : [{ name, email }],
+  );
+}
+
+/** 대역 엔진의 요약 — 색인 문서와 같은 메일 (14단계 2차 — 색인으로 찾은 쪽의 요약은 엔진에서 읽는다) */
+function summaryOfDocument(document: IndexDocument): MessageSummary {
+  return {
+    id: document.id,
+    threadId: document.threadId ?? document.id,
+    mailboxIds: [...document.mailboxIds],
+    from: mailAddressesOf(document.from)[0] ?? null,
+    to: mailAddressesOf(document.to),
+    subject: document.subject,
+    preview: document.preview,
+    receivedAt: new Date(document.receivedAt).toISOString(),
+    isRead: document.keywords.includes('$seen'),
+    isFlagged: document.keywords.includes('$flagged'),
+    hasAttachment: document.hasAttachment,
+    size: document.size,
+    pendingSend: null,
+  };
+}
+
 /** 목록 응답의 data — 계약의 { items, pageInfo } */
 interface Page<T> {
   items: T[];
@@ -644,6 +796,21 @@ describe('응답 계약 (e2e)', () => {
 
   /** 대역 엔진이 받은 메일 목록 요청 (검색 범위·검색어 확인용) */
   const listQueries: { user: string; query: MessageListQuery }[] = [];
+  /** 14단계 2차 — 대역 엔진이 받은 요약 요청 (색인으로 찾은 쪽) */
+  const summaryRequests: { user: string; ids: readonly string[] }[] = [];
+  /** 14단계 3차 — 대역 엔진이 받은 대화 요청 (엔진의 스레드 — 색인 전) */
+  const engineConversations: {
+    user: string;
+    emailId: string;
+    page: { limit: number; cursor?: string };
+  }[] = [];
+  const engineConversationLists: {
+    user: string;
+    query: { mailboxId: string; limit: number; cursor?: string };
+  }[] = [];
+  /** 14단계 3차 리뷰 L6 — 대역 엔진의 붙잡힌 메일(보내기 취소 · 예약을 기다리는) id 와 그것을 함께 읽은 요약 요청 */
+  const fakeHeldIds = new Set<string>();
+  const heldSummaryRequests: { user: string; ids: readonly string[] }[] = [];
   /** 대역 엔진이 받은 여러 통 바꾸기 · 휴지통에서 영구 삭제 */
   const bulkUpdates: {
     user: string;
@@ -967,6 +1134,9 @@ describe('응답 계약 (e2e)', () => {
   const rotated = (res: Response) =>
     cookieValue(setCookie(res, 'refresh_token'));
 
+  /** 14단계 — 검색 색인의 대역 엔진 */
+  const fakeIndexSource = new FakeIndexSource();
+
   beforeAll(async () => {
     fileDir = mkdtempSync(join(tmpdir(), 'arasystem-e2e-files-'));
     const moduleFixture: TestingModule = await Test.createTestingModule({
@@ -1163,6 +1333,111 @@ describe('응답 계약 (e2e)', () => {
             total: 0,
           });
         },
+        // 14단계 2차 — 색인 검색의 범위 · 찾은 쪽의 요약 (엔진 쪽 판단은 jmap-mail.provider.spec.ts 가 본다)
+        searchScope: (
+          _user: string,
+          mailboxId?: string,
+        ): Promise<SearchScope> => {
+          if (mailboxId === MISSING_MAILBOX) {
+            return Promise.reject(
+              new BusinessException('RES_001', {
+                context: { reason: 'e2e-mailbox-not-found' },
+              }),
+            );
+          }
+          return Promise.resolve(
+            mailboxId === undefined
+              ? {
+                  mailboxId: null,
+                  excludedMailboxIds: [SEARCH_EXCLUDED_MAILBOX],
+                  excludedKeywords: ['$ara-sending'],
+                }
+              : {
+                  mailboxId,
+                  excludedMailboxIds: [],
+                  excludedKeywords: ['$ara-sending'],
+                },
+          );
+        },
+        // 14단계 3차 — 대화의 범위(늘 휴지통을 뺀다) · 엔진의 스레드로 본 대화(색인 전 — 받은 것만 적는다)
+        conversationScope: (
+          _user: string,
+          mailboxId?: string,
+        ): Promise<SearchScope> =>
+          mailboxId === MISSING_MAILBOX
+            ? Promise.reject(
+                new BusinessException('RES_001', {
+                  context: { reason: 'e2e-mailbox-not-found' },
+                }),
+              )
+            : Promise.resolve({
+                mailboxId: mailboxId ?? null,
+                excludedMailboxIds: [SEARCH_EXCLUDED_MAILBOX],
+                excludedKeywords: ['$ara-sending'],
+              }),
+        getConversation: (
+          user: string,
+          emailId: string,
+          page: { limit: number; cursor?: string },
+        ) => {
+          engineConversations.push({ user, emailId, page });
+          return emailId === MISSING_MESSAGE
+            ? Promise.reject(
+                new BusinessException('RES_001', {
+                  context: { reason: 'e2e-message-not-found' },
+                }),
+              )
+            : Promise.resolve({
+                items: [],
+                hasNext: false,
+                nextCursor: null,
+                total: 0,
+              });
+        },
+        listConversations: (
+          user: string,
+          query: { mailboxId: string; limit: number; cursor?: string },
+        ) => {
+          engineConversationLists.push({ user, query });
+          return query.mailboxId === MISSING_MAILBOX
+            ? Promise.reject(
+                new BusinessException('RES_001', {
+                  context: { reason: 'e2e-mailbox-not-found' },
+                }),
+              )
+            : Promise.resolve({
+                items: [],
+                hasNext: false,
+                nextCursor: null,
+                total: 0,
+              });
+        },
+        getSummaries: (
+          user: string,
+          ids: readonly string[],
+        ): Promise<MessageSummary[]> => {
+          summaryRequests.push({ user, ids });
+          const emails = fakeIndexSource.mailboxes.get(user)?.emails ?? [];
+          const byId = new Map(emails.map((email) => [email.id, email]));
+          return Promise.resolve(
+            ids.flatMap((id) => {
+              const email = byId.get(id);
+              return email ? [summaryOfDocument(email)] : [];
+            }),
+          );
+        },
+        getSummariesWithHeld: (user: string, ids: readonly string[]) => {
+          heldSummaryRequests.push({ user, ids });
+          const emails = fakeIndexSource.mailboxes.get(user)?.emails ?? [];
+          const byId = new Map(emails.map((email) => [email.id, email]));
+          return Promise.resolve({
+            summaries: ids.flatMap((id) => {
+              const email = byId.get(id);
+              return email ? [summaryOfDocument(email)] : [];
+            }),
+            heldIds: new Set(fakeHeldIds),
+          });
+        },
         updateMessages: (
           user: string,
           ids: readonly string[],
@@ -1599,6 +1874,9 @@ describe('응답 계약 (e2e)', () => {
       .useValue(fakeAccountSecurityProvider)
       .overrideProvider(ACCOUNT_SECURITY_SETTINGS)
       .useValue(TEST_ACCOUNT_SECURITY_SETTINGS)
+      // 14단계 — 검색 색인의 엔진 읽기는 대역으로
+      .overrideProvider(MAIL_INDEX_SOURCE)
+      .useValue(fakeIndexSource)
       .compile();
 
     // CI 의 빈 DB 에도 표가 있어야 한다 — 운영처럼 마이그레이션으로 만든다 (synchronize 를 켜지 않는다)
@@ -1614,6 +1892,13 @@ describe('응답 계약 (e2e)', () => {
     configureApp(app);
 
     await app.init();
+    // 14단계 — 검색 색인의 5분 맞추기 · 1분 채우기는 돌리지 않는다 — 테스트가 직접 부른다.
+    // 거꾸로 같은 DB 를 쓰는 개발 서버(개발 PC 에서만 — CI 에는 없다)의 cron 은 사내 도메인(arasystem.test) 주소만 맞추고 채우므로
+    // 이 시험의 줄(e2e.arasystem.test)을 건드리지 않는다 (MailSearchSyncService.isIndexedAddress)
+    const scheduler = app.get(SchedulerRegistry);
+    for (const name of ['mail-search-sync', 'mail-search-build']) {
+      void scheduler.getCronJob(name).stop();
+    }
     server = app.getHttpServer();
     jwt = app.get(JwtService, { strict: false });
     authSettings = app.get<AuthSettings>(AUTH_SETTINGS, { strict: false });
@@ -1645,6 +1930,9 @@ describe('응답 계약 (e2e)', () => {
       'DELETE FROM login_events WHERE user_email LIKE $1',
       'DELETE FROM app_password_usages WHERE user_email LIKE $1',
       'DELETE FROM two_factor_settings WHERE user_email LIKE $1',
+      // 14단계 — 검색 색인 (로그인하면 상태 줄이 생긴다)
+      'DELETE FROM mail_search_messages WHERE user_email LIKE $1',
+      'DELETE FROM mail_search_states WHERE user_email LIKE $1',
     ]) {
       await dataSource.query(statement, [TEST_DOMAIN_PATTERN]);
     }
@@ -5042,7 +5330,11 @@ describe('응답 계약 (e2e)', () => {
 
         expect(body(res)).toEqual({
           success: true,
-          data: { undoSendSeconds: 10, externalImages: 'ask' },
+          data: {
+            undoSendSeconds: 10,
+            externalImages: 'ask',
+            groupByConversation: false,
+          },
         });
       });
 
@@ -5053,6 +5345,7 @@ describe('응답 계약 (e2e)', () => {
         expect(dataOf<unknown>(first)).toEqual({
           undoSendSeconds: 10,
           externalImages: 'always',
+          groupByConversation: false,
         });
 
         const second = await patchSettings(ME, { undoSendSeconds: 30 }).expect(
@@ -5061,6 +5354,7 @@ describe('응답 계약 (e2e)', () => {
         expect(dataOf<unknown>(second)).toEqual({
           undoSendSeconds: 30,
           externalImages: 'always',
+          groupByConversation: false,
         });
 
         const read = await request(server)
@@ -5070,6 +5364,7 @@ describe('응답 계약 (e2e)', () => {
         expect(dataOf<unknown>(read)).toEqual({
           undoSendSeconds: 30,
           externalImages: 'always',
+          groupByConversation: false,
         });
         const rows: {
           undo_send_seconds: number;
@@ -5083,6 +5378,40 @@ describe('응답 계약 (e2e)', () => {
         ]);
       });
 
+      it('대화로 묶어 보기(14단계) — 처음 끔, PATCH 로 켜고 끄며 다른 칸은 그대로 · DB 의 열에 저장', async () => {
+        const GROUP = 'settings.group@e2e.arasystem.test';
+        const on = await patchSettings(GROUP, {
+          groupByConversation: true,
+        }).expect(200);
+        expect(dataOf<unknown>(on)).toEqual({
+          undoSendSeconds: 10,
+          externalImages: 'ask',
+          groupByConversation: true,
+        });
+        const read = await request(server)
+          .get('/api/mail-settings')
+          .set('Cookie', cookieOf(GROUP))
+          .expect(200);
+        expect(dataOf<{ groupByConversation: boolean }>(read)).toMatchObject({
+          groupByConversation: true,
+        });
+        const [row]: { group_by_conversation: boolean }[] =
+          await dataSource.query(
+            'SELECT group_by_conversation FROM mail_settings WHERE user_email = $1',
+            [GROUP],
+          );
+        expect(row).toEqual({ group_by_conversation: true });
+        const off = await patchSettings(GROUP, {
+          groupByConversation: false,
+          undoSendSeconds: 5,
+        }).expect(200);
+        expect(dataOf<unknown>(off)).toEqual({
+          undoSendSeconds: 5,
+          externalImages: 'ask',
+          groupByConversation: false,
+        });
+      });
+
       it.each<[string, object]>([
         ['빈 본문(하나 이상)', {}],
         ['고를 수 없는 초', { undoSendSeconds: 7 }],
@@ -5090,6 +5419,8 @@ describe('응답 계약 (e2e)', () => {
         ['null 초', { undoSendSeconds: null }],
         ['모르는 외부 이미지 값', { externalImages: 'never' }],
         ['null 외부 이미지', { externalImages: null }],
+        ['글로 쓴 대화로 묶기', { groupByConversation: 'true' }],
+        ['null 대화로 묶기', { groupByConversation: null }],
         ['모르는 칸', { theme: 'dark' }],
       ])('잘못된 본문은 400 VAL_001 — %s', async (_label, payload) => {
         const res = await patchSettings(ME, payload).expect(400);
@@ -7573,6 +7904,1352 @@ describe('응답 계약 (e2e)', () => {
     });
   });
 
+  describe('14단계 1차 — 검색 색인 바탕 (GET /api/search-index · 색인 표 · 채우기)', () => {
+    const ME = 'search.index@e2e.arasystem.test';
+    const OTHER = 'search.other@e2e.arasystem.test';
+    const FROM_IP = '198.51.100.140';
+
+    const signIn = async (email: string) => {
+      const res = await request(server)
+        .post('/api/auth/login')
+        .set('X-Forwarded-For', FROM_IP)
+        .send({ email, password: CORRECT_PASSWORD })
+        .expect(200);
+      return `access_token=${cookieValue(setCookie(res, 'access_token'))}`;
+    };
+    const statusOf = (cookie: string) =>
+      request(server).get('/api/search-index').set('Cookie', cookie);
+
+    afterEach(async () => {
+      fakeIndexSource.mailboxes.clear();
+      for (const table of ['mail_search_messages', 'mail_search_states']) {
+        await dataSource.query(
+          `DELETE FROM "${table}" WHERE user_email = ANY($1::text[])`,
+          [[ME, OTHER]],
+        );
+      }
+    });
+
+    it('로그인하면 상태 줄이 building 으로 생긴다 — 준비 상태는 { building, 0, null } · 로그인 없이는 401 AUTH_001', async () => {
+      const cookie = await signIn(ME);
+      const rows: { status: string; email_state: string | null }[] =
+        await dataSource.query(
+          'SELECT status, email_state FROM mail_search_states WHERE user_email = $1',
+          [ME],
+        );
+      expect(rows).toEqual([{ status: 'building', email_state: null }]);
+
+      const res = await statusOf(cookie).expect(200);
+      expect(dataOf(res)).toEqual({ status: 'building', done: 0, total: null });
+
+      const anonymous = await request(server)
+        .get('/api/search-index')
+        .expect(401);
+      expect(body(anonymous).error?.code).toBe('AUTH_001');
+    });
+
+    it('상태 줄이 없던 직원은 준비 상태를 물을 때 만든다 · 멈춘 줄은 로그인하면 푼다', async () => {
+      // 세션 없이 서명만 맞춘 쿠키 — 로그인을 거치지 않았다
+      await statusOf(cookieOf(OTHER)).expect(200);
+      await dataSource.query(
+        `UPDATE mail_search_states SET paused_reason = 'locked', failure_count = 3 WHERE user_email = $1`,
+        [OTHER],
+      );
+      await signIn(OTHER);
+      const rows: { paused_reason: string | null; failure_count: number }[] =
+        await dataSource.query(
+          'SELECT paused_reason, failure_count FROM mail_search_states WHERE user_email = $1',
+          [OTHER],
+        );
+      expect(rows).toEqual([{ paused_reason: null, failure_count: 0 }]);
+    });
+
+    it('채우기 → ready — 색인 줄의 글자 두 개 묶음(GIN)과 접기 글(strpos)로 부분 일치를 찾는다 (실제 PostgreSQL)', async () => {
+      const cookie = await signIn(ME);
+      fakeIndexSource.mailboxes.set(ME, {
+        state: 's1',
+        emails: [
+          indexDocument({
+            id: 'm-contract',
+            subject: 'Re: [공지] 11월 계약서',
+            bodyText: '계약서를 보내 드립니다. Project PLAN 첨부',
+            attachmentNames: ['계약서.PDF'],
+            hasAttachment: true,
+            mailboxIds: ['inbox', 'archive'],
+            keywords: ['$seen'],
+            receivedAt: '2026-11-04T01:00:00Z',
+          }),
+          indexDocument({
+            id: 'm-meeting',
+            subject: '회의록',
+            bodyText: '내일 회의는 3층 회의실',
+            receivedAt: '2026-11-05T01:00:00Z',
+          }),
+        ],
+      });
+
+      const build = app.get(MailSearchBuildService);
+      // 마무리(따라잡기 · 대조)는 남은 시간이 FINISH_MIN_REMAINING_MS 이상일 때만 시작한다 — 넉넉히
+      expect(await build.build(ME, Date.now() + 120_000)).toBe('ready');
+      expect(dataOf(await statusOf(cookie).expect(200))).toEqual({
+        status: 'ready',
+        done: 2,
+        total: 2,
+      });
+
+      const find = async (column: string, word: string, grams: string[]) =>
+        (
+          await dataSource.query<{ email_id: string }[]>(
+            `SELECT email_id FROM mail_search_messages WHERE user_email = $1 AND grams @> $2::text[] AND strpos(${column}, $3) > 0 ORDER BY received_at DESC`,
+            [ME, grams, word],
+          )
+        ).map((row) => row.email_id);
+      // 붙여 쓴 말 · 앞부분 · 말머리 · 대소문자
+      expect(await find('fold_body', '계약', ['계약'])).toEqual(['m-contract']);
+      expect(await find('fold_body', 'proj', ['pr', 'ro', 'oj'])).toEqual([
+        'm-contract',
+      ]);
+      expect(await find('fold_subject', '공지', ['공지'])).toEqual([
+        'm-contract',
+      ]);
+      expect(await find('fold_attachment', '.pdf', ['.p', 'pd', 'df'])).toEqual(
+        ['m-contract'],
+      );
+      expect(await find('fold_body', '회의', ['회의'])).toEqual(['m-meeting']);
+      // 메일함 범위(GIN) · 배열 칸이 그대로 들어갔다
+      const inArchive: { email_id: string; keywords: string[] }[] =
+        await dataSource.query(
+          `SELECT email_id, keywords FROM mail_search_messages WHERE user_email = $1 AND mailbox_ids && $2::text[]`,
+          [ME, ['archive']],
+        );
+      expect(inArchive).toEqual([
+        { email_id: 'm-contract', keywords: ['$seen'] },
+      ]);
+    });
+
+    it('표 쓰기 — 넣기 · 메일함 · 키워드만 바꾸기(한 문장) · 지우기, 상태 줄이 없으면 아무것도 쓰지 않는다', async () => {
+      await statusOf(cookieOf(OTHER)).expect(200);
+      const repository = app.get(MailSearchIndexRepository);
+      const now = new Date();
+      const row = toIndexRow(indexDocument({ id: 'w1', subject: '견적' }));
+
+      expect(
+        (
+          await repository.write(
+            OTHER,
+            { upserts: [row, { ...row, emailId: 'w2' }] },
+            now,
+          )
+        ).written,
+      ).toBe(true);
+      const updated = await repository.write(
+        OTHER,
+        {
+          updates: [
+            {
+              id: 'w1',
+              mailboxIds: ['trash'],
+              keywords: ['$seen', '$flagged'],
+            },
+            { id: 'not-indexed', mailboxIds: ['inbox'], keywords: [] },
+          ],
+          deletes: ['w2'],
+          state: { emailState: 's9', lastSyncedAt: now },
+        },
+        now,
+      );
+      expect([...updated.updatedIds]).toEqual(['w1']);
+      expect(await repository.indexedIds(OTHER)).toEqual(['w1']);
+      expect([...(await repository.existingIds(OTHER, ['w1', 'w2']))]).toEqual([
+        'w1',
+      ]);
+      const [stored]: { mailbox_ids: string[]; keywords: string[] }[] =
+        await dataSource.query(
+          'SELECT mailbox_ids, keywords FROM mail_search_messages WHERE user_email = $1',
+          [OTHER],
+        );
+      expect(stored).toEqual({
+        mailbox_ids: ['trash'],
+        keywords: ['$seen', '$flagged'],
+      });
+      expect((await repository.findState(OTHER))?.emailState).toBe('s9');
+      expect(await repository.recordFailure(OTHER, now)).toBe(1);
+
+      // 퇴사 마무리처럼 상태 줄 → 색인 줄을 지우면, 뒤늦은 쓰기는 아무것도 하지 않는다
+      await dataSource.query(
+        'DELETE FROM mail_search_states WHERE user_email = $1',
+        [OTHER],
+      );
+      await dataSource.query(
+        'DELETE FROM mail_search_messages WHERE user_email = $1',
+        [OTHER],
+      );
+      expect(
+        (await repository.write(OTHER, { upserts: [row] }, now)).written,
+      ).toBe(false);
+      expect(await repository.countMessages(OTHER)).toBe(0);
+    });
+  });
+
+  describe('14단계 2차 — 색인으로 찾기 · 조건 · 강조 (GET /api/messages · GET /api/messages/{id})', () => {
+    const ME = 'search.query@e2e.arasystem.test';
+    const SEOJUN = { name: '박서준', email: 'seojun.park@e2e.arasystem.test' };
+    const DOCUMENTS = [
+      indexDocument({
+        id: 'm-meeting',
+        subject: '회의 일정',
+        bodyText: '내일 회의는 3층 회의실에서 합니다',
+        preview: '내일 회의는 3층 회의실에서 합니다',
+        from: [SEOJUN],
+        to: [{ name: '김아라', email: ME }],
+        receivedAt: '2026-11-05T01:00:00Z',
+      }),
+      indexDocument({
+        id: 'm-contract',
+        subject: '[공지] 11월 계약서',
+        bodyText: '계약서를 보내 드립니다. 갱신 일정은 다음 주입니다.',
+        preview: '계약서를 보내 드립니다.',
+        attachmentNames: ['계약서.PDF'],
+        hasAttachment: true,
+        cc: [{ name: 'Partner', email: 'partner@example.com' }],
+        receivedAt: '2026-11-04T01:00:00Z',
+      }),
+      indexDocument({
+        id: 'm-renewal',
+        subject: '회의록',
+        bodyText: '계약 갱신 회의 내용을 정리했습니다',
+        preview: '계약 갱신 회의 내용을 정리했습니다',
+        receivedAt: '2026-11-03T01:00:00Z',
+      }),
+      indexDocument({
+        id: 'm-floor',
+        subject: '7층 공사 안내',
+        bodyText: '공사 기간 동안 엘리베이터를 쓸 수 없습니다',
+        receivedAt: '2026-11-02T01:00:00Z',
+      }),
+      // 휴지통에만 든 메일 — 메일함을 정하지 않은 검색에서 빠진다
+      indexDocument({
+        id: 'm-trash',
+        subject: '지난 계약 해지',
+        bodyText: '계약 해지 통보',
+        mailboxIds: [SEARCH_EXCLUDED_MAILBOX],
+        receivedAt: '2026-11-01T01:00:00Z',
+      }),
+      // 답장 — 내 글 아래에 원문 인용(> 줄)이 있다 (미리 보기 고르기 — 2026-11-06 사용자 관점 점검)
+      indexDocument({
+        id: 'm-reply',
+        subject: 'RE: 해오름 프로젝트 안내',
+        bodyText:
+          '네, 받았습니다. 금요일까지 확인하겠습니다.\n\n> 원본 메일\n> 해오름 프로젝트 R9A51 자료를 보냅니다.',
+        preview:
+          '네, 받았습니다. 금요일까지 확인하겠습니다. > 원본 메일 > 해오름 프로젝트 R9A51 자료를 보냅니다.',
+        receivedAt: '2026-10-30T01:00:00Z',
+      }),
+    ];
+
+    interface ListItem {
+      id: string;
+      subject: string;
+      searchHighlight: {
+        subject: [number, number][];
+        preview: { text: string; ranges: [number, number][] };
+      } | null;
+    }
+
+    const list = (params: Record<string, string | number>) =>
+      request(server)
+        .get('/api/messages')
+        .query(params)
+        .set('Cookie', cookieOf(ME));
+    const idsOf = async (params: Record<string, string | number>) =>
+      dataOf<Page<ListItem>>(await list(params).expect(200)).items.map(
+        (item) => item.id,
+      );
+    const setStatus = (status: 'ready' | 'building') =>
+      dataSource.query(
+        'UPDATE mail_search_states SET status = $2 WHERE user_email = $1',
+        [ME, status],
+      );
+
+    beforeAll(async () => {
+      // 상태 줄은 준비 상태를 물을 때 생긴다 — 채우기로 ready (색인 판은 지금 판)
+      await request(server)
+        .get('/api/search-index')
+        .set('Cookie', cookieOf(ME))
+        .expect(200);
+      fakeIndexSource.mailboxes.set(ME, { state: 'q1', emails: DOCUMENTS });
+      const build = app.get(MailSearchBuildService);
+      expect(await build.build(ME, Date.now() + 120_000)).toBe('ready');
+    });
+
+    afterAll(async () => {
+      fakeIndexSource.mailboxes.delete(ME);
+      for (const table of ['mail_search_messages', 'mail_search_states']) {
+        await dataSource.query(`DELETE FROM "${table}" WHERE user_email = $1`, [
+          ME,
+        ]);
+      }
+    });
+
+    it('색인이 준비되면 부분 일치로 찾는다 — 휴지통 · 스팸메일함에만 든 메일은 빼고 받은 시각 최신부터, 요약은 엔진에서 · 첫 쪽의 total', async () => {
+      const queriesBefore = listQueries.length;
+
+      const res = await list({ q: '계약' }).expect(200);
+      const page = dataOf<Page<ListItem>>(res);
+
+      expect(page.items.map((item) => item.id)).toEqual([
+        'm-contract',
+        'm-renewal',
+      ]);
+      expect(page.pageInfo).toEqual({
+        hasNext: false,
+        nextCursor: null,
+        total: 2,
+      });
+      // 엔진의 목록 검색은 묻지 않았다 — 찾은 쪽의 요약만
+      expect(listQueries.length).toBe(queriesBefore);
+      expect(summaryRequests.at(-1)).toEqual({
+        user: ME,
+        ids: ['m-contract', 'm-renewal'],
+      });
+    });
+
+    it('강조 — 제목의 맞은 곳 · 본문에서 맞은 곳 둘레의 미리 보기와 그 안의 맞은 곳 (UTF-16 [시작, 끝))', async () => {
+      const [contract] = dataOf<Page<ListItem>>(
+        await list({ q: '계약 갱신' }).expect(200),
+      ).items;
+
+      expect(contract.id).toBe('m-contract');
+      expect(contract.searchHighlight).toEqual({
+        subject: [[9, 11]],
+        preview: {
+          text: '계약서를 보내 드립니다. 갱신 일정은 다음 주입니다.',
+          ranges: [
+            [0, 2],
+            [14, 16],
+          ],
+        },
+      });
+    });
+
+    it('조건 — 보낸 사람 · 받는 사람(참조 포함) · 제목 · 내용 · 기간 · 첨부, 검색어 없이도 · 검색어와 함께면 모두 맞아야', async () => {
+      expect(await idsOf({ from: '박서준' })).toEqual(['m-meeting']);
+      expect(await idsOf({ from: 'seojun' })).toEqual(['m-meeting']);
+      expect(await idsOf({ to: 'partner' })).toEqual(['m-contract']);
+      expect(await idsOf({ subject: '회의' })).toEqual([
+        'm-meeting',
+        'm-renewal',
+      ]);
+      expect(await idsOf({ body: '회의실' })).toEqual(['m-meeting']);
+      expect(await idsOf({ hasAttachment: 'true' })).toEqual(['m-contract']);
+      expect(
+        await idsOf({
+          after: '2026-11-03T00:00:00.000Z',
+          before: '2026-11-04T01:00:00.000Z',
+        }),
+      ).toEqual(['m-renewal']);
+      expect(await idsOf({ q: '회의', from: '이도윤' })).toEqual(['m-renewal']);
+      expect(await idsOf({ q: '"갱신 일정"' })).toEqual(['m-contract']);
+      // 메일함 범위
+      expect(await idsOf({ mailboxId: 'inbox', q: '계약' })).toEqual([
+        'm-contract',
+        'm-renewal',
+      ]);
+      expect(
+        await idsOf({ mailboxId: SEARCH_EXCLUDED_MAILBOX, q: '계약' }),
+      ).toEqual(['m-trash']);
+    });
+
+    it('한 글자 낱말뿐이면 제목 · 사람 · 첨부 이름에서만 — 본문에만 있는 메일은 빠진다', async () => {
+      // '층' 은 m-floor 의 제목 · m-meeting 의 본문에 있다
+      expect(await idsOf({ q: '층' })).toEqual(['m-floor']);
+      // 두 글자 넘는 낱말과 함께면 본문에서도 확인한다
+      expect(await idsOf({ q: '층 회의실' })).toEqual(['m-meeting']);
+      // 본문을 찾지 않았으니 미리 보기에도 강조하지 않는다 — '공' 은 m-floor 의 제목과 본문에 있다 (2026-11-06 실사용 시험)
+      const found = dataOf<Page<ListItem>>(
+        await list({ q: '공' }).expect(200),
+      ).items;
+      expect(found.map((item) => item.id)).toEqual(['m-contract', 'm-floor']);
+      expect(found[1].searchHighlight).toEqual({
+        subject: [[3, 4]],
+        preview: { text: '', ranges: [] },
+      });
+    });
+
+    it('미리 보기는 답장의 원문 인용(> 줄)을 피한다 — 인용 안에서만 맞고 제목에서도 맞으면 인용 앞의 글, 인용에만 있는 말은 > 를 뗀 인용 조각 (2026-11-06 사용자 관점 점검)', async () => {
+      const [byTitle] = dataOf<Page<ListItem>>(
+        await list({ q: '해오름' }).expect(200),
+      ).items;
+      expect(byTitle.id).toBe('m-reply');
+      expect(byTitle.searchHighlight).toEqual({
+        subject: [[4, 7]],
+        preview: {
+          text: '네, 받았습니다. 금요일까지 확인하겠습니다.…',
+          ranges: [],
+        },
+      });
+
+      const [byQuote] = dataOf<Page<ListItem>>(
+        await list({ q: 'R9A51' }).expect(200),
+      ).items;
+      expect(byQuote.id).toBe('m-reply');
+      expect(byQuote.searchHighlight?.preview).toEqual({
+        text: '…원본 메일 해오름 프로젝트 R9A51 자료를 보냅니다.',
+        ranges: [[16, 21]],
+      });
+    });
+
+    it('메일함 범위의 후보는 찾기 GIN 하나로 — 주소 · 묶음 · 메일함을 색인 조건으로 맞추고, 메일함만으로 줄을 모아 묶음을 줄마다 풀지 않는다 (실제 PostgreSQL — 2026-11-06 실사용 시험)', async () => {
+      // 메일함만 담은 GIN 은 없다 — 있으면 계획기가 그것만으로 메일함의 줄(회사 전체 posting)을 읽고 묶음 배열을 줄마다 풀 수 있다
+      const gins: { indexname: string }[] = await dataSource.query(
+        `SELECT indexname FROM pg_indexes WHERE tablename = 'mail_search_messages' AND indexdef ILIKE '%USING gin%' ORDER BY indexname`,
+      );
+      expect(gins.map((row) => row.indexname)).toEqual([
+        'IDX_mail_search_messages_refs',
+        'IDX_mail_search_messages_user_grams_mailboxes',
+      ]);
+
+      interface PlanNode {
+        'Index Name'?: string;
+        'Index Cond'?: string;
+        Filter?: string;
+        'Recheck Cond'?: string;
+        Plans?: PlanNode[];
+      }
+      const nodesOf = (node: PlanNode): PlanNode[] => [
+        node,
+        ...(node.Plans ?? []).flatMap(nodesOf),
+      ];
+      const scope: SearchScope = {
+        mailboxId: 'inbox',
+        excludedMailboxIds: [],
+        excludedKeywords: ['$ara-sending'],
+      };
+      for (const text of ['계약', '계약서 갱신']) {
+        const query = candidatesSql(
+          ME,
+          scope,
+          planSearch({ text, hasAttachment: false }),
+          null,
+          SEARCH_CHECK_ROWS_LIMIT + 1,
+        );
+        // 서비스와 같은 계획기 설정(SET LOCAL — 트랜잭션 안)으로
+        const rows: { 'QUERY PLAN': unknown }[] = await dataSource.transaction(
+          async (manager) => {
+            for (const setting of PLANNER_SETTINGS.bitmap) {
+              await manager.query(setting);
+            }
+            return manager.query(
+              `EXPLAIN (FORMAT JSON) ${query.sql}`,
+              query.params,
+            );
+          },
+        );
+        const raw = rows[0]['QUERY PLAN'];
+        const [explained] = (
+          typeof raw === 'string' ? JSON.parse(raw) : raw
+        ) as { Plan: PlanNode }[];
+        const nodes = nodesOf(explained.Plan);
+        const scans = nodes.filter((node) => node['Index Name']);
+        expect(scans.map((node) => node['Index Name'])).toEqual([
+          'IDX_mail_search_messages_user_grams_mailboxes',
+        ]);
+        expect(scans[0]['Index Cond']).toContain('mailbox_ids');
+        expect(scans[0]['Index Cond']).toContain('grams');
+        // 묶음은 줄마다 보지 않는다 — 걸러 내기(Filter)에 묶음이 없다
+        expect(nodes.map((node) => node.Filter ?? '').join(' ')).not.toContain(
+          'grams',
+        );
+      }
+    });
+
+    it('쪽 넘기기 — 다음 쪽은 커서의 자리부터, 다음 쪽의 total 은 null · 다른 검색의 커서는 400 VAL_001', async () => {
+      const first = dataOf<Page<ListItem>>(
+        await list({ q: '계약', limit: 1 }).expect(200),
+      );
+      expect(first.items.map((item) => item.id)).toEqual(['m-contract']);
+      expect(first.pageInfo).toMatchObject({ hasNext: true, total: 2 });
+      const cursor = first.pageInfo.nextCursor as string;
+
+      const second = dataOf<Page<ListItem>>(
+        await list({ q: '계약', limit: 1, cursor }).expect(200),
+      );
+      expect(second.items.map((item) => item.id)).toEqual(['m-renewal']);
+      expect(second.pageInfo).toEqual({
+        hasNext: false,
+        nextCursor: null,
+        total: null,
+      });
+
+      const others: Record<string, string>[] = [
+        { q: '견적', cursor },
+        { q: '계약', from: '이도윤', cursor },
+        { q: '계약', mailboxId: 'inbox', cursor },
+      ];
+      for (const params of others) {
+        const res = await list(params).expect(400);
+        expect(body(res).error?.code).toBe('VAL_001');
+      }
+    });
+
+    it('쪽을 넘기는 중에는 처음 방식대로 — 색인 커서는 다시 채우기에 들어가도 색인으로, 준비 중의 새 검색은 엔진 방식(조건도 넘긴다 · 강조 없음)', async () => {
+      const cursor = dataOf<Page<ListItem>>(
+        await list({ q: '계약', limit: 1 }).expect(200),
+      ).pageInfo.nextCursor as string;
+      await setStatus('building');
+      try {
+        const queriesBefore = listQueries.length;
+        const next = dataOf<Page<ListItem>>(
+          await list({ q: '계약', limit: 1, cursor }).expect(200),
+        );
+        expect(next.items.map((item) => item.id)).toEqual(['m-renewal']);
+        expect(listQueries.length).toBe(queriesBefore);
+
+        const engine = dataOf<Page<ListItem>>(
+          await list({
+            q: ' 계약 ',
+            from: '이도윤',
+            hasAttachment: 'true',
+          }).expect(200),
+        );
+        expect(engine.items).toEqual([]);
+        expect(listQueries.slice(queriesBefore)).toEqual([
+          {
+            user: ME,
+            query: {
+              mailboxId: undefined,
+              limit: 20,
+              cursor: undefined,
+              text: '계약',
+              conditions: { from: '이도윤', hasAttachment: true },
+            },
+          },
+        ]);
+      } finally {
+        await setStatus('ready');
+      }
+    });
+
+    it('다른 직원의 줄은 섞이지 않는다 — 같은 낱말 · 같은 메일함 id 여도 (두 글자 · 확인 · 한 글자 · 조건만 · 메일함 범위 — 리뷰 L6)', async () => {
+      const OTHER = 'search.neighbor@e2e.arasystem.test';
+      await request(server)
+        .get('/api/search-index')
+        .set('Cookie', cookieOf(OTHER))
+        .expect(200);
+      // 엔진의 메일함 id 는 계정마다 같은 꼴이다(inbox) — 글도 ME 의 것과 같게
+      fakeIndexSource.mailboxes.set(OTHER, {
+        state: 'n1',
+        emails: DOCUMENTS.map((document) => ({
+          ...document,
+          id: `x-${document.id}`,
+        })),
+      });
+      try {
+        const build = app.get(MailSearchBuildService);
+        expect(await build.build(OTHER, Date.now() + 120_000)).toBe('ready');
+
+        const searches: Record<string, string>[] = [
+          { q: '계약' },
+          { q: '계약서' },
+          { q: '층' },
+          { subject: '회의' },
+          { hasAttachment: 'true' },
+          { after: '2026-11-01T00:00:00.000Z' },
+          { mailboxId: 'inbox', q: '회의' },
+          { mailboxId: SEARCH_EXCLUDED_MAILBOX, q: '계약' },
+        ];
+        for (const params of searches) {
+          const before = summaryRequests.length;
+          const ids = await idsOf(params);
+          expect(ids.length).toBeGreaterThan(0);
+          // 색인이 찾은 id 그대로(엔진에 요약을 묻기 전) — 다른 직원의 줄이 없다
+          const asked = summaryRequests
+            .slice(before)
+            .flatMap((request) => [...request.ids]);
+          expect(asked.length).toBeGreaterThan(0);
+          expect(asked.filter((id) => id.startsWith('x-'))).toEqual([]);
+        }
+      } finally {
+        fakeIndexSource.mailboxes.delete(OTHER);
+        for (const table of ['mail_search_messages', 'mail_search_states']) {
+          await dataSource.query(
+            `DELETE FROM "${table}" WHERE user_email = $1`,
+            [OTHER],
+          );
+        }
+      }
+    });
+
+    it('검색 글의 NUL 은 U+FFFD 로 바꿔 찾는다 — DB 오류(500)가 아니다, 엔진 방식도 (리뷰 L2)', async () => {
+      const NUL = String.fromCharCode(0);
+      expect(await idsOf({ q: `계약${NUL}` })).toEqual([
+        'm-contract',
+        'm-renewal',
+      ]);
+      expect(await idsOf({ q: `계${NUL}약`, subject: `회${NUL}의` })).toEqual(
+        [],
+      );
+      await setStatus('building');
+      try {
+        const res = await list({ q: `계${NUL}약` }).expect(200);
+        expect(dataOf<Page<ListItem>>(res).items).toEqual([]);
+      } finally {
+        await setStatus('ready');
+      }
+    });
+
+    it('검색어와 조건 칸 넷의 낱말은 합쳐 8개까지 — 넘으면 400 VAL_001 (읽기 화면도 같다 — 리뷰 M2)', async () => {
+      const words = (prefix: string, count: number) =>
+        Array.from({ length: count }, (_, index) => `${prefix}${index}`).join(
+          ' ',
+        );
+      await list({ q: words('q', 4), to: words('t', 4) }).expect(200);
+      const overLimit: Record<string, string>[] = [
+        { q: words('q', 4), to: words('t', 5) },
+        { from: words('f', 3), subject: words('s', 3), body: words('b', 3) },
+      ];
+      for (const params of overLimit) {
+        const res = await list(params).expect(400);
+        expect(body(res).error?.code).toBe('VAL_001');
+      }
+      const detail = await request(server)
+        .get(`/api/messages/${IMAGE_MESSAGE}`)
+        .query({ q: words('q', 5), body: words('b', 4) })
+        .set('Cookie', cookieOf(ME))
+        .expect(400);
+      expect(body(detail).error?.code).toBe('VAL_001');
+    });
+
+    it('판을 되돌리면(서버가 뜰 때) building · 엔진 방식이 되고, 다시 채울 때 첫 묶음이 옛 판 줄을 지운다 — 실제 PostgreSQL (리뷰 M1)', async () => {
+      const RESET = 'search.reset@e2e.arasystem.test';
+      await request(server)
+        .get('/api/search-index')
+        .set('Cookie', cookieOf(RESET))
+        .expect(200);
+      fakeIndexSource.mailboxes.set(RESET, {
+        state: 'r1',
+        emails: DOCUMENTS.map((document) => ({
+          ...document,
+          id: `r-${document.id}`,
+        })),
+      });
+      try {
+        const build = app.get(MailSearchBuildService);
+        expect(await build.build(RESET, Date.now() + 120_000)).toBe('ready');
+        // 옛 판으로 만든 줄처럼 — 판을 내리고 엔진에 없는 줄도 하나 남긴다
+        await dataSource.query(
+          `UPDATE mail_search_states SET index_format = $2 WHERE user_email = $1`,
+          [RESET, INDEX_FORMAT - 1],
+        );
+        await dataSource.query(
+          `UPDATE mail_search_messages SET fold_body = 'old-format' WHERE user_email = $1`,
+          [RESET],
+        );
+
+        // 판이 다르면 되돌리기 전에도 상태는 building (검색은 엔진 방식)
+        expect(
+          dataOf(
+            await request(server)
+              .get('/api/search-index')
+              .set('Cookie', cookieOf(RESET))
+              .expect(200),
+          ),
+        ).toEqual({ status: 'building', done: 0, total: null });
+
+        const repository = app.get(MailSearchIndexRepository);
+        expect(
+          await repository.resetOutdatedFormats(
+            `@${TEST_MAIL_SETTINGS.domain}`,
+            INDEX_FORMAT,
+            new Date(),
+          ),
+        ).toBeGreaterThanOrEqual(1);
+        const [state]: {
+          status: string;
+          index_format: number;
+          build_started_at: Date | null;
+        }[] = await dataSource.query(
+          'SELECT status, index_format, build_started_at FROM mail_search_states WHERE user_email = $1',
+          [RESET],
+        );
+        expect(state).toEqual({
+          status: 'building',
+          index_format: INDEX_FORMAT,
+          build_started_at: null,
+        });
+
+        expect(await build.build(RESET, Date.now() + 120_000)).toBe('ready');
+        const rows: { email_id: string; fold_body: string }[] =
+          await dataSource.query(
+            'SELECT email_id, fold_body FROM mail_search_messages WHERE user_email = $1 ORDER BY email_id',
+            [RESET],
+          );
+        expect(rows.map((row) => row.email_id)).toEqual(
+          DOCUMENTS.map((document) => `r-${document.id}`).sort(),
+        );
+        expect(rows.filter((row) => row.fold_body === 'old-format')).toEqual(
+          [],
+        );
+      } finally {
+        fakeIndexSource.mailboxes.delete(RESET);
+        for (const table of ['mail_search_messages', 'mail_search_states']) {
+          await dataSource.query(
+            `DELETE FROM "${table}" WHERE user_email = $1`,
+            [RESET],
+          );
+        }
+      }
+    });
+
+    it('검색 칸의 검사 — 길이 · 낱말 수 · 기간 형식 · 첨부 값이 틀리면 400 VAL_001 (엔진 · 색인에 묻지 않는다)', async () => {
+      const before = summaryRequests.length;
+      const rejected: Record<string, string>[] = [
+        { subject: '가'.repeat(MAX_SEARCH_LENGTH + 1) },
+        {
+          body: Array.from(
+            { length: MAX_SEARCH_WORDS + 1 },
+            (_, index) => `w${index}`,
+          ).join(' '),
+        },
+        { after: '2026-11-01' },
+        { before: '2026-11-01T00:00:00+09:00' },
+        { hasAttachment: 'false' },
+      ];
+      for (const params of rejected) {
+        const res = await list(params).expect(400);
+        expect(body(res).error?.code).toBe('VAL_001');
+      }
+      expect(summaryRequests.length).toBe(before);
+    });
+
+    describe('읽기 화면의 강조 (GET /api/messages/{id} 의 q · subject · body)', () => {
+      interface ReadDetail {
+        subject: string;
+        htmlBody: string | null;
+        textBody: string | null;
+        imagesShown: boolean;
+        searchHighlight: {
+          subject: [number, number][];
+          attachments: Record<string, [number, number][]>;
+          textBody: [number, number][];
+        } | null;
+      }
+      const read = (query: Record<string, string>) =>
+        request(server)
+          .get(`/api/messages/${IMAGE_MESSAGE}`)
+          .query(query)
+          .set('Cookie', cookieOf(ME));
+
+      it('검색 쿼리가 없으면 searchHighlight 는 null', async () => {
+        const detail = dataOf<ReadDetail>(await read({}).expect(200));
+        expect(detail.searchHighlight).toBeNull();
+        expect(detail.htmlBody).not.toContain('<mark>');
+      });
+
+      it('검색어 — 본문의 글에 <mark>(정화한 뒤 — 태그 · 속성은 그대로) · textBody 의 위치, 보낸 사람 조건은 강조하지 않는다', async () => {
+        const detail = dataOf<ReadDetail>(
+          await read({ q: '안녕', from: '바깥' }).expect(200),
+        );
+        expect(detail.searchHighlight).toEqual({
+          subject: [],
+          attachments: {},
+          textBody: [[0, 2]],
+        });
+        expect(detail.htmlBody).toContain('<p><mark>안녕</mark>하세요</p>');
+        expect(detail.htmlBody).not.toContain('<mark>로고');
+      });
+
+      it('한 글자 낱말뿐이면 본문에는 강조하지 않는다 — 제목은 그대로 (2026-11-06 실사용 시험)', async () => {
+        // '든' 은 제목(그림이 든 메일)에, '안' 은 본문(안녕하세요)에 있다
+        const detail = dataOf<ReadDetail>(
+          await read({ q: '든 안' }).expect(200),
+        );
+        expect(detail.searchHighlight).toEqual({
+          subject: [[4, 5]],
+          attachments: {},
+          textBody: [],
+        });
+        expect(detail.htmlBody).not.toContain('<mark>');
+      });
+
+      it('images=show 와 함께 — 중계 주소로 바꾼 본문에 강조, 제목 조건은 제목에', async () => {
+        const detail = dataOf<ReadDetail>(
+          await read({ images: 'show', subject: '그림', q: '안녕' }).expect(
+            200,
+          ),
+        );
+        expect(detail.imagesShown).toBe(true);
+        expect(detail.htmlBody).toContain('/api/mail-images/');
+        expect(detail.htmlBody).toContain('<mark>안녕</mark>');
+        expect(detail.searchHighlight?.subject).toEqual([[0, 2]]);
+      });
+
+      it('검색 칸은 목록과 같은 검사 · 목록에만 있는 조건(after · hasAttachment)은 받지 않는다 — 400 VAL_001', async () => {
+        const rejected: Record<string, string>[] = [
+          { q: '가'.repeat(MAX_SEARCH_LENGTH + 1) },
+          { after: '2026-11-01T00:00:00.000Z' },
+          { before: '2026-11-30T15:00:00.000Z' },
+          { hasAttachment: 'true' },
+          { cursor: 'abc' },
+          { limit: '20' },
+          { mailboxId: 'inbox' },
+        ];
+        for (const query of rejected) {
+          const res = await read(query).expect(400);
+          expect(body(res).error?.code).toBe('VAL_001');
+        }
+      });
+    });
+  });
+
+  describe('14단계 3차 — 대화 키 · 같은 대화 · 대화로 묶은 목록 (실제 PostgreSQL)', () => {
+    const ME = 'thread.me@e2e.arasystem.test';
+    const OTHER = 'thread.other@e2e.arasystem.test';
+    const MINE = { name: '김아라', email: ME };
+    const at = (day: number, hour: number) => `2026-11-0${day}T0${hour}:00:00Z`;
+    /** 견적 대화 — 회신 · 답장 · 전달 말머리 · 겹친 Re · 꼬리표, 휴지통에만 든 답장 하나 */
+    const DOCUMENTS = [
+      indexDocument({
+        id: 't-orig',
+        subject: '견적 요청',
+        messageIds: ['orig@e2e.test'],
+        receivedAt: at(1, 1),
+      }),
+      indexDocument({
+        id: 't-re',
+        subject: 'Re: 견적 요청',
+        messageIds: ['re1@e2e.test'],
+        inReplyTo: ['orig@e2e.test'],
+        references: ['orig@e2e.test'],
+        receivedAt: at(1, 2),
+      }),
+      indexDocument({
+        id: 't-hoesin',
+        subject: '회신: 견적 요청',
+        messageIds: ['re2@e2e.test'],
+        inReplyTo: ['re1@e2e.test'],
+        references: ['orig@e2e.test', 're1@e2e.test'],
+        from: [MINE],
+        mailboxIds: ['sent'],
+        receivedAt: at(1, 3),
+      }),
+      indexDocument({
+        id: 't-fwd',
+        subject: 'FW: 전달: [외부] 견적 요청',
+        messageIds: ['fw@e2e.test'],
+        references: ['orig@e2e.test'],
+        receivedAt: at(1, 4),
+      }),
+      indexDocument({
+        id: 't-rere',
+        subject: 'RE: RE: Re[2]: 견적 요청',
+        messageIds: ['re3@e2e.test'],
+        inReplyTo: ['re2@e2e.test'],
+        keywords: [],
+        receivedAt: at(1, 5),
+      }),
+      indexDocument({
+        id: 't-trash',
+        subject: 'Re: 견적 요청',
+        messageIds: ['re4@e2e.test'],
+        inReplyTo: ['re3@e2e.test'],
+        mailboxIds: [SEARCH_EXCLUDED_MAILBOX],
+        receivedAt: at(1, 6),
+      }),
+      // 답장 관계는 있지만 제목이 다르다 — 따로
+      indexDocument({
+        id: 't-other',
+        subject: 'Re: 다른 일',
+        messageIds: ['other@e2e.test'],
+        inReplyTo: ['orig@e2e.test'],
+        receivedAt: at(1, 7),
+      }),
+      // Message-ID 가 없다 — 혼자
+      indexDocument({
+        id: 't-nomid',
+        subject: 'Re: 견적 요청',
+        messageIds: [],
+        inReplyTo: ['orig@e2e.test'],
+        receivedAt: at(1, 8),
+      }),
+      // 원본(lo@)보다 먼저 들어온 답장 둘 — 원본이 오면 합친다
+      indexDocument({
+        id: 't-late-r1',
+        subject: '답장: 회의록 공유',
+        messageIds: ['lr1@e2e.test'],
+        inReplyTo: ['lo@e2e.test'],
+        receivedAt: at(2, 1),
+      }),
+      indexDocument({
+        id: 't-late-r2',
+        subject: 'Re: 회의록 공유',
+        messageIds: ['lr2@e2e.test'],
+        inReplyTo: ['lo@e2e.test'],
+        receivedAt: at(2, 2),
+      }),
+      // 발송 중인 내부 초안 — 견적 대화에 이어지지만 목록 · 다른 메일의 대화에서는 빠진다
+      indexDocument({
+        id: 't-sending',
+        subject: 'Re: 견적 요청',
+        messageIds: ['re5@e2e.test'],
+        inReplyTo: ['re3@e2e.test'],
+        mailboxIds: ['drafts'],
+        keywords: ['$draft', '$ara-sending'],
+        receivedAt: at(2, 3),
+      }),
+      // 주소 없이 이름만 `대표 <ceo@…>` 꼴인 보낸 사람 — 참여자가 그 주소로 보이지 않는다 (리뷰 L3, 공지 메일함)
+      indexDocument({
+        id: 't-notice',
+        subject: '공지',
+        messageIds: ['notice@e2e.test'],
+        from: [{ name: '대표 <ceo@example.com>', email: null }],
+        mailboxIds: ['notice'],
+        receivedAt: at(3, 1),
+      }),
+      indexDocument({
+        id: 't-notice-re',
+        subject: 'Re: 공지',
+        messageIds: ['notice-re@e2e.test'],
+        inReplyTo: ['notice@e2e.test'],
+        mailboxIds: ['notice'],
+        receivedAt: at(3, 2),
+      }),
+    ];
+    const LATE_ORIGINAL = indexDocument({
+      id: 't-late-orig',
+      subject: '회의록 공유',
+      messageIds: ['lo@e2e.test'],
+      receivedAt: at(1, 9),
+    });
+
+    const keysOf = async (user: string) =>
+      Object.fromEntries(
+        (
+          await dataSource.query<{ email_id: string; thread_key: string }[]>(
+            'SELECT email_id, thread_key FROM mail_search_messages WHERE user_email = $1',
+            [user],
+          )
+        ).map((row) => [row.email_id, row.thread_key]),
+      );
+    const conversation = (
+      id: string,
+      query: Record<string, string | number> = {},
+    ) =>
+      request(server)
+        .get(`/api/messages/${id}/conversation`)
+        .query(query)
+        .set('Cookie', cookieOf(ME));
+    const conversations = (query: Record<string, string | number>) =>
+      request(server)
+        .get('/api/conversations')
+        .query(query)
+        .set('Cookie', cookieOf(ME));
+    interface ConversationPage {
+      items: { id: string }[];
+      pageInfo: Page<unknown>['pageInfo'];
+      basis: string;
+    }
+    interface ConversationRow {
+      id: string;
+      latest: { id: string };
+      participants: { name: string | null; email: string }[];
+      messageCount: number;
+      messageIds: string[];
+      pendingSendIds: string[];
+      isRead: boolean;
+      isFlagged: boolean;
+      hasAttachment: boolean;
+    }
+    interface ConversationListPage {
+      items: ConversationRow[];
+      pageInfo: Page<unknown>['pageInfo'];
+      basis: string;
+    }
+    const setStatus = (status: 'ready' | 'building') =>
+      dataSource.query(
+        'UPDATE mail_search_states SET status = $2 WHERE user_email = $1',
+        [ME, status],
+      );
+
+    beforeAll(async () => {
+      for (const [user, emails] of [
+        [ME, DOCUMENTS],
+        [
+          OTHER,
+          // 같은 메일을 받은 다른 직원 — 같은 Message-ID · 제목이어도 그 직원의 대화다
+          [
+            indexDocument({
+              id: 'x-orig',
+              subject: '견적 요청',
+              messageIds: ['orig@e2e.test'],
+              receivedAt: at(1, 1),
+            }),
+            indexDocument({
+              id: 'x-re',
+              subject: 'Re: 견적 요청',
+              messageIds: ['re1@e2e.test'],
+              inReplyTo: ['orig@e2e.test'],
+              receivedAt: at(1, 2),
+            }),
+          ],
+        ],
+      ] as const) {
+        await request(server)
+          .get('/api/search-index')
+          .set('Cookie', cookieOf(user))
+          .expect(200);
+        fakeIndexSource.mailboxes.set(user, {
+          state: 'c1',
+          emails: [...emails],
+        });
+        expect(
+          await app
+            .get(MailSearchBuildService)
+            .build(user, Date.now() + 120_000),
+        ).toBe('ready');
+      }
+    });
+
+    afterAll(async () => {
+      for (const user of [ME, OTHER]) {
+        fakeIndexSource.mailboxes.delete(user);
+        for (const table of ['mail_search_messages', 'mail_search_states']) {
+          await dataSource.query(
+            `DELETE FROM "${table}" WHERE user_email = $1`,
+            [user],
+          );
+        }
+      }
+    });
+
+    it('대화 키 — 답장 관계 + 말머리(Re · RE · Re[2] · 회신 · 전달 · FW · [꼬리표])를 뗀 제목이 같으면 가장 작은 키 하나, 제목이 다르거나 Message-ID 가 없으면 혼자 · 다른 직원과 섞이지 않는다', async () => {
+      const keys = await keysOf(ME);
+      for (const id of [
+        't-orig',
+        't-re',
+        't-hoesin',
+        't-fwd',
+        't-rere',
+        't-trash',
+      ]) {
+        expect(keys[id]).toBe('t-fwd');
+      }
+      expect(keys['t-other']).toBe('t-other');
+      expect(keys['t-nomid']).toBe('t-nomid');
+      // 원본이 아직 없다 — 두 답장은 따로
+      expect(keys['t-late-r1']).toBe('t-late-r1');
+      expect(keys['t-late-r2']).toBe('t-late-r2');
+      expect(await keysOf(OTHER)).toEqual({
+        'x-orig': 'x-orig',
+        'x-re': 'x-orig',
+      });
+    });
+
+    it('늦게 온 원본은 들어올 때 갈려 있던 답장들을 잇는다 — 같은 메일을 다시 넣어도(겹친 채우기) 합친 키를 풀지 않는다', async () => {
+      const repository = app.get(MailSearchIndexRepository);
+      fakeIndexSource.mailboxes.get(ME)?.emails.push(LATE_ORIGINAL);
+      await repository.write(
+        ME,
+        { upserts: [toIndexRow(LATE_ORIGINAL)] },
+        new Date(),
+      );
+      let keys = await keysOf(ME);
+      for (const id of ['t-late-orig', 't-late-r1', 't-late-r2']) {
+        expect(keys[id]).toBe('t-late-orig');
+      }
+
+      await repository.write(
+        ME,
+        { upserts: [toIndexRow(DOCUMENTS[1]), toIndexRow(DOCUMENTS[8])] },
+        new Date(),
+      );
+      keys = await keysOf(ME);
+      expect(keys['t-re']).toBe('t-fwd');
+      expect(keys['t-late-r1']).toBe('t-late-orig');
+    });
+
+    it('같은 대화 — 오래된 차례 · 보낸편지함 포함 · 휴지통에만 든 메일은 빼되 지금 메일은 넣는다, total · basis index', async () => {
+      const page = dataOf<ConversationPage>(
+        await conversation('t-rere').expect(200),
+      );
+      expect(page.items.map((item) => item.id)).toEqual([
+        't-orig',
+        't-re',
+        't-hoesin',
+        't-fwd',
+        't-rere',
+      ]);
+      expect(page.pageInfo).toEqual({
+        hasNext: false,
+        nextCursor: null,
+        total: 5,
+      });
+      expect(page.basis).toBe('index');
+
+      const fromTrash = dataOf<ConversationPage>(
+        await conversation('t-trash').expect(200),
+      );
+      expect(fromTrash.items.map((item) => item.id)).toContain('t-trash');
+      expect(fromTrash.pageInfo.total).toBe(6);
+
+      // 발송 중인 내부 초안도 그 메일을 열면 넣는다 (엔진 방식과 같다)
+      const sending = dataOf<ConversationPage>(
+        await conversation('t-sending').expect(200),
+      );
+      expect(sending.items.map((item) => item.id)).toEqual([
+        't-orig',
+        't-re',
+        't-hoesin',
+        't-fwd',
+        't-rere',
+        't-sending',
+      ]);
+      expect(sending.pageInfo.total).toBe(6);
+
+      // 한 통뿐인 대화는 그 메일 하나
+      const alone = dataOf<ConversationPage>(
+        await conversation('t-other').expect(200),
+      );
+      expect(alone.items.map((item) => item.id)).toEqual(['t-other']);
+    });
+
+    it('같은 대화의 쪽 넘기기 — 커서는 그 메일의 대화에서만, limit 처음 값이자 최대 100', async () => {
+      const first = dataOf<ConversationPage>(
+        await conversation('t-rere', { limit: 2 }).expect(200),
+      );
+      expect(first.items.map((item) => item.id)).toEqual(['t-orig', 't-re']);
+      expect(first.pageInfo).toMatchObject({ hasNext: true, total: 5 });
+      const second = dataOf<ConversationPage>(
+        await conversation('t-rere', {
+          limit: 2,
+          cursor: first.pageInfo.nextCursor as string,
+        }).expect(200),
+      );
+      expect(second.items.map((item) => item.id)).toEqual([
+        't-hoesin',
+        't-fwd',
+      ]);
+      expect(second.pageInfo.total).toBeNull();
+
+      for (const [id, query] of [
+        ['t-re', { cursor: first.pageInfo.nextCursor as string }],
+        ['t-rere', { limit: 101 }],
+        ['t-rere', { limit: 0 }],
+        ['t-rere', { q: '견적' }],
+      ] as const) {
+        const res = await conversation(id, query).expect(400);
+        expect(body(res).error?.code).toBe('VAL_001');
+      }
+    });
+
+    it('색인 준비 중 · 색인에 없는 메일은 엔진의 스레드(basis engine) — 엔진에도 없으면 404 RES_001', async () => {
+      const before = engineConversations.length;
+      const missing = await conversation(MISSING_MESSAGE).expect(404);
+      expect(body(missing).error?.code).toBe('RES_001');
+      await setStatus('building');
+      try {
+        const engine = dataOf<ConversationPage>(
+          await conversation('t-re').expect(200),
+        );
+        expect(engine.basis).toBe('engine');
+      } finally {
+        await setStatus('ready');
+      }
+      expect(
+        engineConversations.slice(before).map((call) => call.emailId),
+      ).toEqual([MISSING_MESSAGE, 't-re']);
+    });
+
+    it('대화로 묶은 목록 — 그 메일함 안 마지막 받은 시각 최신부터, 통 수는 대화 전체(휴지통에만 든 것 빼고) · 그 메일함 안 id · 읽음 · 참여자', async () => {
+      const page = dataOf<ConversationListPage>(
+        await conversations({ mailboxId: 'inbox' }).expect(200),
+      );
+      expect(page.basis).toBe('index');
+      expect(page.items.map((row) => row.latest.id)).toEqual([
+        't-late-r2',
+        't-nomid',
+        't-other',
+        't-rere',
+      ]);
+      expect(page.pageInfo).toEqual({
+        hasNext: false,
+        nextCursor: null,
+        total: 4,
+      });
+      const quote = page.items[3];
+      expect(quote).toMatchObject({
+        id: 't-fwd',
+        messageCount: 5,
+        messageIds: ['t-rere', 't-fwd', 't-re', 't-orig'],
+        pendingSendIds: [],
+        isRead: false,
+        isFlagged: false,
+        hasAttachment: false,
+      });
+      expect(quote.participants.map((p) => p.email)).toEqual([
+        'doyun.lee@e2e.arasystem.test',
+        ME,
+      ]);
+      expect(page.items[0]).toMatchObject({
+        id: 't-late-orig',
+        messageCount: 3,
+        messageIds: ['t-late-r2', 't-late-r1', 't-late-orig'],
+      });
+
+      // 보낸편지함에서는 그 메일함의 메일만 — 통 수는 대화 전체. 붙잡힌 메일(보내기 취소를 기다리는)은 pendingSendIds 로 (리뷰 L6)
+      const before = heldSummaryRequests.length;
+      fakeHeldIds.add('t-hoesin');
+      try {
+        const sent = dataOf<ConversationListPage>(
+          await conversations({ mailboxId: 'sent' }).expect(200),
+        );
+        expect(sent.items).toHaveLength(1);
+        expect(sent.items[0]).toMatchObject({
+          latest: { id: 't-hoesin' },
+          messageIds: ['t-hoesin'],
+          pendingSendIds: ['t-hoesin'],
+          messageCount: 5,
+        });
+      } finally {
+        fakeHeldIds.clear();
+      }
+      // 기다리는 제출은 쪽마다 한 번 — 마지막 메일의 요약과 같은 요청
+      expect(heldSummaryRequests.slice(before)).toEqual([
+        { user: ME, ids: ['t-hoesin'] },
+      ]);
+    });
+
+    it('참여자는 첫 보낸 사람 칸에서 — 이름 안의 `<주소>` 는 참여자 주소가 되지 않는다 (리뷰 L3)', async () => {
+      const keys = await keysOf(ME);
+      expect(keys['t-notice-re']).toBe('t-notice');
+      const senders = await dataSource.query<
+        {
+          email_id: string;
+          from_email: string | null;
+          from_name: string | null;
+        }[]
+      >(
+        'SELECT email_id, from_email, from_name FROM mail_search_messages WHERE user_email = $1 AND email_id = ANY($2::text[]) ORDER BY email_id',
+        [ME, ['t-notice', 't-notice-re']],
+      );
+      expect(senders).toEqual([
+        { email_id: 't-notice', from_email: null, from_name: null },
+        {
+          email_id: 't-notice-re',
+          from_email: 'doyun.lee@e2e.arasystem.test',
+          from_name: '이도윤',
+        },
+      ]);
+      const notice = dataOf<ConversationListPage>(
+        await conversations({ mailboxId: 'notice' }).expect(200),
+      );
+      expect(notice.items).toHaveLength(1);
+      expect(notice.items[0]).toMatchObject({
+        messageCount: 2,
+        messageIds: ['t-notice-re', 't-notice'],
+        participants: [
+          { name: '이도윤', email: 'doyun.lee@e2e.arasystem.test' },
+        ],
+      });
+    });
+
+    it('꾸민 색인 커서(모양이 틀림 · `m` 만 맞음)는 두 경로 모두 400 VAL_001 — 색인에 없는 메일이어도 404 보다 먼저 (리뷰 L1 · L8)', async () => {
+      const forged = (payload: Record<string, unknown>) =>
+        Buffer.from(JSON.stringify(payload)).toString('base64url');
+      for (const [id, cursor] of [
+        ['t-rere', forged({ m: 'ti' })],
+        ['t-rere', forged({ v: 1, m: 'ti', t: 'x', k: '../a', s: 'zz' })],
+        [MISSING_MESSAGE, forged({ m: 'ti' })],
+        [MISSING_MESSAGE, forged({ v: 1, m: 'ti', t: 1, k: 'a', s: 'zz' })],
+      ] as const) {
+        const res = await conversation(id, { cursor }).expect(400);
+        expect(body(res).error?.code).toBe('VAL_001');
+      }
+      for (const cursor of [
+        forged({ m: 'li' }),
+        forged({ v: 1, m: 'li', t: -1, k: 't-fwd', s: 'zz' }),
+      ]) {
+        const res = await conversations({ mailboxId: 'inbox', cursor }).expect(
+          400,
+        );
+        expect(body(res).error?.code).toBe('VAL_001');
+      }
+    });
+
+    it('묶은 목록의 쪽 넘기기 · 범위 — 커서는 그 메일함에서만, 없는 메일함은 404 · mailboxId 없음은 400', async () => {
+      const first = dataOf<ConversationListPage>(
+        await conversations({ mailboxId: 'inbox', limit: 2 }).expect(200),
+      );
+      expect(first.items.map((row) => row.latest.id)).toEqual([
+        't-late-r2',
+        't-nomid',
+      ]);
+      expect(first.pageInfo).toMatchObject({ hasNext: true, total: 4 });
+      const second = dataOf<ConversationListPage>(
+        await conversations({
+          mailboxId: 'inbox',
+          limit: 2,
+          cursor: first.pageInfo.nextCursor as string,
+        }).expect(200),
+      );
+      expect(second.items.map((row) => row.latest.id)).toEqual([
+        't-other',
+        't-rere',
+      ]);
+      expect(second.pageInfo).toEqual({
+        hasNext: false,
+        nextCursor: null,
+        total: null,
+      });
+
+      const otherMailbox = await conversations({
+        mailboxId: 'sent',
+        cursor: first.pageInfo.nextCursor as string,
+      }).expect(400);
+      expect(body(otherMailbox).error?.code).toBe('VAL_001');
+      const missing = await conversations({
+        mailboxId: MISSING_MAILBOX,
+      }).expect(404);
+      expect(body(missing).error?.code).toBe('RES_001');
+      const invalid: Record<string, string>[] = [
+        {},
+        { mailboxId: '../a' },
+        { mailboxId: 'inbox', q: '견적' },
+      ];
+      for (const query of invalid) {
+        const res = await conversations(query).expect(400);
+        expect(body(res).error?.code).toBe('VAL_001');
+      }
+    });
+
+    it('색인 준비 중이면 엔진의 스레드(basis engine — collapseThreads) · 다른 직원의 줄은 섞이지 않는다', async () => {
+      const before = engineConversationLists.length;
+      await setStatus('building');
+      try {
+        const engine = dataOf<ConversationListPage>(
+          await conversations({ mailboxId: 'inbox' }).expect(200),
+        );
+        expect(engine.basis).toBe('engine');
+      } finally {
+        await setStatus('ready');
+      }
+      expect(engineConversationLists.slice(before)).toEqual([
+        {
+          user: ME,
+          query: { mailboxId: 'inbox', limit: 20, cursor: undefined },
+        },
+      ]);
+      const mine = dataOf<ConversationListPage>(
+        await conversations({ mailboxId: 'inbox' }).expect(200),
+      );
+      expect(
+        mine.items
+          .flatMap((row) => [row.id, ...row.messageIds])
+          .filter((id) => id.startsWith('x-')),
+      ).toEqual([]);
+    });
+  });
+
   describe('13단계 — 제한된 세션 · 2단계 인증 필수 · 문의 연락처', () => {
     let systemSettings: SystemSettingsService;
     /** 시작 전 설정 — 끝나면 되돌린다(컨테이너 안에서 돌리면 개발 DB 다). 준비가 실패했으면 없다 */
diff --git a/backend/test/search-text-samples.ts b/backend/test/search-text-samples.ts
new file mode 100644
index 0000000..bbbbfc2
--- /dev/null
+++ b/backend/test/search-text-samples.ts
@@ -0,0 +1,146 @@
+/**
+ * 메일 검색의 접기 · 글자 두 개 묶음 · 맞은 곳 · 말머리 떼기 표본 — 단위 테스트 전용 (앱 코드에서 import 하지 않는다).
+ * 서버의 색인 · 찾기(src/shared/utils/search-text.ts · subject-base.ts)와 화면의 미리 확인 · 강조(frontend `shared/utils/search-match.ts`)를 같은 표로 본다.
+ *
+ * ⚠️ frontend `src/test-utils/search-text-samples.ts` 와 **같은 표**다(행과 순서까지 그대로).
+ *    한쪽을 고치면 둘 다 고친다 — 접기 · 위치 규칙을 바꾸면 두 쪽 함수와 두 표를 함께 (서버가 준 맞은 곳의 위치를 화면이 그대로 그린다).
+ * 답은 손으로 적었고 두 쪽 테스트가 함수의 결과와 견준다. 단위 테스트는 `@/../test/search-text-samples` 로 부른다 (cpu-time.ts 와 같다).
+ */
+
+/** 접기 — [넣은 글, 접은 글]. 접은 글은 NFC 원문과 UTF-16 길이가 늘 같다 */
+export const FOLD_SAMPLES: readonly (readonly [
+  input: string,
+  folded: string,
+])[] = [
+  ['계약서', '계약서'],
+  ['Project PLAN', 'project plan'],
+  // 전각 ASCII → 반각 (대문자는 소문자로까지)
+  ['ＡＢＣ１２３！', 'abc123!'],
+  ['ＲＥ：회의', 're:회의'],
+  ['［공지］', '[공지]'],
+  // 공백류(전각 공백 · 줄바꿈 · 탭 · NBSP · CR)는 띄어쓰기 하나로 1:1 (색인 판 2) — 이어진 공백을 줄이지는 않는다(위치를 지킨다)
+  ['회의\u3000일정', '회의 일정'],
+  ['계약\n갱신\t안내\u00a0끝', '계약 갱신 안내 끝'],
+  ['a\r\n\nb', 'a   b'],
+  // 소문자가 코드 포인트 하나 · 같은 길이일 때만 — 'İ'(U+0130)는 'i̇' 두 글자가 되므로 그대로
+  ['İstanbul', 'İstanbul'],
+  ['ÀÉÎÕÜ', 'àéîõü'],
+  ['ΣΑΣ', 'σασ'],
+  // 풀어 쓴 한글(NFD)은 NFC 로 모은다
+  ['\u1112\u1161\u11ab\u1100\u1173\u11af', '한글'],
+  // ㈜ 는 그대로 (NFKC 가 아니다 — 길이를 바꾸지 않는다)
+  ['㈜아라', '㈜아라'],
+  // BMP 밖 글자 — Deseret 대문자는 소문자로(둘 다 두 단위), 이모지는 그대로
+  ['\u{10400}😀', '\u{10428}😀'],
+  ['', ''],
+];
+
+/** 글자 두 개 묶음 — [접은 글, 묶음(나온 차례, 겹치지 않게)] */
+export const GRAM_SAMPLES: readonly (readonly [
+  fold: string,
+  grams: readonly string[],
+])[] = [
+  ['계약서', ['계약', '약서']],
+  ['회의 일정', ['회의', '일정']],
+  ['계약', ['계약']],
+  ['계', []],
+  ['a b c', []],
+  ['aaaa', ['aa']],
+  ['ab\nab\tab', ['ab']],
+  // 전각 공백 · NBSP 도 공백이다
+  ['회의\u3000일정\u00a0안내', ['회의', '일정', '안내']],
+  // 문장부호는 글자다 — 're:' 의 'e:' 도 묶음
+  ['re:회의', ['re', 'e:', ':회', '회의']],
+  // BMP 밖 글자는 코드 포인트 하나
+  ['😀😁', ['😀😁']],
+  ['', []],
+];
+
+/** 맞은 곳 — [원문(NFC), 찾는 말들, 맞은 곳들 [시작, 끝) UTF-16] — 겹치거나 맞닿으면 합친다 */
+export const MATCH_SAMPLES: readonly (readonly [
+  original: string,
+  terms: readonly string[],
+  ranges: readonly (readonly [number, number])[],
+])[] = [
+  ['계약서를 보냈습니다', ['계약'], [[0, 2]]],
+  ['Project plan', ['PROJ'], [[0, 4]]],
+  ['ＡＢＣ 주문', ['abc'], [[0, 3]]],
+  [
+    '회의 회의록 회의실',
+    ['회의'],
+    [
+      [0, 2],
+      [3, 5],
+      [7, 9],
+    ],
+  ],
+  // 겹치는 자리도 찾아 합친다
+  ['aaa', ['aa'], [[0, 3]]],
+  // 맞닿은 두 말은 하나로
+  ['계약서', ['계약', '서'], [[0, 3]]],
+  [
+    '회의 일정 안내',
+    ['일정', '회의'],
+    [
+      [0, 2],
+      [3, 5],
+    ],
+  ],
+  // 구절은 줄바꿈 · NBSP 로 갈린 글에도 맞는다 (공백류 → 띄어쓰기 1:1) — 위치는 원문 그대로
+  ['계약\n갱신 안내', ['계약 갱신'], [[0, 5]]],
+  ['계약\u00a0갱신', ['계약 갱신'], [[0, 5]]],
+  // 구절은 띄어쓰기까지 그대로
+  ['회의 일정 안내', ['회의 일정'], [[0, 5]]],
+  ['회의  일정', ['회의 일정'], []],
+  [
+    '[공지] Re: 회의',
+    ['공지', 're'],
+    [
+      [1, 3],
+      [5, 7],
+    ],
+  ],
+  // 빈 말은 건너뛴다 · 없는 말은 맞은 곳 없음
+  ['계약', ['', '없음'], []],
+  // BMP 밖 글자 앞뒤에서도 UTF-16 위치
+  ['😀계약', ['계약'], [[2, 4]]],
+  ['', ['계약'], []],
+];
+
+/** 말머리 떼기 — [제목, 말머리를 뗀 접기 글] */
+export const SUBJECT_BASE_SAMPLES: readonly (readonly [
+  subject: string,
+  base: string,
+])[] = [
+  ['회의 일정 안내', '회의 일정 안내'],
+  ['Re: 회의 일정 안내', '회의 일정 안내'],
+  ['RE: Re: FW: 회의 일정 안내', '회의 일정 안내'],
+  ['Re:회의', '회의'],
+  ['Fwd: 견적서', '견적서'],
+  ['AW: WG: Angebot', 'angebot'],
+  // 한국어 Outlook — 엔진은 떼지 않는다
+  ['회신: 회의 일정 안내', '회의 일정 안내'],
+  ['답장: 회신: 전달: 회의', '회의'],
+  ['회신 : 회의', '회의'],
+  // 수 · 전각 쌍점
+  ['Re[2]: 회의', '회의'],
+  ['RE(3): 회의', '회의'],
+  ['Re：회의', '회의'],
+  ['ＲＥ： 회의', '회의'],
+  // 대괄호 꼬리표 (여러 겹 · 말머리와 섞여도)
+  ['[공지] 회의 일정', '회의 일정'],
+  ['Re: [공지] [중요] 회의', '회의'],
+  ['[외부] RE: 견적', '견적'],
+  // 공백은 하나로 · 대소문자 없이
+  ['  Re:   회의    일정  ', '회의 일정'],
+  ['Project PLAN', 'project plan'],
+  // 쌍점이 없으면 말머리가 아니다
+  ['Re 회의', 're 회의'],
+  ['Reply to 회의', 'reply to 회의'],
+  ['Regarding: 회의', 'regarding: 회의'],
+  ['회신드립니다', '회신드립니다'],
+  // 다 떼면 빈 글
+  ['Re:', ''],
+  ['[공지]', ''],
+  ['', ''],
+];
diff --git a/docker-compose.yml b/docker-compose.yml
index 209a2ea..38871d7 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -234,6 +234,10 @@ services:
     # 판 · digest 까지 고정한다(루트 env 의 DB_IMAGE — docker 스킬 "이미지 버전 고정"). 메이저(15)는 데이터 형식이라 그대로 둔다 —
     # 올리려면 pg_dump → 새 메이저에 복원(mail/README.md "백업"의 복원 차례). 아래 watchtower 표시는 13단계에 뺐다(판을 사람이 올린다)
     image: ${DB_IMAGE}
+    # 공유 버퍼(shared_buffers) 256MB — 기본 128MB 의 두 배 · 메모리 한도(아래 deploy — 1g)의 1/4. 14단계 메일 검색 색인 때문이다(아래 deploy 의 "메모리").
+    # 공식 이미지의 꼴이다 — entrypoint(docker-entrypoint.sh)가 처음 기동의 initdb 를 하고 이 인자를 postgres 에 그대로 넘긴다.
+    # 명령줄 값은 데이터 폴더의 postgresql.conf · ALTER SYSTEM 보다 이긴다 — 값은 이 한 곳에 둔다(개발도 같다 — docker-compose.dev.yml 은 덮어쓰지 않는다)
+    command: ["postgres", "-c", "shared_buffers=256MB"]
     expose:
       - "5432"
     environment:
@@ -252,11 +256,15 @@ services:
       timeout: 5s
       retries: 5
       start_period: 10s
+    # 메모리 — 1g (14단계에 512m 에서 올렸다 — 2026-11-05 사용자 결정). 메일 검색 색인의 찾기는 표 · 색인이 메모리에 있을 때만 1초 안이다 —
+    # 2026-11-05 개발(1만 통 · 색인 121MB)에서 캐시가 비면 3~8배 느렸다. 512m 로도 모자라지는 않았다(채우기 0.16GB 안팎 · 찾기 시험 최대 236MiB) — 늘린 몫은 색인을 메모리에 두는 자리다.
+    # 공유 버퍼(위 command) 밖은 연결마다의 작업 메모리와 표 · 색인의 페이지 캐시다 — 페이지 캐시도 이 한도에 잡힌다(다시 쓸 수 있는 메모리라 줄여 가며 쓴다).
+    # 8GB 서버의 합은 mail/README.md "메모리 예산". 값을 바꾸면 다음 up 이 db 를 다시 만든다 — 수 초 멈추고 backend 는 다시 붙는다(같은 절의 차례)
     deploy:
       resources:
         limits:
           cpus: '0.5'
-          memory: 512m
+          memory: 1g
 
   # ----------------------------------------
   # 4. Redis — 내부 네트워크 전용 · 기본 비활성
diff --git a/docs/design/webmail/README.md b/docs/design/webmail/README.md
index 67430ec..31be2fd 100644
--- a/docs/design/webmail/README.md
+++ b/docs/design/webmail/README.md
@@ -297,7 +297,8 @@ API 와 서버 규칙은 계약 2절 "새 메일 확인" · "검색" · "여러
 - **알림**(오른쪽 아래 · 되돌리기가 있으면 10초): "메일 N통을 보낸편지함으로 옮겼습니다." [되돌리기] · "메일 N통을 휴지통으로 옮겼습니다." [되돌리기] ·
   "메일 N통을 영구 삭제했습니다." · 일부만 처리했으면 뒤에 "1통은 그사이 옮겨졌거나 지워져 그대로 두었습니다."
   (메일함 이름의 받침에 맞춰 '으로/로'). 읽음 · 중요 표시는 목록이 바로 바뀌므로 알리지 않는다.
-- **영구 삭제 확인**: 휴지통에서만. 제목 "메일 N통을 영구 삭제할까요?" · 글 "휴지통에서 지운 메일은 되돌릴 수 없습니다." ·
+  [되돌리기] 뒤 알림은 한 메일함으로 되돌렸으면 "메일 N통을 받은편지함으로 되돌렸습니다.", 여러 곳이면 "메일 N통을 되돌렸습니다."(2026-11-07 — 잇달아 되돌린 알림을 가를 수 있게).
+- **영구 삭제 확인**: 휴지통에서만. 제목 "메일 N통을 영구 삭제할까요?"(대화로 묶은 휴지통에서 줄을 골랐으면 "휴지통에 있는 메일 N통을 영구 삭제할까요?" — 14단계) · 글 "휴지통에서 지운 메일은 되돌릴 수 없습니다." ·
   [영구 삭제](#B42318 채움) [취소] — 열리면 「취소」에 초점이 간다.
 - 메일함을 바꾸거나 검색하면 선택을 푼다.
 
@@ -539,10 +540,10 @@ API 와 서버 규칙은 계약 2절 "실시간 알림".
 - **보낸 뒤 알림**(오른쪽 아래): "메일을 보냈습니다." + [보내기 취소] + 아래 남은 시간 막대(설정한 초 — 마우스를 올려도 멈추지 않는다) → 시간이 지나면 저절로 닫힌다.
   일부가 받지 못하면 빨간 알림 "보냈지만 1명은 받지 못합니다. 주소 (까닭)" + [보내기 취소](주소를 고쳐 다시 보낼 수 있게).
   [보내기 취소] → "보내기를 취소했습니다. 쓰던 메일로 돌아왔습니다." + 그 메일로 쓰기 화면(받는 사람 · 제목 · 본문 · 첨부 그대로). 늦게 누르면 "이미 보낸 메일이라 취소할 수 없습니다."
-  예약 → "10월 30일 (금) 오전 9:00 에 보냅니다." + [예약됨 보기]. 로그아웃 · 다른 계정 로그인 때 알림은 닫는다 — 메일은 그대로 보내진다.
+  예약 → "10월 30일 (금) 오전 9:00에 보냅니다." + [예약됨 보기]. 로그아웃 · 다른 계정 로그인 때 알림은 닫는다 — 메일은 그대로 보내진다.
 - **「예약됨」**: 메일함 패널의 보낸편지함 아래(예약한 메일이 있을 때만, 시계 아이콘, 오른쪽에 통 수). 목록은 받는 사람 · 제목 · 보낼 시각(청록 글 — "10월 30일 (금) 오전 9:00") 차례,
   고르는 칸 · 여러 통 처리는 없다. 보낸 메일은 저절로 빠지고 보낸편지함에 남는다.
-- **예약한 메일을 열면**: 머리 아래 청록 안내 줄 "10월 30일 (금) 오전 9:00 에 보낼 메일입니다." + [고치기](예약을 취소하고 쓰기 화면으로) [예약 취소](보내지 않고 임시보관함으로 —
+- **예약한 메일을 열면**: 머리 아래 청록 안내 줄 "10월 30일 (금) 오전 9:00에 보낼 메일입니다." + [고치기](예약을 취소하고 쓰기 화면으로) [예약 취소](보내지 않고 임시보관함으로 —
   알림 "예약을 취소하고 임시보관함으로 옮겼습니다." + [고치기]). 답장 · 전달 · 스팸 신고 단추는 없다. [삭제]는 예약을 취소한 뒤 휴지통으로(확인 창).
 - **보낸편지함**: 아직 보내지 않은 메일은 날짜 칸이 "예약 · 10월 30일 오전 9:00"(청록) — 보내기 취소를 기다리는 동안은 "보내는 중".
 
@@ -571,7 +572,7 @@ API 와 서버 규칙은 계약 2절 "실시간 알림".
 ### 쓰기 화면 — 첨부 칸 (`ComposeLargeFiles`)
 
 - **링크로 바뀌는 때**: 파일 하나가 20MB 를 넘을 때, 메일에 담은 파일의 합계를 25MB 넘게 만들 때(고른 차례대로 그 파일부터), 메일에 담지 못하는 형식(mp4 · mov · dwg · dxf · psd · ai · 7z)일 때 저절로 링크로 보낸다.
-  묻는 창은 없다 — 합계 때문에 바뀌면 칸 아래 ⓘ 한 줄 "‘회의자료_전체.pptx’(9.4 MB)는 메일에 담으면 합계가 25MB 를 넘어 링크로 보냅니다."(role=status). 받는 사람이 사내뿐이어도 같은 규칙이다.
+  묻는 창은 없다 — 합계 때문에 바뀌면 칸 아래 ⓘ 한 줄 "‘회의자료_전체.pptx’(9.4 MB)는 메일에 담으면 합계가 25MB를 넘어 링크로 보냅니다."(role=status). 받는 사람이 사내뿐이어도 같은 규칙이다.
   메일에 담은 파일도 줄의 링크 단추(40 · 「링크로 보내기」 — 마우스를 올리면 같은 글)로 바꿀 수 있다 — **이 쓰기 화면에서 고른 파일에만** 있다(전달 원본 · 저장본에서 이어 온 첨부에는 없다 — 처음 판).
   링크 → 메일에 담기 단추는 없다(빼고 다시 고르면 한도 안에서 담긴다 — 아래 "처음 판에서 미룬 것").
 - **안내문**: "파일당 최대 20MB · 합계 25MB · 최대 20개 · 더 큰 파일은 파일당 2GB, 10개까지 링크로 보냅니다".
@@ -590,7 +591,7 @@ API 와 서버 규칙은 계약 2절 "실시간 알림".
   | 위험 | "위험한 내용이 발견되어 보낼 수 없습니다. 이 파일을 빼 주세요."(경고 삼각형) | 빨간 줄 · ✕ |
 
 - **올리기 전 검사**(지금 첨부 사전 검사와 같은 결 — 넘으면 올리지 않고 빨간 줄, 그 파일만 빠지고 보내기는 막지 않는다):
-  "파일 하나는 2GB 까지 보낼 수 있습니다." · "링크로 보내는 파일은 메일 한 통에 10개까지입니다." ·
+  "파일 하나는 2GB까지 보낼 수 있습니다." · "링크로 보내는 파일은 메일 한 통에 10개까지입니다." ·
   "대용량 첨부는 10GB까지 보관할 수 있어 더 올릴 수 없습니다. 보내지 않은 파일을 지우거나 링크를 끊으면 바로 공간이 생깁니다. [대용량 첨부 보기]" ·
   "지금은 서버에 공간이 모자라 올릴 수 없습니다. 잠시 후 다시 시도해 주세요." · 형식은 `FILE_001` 사전 문구.
   링크로 보낼 수 있는 형식 = 일반 첨부 목록 + mp4 · mov · dwg · dxf · psd · ai · 7z. 실행 파일(exe · msi · bat · cmd · js · vbs · scr 등)과 디스크 이미지(iso · img · vhd)는 막는다. 파일 고르기 창은 두 목록을 합친 형식만.
@@ -651,7 +652,7 @@ API 와 서버 규칙은 계약 2절 "실시간 알림".
   "한국 시간으로 2026년 11월 29일(일)까지 내려받을 수 있습니다. 30일 남았습니다."(날짜만 굵게) → 파일 목록(줄마다 아이콘 36 · 이름 · "1.2 GB · 보안 검사 결과 이상 없음" · [내려받기](채운 단추 44)) →
   "내려받다 끊기면 브라우저의 다운로드 목록에서 다시 시도해 주세요. 받은 곳부터 이어서 받습니다." →
   청록 상자 "이 화면은 로그인이나 비밀번호를 묻지 않습니다. 묻는 화면이 나오면 닫고 보낸 사람에게 확인해 주세요." →
-  "받을 이유가 없는 파일이면 postmaster@arasystem.it.kr 로 알려 주세요."(운영 설정 — 처음 값 postmaster@메일 도메인) → 영어 한 줄.
+  "받을 이유가 없는 파일이면 postmaster@arasystem.it.kr(으)로 알려 주세요."(조사는 주소의 끝 글자로 고르고 영문이면 "(으)로" — 주소는 운영 설정이라 바뀔 수 있다, 2026-11-07)(운영 설정 — 처음 값 postmaster@메일 도메인) → 영어 한 줄.
 - 메일 제목 · 본문 · 받는 사람, 내려받은 수 · 남은 수는 보이지 않는다. [내려받기]는 형식과 상관없이 늘 저장이고, 누르기 직전에 상태를 한 번 더 묻는다. noindex · no-referrer.
 - **상태**(모든 상태에서 머리 · 영어 한 줄은 그대로. 신고 주소 줄은 링크 정보를 받은 상태에서만 — 없는 링크 · 요청이 너무 많음 · 오류 응답에는 그 값이 없다):
   - 검사 중 — 모두 검사 중이면 제목 "보안 검사 중입니다" / "파일을 검사하고 있습니다. 몇 분 뒤 이 화면을 다시 열어 주세요." + [다시 확인]. 일부면 그 줄만 "보안 검사 중" + [내려받기] `aria-disabled`.
@@ -685,7 +686,7 @@ API 와 서버 규칙은 계약 2절 "실시간 알림".
   - 최근에 보낸 차례 · 20개씩 [더 보기].
 - **[링크 복사]는 두지 않는다** — 서버는 링크를 해시로만 알아 원래 주소를 모른다. 주소는 보낸 메일의 읽기 화면(보낸 사람 자신)에서 복사한다.
 - [링크 끊기] → 읽기 화면과 같은 확인 창 · 같은 알림(창 글에 메일 제목). 끊는 동안 그 덩이의 [링크 끊기]를 막고, 끝나면 초점을 덩이 머리로.
-- **빈 상태**: 사용량 "0 / 10 GB" + "링크로 보낸 파일이 없습니다" / "메일 쓰기에서 20MB 가 넘는 파일을 고르면 링크로 보냅니다. 받는 사람은 보낸 날부터 30일 동안 내려받을 수 있습니다."
+- **빈 상태**: 사용량 "0 / 10 GB" + "링크로 보낸 파일이 없습니다" / "메일 쓰기에서 20MB가 넘는 파일을 고르면 링크로 보냅니다. 받는 사람은 보낸 날부터 30일 동안 내려받을 수 있습니다."
   보내지 않은 파일이 있으면 그 묶음은 위에 그대로 있다. 목록을 받지 못하면 지금의 목록 오류와 같은 모양.
 - **위험이 나오면** 빨간 알림 "올린 대용량 파일 ‘견적_요청서.zip’에서 위험한 내용이 발견되어 막았습니다." + [대용량 첨부 보기] —
   웹메일을 열어 둔 동안 실시간 알림(`large-file`)으로 바로 띄운다. 그때 열려 있지 않았으면 알림은 없고 목록 · 첨부 칸의 상태(위험)로만 안다 —
@@ -1034,7 +1035,7 @@ API 와 서버 규칙은 계약 2절 "실시간 알림".
 같은 대화(답장 · 전달로 이어진 메일)를 읽기 화면에 늘 보이고, 목록은 사용자가 켜면 대화로 묶는다.
 까닭은 엔진 실측(2026-11-03)이다 — 엔진 스레드는 `회신:` · `답장:` · `전달:` 을 떼지 않아 한국어 Outlook 의 답장이 따로 떨어지고, 엔진 검색은 어절이 통째로 같을 때만 맞는다.
 데이터 · API 규칙(색인 · 대화 · 조건)은 구현 때 계약 2절에 더한다. 구현 · 배포는 전환 뒤 안정화(1~2주) 다음이다.
-새 토큰은 없다 — 조건 칸 40 은 필터 조건 칸의 밀도 예외(`--size-filter-control`), [대화로 묶기] 36 은 안내 줄 단추의 밀도 예외(`--size-notice-action`)를 다시 쓴다.
+새 크기 토큰은 없다 — 조건 칸 40 은 필터 조건 칸의 밀도 예외(`--size-filter-control`), [대화로 묶기] 36 은 안내 줄 단추의 밀도 예외(`--size-notice-action`)를 다시 쓴다(구현 때 [조건] 32 도 — 아래 "14단계 구현하며 정한 보완"). 강조 노랑만 색 토큰(`--color-search-mark`)을 하나 둔다.
 문구는 위 「화면 문구 — 사용자에게 말하듯」을 따른다.
 
 ### 검색 · 조건 검색 · 강조 (`Search14`)
@@ -1050,8 +1051,8 @@ API 와 서버 규칙은 계약 2절 "실시간 알림".
 - **결과 줄**(높이 64, 세 줄): 보낸 사람 · 시각 / 제목(+ 첨부 표시) / 미리 보기 한 줄(맞은 말 둘레). 제목 · 미리 보기의 맞은 말은 `<mark>`(노랑 `#FCE7A4` · 글자색은 그대로).
 - **읽기 화면 강조**: 제목 · 본문 · 첨부 이름의 맞은 말. 본문은 서버가 정화한 HTML 의 글 조각에만 `<mark>` 를 넣는다(찾기와 같은 정규화 · 부분 일치). 맞은 곳 사이 이동(다음 · 이전)은 이번에 넣지 않는다.
 - **검색 준비 중**: 지난 메일의 색인을 만드는 동안 그 직원의 검색은 지금 방식(엔진) 그대로이고, 결과 머리 아래 안내 줄(옅은 청록 바탕 · role=status)
-  "지난 메일을 검색할 수 있게 준비하고 있습니다. 준비가 끝날 때까지는 낱말이 통째로 같은 메일만 찾습니다."
-- **결과 없음**: "‘계약’에 맞는 메일이 없습니다" / "다른 말로 찾거나 조건을 줄여 보세요." + [전체 메일함에서 찾기](그 메일함에서 찾을 때만). 지금의 한계 안내("낱말 단위로 찾습니다 …")는 색인이 준비된 뒤에는 뺀다.
+  "지난 메일을 검색할 수 있게 밤사이에 준비하고 있습니다. 메일이 많으면 며칠 걸릴 수 있고, 그동안은 낱말이 통째로 같은 메일만 찾습니다."(2026-11-07 사용자 관점 점검 — 색인은 밤에만 채워, 낮 내내 같은 글이면 멈춘 줄 안다)
+- **결과 없음**: "‘계약’에 맞는 메일이 없습니다" / "다른 말로 찾거나 조건을 줄여 보세요." + [전체 메일함에서 찾기](그 메일함에서 찾을 때만). 지금의 한계 안내는 색인이 준비된 뒤에는 뺀다 — 준비 중에는 위 안내 줄과 겹치지 않게 "준비가 끝나기 전에는 ‘서버이전’의 ‘서버’처럼 붙여 쓴 말의 일부나, 제목 맨 앞의 [공지]나 Re: 같은 말머리로는 찾지 못합니다."(2026-11-07).
 - 검색 결과는 대화로 묶지 않는다(한 통씩).
 
 ### 읽기 화면 — 같은 대화 (`Thread14`)
@@ -1073,6 +1074,7 @@ API 와 서버 규칙은 계약 2절 "실시간 알림".
 ### 처음 판에서 미룬 것
 
 본문 강조의 다음 · 이전 이동, 검색어 줄임말(from: 같은 꼴), 대화째 끌어다 놓기, 첨부 파일 안의 글 찾기, 끝이 바뀐 말 찾기(형태소 분석).
+같은 대화 칸 머리의 [모두 펼치기]와 펼친 줄 머리의 [답장]도 다음 후보로 둔다(2026-11-07 사용자 관점 점검에서 나온 제안 — 사용자가 미루기로 정함). 지금은 줄마다 펼치고, [답장]은 펼친 본문 아래에만 있다.
 
 ## 구현하며 정한 보완 (2026-10-26 — 캔버스에는 아직 없다)
 
@@ -1374,3 +1376,99 @@ API 와 서버 규칙은 계약 2절 "실시간 알림".
 - **설정 › 대용량 첨부**: 보낸 링크 머리의 메일 제목이 없으면(지웠거나 읽지 못함 — `subject: null`) 글자만, 빈 제목은 메일이 있는 것이라 링크다.
   [지우기]가 `FILE_003`(그사이 보내져 링크에 실림)이면 목록 · 사용량을 다시 받고 사전 문구로 알린다.
 - **내려받기 화면**: 보낸 사람 이름이 비어 있으면 주소를 쓴다. 불러오는 동안은 `role="status"` "불러오는 중"(자리 막대는 `aria-hidden`).
+
+### 14단계 구현하며 정한 보완 — 검색 (2026-11-06 — 캔버스에는 아직 없다)
+
+주소 · 이어 찾기의 값은 계약 2절 "검색 — 14단계"의 클라이언트 줄이 같은 내용이다.
+
+- **크기**: [조건] 단추는 높이 32 — 목록 표 별 · 보기 전환의 밀도 예외(`--size-compact-control`)를 다시 쓴다. 패널의 칸 · 단추 40(`--size-filter-control`), 조건 줄 40 · 줄 안 [조건 지우기] 36(`--size-notice-action`). 새 크기 토큰은 없다.
+- **[조건] 패널**
+  - 단추의 title "조건으로 찾기", 조건이 걸려 있으면 화면 낭독에 ", 조건이 걸려 있음"을 붙인다.
+  - 칸 안내는 "이름이나 메일 주소"(보낸 사람 · 받는 사람) · "제목에 든 말" · "내용에 든 말"(칸 이름 "내용"과 같게 — 2026-11-07)이고, 날짜 칸은 "시작 날짜" · "끝 날짜"다.
+  - 날짜가 거꾸로면 알림 대신 칸 아래 "끝 날짜를 시작 날짜와 같거나 그 뒤로 골라 주세요.", 고를 수 있는 날짜 밖이면 "날짜는 1970년 1월 1일부터 9999년 12월 30일 사이에서 골라 주세요."(날짜 고르기는 이미 막고, 해를 손으로 칠 때만 보인다).
+  - 패널의 [조건 지우기]는 패널 안의 칸만 비운다 — 보낸 사람 · 받는 사람 · 제목 · 내용 · 기간(전체 기간으로) · 날짜 · 첨부 체크와 칸 아래 알림까지(2026-11-07 사용자 확정 — 보드와 다르다).
+    패널은 열린 채이고 찾지 않으며 초점은 그 단추에 남는다. 걸린 조건 · 조건 줄 · 결과는 [찾기]를 누를 때까지 그대로이고, [찾기] 없이 닫았다 다시 열면 걸린 조건으로 다시 채운다.
+    비운 채 [찾기]를 누르면 검색어가 있으면 조건만 빼고 다시 찾고, 검색어도 없으면(조건만 걸린 검색) 검색을 닫는다. 걸린 조건을 바로 빼는 것은 결과의 조건 줄 [조건 지우기]다(조건만 걸린 검색이면 검색을 닫는다).
+  - 패널이 열린 채 검색 칸에서 Esc 를 누르면 패널만 닫고 초점은 검색 칸에 남는다.
+- **기간**: "최근 N"은 고른 순간 날짜로 바꾼다 — 그만큼 앞의 같은 날부터 오늘까지(1주는 7일 전, 달은 말일을 넘지 않는다).
+- **조건 줄 글**: "조건: " 뒤에 쉼표로 잇는다 — "{이름} 님이 보낸 메일" · "{이름} 님이 받은 메일" · "제목에 ‘{말}’이/가 든 메일" · "내용에 ‘{말}’이/가 든 메일" · "최근 1달" 또는 "2026. 10. 1.부터 11. 5.까지"(같은 해면 끝 날짜의 해를 뺀다) · "…부터" · "…까지" · "첨부 있음". 시작과 끝이 같은 날이면 "2026. 11. 6. 하루", 보낸 사람 · 받는 사람 값이 내 이름이나 주소와 통째로 같으면(앞뒤 공백 · 대소문자 무시) "내가 보낸 메일" · "내가 받은 메일"(2026-11-07).
+- **결과 줄**: 분할 보기는 보드대로 세 줄 64 다. **목록 보기(표)는 행 38 그대로 두고 제목만 강조한다**(미리 보기 줄 없음).
+  결과 줄에도 별 · 고르기 칸을 남겼다 — 3단계부터 검색 결과에서도 여러 통을 고르고 처리한다(보드의 결과 줄에는 없다).
+- **글**
+  - 조건만으로 찾았을 때 머리 글은 "N통" · "찾는 중", 결과 없음은 "조건에 맞는 메일이 없습니다" / "조건을 바꾸거나 줄여 보세요.".
+    결과 없음의 도움말은 검색어 + 조건이면 "다른 말로 찾거나 조건을 줄여 보세요.", 검색어만(걸린 조건 없음)이면 "다른 말로 찾아 보세요."(2026-11-07 — 조건이 없는데 "조건을 줄여"라고 했다).
+  - 옛 한계 안내("낱말 단위로 찾습니다 …")는 색인을 채우는 동안(`building`)만 결과 없음 아래에 더한다.
+  - 한 글자 안내: "한 글자로만 찾을 때는 본문은 빼고 제목, 보낸 사람과 받는 사람, 첨부 파일 이름에서 찾습니다. 본문까지 찾으려면 두 글자 이상으로 찾아 주세요." — 색인이 준비됐고 본문을 찾을 말(검색어나 내용 조건)이 있을 때만.
+  - 준비 상태를 받지 못하면(요청 실패) 안내 줄 · 옛 한계 안내 · 한 글자 안내를 모두 보이지 않는다.
+- **[더 찾기]**: 한 번에 다 찾지 못하면 "아직 맞는 메일을 찾지 못했습니다" / "메일이 많아 한 번에 다 찾지 못했습니다. [더 찾기]를 누르면 이어서 찾습니다." + [더 찾기](찾는 동안 "찾는 중…").
+  하나도 못 찾았으면 "찾는 중"을 이어 보이고, 하나라도 찾으면 먼저 보이면서 뒤에서 잇는다. 목록 보기의 [다음]은 이어 받는 동안 기다렸다가 넘기고, 그동안 꺼짐 · `aria-busy` 다.
+- **낱말이 너무 많은 주소**(손으로 고친 주소): "찾을 말이 너무 많습니다" / "검색어와 조건에 넣은 낱말은 모두 합쳐 8개까지 찾을 수 있습니다. 검색 칸이나 [조건]에서 낱말을 줄여 주세요." — [전체 메일함에서 찾기] · 알림 없이, 조건 줄의 [조건 지우기]는 남긴다.
+- **강조 색**: 노랑 `#FCE7A4` 는 색 토큰 `--color-search-mark` 하나로 두고, 본문 틀 안 CSS 는 같은 값을 직접 적는다(짝). 보낸 사람이 본문에 쓴 `<mark>` 도 같은 노랑으로 보인다(드물어 가르지 않는다).
+  미리 보기 줄(회색 `--color-text-muted`)의 맞은 말만 글자를 `--color-text-secondary`(#4A5363)로 진하게 한다 — 회색 그대로면 노랑 위 대비가 4.05:1 로 4.5:1 에 못 미친다(2026-11-07 사용자 확정 — 보드와 다르다, 앱도 같다). 제목 · 읽기 화면 · 본문 틀의 강조는 진한 글 위라 글자색 그대로다.
+- 긴 안내 글(결과 없음 · [더 찾기] · 안내 줄)은 낱말 가운데서 줄을 바꾸지 않는다(`word-break: keep-all`).
+
+### 14단계 구현하며 정한 보완 — 같은 대화 (2026-11-06 — 캔버스에는 아직 없다)
+
+받기 · 다시 받기의 값은 계약 2절 "대화 — 14단계"의 클라이언트 줄이 같은 내용이다.
+
+- **크기**: 줄 48 · 머리글자 28, 펼친 줄의 [답장] · [이 메일만 열기] 36(안내 줄 단추의 밀도 예외 `--size-notice-action` 재사용), [더 보기] · [다시 시도] 44. 새 크기 토큰은 없다.
+- **보드와 다르게 한 것**
+  - 지금 보는 메일 줄의 바탕은 가장 가까운 기존 토큰 `--color-brand-tint`(#F3F8F8 — 보드 #F2F8F8, 시각 글자 대비 4.6:1).
+  - 칸 제목은 h3 다 — 읽기 화면 제목이 h2 · 첨부 칸이 h3 이라 같은 층으로(보드는 제목을 h1 로 써서 h2 였다).
+  - 펼친 본문은 읽기 화면과 같은 본문 틀(14px — 보드 13.5px)이다.
+  - 펼친 줄에는 외부 이미지 안내 · 첨부 목록을 두지 않는다 — 본문을 줄였거나 HTML 을 보이지 못하면 읽기 화면과 같은 노란 안내 줄만 두고, 나머지는 [이 메일만 열기]로 연 읽기 화면에서 본다.
+    다만 첨부가 있으면 본문 아래 · [답장] 위에 클립과 "첨부 파일 N개는 [이 메일만 열기]를 누르면 볼 수 있습니다."(12.5 회색 — 수는 읽기 화면과 같은 셈: 본문 그림 빼고 대용량 첨부 더해)를 둔다(2026-11-07 — 본문은 첨부했다는데 표시가 없었다).
+- **보드에 없어서 정한 것**
+  - 칸 머리의 통 수는 다 셀 수 있을 때만 "같은 대화 N통"이고, 아직 다 받지 못해 수를 모르면 "같은 대화"다.
+  - 남은 메일이 있으면 상자 아래 [더 보기](받는 동안 "불러오는 중…" · `aria-busy`).
+  - 받지 못하면 칸 자리에 "같은 대화를 불러오지 못했습니다." + [다시 시도] + 문의 코드. 이 경로가 없는 옛 서버(404)면 칸이 없다.
+  - 시각은 "오늘 오전 9:30" · "어제 …" · "10월 29일 (목) 오전 9:30" · 다른 해는 "2025. 10. 29. (수) …" 꼴이다.
+  - 내가 보낸 메일 · 임시 저장본은 이름 자리에 "나" + 회색 메일함 이름("보낸편지함" · "임시보관함"), 다른 메일함에 든 내 메일은 "나"만. 지금 보는 메일 줄에는 회색 글을 두지 않는다(보드 그대로).
+  - 미리 보기가 비면 제목을 보인다. 우리 웹 · 앱의 원문 인용 머리 "> 원본 메일"(끝에서 잘린 "> 원…" 포함)부터 뒤는 잘라 내고 남는 글이 없으면 제목이다 — 다른 메일 프로그램의 인용 꼴은 그대로(2026-11-07).
+  - 줄 차례는 서버 차례(받은 시각 — 내 메일은 저장한 시각) 그대로이고, 보내기를 기다리는 메일(보내기 취소 · 예약)만 받은 줄의 맨 끝에 보낼 시각 차례로 둔다(2026-11-07 — 예약 줄이 시각 차례를 거슬렀다).
+  - 임시 저장본 줄은 [답장]이 없고 [이 메일만 열기]가 쓰기 화면으로 연다. 예약한 메일은 [답장]이 없다(보내기 취소를 기다리는 메일은 읽기 화면처럼 있다).
+  - 붙잡힌 메일의 시각 자리는 목록과 같은 보내기 취소 · 예약 표시(청록 굵게)다.
+- **펼치기**: 안 읽은 메일을 펼치면 읽음이 된다(읽기 화면에서 연 것과 같다). 접힌 줄의 받아 둔 본문은 최근 10통까지만 기억한다. 펼친 본문 안에서 Ctrl+P 는 그 펼친 메일의 인쇄 화면을 연다.
+- **안 읽은 줄**(2026-11-07 사용자 확정 — 보드와 다르다): 목록 줄과 같은 굵기 · 색이다 — 이름 650, 미리 보기 · 시각 600(붙잡힌 메일의 시각은 청록 그대로). 화면 낭독은 이름 앞에 목록과 같은 "안 읽음, ". 임시 저장본은 목록처럼 읽음 여부를 보이지 않는다.
+  이 탭에서 바꾼 읽음(줄을 펼침 · 읽기 화면에서 연 메일 · 목록과 여러 통 처리의 읽음 · 안 읽음 표시 · 메일함 ⋯ › 모두 읽음)은 줄에 바로 보이고, 바꾸지 못해 되돌리면 줄도 되돌린다. 받는 동안 바꾼 것과 받기를 시작할 때 보내던 것은 받은 값보다 이 탭의 값을 믿는다.
+  다른 탭 · 기기에서 바꾼 읽음은 다음에 칸을 다시 받을 때 보인다(그 줄을 펼치면 받은 본문대로 바로 풀린다). 읽은 줄의 이름(600)과 안 읽은 줄(650)의 차이는 작아 눈에 띄는 차이는 미리 보기 · 시각이다 — 읽은 줄 이름을 낮추는 것은 보드를 바꾸는 일이라 두었다.
+- **[이 메일만 열기]**: 분할 보기는 방문 기록을 쌓고(목록 줄을 누른 것과 같다), 목록 보기는 바꿔 끼운다(이전 · 다음과 같다 — [목록으로]가 기록을 쌓지 않게).
+  지금 목록에 든 메일은 그 목록 안에서, 검색 결과 · 예약됨은 받아 둔 줄에 있을 때만 그 목록 안에서, 그 밖은 그 메일이 든 메일함에서 연다.
+- **초점**: 누른 단추가 사라지면(칸의 [다시 시도]가 성공 · [더 보기]로 끝까지 받음 · 다시 받아 줄이 빠짐) 그 줄의 펼침 단추 → 새 [다시 시도] → 칸 제목 차례로 옮기고, 칸이 통째로 사라지면 본문으로 옮긴다.
+  [이 메일만 열기] 뒤에는 삭제 뒤 다음 메일로 갈 때처럼 따로 옮기지 않는다(두 길을 함께 고칠 거리).
+- **다시 받기**: 새 메일 · 지움 · 옮김으로 메일함 통 수가 바뀔 때와 쓰기 화면에서 돌아올 때만 다시 받는다 — 읽음 표시만 바뀐 소식으로는 받지 않는다(받으면 메일을 열 때마다 대화를 한 번 더 받는다). 칸의 읽음은 위 "안 읽은 줄"처럼 이 탭에서 바꾼 것만 바로 적는다.
+
+### 14단계 구현하며 정한 보완 — 목록 대화로 묶어 보기 (2026-11-06 — 캔버스에는 아직 없다)
+
+받기 · 맞추기 · 줄에 하는 일의 규칙은 계약 2절 "대화 — 14단계"의 클라이언트 줄(목록을 대화로 묶어 보기)이 같은 내용이다.
+
+- **크기 · 모양**
+  - [대화로 묶기]는 36 — 안내 줄 단추의 밀도 예외(`--size-notice-action`)를 다시 쓴다. 새 크기 토큰은 없다.
+    분할 보기는 아이콘만(36×36 — 휴지통 [비우기]와 같은 결, 이름은 title · 화면 낭독), 목록 보기는 이름까지 보인다.
+    분할 보기에 이름까지 넣으면(99) 1440 에서 개수 글 자리가 25px 남짓이라 아이콘으로 두고, 설정 설명이 말풍선 모양이라고 알린다(2026-11-07 잼).
+  - 켠 모양은 옅은 청록 바탕 + 진한 청록 글자이고 테두리는 그대로다(보드의 #9FD3D7 테두리는 새 색 토큰이라 두지 않았다).
+  - 설정 › 메일 › 보내기 · 읽기의 한 줄은 외부 이미지 아래 가는 선 뒤 — 끔 · 켬 전환(`.segmented--outline` — 보내기 취소와 같은 모양)과
+    "답장과 전달로 이어진 메일을 메일함 목록에서 한 줄로 묶어 보여 줍니다. 메일함 목록 위의 말풍선 모양 [대화로 묶기] 단추로도 켜고 끌 수 있습니다." — 줄 이름은 단추와 같은 "대화로 묶기"(2026-11-07).
+- **줄**
+  - 고르기 칸 · 별을 남겼다(보드의 줄에는 없다 — 검색 결과 줄과 같은 판단, 3단계부터 목록에서 여러 통을 고른다).
+    메일이 모두 보내기를 기다리는 줄은 고르기 칸 · 별이 꺼짐(aria-disabled) + 까닭이고, 목록 보기에서 Ctrl · Shift + 클릭으로도 고르지 않는다.
+  - 참여자: 다른 사람은 받은 차례대로, 나는 끝에 "나"(보드 "이도윤, 나" · "인사팀, 김민수, 나"). 보낸편지함 · 임시보관함에서 참여자가 나뿐이면 메일 목록처럼 "받는 사람: …"이다.
+    임시보관함의 제목 없는 줄은 흐린 "(제목 없음)"이다(메일 줄과 같다).
+  - 목록 보기(표)는 고르기 · 별 · 참여자(+ 회색 "N통" — 머리 글은 모든 메일함에서 "참여자", 2026-11-07) · 제목 · 날짜다 — **크기 칸은 뺐다**(대화의 크기는 마지막 메일의 크기가 아니다).
+    표 제목은 "{메일함} 대화 목록", 머리 고르기는 "불러온 대화 모두 고르기", 고른 수는 "대화 N개 선택됨"이다(분할 보기의 도구 줄은 "N개 선택됨" — 화면 낭독은 "대화 N개 선택됨", 단추 일곱과 한 줄 53 이 되게, 2026-11-07).
+  - 목록 머리가 좁으면 개수가 먼저 줄고 메일함 이름은 남는다(개수에 마우스를 올리면 다 보인다). **묶지 않았을 때의 머리 글도 보드 글로 바꿨다**("전체 9 · 안 읽음 2" → "메일 9통, 안 읽은 메일 2통").
+    분할 보기(좁은 머리)는 안 읽은 메일이 있으면 "안 읽은 메일 N통"만, 없으면 "메일 N통" · "대화 N개"를 보이고 전체 글은 title · 화면 낭독에 둔다 — 머리의 칸 사이는 이름↔개수 6 · 머리↔단추 4 · 단추끼리 4(2026-11-07 — 1440 에서 안 읽은 수가 늘 잘렸다).
+  - 줄에 한 옮기기 · 삭제 · 스팸 신고 · 스팸 아님 알림은 "{메일함}에 있는 메일 N통을 {갈 곳} 옮겼습니다." 꼴이다(줄의 통 수는 대화 전체라 "4통" 줄에서 "메일 2통"이 헷갈렸다 — 2026-11-07). 휴지통의 영구 삭제도 같은 꼴이다 — 확인 창 "휴지통에 있는 메일 N통을 영구 삭제할까요?" · 알림 "휴지통에 있는 메일 N통을 영구 삭제했습니다."(일부만 지웠으면 뒤의 "N통은 그사이 …"는 그대로). 묶지 않은 목록 · 읽기 화면은 그대로다.
+  - 메일 화면은 탭이 다시 보일 때 설정을 마지막으로 받은 지 60초가 지났으면 조용히 다시 받는다 — 다른 탭 · PC 에서 바꾼 묶기면 목록을 다시 열고, 보내기 취소 초 · 외부 이미지도 받은 값을 쓴다(받는 동안 단추를 숨기지 않고, 세션이 끝났으면 받지 않는다 — 2026-11-07).
+  - "새 메일 N통 · 맨 위로"는 맨 앞에 새로 생긴 줄을 1통, 새 메일이 든 기존 줄을 새 메일 수로 센다.
+- **줄의 별**: 중요 표시가 하나라도 있으면 모두 풀고, 없으면 모두 표시한다. 보내기를 기다리는 메일만 중요 표시가 남으면
+  "보내기를 기다리는 메일은 목록에서 중요 표시를 바꿀 수 없습니다. 메일을 열어 바꿔 주세요."
+- **읽기 화면**
+  - [이전] · [다음]은 대화 사이를 오간다(앞뒤 줄의 마지막 메일). 위치는 "n / 대화 수"이고, 같은 대화 칸의 [이 메일만 열기]로 연 더 오래된 메일도 그 메일이 든 줄을 기준으로 한다. [목록으로]는 그 줄로 초점을 돌려준다.
+  - [삭제](한 통) 뒤 열 메일(분할 보기 — 목록 보기는 지금처럼 목록으로): 그 줄에서 지운 메일의 다음 칸(더 오래된 메일), 없으면 앞 칸 →
+    줄이 비면 다음 줄의 마지막 메일, 없으면 앞 줄의 마지막 메일. 아직 다시 받기 전이라 줄에 남아 있는 옛 마지막 메일이면 남은 메일의 첫 칸이다(메일 목록의 삭제 뒤와 같은 결).
+- **첫 진입**: 설정을 받기 전에는 이 브라우저가 그 직원에게서 마지막으로 안 값(처음이면 끔)으로 연다 — 서버 값이 다르면 받는 즉시 바꾼다.
+  설정을 받지 못했으면 그 값대로 두고 [대화로 묶기]도 누를 수 있다(받는 동안에는 단추를 숨긴다). 로그아웃해도 그 값은 남고, 다른 직원이 로그인하면 그 직원의 값이다.
+- **알려진 한계**: 여러 통인 줄의 마지막 메일만 읽으면 다음 맞추기까지 줄이 굵은 채다. 마지막 메일이 아닌, 보내기를 기다리는 메일은 풀린 뒤에도 다음 맞추기까지 고를 수 없다(계약 2절).
+  분할 보기 머리는 [비우기] 단추가 있는 휴지통 · 스팸메일함, 세 자리 이상 안 읽은 수, "받은편지함"보다 긴 메일함 이름, 1120~1220 폭에서는 1440 에서도 개수 글이 잘린다(title 로 다 보인다).
+  분할 보기 도구 줄의 "N개 선택됨"은 세 자리부터 두 줄로 넘친다(메일 목록의 "123통 선택됨"도 같다).
diff --git a/docs/mail/api-contract.md b/docs/mail/api-contract.md
index aad71a7..ca5bcdc 100644
--- a/docs/mail/api-contract.md
+++ b/docs/mail/api-contract.md
@@ -264,8 +264,11 @@ HTML 은 정화하기 **전에** 길이(HTML 부분이 여럿이면 이어 붙
 | `GET /api/mail-quota` | — | 200 `MailQuota` | `MAIL_001` |
 | `GET /api/mail-state` | — | 200 `MailState` (아래 "새 메일 확인") | 503 `MAIL_001` |
 | `GET /api/mail-events` | — | `text/event-stream` (표준 래퍼 없음 — 아래 "실시간 알림", 5단계) | 401 `AUTH_001`, 429 `REQ_001`(한 직원의 연결 5개 초과), 503 `MAIL_001` |
-| `GET /api/messages` | `mailboxId` · `cursor` · `limit`(기본 20, 최대 100) · `q` — `mailboxId` 와 `q` 중 하나는 있어야 한다(`q` 만 있으면 휴지통·스팸메일함을 뺀 모든 메일함에서 찾는다 — 아래 "검색") | 200 `{ items: MessageSummary[], pageInfo }` — 받은 시각 내림차순, `total` 포함 | 400 `VAL_001`, `MAIL_001` |
-| `GET /api/messages/{id}` | `images`(선택 — `show` 면 외부 이미지를 보이는 본문, 9단계 "외부 이미지 보기") | 200 `MessageDetail` — **조회만으로 읽음 처리하지 않는다** | 400 `VAL_001`(모르는 `images` · 모르는 쿼리 — 9단계부터, 전에는 무시했다), 404 `RES_001` |
+| `GET /api/messages` | `mailboxId` · `cursor` · `limit`(기본 20, 최대 100) · `q` · 조건 `from` · `to` · `subject` · `body` · `after` · `before` · `hasAttachment`(14단계) — `mailboxId` 와 검색(`q` 또는 조건) 중 하나는 있어야 한다(검색만 있으면 휴지통·스팸메일함을 뺀 모든 메일함에서 찾는다 — 아래 "검색" · "검색 — 14단계") | 200 `{ items: MessageSummary[], pageInfo }` — 받은 시각 내림차순, `total` 포함(14단계 색인 방식은 첫 쪽만 · 1,000까지 — 넘으면 `null`) | 400 `VAL_001`, `MAIL_001` |
+| `GET /api/messages/{id}` | `images`(선택 — `show` 면 외부 이미지를 보이는 본문, 9단계 "외부 이미지 보기") · 검색 쿼리 `q` · `from` · `to` · `subject` · `body`(선택 — 맞은 말 강조, 14단계) | 200 `MessageDetail` — **조회만으로 읽음 처리하지 않는다** | 400 `VAL_001`(모르는 `images` · 모르는 쿼리 — 9단계부터, 전에는 무시했다), 404 `RES_001` |
+| `GET /api/messages/{id}/conversation` | `cursor` · `limit`(기본 100, 최대 100) | 200 `{ items: MessageSummary[], pageInfo, basis }` — 그 메일의 같은 대화, 오래된 차례(아래 "대화 — 14단계") | 400 `VAL_001`, 404 `RES_001`, 503 `MAIL_001` |
+| `GET /api/conversations` | `mailboxId`(필수) · `cursor` · `limit`(기본 20, 최대 100) — 검색 쿼리는 받지 않는다 | 200 `{ items: ConversationSummary[], pageInfo, basis }` — 그 메일함을 대화로 묶은 목록(아래 "대화 — 14단계") | 400 `VAL_001`, 404 `RES_001`(없는 메일함), 503 `MAIL_001` |
+| `GET /api/search-index` | — | 200 `{ status, done, total }` — 그 직원의 검색 색인 준비 상태(아래 "검색 색인", 14단계) | — |
 | `PATCH /api/messages/{id}` | `{ isRead?, isFlagged?, mailboxId?, isJunk? }` (하나 이상 — `isJunk` 는 4단계 "스팸 · 원문") | 200 `MessageSummary` | 404 `RES_001`, 400 `VAL_001`, 409 `MAIL_015`(붙잡힌 메일의 `mailboxId` · `isJunk` — 9단계, 아래 "보내기 취소 · 예약 발송"), 503 `MAIL_001`(붙잡혔는지 확인하지 못함 — 바꾸지 않았다) |
 | `PATCH /api/messages` | `{ ids, isRead?, isFlagged?, mailboxId?, isJunk? }` — 여러 통 (아래 "여러 통 한꺼번에") | 200 `MessagesPatched` — 붙잡힌 메일(9단계)의 `mailboxId` · `isJunk` 는 바꾸지 않고 `failedIds` 로 | 400 `VAL_001`, 404 `RES_001`(없는 `mailboxId` — 아무것도 바꾸지 않음), 503 `MAIL_001` |
 | `DELETE /api/messages/{id}` | — | 204 — 휴지통이 아니면 휴지통으로 이동, 휴지통에만 있으면 영구 삭제(확인한 상태 그대로일 때만 — 아래). 휴지통과 다른 메일함에 함께 있으면 휴지통에서만 뺀다. **웹 클라이언트는 쓰지 않는다**(3단계 — 아래 "여러 통 한꺼번에") | 404 `RES_001`, 409 `MAIL_015`(붙잡힌 메일 — 9단계), 503 `MAIL_001`(확인하는 사이 계속 바뀜 — 지우지 않았다) |
@@ -662,7 +665,7 @@ interface MailState {
   영문 · 숫자로 끝나는 낱말(ERP · 2026)은 받침을 알 수 없어 두 가지를 다 붙인다. 따옴표 구절에는 붙이지 않는다.
   조사 목록은 서버 상수 한 곳(`jmap/search-terms.ts`)에 둔다 — 한글로 끝나는 낱말은 형태 44개, 영문 · 숫자로 끝나면 59개가 되고,
   개발 엔진에서 낱말 8개(조건 472개)를 전체 메일함에서 찾는 데 0.16초였다.
-- **알려진 한계** (엔진 색인 때문 — 자체 검색 색인을 두기 전까지): 붙여 쓴 말의 일부('회의실'의 '회의', '서버이전'의 '서버'), 앞부분만 친 말('견적' → '견적서'),
+- **알려진 한계** (엔진 색인 때문 — 14단계부터는 그 직원의 자체 색인을 채우는 동안(`building`)의 검색에만 남는다, 아래 "검색 — 14단계"): 붙여 쓴 말의 일부('회의실'의 '회의', '서버이전'의 '서버'), 앞부분만 친 말('견적' → '견적서'),
   끝이 바뀐 말('보냈습니다'의 '보내'), **제목 맨 앞의 말머리**('[공지]' · '[긴급]' · 'Re:' · 'Fwd:' — 엔진이 제목을 정규화하며 색인에서 뺀다. 제목 가운데의 '[결재]'는 찾는다).
   화면은 결과가 없을 때 이 한계를 한 줄로 알린다.
 - 결과는 받은 시각 내림차순, `total` 포함. 커서는 그 검색어 · 범위로만 쓴다(다르면 400 `VAL_001`). 발송 중인 내부 초안은 지금처럼 빠진다.
@@ -676,6 +679,172 @@ interface MailState {
   범위의 기본값은 검색을 시작한 메일함이고 결과 머리에서 "그 메일함 | 전체 메일함"으로 바꾼다(휴지통 · 스팸메일함에서 시작하면 그 안에서 찾는다).
   ✕ · Esc · "검색 닫기"는 검색 전 메일함으로 돌아간다. 임시보관함의 결과를 누르면 지금처럼 쓰기 화면에서 이어 쓴다.
 
+### 검색 색인 (`GET /api/search-index`) — 14단계 (색인 바탕 — 검색은 아래 "검색 — 14단계", 대화는 "대화 — 14단계")
+
+14단계는 엔진 검색 대신 **서버의 자체 색인**(지금 DB — 디자인 README 「14단계 — 검색 · 대화 묶기」)으로 찾는다. 이 절은 그 바탕 — 색인을 만들고 맞추는 규칙과 준비 상태다.
+
+- **색인에 드는 것**: 직원 주소 + 엔진 메일 id 마다 한 줄 — 메일함 · 키워드 · 받은 시각 · 답장 관계(Message-ID · In-Reply-To · References) · 제목 · 보낸 사람 · 받는 사람 · 참조 · 첨부 이름 · 본문 글(앞 2만 자 — 잰 뒤 정한다).
+  메일 글이 DB 와 매일 백업에 한 벌 더 들어간다(사용자가 받아들였다). 퇴사 마무리는 이 표도 지운다. 언제나 로그인한 직원 주소로만 읽고 쓴다.
+- **만드는 때**: 직원이 웹메일에 처음 로그인할 때(비밀번호가 만료된 로그인은 빼고 — 새 비밀번호를 정하면 만든다) 또는 아래 경로를 처음 물을 때 그 직원의 상태 줄을 `building` 으로 만든다. 로그인한 적 없는 계정은 색인하지 않는다.
+- **지난 메일 채우기**: 밤에만 한 사람씩(KST 22:00 ~ 02:45 · 05:00 ~ 07:30 — 03:00 · 04:00 · 04:30 엔진 정리 · 03:30 백업을 피한다). 다 채우면 `ready`.
+- **새로 온 · 바뀐 · 지운 메일**은 엔진의 변경(Email/changes)으로 바로 맞춘다 — 실시간 연결이 알릴 때 · 5분마다 · 검색 바로 전. 엔진이 변경을 셀 수 없다고 하면 그 직원 전체를 대조한다.
+  비밀번호가 만료됐거나 잠긴 계정은 대리 접근이 막혀 건너뛰고, 다음 로그인 · 아래 경로를 물을 때 다시 한다.
+- `GET /api/search-index` → `{ status, done, total }`
+  - `status`: `building`(지난 메일을 채우는 중 — 그동안 그 직원의 검색 · 대화는 지금 방식(엔진)이고, 화면은 검색 결과 머리 아래에 "검색 준비 중" 줄을 보인다) · `ready`.
+  - `done`: 채운 메일 수(`total` 을 넘지 않는다) · `total`: 채우기를 시작할 때의 메일 수(시작 전이면 `null`, `ready` 면 `done` 과 같다).
+  - **조회지만 상태 줄을 만들고 멈춤을 푼다** — 줄이 없던 직원은 이때 `building` 으로 만들고, 대리 접근이 막혀 멈췄던 줄은 다시 해 보게 한다(로그인한 직원이 물었으니 다시 될 것이다). 같은 직원이 여러 번 물어도 결과는 같다(멱등).
+  - 로그인 필요(401 `AUTH_001`) · 제한된 세션은 403 `AUTH_010`(6절).
+- 로그 가림: 검색 조건의 이름 `from` · `to` · `subject` · `body` 도 `q` · `cursor` 처럼 길이만 남긴다(`maskUrlForLog`). 개발 환경도 DB 쿼리 로그(매개변수)를 남기지 않는다 — 메일 글이 DB 에 있다.
+
+### 검색 — 14단계 (자체 색인 · 조건 검색 · 강조)
+
+- **방식**: 그 직원의 색인이 `ready` 면 색인으로, 아니면(`building`) 엔진으로 찾는다(위 3단계 절의 규칙 · 한계 그대로 — 조건은 엔진 필터로, 낱말이 통째로 같을 때만).
+  방식은 첫 쪽에서 정해지고 커서가 그 방식을 잇는다 — 쪽을 넘기는 중에 준비가 끝나도 그 검색은 처음 방식대로다. 색인 방식은 찾기 바로 전에 그 직원의 색인을 한 번 맞춘다(1.5초 안 — 방금 온 메일도 찾아지게).
+- **쿼리** (`GET /api/messages` — 3단계의 `mailboxId` · `q` · `cursor` · `limit` 에 더한다)
+
+  | 이름 | 찾는 곳 | 검사 |
+  | --- | --- | --- |
+  | `q` | 보낸 사람 · 받는 사람 · 참조 · 제목 · 본문 · 첨부 이름 | 3단계와 같다 |
+  | `from` | 보낸 사람(이름 · 주소) | 넷 모두 `q` 와 같은 검사 — 앞뒤 공백을 지우고 공백뿐이면 없는 것, 1~200자(UTF-16), 낱말 8개, 길이를 먼저 본다 |
+  | `to` | 받는 사람과 참조 | |
+  | `subject` | 제목 | |
+  | `body` | 본문 | |
+  | `after` · `before` | 받은 시각이 `after` 이상 · `before` 미만 | ISO 8601 UTC(`Z` · 소수 초 3자리까지 · 있는 날짜) |
+  | `hasAttachment` | 진짜 첨부가 있는 메일만(목록의 `hasAttachment` 와 같은 판정) | `true` 만 받는다 |
+
+  `q` 나 조건 하나라도 있으면 검색이다(검색 칸이 비어도 조건만으로). 메일함 범위는 3단계와 같고(`mailboxId` 가 없으면 휴지통 · 스팸메일함을 뺀 모두), `mailboxId` 도 검색도 없으면 400 `VAL_001`.
+  **`q` 와 조건 칸 넷(`from` · `to` · `subject` · `body`)을 합친 낱말은 8개까지**다(넘으면 400 `VAL_001` — 색인을 채우는 동안의 엔진 방식이 낱말마다 조사 형태를 붙여 묻기 때문에, 3단계에서 잰 비용(낱말 8개 · 조건 472개 · 0.16초) 안에 두려고. 화면은 보내기 전에 같은 수를 본다).
+  검색 글의 NUL(U+0000)은 색인과 같이 U+FFFD 로 바꿔 찾는다.
+  화면은 고른 날짜를 브라우저 시간대의 시작일 0시 · 끝나는 날 다음 날 0시로 바꿔 보낸다(부재중과 같은 방식).
+- **찾는 규칙 (색인 방식)**
+  - 부분 일치 — 낱말이 그 칸의 글 어디에 있어도 맞는다('계약' → 계약서 · 계약은 · 계약직, 제목 맨 앞의 [공지] · Re: 도). 영문 대소문자 · 전각 영숫자는 가리지 않는다(NFC).
+  - 여러 낱말은 모두 맞아야 하고 큰따옴표는 구절이다(3단계와 같다). 구절은 줄바꿈 · NBSP 로 갈린 글에도 맞는다 — 띄어쓰기 두 칸에는 맞지 않는다.
+  - **한 글자 낱말**: 두 글자 넘는 낱말과 함께면 모두 찾는다. 한 글자 낱말뿐이면 제목 · 사람(보낸 사람 · 받는 사람 · 참조) · 첨부 이름에서만 찾고 본문은 찾지 않는다(2026-11-05 사용자 확정 — 본문을 다 훑으면 메일이 많은 직원은 수 초. 화면은 결과 머리에 한 줄 알린다).
+  - **본문 강조**(목록 미리 보기 · 읽기 화면)는 본문을 찾은 두 글자 이상 낱말만이다. 한 글자 낱말뿐이면 본문에 강조하지 않고(제목 · 첨부 이름은 그대로), 두 글자 이상 낱말과 섞이면 그 낱말만 강조한다 —
+    함께 찾은 한 글자 낱말은 본문에서 맞았어도 강조하지 않는다(본문 곳곳에 흩어진다 — 2026-11-06 실사용 시험). 두 글자 이상 낱말이 보낸 사람 · 받는 사람 조건에만 있어도 섞인 검색이다.
+  - 본문은 앞 2만 자까지 찾는다. 첨부 파일 안의 글 · 끝이 바뀐 말('보내' → '보냈습니다')은 찾지 않는다(첨부 이름은 찾는다). 받는 사람 칸은 주소들을 이어 보므로 구절이 이웃한 두 주소에 걸쳐 맞을 수 있다(작은 한계).
+- **응답 (목록)**
+  - 항목(MessageSummary)에 `searchHighlight: { subject: [start, end][], preview: { text, ranges: [start, end][] } } | null` — 색인 방식 검색에서만 차고, 메일함 목록 · 엔진 방식은 `null`.
+    위치는 NFC 글의 UTF-16 [시작, 끝)이고, 강조가 있으면 `subject` 도 NFC 로 싣는다. `preview.text` 는 본문에서 맞았으면 맞은 말 둘레 한 줄(잘린 쪽에 "…"), 아니면 엔진 미리 보기다.
+    본문의 맞은 곳은 이 차례로 고른다(2026-11-06 실사용 시험 — 답장은 처음 맞은 곳이 거의 늘 원문 인용 안이었다).
+    ① 인용 줄(앞 공백 뒤 `>`) 밖의 첫 맞은 곳 — 둘레는 인용 줄 전까지.
+    ② 인용 안에서만 맞았고, 본문에서 맞은 말이 모두 검색어(`q`)의 낱말로 제목 · 보낸 사람 · 받는 사람과 참조 · 첨부 이름에서도 맞았으면 인용 밖의 첫 글 — 맞은 곳이 없으면 `ranges` 는 빈 배열, 인용 밖 글이 없으면 ③.
+    ③ 그 밖에는 줄 앞 `>` 표시(겹친 것 · 사이 공백)를 뺀 인용 조각을 그 인용 안에서만 — `ranges` 는 보이는 글 기준.
+    내용 조건(`body`)의 낱말은 ②에 들지 않는다. `>` 없는 인용 꼴("-----Original Message-----" 등)과 인용 머리 줄("…님이 작성:")은 알아보지 않는다(알려진 한계).
+  - **`hasNext: true` 인데 항목이 `limit` 보다 적거나 0개일 수 있다**(색인 방식) — 한 요청이 확인하는 메일 수에 상한이 있어(3,000 — 1초 안에 답하려고) 그때까지 찾은 것과 이어 찾을 커서를 준다. 화면은 커서가 있으면 이어 묻는다(빈 쪽이 이어지면 몇 번까지만 — 화면 상수).
+  - `total`: 첫 쪽에서 셀 수 있으면 0~1,000, 1,000 을 넘거나 이 요청에서 다 세지 못했으면 `null`, 다음 쪽은 늘 `null`(엔진 방식은 3단계와 같다).
+    **화면은 `null` 이면 통 수를 보이지 않는다** — "1,000통 넘게"라고 쓰지 않는다(다 세지 못한 것일 수도 있다).
+  - 커서는 불투명한 문자열이다. 방식 · 메일함 · `q` · 모든 조건이 지문에 들어가 다른 검색에 쓰면 400 `VAL_001`. 3단계의 옛 커서는 그대로 통한다.
+- **읽기 화면** (`GET /api/messages/{id}`)
+  - `images` 에 더해 `q` · `from` · `to` · `subject` · `body` 를 받는다(검사는 목록과 같다 — `from` · `to` 는 받기만 하고 강조하지 않는다). `after` · `before` · `hasAttachment` · `cursor` · `limit` 은 받지 않는다(400 `VAL_001`) — 화면은 검색 주소의 조건 가운데 이 다섯만 넘긴다.
+  - 강조할 말이 있으면 `searchHighlight: { subject: Range[], attachments: { [첨부 id]: Range[] }(맞은 첨부만), textBody: Range[] }` 를 싣고, `subject` · 첨부 이름 · `textBody` 를 NFC 로 싣는다. 없으면 `null`.
+  - `htmlBody` 는 **정화한 뒤** 맞은 글 조각에 속성 없는 `<mark>` 를 넣는다 — 태그를 건너는 말 · 속성 · 주석 · `style` 안은 건드리지 않고, 한 통에 1,000개까지.
+  - 강조할 말: `q` 는 제목 · 본문 · 첨부 이름에, `subject` 는 제목에, `body` 는 본문에. `from` · `to` 는 강조하지 않는다(섞인 검색인지 정하는 데만 쓴다). 본문에는 목록과 같이 본문을 찾은 두 글자 이상 낱말만이다. 화면은 `<mark>` 를 노랑 `#FCE7A4` · 글자색 그대로로 그린다(디자인 README 14단계).
+  - **강조가 든 응답은 보이기만 한다** — 답장 · 전달의 원문 인용 · 인쇄 · 다른 화면의 메일 기억(목록 · 스토어)에는 검색 쿼리 없이 받은 응답을 쓴다(보내는 정화는 `mark` 를 지우지만, 인용 · 인쇄 모양이 검색에 따라 달라지지 않게).
+  - 한 글자 낱말뿐이라 본문을 찾지 않았다는 표시는 응답에 없다 — 화면은 서버와 같은 낱말 나누기(짝 — backend `shared/utils/search-text.ts` · 표본 표 `backend/test/search-text-samples.ts`)로 알아보고 결과 머리에 한 줄 알린다.
+  - 보낸 사람이 본문에 직접 쓴 `<mark>`(받은 메일 정화가 남긴다)도 같은 노랑으로 보여 검색 강조와 가르지 않는다(드물고 브라우저 기본도 노랑이다 — 알려진 한계).
+- **클라이언트 — 화면 주소**(14단계 웹, 3단계 주소에 더한다): 조건도 검색어처럼 화면 주소에 싣는다(앞단 nginx 의 접근 로그는 쿼리를 남기지 않는다).
+  - 꼴: `/mail/search?q=…&in=<메일함 id | all>&from=…&to=…&subject=…&body=…&since=YYYY-MM-DD&until=YYYY-MM-DD&attachment=1`, 결과에서 연 메일은 `/mail/search/<메일 id>?…`(같은 쿼리).
+    빈 칸은 싣지 않는다(검색어가 비면 `q` 도 뺀다 — 조건만으로 찾는다). `in` 이 비면 `all`.
+  - `q` · `from` · `to` · `subject` · `body`: 앞뒤 공백을 지우고 200자에서 자른다. 같은 이름이 여럿이면 첫 값, 모르는 이름은 무시한다.
+  - `since` · `until`: 브라우저 시간대의 날짜이고 **양 끝을 포함한다** — API 에는 `after` = `since` 날 0시, `before` = `until` 다음 날 0시(UTC ISO)로 보낸다. "최근 1주" 같은 기간은 고른 순간 날짜로 바꿔 싣는다(7일 전 · 달은 말일을 넘지 않는다).
+    있는 날짜이고 1970-01-01 ~ 9999-12-30 이어야 한다(아니면 그 날짜만 버린다). `since` 가 `until` 보다 늦으면 기간을 통째로 버린다. 한쪽만 있어도 된다.
+  - `attachment`: `1` 일 때만 `hasAttachment=true` 다(다른 값은 무시).
+  - 검색어와 조건 칸 넷을 합친 낱말이 8개를 넘으면 목록을 묻지 않고 "찾을 말이 너무 많습니다"를 보인다(손으로 고친 주소 — 화면의 [찾기]는 보내기 전에 막는다). 그때 연 메일은 강조 쿼리 없이 받는다.
+  - 읽기 화면 API 에는 `q` · `from` · `to` · `subject` · `body` 다섯만 넘긴다([이미지 보기]도 같은 쿼리로).
+- **클라이언트 — 이어 찾기**: `hasNext` 인데 쪽이 모자라면 한 번에(열 때 · [메일 더 보기] · [더 찾기] · 목록 보기의 [다음]) 요청을 5번까지 보낸다(화면 상수 `MAIL_SEARCH_FILL_MAX_REQUESTS`) — 새로 20통이 차거나 `hasNext` 가 false 면 멈춘다.
+  그래도 못 찾았으면 [더 찾기] 화면이다. 다음 쪽의 `total` 이 `null` 이면 첫 쪽의 수를 남기고, 첫 쪽부터 `null` 이면 통 수 · "n / 전체"를 보이지 않는다.
+  목록을 새로 고치는 동안은 이어 받지 않는다(옛 커서로 붙지 않게).
+- **클라이언트 — 준비 상태**: `GET /api/search-index` 를 받지 못하면(실패) "검색 준비 중" · 옛 한계 안내 · 한 글자 안내를 모두 보이지 않는다. 한 글자 안내는 `ready` 이고 본문을 찾을 말(검색어나 내용 조건)이 있을 때만이다.
+- 새 에러 코드는 없다(`VAL_001` · `RES_001` · `MAIL_001`).
+
+### 대화 — 14단계 (같은 대화 · 대화로 묶어 보기)
+
+읽기 화면은 그 메일의 같은 대화를 늘 보이고, 목록은 사용자가 켜면 대화로 묶는다(디자인 README 「14단계 — 검색 · 대화 묶기」의 `Thread14` · `ListThreads14`). 검색 결과는 묶지 않는다.
+
+- **대화의 기준(`basis`)** — 응답마다 싣는다.
+  - `index`(그 직원의 색인이 `ready`): 답장 관계(Message-ID · In-Reply-To · References)로 이어지고 **말머리를 뗀 제목이 같은** 메일이 한 대화다.
+    말머리는 앞의 `Re` · `RE` · `Fw` · `FW` · `Fwd` · `AW` · `WG` · `회신` · `답장` · `전달`(뒤의 `[2]` 같은 수 · 전각 쌍점 `：` 도) + 쌍점과 대괄호 꼬리표(`[공지]` 등)이고 여러 겹을 뗀다(짝 — backend `shared/utils/subject-base.ts` · frontend `shared/utils/search-match.ts`).
+    Message-ID 가 없는 메일은 혼자다. 원본이 늦게 와도 이어지고, 한 번 이어진 대화는 나뉘지 않는다(가운데 메일을 지워도). 답장 관계가 있어도 제목이 다르면 묶지 않는다(엔진과 같다).
+  - `engine`(색인을 채우는 동안): 엔진의 스레드(`threadId`). 두 기준의 묶음은 조금 다를 수 있다 — 준비가 끝나면 묶음이 바뀔 수 있다.
+  - 기준은 첫 쪽에서 정해지고 커서가 잇는다(검색과 같다). 색인 방식은 읽기 바로 전에 그 직원의 색인을 한 번 맞춘다(1.5초 안). 첫 쪽에서 색인을 읽지 못하면(DB 장애) 엔진으로 답한다.
+- **대화에 드는 메일**: 모든 메일함(보낸편지함 · 임시보관함 포함)의 메일 — 휴지통 · 스팸메일함에만 든 메일은 뺀다. 보내는 중인 내부 초안은 빼고, 붙잡힌 메일(보내기 취소 · 예약 — `pendingSend`)은 넣는다.
+
+#### `GET /api/messages/{id}/conversation` — 같은 대화
+
+- 쿼리 `cursor` · `limit`(1~100, 처음 100). 응답 `{ items: MessageSummary[], pageInfo, basis: 'index' | 'engine' }`.
+- **오래된 차례**(받은 시각 — 같으면 id). 그 메일은 휴지통 · 스팸메일함에 있어도 늘 든다. 한 통뿐이면 그 메일 하나다(화면은 칸을 보이지 않는다).
+- `total`: `index` 는 첫 쪽에서만(다음 쪽 `null`), `engine` 은 쪽마다(스레드가 1,000통을 넘으면 `null`).
+- **`hasNext: true` 인데 항목이 `limit` 보다 적거나 0개일 수 있다**(`engine` — 한 요청이 커서 자리부터 1,000통까지만 훑는다. 검색과 같은 결 — 응답은 늘 커서 자리보다 앞으로 간다).
+  화면은 커서가 있으면 이어 묻되, 빈 쪽이 이어지면 몇 번까지만 묻고 [더 보기]로 넘긴다(검색의 이어 찾기와 같은 결 — 휴지통에만 든 메일이 많은 큰 스레드).
+- 커서는 그 메일 · 그 기준에서만 통한다 — 다른 메일 · 꾸민 커서는 400 `VAL_001`(그 메일이 색인에 없어도 커서를 먼저 본다).
+- 404 `RES_001`: 없는 메일 · 쪽을 넘기는 중에 색인에서 사라진 메일.
+  503 `MAIL_001`: 엔진 장애 · `engine` 기준이 한 요청의 시간(15초) 안에 1,000통 이하 스레드를 다 읽지 못하거나 더 큰 스레드의 첫 묶음도 읽지 못함.
+- **클라이언트 — 읽기 화면의 같은 대화 칸**(14단계 웹 — 디자인 README "14단계 구현하며 정한 보완 — 같은 대화")
+  - 한 번에 100통씩 받고, 쪽이 모자라면 한 번에 요청을 5번까지 이어 묻는다(화면 상수 `MAIL_CONVERSATION_FILL_MAX_REQUESTS` — 새로 100통이 차거나 `hasNext` 가 false 면 멈춘다). 남으면 [더 보기]. 화면의 시간 한도는 30초다.
+  - 칸 머리의 통 수: `total` → (다음 쪽이 없으면) 받은 수 → 모르면 수 없이 "같은 대화"(짐작한 수는 보이지 않는다).
+  - 처음 받기 · 다시 받기 · 펼친 본문은 알림 없이(`silent`) 칸 · 줄 안에 안내와 [다시 시도]를 둔다. 404 · 모양이 틀린 응답이면 칸이 없다(이 경로가 없는 옛 서버). [더 보기]만 인터셉터가 알린다.
+  - 다시 받는 때: 메일함들의 통 수(`totalCount`)가 바뀌었을 때(새 메일 · 지움 · 옮김 — 읽음 · 중요 표시만 바뀐 소식으로는 받지 않는다), 쓰기 화면에서 돌아올 때, 붙잡힌 메일이 보낼 시각 + 2초가 됐을 때.
+    받기가 끝난 때부터 10초 안에 온 소식은 모아 한 번 받고, 받는 중에 온 소식은 끝난 뒤 한 번 더 받는다. [더 보기]로 늘린 대화는 저절로 다시 받지 않는다(붙잡힌 메일만 `GET /api/messages/{id}` 로 고친다).
+    알려진 한계: 같은 메일함에서 한 통이 들어오며 한 통이 빠지면 통 수가 같아 그 소식으로는 다시 받지 않는다.
+  - 펼친 줄은 검색 쿼리 없이 `GET /api/messages/{id}` 로 받고, 받은 뒤에도 펼쳐 있으며 안 읽은 메일이면 `PATCH` 로 읽음으로 바꾼다(읽기 화면과 같은 길). 그 메일이 그사이 지워졌으면(404) 대화를 다시 받아 그 줄을 뺀다.
+  - 줄의 읽음(2026-11-07): 안 읽은 줄을 목록처럼 굵게 그린다. 이 탭이 바꾼 읽음은 줄에 바로 적고, 받는 동안 바꾼 것 · 받기를 시작할 때 보내던 것은 받은 값보다 앞세운다(받은 값은 그 바꿈이 엔진에 닿기 전일 수 있다). 다른 탭 · 기기의 읽음은 다음 받기 때 보인다(읽음만 바뀐 소식으로는 다시 받지 않는다).
+  - 줄 차례: 받은 메일은 응답 차례 그대로, 붙잡힌 메일(`pendingSend` — 보내기 취소 · 예약)은 받은 줄 뒤에 `sendAt` 차례로 둔다. 줄의 미리 보기는 우리 원문 인용 머리 "> 원본 메일"부터 잘라 내고(남는 글이 없으면 제목), 펼친 줄은 첨부 목록 대신 첨부 수만 안내한다(2026-11-07).
+
+#### `GET /api/conversations` — 대화로 묶어 보기
+
+```ts
+interface ConversationSummary {
+  id: string                // 대화 id — 불투명(기준마다 다르다)
+  latest: MessageSummary    // 그 메일함 안의 마지막 메일 — 줄의 제목 · 시각 · pendingSend
+  participants: Address[]   // 대화 전체의 보낸 사람(주소가 있는 사람만) — 받은 차례, 주소마다 한 번, 10명까지 · 이름 100자까지
+  messageCount: number      // 대화 전체의 메일 수 — 위 "대화에 드는 메일"에 그 메일함의 메일을 더한 수(휴지통 · 스팸메일함을 묶어 볼 때)
+  messageIds: string[]      // 그 메일함 안의 그 대화 메일 — 최신부터 500통까지
+  pendingSendIds: string[]  // messageIds 가운데 붙잡힌 메일(보내기 취소 · 예약 — pendingSend 가 있는 메일). 없으면 []
+  isRead: boolean           // 그 메일함 안의 메일을 모두 읽었으면 true
+  isFlagged: boolean        // 그 메일함 안에 중요 표시한 메일이 하나라도 있으면 true
+  hasAttachment: boolean    // 그 메일함 안에 첨부가 있는 메일이 하나라도 있으면 true
+}
+```
+
+- 쿼리 `mailboxId`(필수) · `cursor` · `limit`(1~100, 처음 20). 검색 쿼리(`q` · 조건)는 받지 않는다(400 `VAL_001`).
+- 응답 `{ items: ConversationSummary[], pageInfo, basis }` — 그 메일함 안의 마지막 받은 시각 최신부터.
+- `total`: `index` 는 첫 쪽에서 그 메일함의 대화 수(다음 쪽 `null`), `engine` 은 엔진이 센 스레드 수(쪽마다).
+- 커서는 그 메일함 · 그 기준에서만 통한다(다른 메일함 · 다른 목록 · 꾸민 커서는 400 `VAL_001`). 없는 메일함은 404 `RES_001`, 엔진 장애(메일함을 읽지 못함 포함)는 503 `MAIL_001`.
+- **`engine` 기준의 상한**: 한 요청이 스레드마다 최신 500통 · 모두 2,000통까지 · 15초 안에서 읽는다(몫은 작은 스레드부터 다 주고 남는 것을 큰 스레드끼리 나눈다).
+  시간이 끝나도 503 이 아니라 그 쪽의 줄을 읽은 만큼으로 채워 답한다(커서는 보통의 다음 쪽 커서다).
+  상한에 걸린 줄(스레드마다 500 · 한 요청 2,000 · 15초 — 500통 이하 스레드도 한 쪽에 큰 스레드가 많으면 걸린다)은 `messageCount` 가 어림이다(읽지 못한 오래된 메일을 모두 센다 — 휴지통 · 스팸메일함에만 든 것도).
+  `participants` · `messageIds` · `isRead` · `isFlagged` · `hasAttachment` · `pendingSendIds` 는 읽은 최신 메일로만 정한다.
+- 고르기 · 읽음 · 중요 · 이동 · 삭제는 그 줄의 `messageIds` 를 지금의 여러 통 API(`PATCH /api/messages` · `POST /api/message-deletions`)로 보낸다.
+  **`pendingSendIds` 는 빼고 보낸다** — 붙잡힌 메일은 취소로만 보낸편지함을 떠난다(9단계 "보내기 취소 · 예약 발송" — 섞여 와도 서버가 `failedIds` · `skippedIds` 로 막는다).
+  줄의 메일이 모두 붙잡힌 메일이면 그 줄은 고를 수 없다(목록의 고르기 칸과 같은 결).
+- 500통이 넘는 대화는 `messageIds` 가 최신 500통이다 — 그 줄에 한 일은 그만큼에만 하고, 남은 메일은 다음에 다시 맞춘 목록의 같은 줄로 남는다(드문 경우).
+- **알려진 한계**: 쪽을 넘기는 사이 늦게 온 원본으로 두 대화가 합쳐지면 줄이 겹치거나 빠질 수 있다 — 처음부터 다시 받으면 맞는다.
+  마지막 메일이 그 메일함을 떠났는데 색인이 아직 맞추지 않았으면 그 줄이 한 번 빠진다.
+- **클라이언트 — 목록을 대화로 묶어 보기**(14단계 웹 — 디자인 README "14단계 구현하며 정한 보완 — 목록 대화로 묶어 보기")
+  - 켜고 끄기: 목록 머리 [대화로 묶기]와 설정 › 메일 › 보내기 · 읽기의 한 줄이 같은 `groupByConversation` 을 `PATCH` 로 저장한다 — 화면을 먼저 바꾸고 끝내 실패하면 되돌린다(칸마다 저장은 한 번에 하나 — 아래 "보내기 · 읽기 설정").
+    메일함 목록만 묶는다 — 검색 결과 · 「예약됨」은 묶지 않는다.
+  - 첫 진입: 설정을 받기 전 · 받지 못했으면 이 브라우저가 그 직원에게서 마지막으로 안 값(localStorage — 직원마다, 처음이거나 읽지 못하면 끔)으로 연다. 받은 값이 다르면 바로 그 값으로 다시 연다
+    (짐작이 틀리면 버릴 첫 쪽 요청이 하나 나간다). 받지 못한 동안에도 [대화로 묶기]를 누를 수 있고, 저장 응답(설정 전체)을 받은 설정으로 삼는다 — 실패하면 누르기 전 짐작으로 돌아간다.
+    로그아웃 · 세션 만료는 짐작을 바꾸지 않고, 세션이 끝나면(제한된 세션 포함) 목록을 다시 부르지 않는다.
+  - 쪽은 20줄 · 받은 커서 그대로. 켜고 끔 · 메일함 바꿈 · 다른 목록으로 가면 앞 목록의 응답을 버리고 그 요청을 끊는다(`AbortSignal` — `engine` 기준은 한 요청이 15초까지). 끊긴 요청은 알리지 않는다.
+  - 새 메일 확인 · 실시간: 메일 목록 대신 불러온 줄 수만큼(최대 100줄) `silent` 로 처음 쪽부터 다시 받는다 — 요청 수는 메일 목록과 같다.
+  - 다른 탭 · PC 에서 바꾼 설정: 메일 화면은 탭이 다시 보일 때 설정을 마지막으로 받은 지 60초가 지났으면 `GET /api/mail-settings` 를 `silent` 로 다시 받는다 — 저장하는 중이면 받지 않고, 받는 사이 고른 값이 있으면 받은 값을 버리고, 세션이 끝났으면 받지 않는다. 받은 `groupByConversation` 이 다르면 그 값으로 목록을 다시 연다(2026-11-07).
+  - 줄에 하는 일: 할 일 메일 = `messageIds` − `pendingSendIds` − (마지막 메일이 붙잡힌 메일이면) 그 메일. 100통씩 나눠 보낸다.
+    - 화면을 먼저 바꾸는 것은 줄의 메일을 모두 바꿨을 때만 줄 전체(읽음 · 중요 해제)다 — 일부만이면 그대로 두고 다음 맞추기가 서버 값으로 고친다. 중요 해제는 붙잡힌 메일까지 바꿨을 때만이다(붙잡힌 메일의 중요 표시는 남는다).
+    - 줄의 별: 중요 표시가 하나라도 있으면 모두 풀고, 없으면 할 일 메일을 모두 표시한다. 붙잡힌 메일이 든 줄을 풀면 줄을 미리 풀지 않고 묶은 목록을 한 번 다시 받는다 — 그래도 중요 표시가 남으면 알린다.
+    - 읽기 화면의 별(한 통)이 실패하면 그 메일이 든 줄을 앞 값으로 되돌린다.
+    - 옮기기 · 삭제 뒤에는 묶은 목록을 한 번 다시 받는다(남은 줄의 마지막 메일 · 통 수를 맞추려고). 서버가 바꾸지 못한 메일(`failedIds` · `skippedIds`)이 든 줄은 앞 값으로 되돌린 뒤 다시 받는다. 안 읽은 수는 끝난 뒤 메일함 목록으로 맞춘다.
+  - 목록 머리의 대화 수는 `total` 이다 — `null` 이면 그 부분을 뺀다.
+  - 알려진 한계: 여러 통인 줄의 마지막 메일만 읽으면 다음 맞추기(실시간이면 곧, 아니면 1분)까지 그 줄이 굵은 채다 — 읽을 때마다 다시 받지 않는다(경로마다 1분 100회).
+    마지막 메일이 아닌 붙잡힌 메일은 보낼 시각을 몰라, 풀린 뒤에도 다음 맞추기까지 그 메일만 든 줄을 고를 수 없다.
+
+#### 설정
+
+- `groupByConversation`(아래 "보내기 · 읽기 설정") — 처음 `false`. 서버는 저장해 돌려주기만 하고, 묶은 목록을 부를지는 화면이 정한다.
+
+새 에러 코드는 없다(`VAL_001` · `RES_001` · `MAIL_001`).
+
 ### 여러 통 한꺼번에 (`PATCH /api/messages` · `POST /api/message-deletions`) — 3단계
 
 ```ts
@@ -1134,7 +1303,7 @@ interface PendingSend {
 - **로그**: 취소 · 예약은 log(메일 id · 보낼 시각만) — 받는 사람 · 제목은 남기지 않는다.
 - **클라이언트**: [보내기]를 누르면 지금처럼 쓰기 화면을 닫고 떠난다. 알림 "메일을 보냈습니다." + [보내기 취소] + 남은 시간 막대 — `pendingSend.sendAt` 에 닫는다(마우스를 올려도 멈추지 않는다).
   일부 거절의 실패 알림에도 [보내기 취소]를 둔다. [보내기 취소] → `DELETE` → 쓰기 화면을 `?draft=<draftId>` 로 다시 연다(새 키) + 알림 "보내기를 취소했습니다. 쓰던 메일로 돌아왔습니다.".
-  `MAIL_014` 는 인터셉터 알림. 예약은 알림 "‘시각’ 에 보냅니다." + [예약됨 보기]. 세션이 바뀌면 알림을 닫는다 — 메일은 그대로 보내진다.
+  `MAIL_014` 는 인터셉터 알림. 예약은 알림 "‘시각’에 보냅니다." + [예약됨 보기]. 세션이 바뀌면 알림을 닫는다 — 메일은 그대로 보내진다.
 
 ### 외부 이미지 보기 (`images=show` · `/api/mail-images`) — 9단계
 
@@ -1222,19 +1391,23 @@ interface MailBlockList {
 interface MailSettings {
   undoSendSeconds: 0 | 5 | 10 | 20 | 30          // 보내기 취소 — 0 이면 바로 보낸다. 처음 10
   externalImages: 'ask' | 'trusted' | 'always'   // 외부 이미지 — 늘 묻기 · 주소록과 사내 직원은 늘 보기 · 늘 보기. 처음 'ask'
+  groupByConversation: boolean                   // 목록을 대화로 묶어 보기 — 처음 false (14단계 — 위 "대화 — 14단계")
 }
 ```
 
+- `groupByConversation` 은 서버가 저장해 돌려주기만 한다 — 묶은 목록(`GET /api/conversations`)을 부를지는 화면이 정한다. `PATCH` 는 boolean 만 받는다(`null` · `"true"` · `1` 은 400 `VAL_001`).
+
 - 서버는 발송 때 `undoSendSeconds`, 메일을 읽을 때 `externalImages` 를 본다(직원마다 잠깐 기억해도 된다 — 그 서버에서 바꾸면 바로 맞춘다).
   서버마다 60초 기억하고, 읽지 못하면(DB 장애) 처음 값(10초 · `ask`)으로 보고 warn 을 남긴다(구현하며 정함).
 - 화면(설정 › 메일 › 보내기 · 읽기)은 고르는 대로 `PATCH` 하고 "저장했습니다"를 보인다(저장 단추 없음).
   칸마다 저장은 한 번에 하나다 — 끝났을 때 마지막으로 고른 값이 서버의 답과 다르면 그 값을 다시 보낸다(늦게 온 앞 응답 때문에 화면과 서버가 갈리지 않게 — 2026-10-29 리뷰).
+  메일 화면은 탭이 다시 보일 때 마지막으로 받은 지 60초가 지났으면 조용히 다시 받는다(14단계 — 위 "대화 — 14단계"의 묶어 보기 클라이언트 줄).
   "저장했습니다"는 기다리던 저장이 모두 끝나고 마지막이 성공했을 때 보인다. 끝내 실패하면 서버가 마지막으로 확인해 준 값으로 되돌리고 인터셉터가 알린다.
 
 ### 이 단계에서 하지 않는 것
 
 탭을 모두 닫아도 오는 알림(웹 푸시 — 엔진은 `webpush-vapid` 를 지원한다), 알림 소리(운영체제 설정을 따른다), 휴대폰 푸시, 본문 안 이미지(인라인 cid — 붙여 넣은 이미지는 첨부로, 서명 그림만 예외), 메일 안의 배경 그림 보이기 · 보낸 사람마다 고르는 "이미지 늘 보기" 목록(9단계는 설정 세 가지로),
-여러 개의 서명, 자체 검색 색인(붙여 쓴 말 · 앞부분 · 제목 말머리로 찾기), 조건 검색(보낸 사람 · 기간 · 첨부 있음), 검색어 강조,
+여러 개의 서명(자체 검색 색인 · 조건 검색 · 검색어 강조는 14단계에서 했다 — 위 "검색 — 14단계"),
 끌어다 놓아 옮기기, 메일함 옮기기(다른 상위로) · 하위 메일함까지 한꺼번에 지우기, 앱 비밀번호 · 2단계 인증(엔진은 지원한다), 부재중 응답의 서식 본문 · 사내/외부 구분,
 예약한 메일의 「지금 보내기」 · 7일 넘는 예약(엔진 한도) · 차단할 때 이미 받은 그 보낸 사람의 메일 모두 옮기기(9단계는 그 메일만).
 
diff --git a/frontend/src/components/mail/ConversationListItem.vue b/frontend/src/components/mail/ConversationListItem.vue
new file mode 100644
index 0000000..8dcdaed
--- /dev/null
+++ b/frontend/src/components/mail/ConversationListItem.vue
@@ -0,0 +1,333 @@
+<script setup lang="ts">
+// 분할 보기의 대화 줄 (14단계 — 디자인 원본 ListThreads14) — 2줄: 참여자 · 통 수(회색 "4통" — 한 통이면 없다) · 마지막 시각 / 마지막 메일 제목(+ 첨부)
+// - 하나라도 안 읽었으면 굵게(뱃지 없이 — 메일 줄과 같다), 중요 표시한 메일이 있으면 별이 찬다. 누르면 그 메일함의 마지막 메일을 연다(아래에 같은 대화 칸)
+// - 고르기 칸 · Ctrl(⌘) / Shift + 클릭 · 별은 메일 줄(MessageListItem)과 같은 자리 · 크기다 — 하는 일은 그 줄의 메일 모두(붙잡힌 메일은 빼고 — 스토어)
+// - 줄의 메일이 모두 보내기를 기다리는 메일이면 고르기 · 별을 쓸 수 없다(aria-disabled + 까닭은 title — 메일 줄의 고르기 칸과 같은 결)
+// - 마지막 메일이 붙잡힌 메일이면 시각 자리가 "보내는 중" · "예약 · …"(청록 굵게 — 메일 목록과 같다)
+// - 임시보관함의 제목 없는 저장본은 메일 줄처럼 흐린 "(제목 없음)" (리뷰 L5)
+import { computed } from 'vue'
+import type { RouteLocationRaw } from 'vue-router'
+
+import AppIcon from '@/components/AppIcon.vue'
+import MailCheckbox from '@/components/mail/MailCheckbox.vue'
+import { MAIL_BULK_TEXT, MAIL_LIST_ROW_TEXT, MAIL_NO_SUBJECT } from '@/shared/constants/mail'
+import { MAIL_CONVERSATION_LIST_TEXT } from '@/shared/constants/mail-conversation'
+import { SEND_LATER_TEXT } from '@/shared/constants/mail-send-later'
+import type { ConversationSummary } from '@/shared/types/mail'
+import { formatMailListTime } from '@/shared/utils/format'
+import { conversationCountText } from '@/shared/utils/mail-conversation-list'
+import { pendingSendLabel, type RowWho } from '@/shared/utils/mail-list-row'
+
+interface Props {
+  row: ConversationSummary
+  /** 이름 자리 — 참여자 (useConversationRows) */
+  who: RowWho
+  /** 누르면 갈 곳 — 그 메일함의 마지막 메일(임시보관함은 쓰기 화면) */
+  to: RouteLocationRaw
+  /** 하나라도 안 읽었다 (임시보관함은 늘 false) */
+  unread?: boolean
+  /** 임시보관함의 줄 — 제목이 없으면 흐린 글자 */
+  draft?: boolean
+  /** 줄의 메일이 모두 붙잡힌 메일 — 고르기 · 별을 쓸 수 없다 */
+  held?: boolean
+  /** 지금 열려 있는 메일이 든 줄 */
+  selected?: boolean
+  /** 고른 줄 (여러 통 처리) */
+  checked?: boolean
+  /** 하나라도 골랐다 — 모든 줄에 고르기 상자를 보인다 */
+  checking?: boolean
+}
+
+interface Emits {
+  (e: 'toggle-flag', rowId: string): void
+  /** 고르기 · 풀기 — range 면 Shift(범위) */
+  (e: 'check', rowId: string, range: boolean): void
+}
+
+const props = withDefaults(defineProps<Props>(), {
+  unread: false,
+  draft: false,
+  held: false,
+  selected: false,
+  checked: false,
+  checking: false,
+})
+
+const emit = defineEmits<Emits>()
+
+const subject = computed(() => props.row.latest.subject || MAIL_NO_SUBJECT)
+const countText = computed(() => conversationCountText(props.row))
+/** 마지막 메일이 붙잡아 둔 발송이면 "예약 · …" · "보내는 중" (9단계) */
+const pendingLabel = computed(() => pendingSendLabel(props.row.latest))
+const time = computed(() => pendingLabel.value ?? formatMailListTime(props.row.latest.receivedAt))
+
+/** Ctrl(⌘) · Shift + 클릭은 열지 않고 고른다 (메일 줄과 같다). 고를 수 없는 줄은 고르지 않는다 */
+function onMainClick(event: MouseEvent) {
+  if (!event.ctrlKey && !event.metaKey && !event.shiftKey) return
+  event.preventDefault()
+  if (!props.held) emit('check', props.row.id, event.shiftKey)
+}
+
+/** Shift + 누름이 글자를 고르지 않게 한다 */
+function onMouseDown(event: MouseEvent) {
+  if (event.shiftKey) event.preventDefault()
+}
+
+function onStar() {
+  if (!props.held) emit('toggle-flag', props.row.id)
+}
+</script>
+
+<template>
+  <li
+    :class="[
+      'thread-row',
+      { 'is-selected': selected, 'is-unread': unread, 'is-checked': checked, 'is-checking': checking },
+    ]"
+    :data-row-id="row.id"
+    @mousedown="onMouseDown"
+  >
+    <MailCheckbox
+      class="thread-row__check"
+      :checked="checked"
+      :label="MAIL_BULK_TEXT.selectOne(subject)"
+      :unavailable="held"
+      :note="SEND_LATER_TEXT.heldNotSelectable"
+      @toggle="(event: MouseEvent) => emit('check', row.id, event.shiftKey)"
+    />
+    <RouterLink
+      class="thread-row__main"
+      :to="to"
+      :data-message-id="row.latest.id"
+      @click="onMainClick"
+    >
+      <span class="thread-row__top">
+        <span :class="['thread-row__who', { 'is-placeholder': who.placeholder }]">
+          <span
+            v-if="unread"
+            class="visually-hidden"
+          >{{ MAIL_LIST_ROW_TEXT.unreadPrefix }}</span>{{ who.text }}
+        </span>
+        <span
+          v-if="countText"
+          class="thread-row__count"
+          data-thread-count
+        >{{ countText }}</span>
+        <time
+          :class="['thread-row__time', { 'is-pending': pendingLabel }]"
+          :datetime="row.latest.pendingSend?.sendAt ?? row.latest.receivedAt"
+        >{{ time }}</time>
+      </span>
+      <span class="thread-row__bottom">
+        <span :class="['thread-row__subject', { 'is-placeholder': draft && !row.latest.subject }]">{{ subject }}</span>
+        <AppIcon
+          v-if="row.hasAttachment"
+          name="paperclip"
+          :size="13"
+          :stroke-width="2"
+          :label="MAIL_LIST_ROW_TEXT.attachment"
+          class="thread-row__clip"
+        />
+      </span>
+    </RouterLink>
+    <button
+      type="button"
+      :class="['thread-row__star', { 'is-flagged': row.isFlagged }]"
+      :aria-label="MAIL_LIST_ROW_TEXT.flag"
+      :aria-pressed="row.isFlagged"
+      :aria-disabled="held ? 'true' : undefined"
+      :title="held ? MAIL_CONVERSATION_LIST_TEXT.heldFlagNote : undefined"
+      data-thread-star
+      @click="onStar"
+    >
+      <AppIcon
+        name="star"
+        :size="15"
+        :filled="row.isFlagged"
+      />
+    </button>
+  </li>
+</template>
+
+<style scoped>
+/* 메일 줄(MessageListItem)과 같은 자리 · 크기 — 2줄 약 50px (디자인 원본 ListThreads14 · Main) */
+.thread-row {
+  position: relative;
+  display: flex;
+  align-items: stretch;
+  border-bottom: var(--border-width) solid var(--color-border-subtle);
+  background: var(--color-surface);
+}
+
+.thread-row:hover {
+  background: var(--color-surface-panel);
+}
+
+.thread-row.is-selected {
+  background: var(--color-brand-subtle);
+}
+
+.thread-row.is-checked {
+  background: var(--color-row-checked);
+}
+
+.thread-row.is-checked:hover {
+  background: var(--color-row-checked-hover);
+}
+
+/* 고르기 칸 — 숨긴 동안에도 화면 밖에 두어 Tab 으로 닿게 한다 (메일 줄과 같다) */
+.thread-row__check {
+  position: absolute;
+  width: var(--space-1);
+  height: var(--space-1);
+  overflow: hidden;
+  clip-path: inset(50%);
+  white-space: nowrap;
+}
+
+/* 마우스를 올리거나 초점이 가면 · 하나라도 고르면 — 왼쪽 36px(밀도 예외 --size-row-check)에 16px 상자 */
+.thread-row:hover .thread-row__check,
+.thread-row:focus-within .thread-row__check,
+.thread-row.is-checking .thread-row__check {
+  position: static;
+  flex: 0 0 auto;
+  justify-content: flex-end;
+  width: var(--size-row-check);
+  height: auto;
+  overflow: visible;
+  clip-path: none;
+}
+
+.thread-row__check:focus-visible {
+  outline-offset: calc(var(--focus-ring-width) * -1);
+}
+
+.thread-row__main {
+  flex: 1 1 auto;
+  min-width: 0;
+  min-height: var(--size-list-row);
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  gap: var(--space-1);
+  padding: var(--space-6) var(--space-2) var(--space-6) var(--space-16);
+  line-height: var(--line-height-heading);
+  color: inherit;
+  text-decoration: none;
+}
+
+.thread-row:hover .thread-row__main,
+.thread-row:focus-within .thread-row__main,
+.thread-row.is-checking .thread-row__main {
+  padding-left: var(--space-10);
+}
+
+.thread-row__main:hover {
+  color: inherit;
+}
+
+.thread-row__main:focus-visible {
+  outline-offset: calc(var(--focus-ring-width) * -1);
+}
+
+/* 첫 줄 — 참여자(넘치면 줄인다) · 통 수 · 시각(오른쪽 끝) (디자인 원본 ListThreads14) */
+.thread-row__top {
+  display: flex;
+  align-items: center;
+  gap: var(--space-6);
+}
+
+.thread-row__who {
+  flex: 0 1 auto;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  font-weight: 450;
+  color: var(--color-text-strong);
+}
+
+/* 통 수 — 회색 글, 뱃지 · 알약 없음 */
+.thread-row__count {
+  flex: 0 0 auto;
+  font-size: var(--font-size-small);
+  font-weight: 500;
+  color: var(--color-text-muted);
+  font-variant-numeric: tabular-nums;
+}
+
+.thread-row__time {
+  flex: 0 0 auto;
+  margin-left: auto;
+  font-size: var(--font-size-small);
+  color: var(--color-text-muted);
+  font-variant-numeric: tabular-nums;
+}
+
+.thread-row__time.is-pending,
+.thread-row.is-unread .thread-row__time.is-pending {
+  font-weight: 600;
+  color: var(--color-brand-strong);
+}
+
+.thread-row__bottom {
+  min-width: 0;
+  display: flex;
+  align-items: center;
+  gap: var(--space-6);
+}
+
+.thread-row__subject {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  color: var(--color-text);
+}
+
+.thread-row__clip {
+  flex: 0 0 auto;
+  color: var(--color-text-muted);
+}
+
+/* 비어 있는 값 — "(받는 사람 없음)" · 임시 저장본의 "(제목 없음)" (메일 줄과 같다) */
+.thread-row__who.is-placeholder,
+.thread-row__subject.is-placeholder {
+  color: var(--color-text-muted);
+}
+
+/* 안 읽음 — 뱃지 대신 굵기·색으로만 구분 (메일 줄과 같다) */
+.thread-row.is-unread .thread-row__who {
+  font-weight: 650;
+  color: var(--color-text);
+}
+
+.thread-row.is-unread .thread-row__subject,
+.thread-row.is-unread .thread-row__time {
+  font-weight: 600;
+  color: var(--color-text);
+}
+
+.thread-row__star {
+  flex: 0 0 auto;
+  width: var(--size-touch);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border: 0;
+  background: transparent;
+  color: var(--color-icon-muted);
+}
+
+.thread-row__star.is-flagged {
+  color: var(--color-star);
+}
+
+.thread-row__star[aria-disabled='true'] {
+  cursor: not-allowed;
+}
+
+.thread-row__star:focus-visible {
+  outline-offset: calc(var(--focus-ring-width) * -1);
+}
+</style>
diff --git a/frontend/src/components/mail/ConversationMessagePanel.vue b/frontend/src/components/mail/ConversationMessagePanel.vue
new file mode 100644
index 0000000..3fce3e9
--- /dev/null
+++ b/frontend/src/components/mail/ConversationMessagePanel.vue
@@ -0,0 +1,322 @@
+<script setup lang="ts">
+// "같은 대화" 칸에서 펼친 줄의 안 (14단계 — 디자인 원본 Thread14 "하나 펼침")
+// 받는 사람 · 제목 한 줄씩, 본문(MailBodyFrame — 검색 쿼리 없이 받은 본문이라 강조가 없다), [답장] · [이 메일만 열기](36 — 밀도 예외 --size-notice-action 재사용).
+// - 본문이 다 보이지 않으면(서버의 isHtmlBodyOmitted · isBodyTruncated) 읽기 화면과 같은 안내 줄(MAIL_BODY_NOTICES)을 본문 위에 — 읽기 화면도 같은 본문이다.
+//   외부 이미지 안내 · 첨부 목록은 두지 않는다 — [이 메일만 열기]로 연 읽기 화면에 있다. 첨부가 있으면 본문 아래 · [답장] 위에
+//   "첨부 파일 N개는 [이 메일만 열기]를 누르면 볼 수 있습니다." (수는 읽기 화면의 "첨부 파일 N개"와 같다 — 본문 그림 빼고 · 대용량 첨부 더해)
+// - 본문을 받는 동안은 뼈대(aria-busy), 못 받으면 사전 문구 + [다시 시도]. 그사이 지워진 메일(RES_001)이면 [다시 시도] · [답장] · [이 메일만 열기] 없이 —
+//   스토어가 대화를 다시 받아 이 줄을 뺀다. 화면 낭독용 상태 영역은 늘 두고 글만 바꾼다
+// - [답장]은 읽기 화면의 [답장]과 같은 쓰기 화면이고, 임시 저장본 · 예약한 메일에는 없다. [이 메일만 열기]는 그 메일을 읽기 화면으로 연다(mail-conversation.ts) —
+//   분할 보기는 기록에 쌓고, 목록 보기는 이전 · 다음처럼 바꿔 끼운다([목록으로]가 쌓인 기록으로 돌아가지 않게)
+// - 본문 안에서 누른 Ctrl+P(맥 ⌘P)는 이 메일의 인쇄 화면을 연다(읽기 화면과 같은 판정 — useMailPrint)
+import { computed } from 'vue'
+
+import AppIcon from '@/components/AppIcon.vue'
+import MailBodyFrame from '@/components/mail/MailBodyFrame.vue'
+import { useMailPrint } from '@/composables/useMailPrint'
+import { MAIL_NO_SUBJECT } from '@/shared/constants/mail'
+import { MAIL_CONVERSATION_TEXT } from '@/shared/constants/mail-conversation'
+import { formatCount } from '@/shared/utils/format'
+import { formatAddressList } from '@/shared/utils/mail-address'
+import { listedAttachments } from '@/shared/utils/mail-attachment'
+import { mailBodyNotices } from '@/shared/utils/mail-body-notices'
+import type { ConversationRow } from '@/shared/utils/mail-conversation'
+import type { ConversationDetailState } from '@/stores/mail.store'
+
+interface Props {
+  /** 줄을 펼친 단추가 가리키는 id (aria-controls) */
+  panelId: string
+  row: ConversationRow
+  /** 읽기 화면의 보기 방식 — 목록 보기는 [이 메일만 열기]를 바꿔 끼운다 */
+  layout?: 'split' | 'list'
+  detail: ConversationDetailState | null
+}
+
+interface Emits {
+  (e: 'retry'): void
+}
+
+const props = withDefaults(defineProps<Props>(), {
+  layout: 'split',
+})
+const emit = defineEmits<Emits>()
+
+const print = useMailPrint()
+
+const recipients = computed(() => formatAddressList(props.row.message.to))
+const subject = computed(() => props.row.message.subject || MAIL_NO_SUBJECT)
+const ready = computed(() => (props.detail?.status === 'ready' ? props.detail.detail : null))
+const failure = computed(() => (props.detail?.status === 'error' ? props.detail.error : null))
+/** 그사이 지워진 메일 — 다시 해도 같고 그 메일로 갈 곳도 없다 */
+const missing = computed(() => failure.value?.code === 'RES_001')
+const bodyNotices = computed(() => (ready.value ? mailBodyNotices(ready.value) : []))
+/** 읽기 화면에서 볼 수 있는 첨부 수 — 본문 그림(isInline)은 빼고 대용량 첨부는 더한다 (MessageReader 의 첨부 칸과 같은 수) */
+const attachmentCount = computed(() =>
+  ready.value ? listedAttachments(ready.value.attachments).length + (ready.value.largeFiles?.length ?? 0) : 0,
+)
+const bodyTitle = computed(() => MAIL_CONVERSATION_TEXT.bodyTitle(props.row.sender.name, props.row.time))
+
+/** 본문 안에서 누른 키 — Ctrl+P(맥 ⌘P)면 브라우저 인쇄 대신 이 메일의 인쇄 화면 */
+function onFrameKeydown(event: KeyboardEvent) {
+  const current = ready.value
+  if (!current || !print.isPrintShortcut(event)) return
+  event.preventDefault()
+  print.openPrint(current)
+}
+</script>
+
+<template>
+  <div
+    :id="panelId"
+    class="conversation-panel"
+  >
+    <p
+      v-if="recipients"
+      class="conversation-panel__meta"
+    >
+      <span class="conversation-panel__label">{{ MAIL_CONVERSATION_TEXT.recipients }}</span>
+      {{ recipients }}
+    </p>
+    <p class="conversation-panel__meta conversation-panel__meta--muted">
+      <span class="conversation-panel__label">{{ MAIL_CONVERSATION_TEXT.subject }}</span>
+      {{ subject }}
+    </p>
+
+    <template v-if="ready">
+      <p
+        v-for="notice in bodyNotices"
+        :key="notice.kind"
+        class="conversation-panel__notice"
+        :data-notice="notice.kind"
+      >
+        <AppIcon
+          name="alert-circle"
+          :size="15"
+          class="conversation-panel__notice-icon"
+        />
+        <span>{{ notice.text }}</span>
+      </p>
+      <MailBodyFrame
+        class="conversation-panel__body"
+        :html-body="ready.htmlBody"
+        :text-body="ready.textBody"
+        :images-shown="ready.imagesShown === true"
+        :title="bodyTitle"
+        @frame-keydown="onFrameKeydown"
+      />
+      <p
+        v-if="attachmentCount > 0"
+        class="conversation-panel__attachments"
+        data-conversation-attachments
+      >
+        <AppIcon
+          name="paperclip"
+          :size="14"
+          class="conversation-panel__attachments-icon"
+        />
+        <span>{{ MAIL_CONVERSATION_TEXT.attachmentsNote(formatCount(attachmentCount)) }}</span>
+      </p>
+    </template>
+    <p
+      v-else-if="failure"
+      class="conversation-panel__error"
+      data-conversation-detail-error
+    >
+      <AppIcon
+        name="alert-circle"
+        :size="16"
+        class="conversation-panel__error-icon"
+      />
+      <span>{{ failure.message }}</span>
+      <button
+        v-if="!missing"
+        type="button"
+        class="conversation-panel__retry"
+        @click="emit('retry')"
+      >
+        {{ MAIL_CONVERSATION_TEXT.retry }}
+      </button>
+    </p>
+    <div
+      v-else
+      class="conversation-panel__loading"
+      aria-busy="true"
+      :aria-label="MAIL_CONVERSATION_TEXT.bodyLoading"
+      data-conversation-detail-loading
+    >
+      <span class="conversation-panel__bar" />
+      <span class="conversation-panel__bar conversation-panel__bar--short" />
+    </div>
+
+    <div
+      v-if="!missing"
+      class="conversation-panel__actions"
+    >
+      <RouterLink
+        v-if="row.replyLocation"
+        class="conversation-panel__action"
+        :to="row.replyLocation"
+        data-conversation-reply
+      >
+        {{ MAIL_CONVERSATION_TEXT.reply }}
+      </RouterLink>
+      <RouterLink
+        class="conversation-panel__action"
+        :to="row.location"
+        :replace="layout === 'list'"
+        data-conversation-open
+      >
+        {{ MAIL_CONVERSATION_TEXT.openOnly }}
+      </RouterLink>
+    </div>
+
+    <p
+      class="visually-hidden"
+      role="status"
+      data-conversation-detail-status
+    >
+      {{ failure?.message ?? '' }}
+    </p>
+  </div>
+</template>
+
+<style scoped>
+/*
+ * 줄 머리 아래 — 왼쪽 78px 은 이름 선에 맞춘다(줄 안쪽 14 + 화살표 16 + 사이 10 + 머리글자 28 + 사이 10, 디자인 원본 Thread14)
+ */
+.conversation-panel {
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-10);
+  padding: var(--space-2) var(--space-16) var(--space-14)
+    calc(var(--space-14) + var(--space-16) + var(--space-10) + var(--space-28) + var(--space-10));
+}
+
+.conversation-panel__meta {
+  margin: 0;
+  font-size: var(--font-size-label);
+  color: var(--color-text-secondary);
+  overflow-wrap: anywhere;
+}
+
+.conversation-panel__meta--muted {
+  color: var(--color-text-muted);
+}
+
+.conversation-panel__label {
+  margin-right: var(--space-6);
+}
+
+/* 본문 안내 — 읽기 화면의 본문 안내 줄과 같은 모양 (노랑 · 위아래 10 · 좌우 12, 아이콘은 첫 줄에 — MessageReaderNotices) */
+.conversation-panel__notice {
+  display: flex;
+  align-items: flex-start;
+  gap: var(--space-8);
+  margin: 0;
+  padding: var(--space-10) var(--space-12);
+  border-radius: var(--radius-md);
+  background: var(--color-warning-surface);
+  color: var(--color-warning-text);
+  font-size: var(--font-size-label);
+}
+
+.conversation-panel__notice-icon {
+  flex: 0 0 auto;
+  margin-top: var(--space-2);
+}
+
+/* 펼친 본문은 이 칸 폭을 넘지 않는다 (본문 틀의 글줄 최대 폭은 그대로) */
+.conversation-panel__body {
+  min-width: 0;
+}
+
+/* 첨부 안내 — 머리 줄(받는 사람 · 제목)과 같은 12.5px 회색, 아이콘은 첫 줄에 */
+.conversation-panel__attachments {
+  display: flex;
+  align-items: flex-start;
+  gap: var(--space-6);
+  margin: 0;
+  font-size: var(--font-size-label);
+  color: var(--color-text-secondary);
+  word-break: keep-all;
+  overflow-wrap: anywhere;
+}
+
+.conversation-panel__attachments-icon {
+  flex: 0 0 auto;
+  margin-top: var(--space-2);
+  color: var(--color-text-muted);
+}
+
+.conversation-panel__loading {
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-10);
+  padding: var(--space-6) 0;
+}
+
+.conversation-panel__bar {
+  width: 80%;
+  height: var(--space-10);
+  border-radius: var(--radius-xs);
+  background: var(--color-border-subtle);
+}
+
+.conversation-panel__bar--short {
+  width: 45%;
+}
+
+.conversation-panel__error {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: var(--space-4) var(--space-8);
+  margin: 0;
+  font-size: var(--font-size-label);
+  color: var(--color-text-secondary);
+}
+
+.conversation-panel__error-icon {
+  color: var(--color-danger);
+}
+
+/* [다시 시도] 44 — 글자 단추 */
+.conversation-panel__retry {
+  min-height: var(--size-touch);
+  padding: 0 var(--space-10);
+  border: 0;
+  border-radius: var(--radius-md);
+  background: transparent;
+  color: var(--color-brand);
+  font-weight: 600;
+}
+
+.conversation-panel__retry:hover {
+  background: var(--color-brand-subtle);
+}
+
+/* [답장] · [이 메일만 열기] — 글자 시작을 위 글과 맞춘다(단추 안쪽 10 만큼 당긴다) */
+.conversation-panel__actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--space-4);
+  margin-left: calc(var(--space-10) * -1);
+}
+
+/* 높이 36 — 디자인 원본 Thread14 의 확정값, 안내 줄 단추의 밀도 예외(--size-notice-action)를 다시 쓴다 */
+.conversation-panel__action {
+  display: inline-flex;
+  align-items: center;
+  min-height: var(--size-notice-action);
+  padding: 0 var(--space-10);
+  border-radius: var(--radius-md);
+  color: var(--color-brand);
+  font-weight: 600;
+  text-decoration: none;
+}
+
+.conversation-panel__action:hover {
+  background: var(--color-brand-subtle);
+  color: var(--color-brand-strong);
+}
+</style>
diff --git a/frontend/src/components/mail/ConversationMessageRow.vue b/frontend/src/components/mail/ConversationMessageRow.vue
new file mode 100644
index 0000000..0c16ab9
--- /dev/null
+++ b/frontend/src/components/mail/ConversationMessageRow.vue
@@ -0,0 +1,234 @@
+<script setup lang="ts">
+// "같은 대화" 칸의 줄 하나 (14단계 — 디자인 원본 Thread14) — 줄 48: ▸ · 머리글자 · 이름(내가 보냈으면 "나" + 회색 메일함 이름) · 미리 보기 한 줄 · 시각
+// - 지금 보는 메일: 옅은 청록 바탕 · "지금 보고 있는 메일" · 누를 수 없다(aria-current). 화살표 자리만큼 들여 머리글자 선을 맞춘다
+// - 다른 메일: 단추(aria-expanded · 펼쳤을 때 aria-controls) — 누르면 그 자리에서 펼치고(ConversationMessagePanel) 다시 누르면 접는다.
+//   펼친 안의 [다시 시도]가 사라지면 칸이 초점을 이 단추(data-conversation-toggle)로 돌려준다 (MessageConversation)
+// - 붙잡힌 메일(보내기 취소 · 예약 — 9단계)은 시각 자리에 목록과 같은 "보내는 중" · "예약 · …"(청록 굵게)
+// - 안 읽은 메일(row.unread — 2026-11-07)은 목록 줄(MessageListItem)과 같은 굵기 · 색: 이름 650, 미리 보기 · 시각 600(목록 줄의 제목 · 시각 자리).
+//   화면 낭독은 이름 앞에 목록과 같은 "안 읽음, "(MAIL_LIST_ROW_TEXT). 지금 보는 메일의 줄도 같다
+// 뱃지 · 알약 없이 글로만 보인다. 검색 강조는 넣지 않는다
+import { computed } from 'vue'
+
+import AppIcon from '@/components/AppIcon.vue'
+import ConversationMessagePanel from '@/components/mail/ConversationMessagePanel.vue'
+import { MAIL_LIST_ROW_TEXT } from '@/shared/constants/mail'
+import { MAIL_CONVERSATION_TEXT } from '@/shared/constants/mail-conversation'
+import type { ConversationRow } from '@/shared/utils/mail-conversation'
+import type { ConversationDetailState } from '@/stores/mail.store'
+
+interface Props {
+  row: ConversationRow
+  /** 읽기 화면의 보기 방식 — 펼친 줄의 [이 메일만 열기]를 기록에 쌓을지 */
+  layout?: 'split' | 'list'
+  expanded?: boolean
+  /** 펼친 줄의 본문 — 아직 받지 않았으면 null */
+  detail?: ConversationDetailState | null
+}
+
+interface Emits {
+  (e: 'toggle', id: string): void
+  (e: 'retry-detail', id: string): void
+}
+
+const props = withDefaults(defineProps<Props>(), {
+  layout: 'split',
+  expanded: false,
+  detail: null,
+})
+const emit = defineEmits<Emits>()
+
+/** 펼친 안의 id — 메일 id 는 서버의 불투명한 글이라 그대로 붙인다 */
+const panelId = computed(() => `conversation-panel-${props.row.message.id}`)
+</script>
+
+<template>
+  <li
+    :class="['conversation-row', { 'is-unread': row.unread }]"
+    :data-conversation-row="row.message.id"
+  >
+    <div
+      v-if="row.current"
+      class="conversation-row__line conversation-row__line--current"
+      aria-current="true"
+    >
+      <span
+        :class="['conversation-row__avatar', { 'conversation-row__avatar--mine': row.sender.mine }]"
+        aria-hidden="true"
+      >{{ row.sender.initial }}</span>
+      <span class="conversation-row__who">
+        <span
+          v-if="row.unread"
+          class="visually-hidden"
+        >{{ MAIL_LIST_ROW_TEXT.unreadPrefix }}</span>{{ row.sender.name }}
+      </span>
+      <span class="conversation-row__current">{{ MAIL_CONVERSATION_TEXT.current }}</span>
+      <time
+        :class="['conversation-row__time', { 'is-pending': row.pending }]"
+        :datetime="row.timeValue"
+      >{{ row.time }}</time>
+    </div>
+
+    <template v-else>
+      <button
+        type="button"
+        class="conversation-row__line"
+        :aria-expanded="expanded"
+        :aria-controls="expanded ? panelId : undefined"
+        data-conversation-toggle
+        @click="emit('toggle', row.message.id)"
+      >
+        <AppIcon
+          :name="expanded ? 'chevron-down' : 'chevron-right'"
+          :stroke-width="2"
+          class="conversation-row__chevron"
+        />
+        <span
+          :class="['conversation-row__avatar', { 'conversation-row__avatar--mine': row.sender.mine }]"
+          aria-hidden="true"
+        >{{ row.sender.initial }}</span>
+        <span class="conversation-row__who">
+          <span
+            v-if="row.unread"
+            class="visually-hidden"
+          >{{ MAIL_LIST_ROW_TEXT.unreadPrefix }}</span>{{ row.sender.name }}
+        </span>
+        <span
+          v-if="row.sender.mailboxName"
+          class="conversation-row__mailbox"
+        >{{ row.sender.mailboxName }}</span>
+        <span class="conversation-row__preview">{{ row.preview }}</span>
+        <time
+          :class="['conversation-row__time', { 'is-pending': row.pending }]"
+          :datetime="row.timeValue"
+        >{{ row.time }}</time>
+      </button>
+      <ConversationMessagePanel
+        v-if="expanded"
+        :panel-id="panelId"
+        :row="row"
+        :layout="layout"
+        :detail="detail"
+        @retry="emit('retry-detail', row.message.id)"
+      />
+    </template>
+  </li>
+</template>
+
+<style scoped>
+.conversation-row:not(:first-child) {
+  border-top: var(--border-width) solid var(--color-border-subtle);
+}
+
+/* 줄 48 (디자인 원본 Thread14) — 안쪽 위아래 6 · 좌우 14 */
+.conversation-row__line {
+  display: flex;
+  align-items: center;
+  gap: var(--space-10);
+  width: 100%;
+  min-height: var(--space-48);
+  padding: var(--space-6) var(--space-14);
+  border: 0;
+  background: var(--color-surface);
+  text-align: left;
+}
+
+button.conversation-row__line:hover {
+  background: var(--color-surface-panel);
+}
+
+/* 상자가 넘치는 것을 자르므로(모서리) 고리를 안쪽에 그린다 */
+button.conversation-row__line:focus-visible {
+  outline-offset: calc(var(--focus-ring-width) * -1);
+}
+
+/* 지금 보는 메일 — 옅은 청록 바탕, 화살표(16) + 사이(10) 만큼 들인다 */
+.conversation-row__line--current {
+  padding-left: calc(var(--space-14) + var(--space-16) + var(--space-10));
+  background: var(--color-brand-tint);
+}
+
+.conversation-row__chevron {
+  color: var(--color-text-muted);
+}
+
+/* 머리글자 28 — 내가 보낸 메일은 회색 (디자인 원본 Thread14) */
+.conversation-row__avatar {
+  flex: 0 0 auto;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: var(--space-28);
+  height: var(--space-28);
+  border-radius: var(--radius-round);
+  background: var(--color-brand-subtle);
+  color: var(--color-brand-strong);
+  font-size: var(--font-size-small);
+  font-weight: 600;
+}
+
+.conversation-row__avatar--mine {
+  background: var(--color-surface-muted);
+  color: var(--color-text-secondary);
+}
+
+/* 이름은 미리 보기가 다 줄어든 뒤에야 줄인다 (미리 보기의 처음 폭이 0 이다) */
+.conversation-row__who {
+  flex: 0 1 auto;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  font-weight: 600;
+}
+
+.conversation-row__mailbox {
+  flex: 0 0 auto;
+  font-size: var(--font-size-small);
+  color: var(--color-text-muted);
+}
+
+.conversation-row__preview,
+.conversation-row__current {
+  flex: 1 1 0;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  font-size: var(--font-size-label);
+}
+
+.conversation-row__preview {
+  color: var(--color-text-muted);
+}
+
+.conversation-row__current {
+  font-weight: 600;
+  color: var(--color-brand-strong);
+}
+
+.conversation-row__time {
+  flex: 0 0 auto;
+  font-size: var(--font-size-small);
+  color: var(--color-text-muted);
+  font-variant-numeric: tabular-nums;
+}
+
+/* 안 읽음 — 뱃지 대신 굵기 · 색으로만, 목록 줄(MessageListItem)과 같은 값 (미리 보기가 목록 줄의 제목 자리다) */
+.conversation-row.is-unread .conversation-row__who {
+  font-weight: 650;
+  color: var(--color-text);
+}
+
+.conversation-row.is-unread .conversation-row__preview,
+.conversation-row.is-unread .conversation-row__time {
+  font-weight: 600;
+  color: var(--color-text);
+}
+
+/* 붙잡힌 메일 — 목록의 "보내는 중" · "예약 · …"과 같다 (디자인 원본 MailSendLater) — 안 읽음이어도 */
+.conversation-row__time.is-pending,
+.conversation-row.is-unread .conversation-row__time.is-pending {
+  font-weight: 600;
+  color: var(--color-brand-strong);
+}
+</style>
diff --git a/frontend/src/components/mail/ConversationTableRow.vue b/frontend/src/components/mail/ConversationTableRow.vue
new file mode 100644
index 0000000..1c45e3c
--- /dev/null
+++ b/frontend/src/components/mail/ConversationTableRow.vue
@@ -0,0 +1,287 @@
+<script setup lang="ts">
+// 목록 보기 표의 대화 줄(38) — 고르기 · 별 · 참여자(+ 통 수) · 제목(링크 + 첨부 클립) · 날짜 (14단계 — 보드 ListThreads14 에 표가 없어 정했다)
+// - 칸은 메일 표(MessageTableRow)와 같은 자리 · 폭이다. 크기 칸은 없다 — 대화 하나의 크기는 마지막 메일의 크기가 아니다
+// - 참여자 뒤에 회색 "4통"(한 통이면 없다) — 참여자가 길면 이름이 먼저 줄고 통 수는 남는다
+// - 행 어디를 눌러도 그 메일함의 마지막 메일이 열리고(open), 제목은 키보드로 갈 수 있는 링크다. Ctrl(⌘) · Shift + 클릭은 고른다 (메일 표와 같다)
+// - 줄의 메일이 모두 보내기를 기다리는 메일이면 고르기 · 별을 쓸 수 없다(aria-disabled + 까닭은 title)
+// - 임시보관함의 제목 없는 저장본은 메일 표처럼 흐린 "(제목 없음)" (리뷰 L5)
+// 칸 폭 · 칸 공통 여백은 표(MessageTable)가 정한다.
+import { computed } from 'vue'
+import type { RouteLocationRaw } from 'vue-router'
+
+import AppIcon from '@/components/AppIcon.vue'
+import MailCheckbox from '@/components/mail/MailCheckbox.vue'
+import { MAIL_BULK_TEXT, MAIL_LIST_ROW_TEXT, MAIL_NO_SUBJECT } from '@/shared/constants/mail'
+import { MAIL_CONVERSATION_LIST_TEXT } from '@/shared/constants/mail-conversation'
+import { SEND_LATER_TEXT } from '@/shared/constants/mail-send-later'
+import type { ConversationSummary } from '@/shared/types/mail'
+import { formatMailTableDate } from '@/shared/utils/format'
+import { conversationCountText } from '@/shared/utils/mail-conversation-list'
+import { pendingSendLabel, type RowWho } from '@/shared/utils/mail-list-row'
+
+interface Props {
+  row: ConversationSummary
+  who: RowWho
+  to: RouteLocationRaw
+  unread?: boolean
+  /** 임시보관함의 줄 — 제목이 없으면 흐린 글자 */
+  draft?: boolean
+  /** 줄의 메일이 모두 붙잡힌 메일 — 고르기 · 별을 쓸 수 없다 */
+  held?: boolean
+  checked?: boolean
+}
+
+interface Emits {
+  (e: 'open', location: RouteLocationRaw): void
+  (e: 'toggle-flag', rowId: string): void
+  /** 고르기 · 풀기 — range 면 Shift(범위) */
+  (e: 'check', rowId: string, range: boolean): void
+}
+
+const props = withDefaults(defineProps<Props>(), {
+  unread: false,
+  draft: false,
+  held: false,
+  checked: false,
+})
+
+const emit = defineEmits<Emits>()
+
+const subject = computed(() => props.row.latest.subject || MAIL_NO_SUBJECT)
+const countText = computed(() => conversationCountText(props.row))
+/** 마지막 메일이 붙잡아 둔 발송이면 "예약 · …" · "보내는 중" (9단계) */
+const pendingLabel = computed(() => pendingSendLabel(props.row.latest))
+
+/** 행 어디를 눌러도 연다 — 버튼 · 제목 링크(스스로 연다) · 글자를 고르는 중이면 그대로 둔다 (메일 표와 같다) */
+function onRowClick(event: MouseEvent) {
+  const target = event.target instanceof Element ? event.target : null
+  if (target?.closest('button')) return
+  if (event.ctrlKey || event.metaKey || event.shiftKey) {
+    event.preventDefault()
+    if (!props.held) emit('check', props.row.id, event.shiftKey)
+    return
+  }
+  if (target?.closest('a')) return
+  if (window.getSelection()?.toString()) return
+  emit('open', props.to)
+}
+
+/** Shift + 누름이 글자를 고르지 않게 한다 */
+function onMouseDown(event: MouseEvent) {
+  if (event.shiftKey) event.preventDefault()
+}
+
+function onStar() {
+  if (!props.held) emit('toggle-flag', props.row.id)
+}
+</script>
+
+<template>
+  <tr
+    :class="['thread-table-row', { 'is-unread': unread, 'is-checked': checked }]"
+    :data-row-id="row.id"
+    @click="onRowClick"
+    @mousedown="onMouseDown"
+  >
+    <td class="mail-table__check">
+      <!-- 폭 32px · 행 높이를 채우는 고르기 상자 — 44px 기준의 의도된 예외 (메일 표와 같다) -->
+      <MailCheckbox
+        class="thread-table-row__check"
+        :checked="checked"
+        :label="MAIL_BULK_TEXT.selectOne(subject)"
+        :unavailable="held"
+        :note="SEND_LATER_TEXT.heldNotSelectable"
+        @toggle="(event: MouseEvent) => emit('check', row.id, event.shiftKey)"
+      />
+    </td>
+    <td class="mail-table__star">
+      <button
+        type="button"
+        :class="['thread-table-row__star', { 'is-flagged': row.isFlagged }]"
+        :aria-label="MAIL_LIST_ROW_TEXT.flag"
+        :aria-pressed="row.isFlagged"
+        :aria-disabled="held ? 'true' : undefined"
+        :title="held ? MAIL_CONVERSATION_LIST_TEXT.heldFlagNote : undefined"
+        data-thread-star
+        @click="onStar"
+      >
+        <AppIcon
+          name="star"
+          :size="14"
+          :filled="row.isFlagged"
+        />
+      </button>
+    </td>
+    <td class="thread-table-row__who-cell">
+      <div class="thread-table-row__who-line">
+        <span :class="['thread-table-row__who', { 'is-placeholder': who.placeholder }]">
+          <span
+            v-if="unread"
+            class="visually-hidden"
+          >{{ MAIL_LIST_ROW_TEXT.unreadPrefix }}</span>{{ who.text }}
+        </span>
+        <span
+          v-if="countText"
+          class="thread-table-row__count"
+          data-thread-count
+        >{{ countText }}</span>
+      </div>
+    </td>
+    <td class="mail-table__subject">
+      <div class="thread-table-row__subject-line">
+        <RouterLink
+          :class="['thread-table-row__link', { 'is-placeholder': draft && !row.latest.subject }]"
+          :to="to"
+          :data-message-id="row.latest.id"
+        >
+          {{ subject }}
+        </RouterLink>
+        <AppIcon
+          v-if="row.hasAttachment"
+          name="paperclip"
+          :size="13"
+          :stroke-width="2"
+          :label="MAIL_LIST_ROW_TEXT.attachment"
+          class="thread-table-row__clip"
+        />
+      </div>
+    </td>
+    <td
+      :class="['mail-table__date', { 'is-pending': pendingLabel }]"
+      :title="pendingLabel ?? undefined"
+    >
+      <time :datetime="row.latest.pendingSend?.sendAt ?? row.latest.receivedAt">{{
+        pendingLabel ?? formatMailTableDate(row.latest.receivedAt)
+      }}</time>
+    </td>
+  </tr>
+</template>
+
+<style scoped>
+/* 메일 표의 행(MessageTableRow)과 같은 높이 · 바탕 (디자인 원본 MainList · BulkSelect) */
+.thread-table-row {
+  height: var(--size-table-row);
+  cursor: pointer;
+}
+
+.thread-table-row td {
+  border-bottom: var(--border-width) solid var(--color-border-subtle);
+}
+
+.thread-table-row:hover {
+  background: var(--color-row-hover);
+}
+
+.thread-table-row:focus-within {
+  background: var(--color-brand-subtle);
+}
+
+.thread-table-row.is-checked {
+  background: var(--color-row-checked);
+}
+
+.thread-table-row.is-checked:hover {
+  background: var(--color-row-checked-hover);
+}
+
+.thread-table-row__check {
+  width: var(--table-col-check);
+  height: calc(var(--size-table-row) - var(--border-width));
+  justify-content: flex-start;
+}
+
+.thread-table-row__star {
+  width: var(--size-compact-control);
+  height: calc(var(--size-table-row) - var(--border-width));
+  display: flex;
+  align-items: center;
+  justify-content: flex-start;
+  padding: 0;
+  border: 0;
+  border-radius: var(--radius-xs);
+  background: transparent;
+  color: var(--color-icon-muted);
+}
+
+.thread-table-row__star.is-flagged {
+  color: var(--color-star);
+}
+
+.thread-table-row__star[aria-disabled='true'] {
+  cursor: not-allowed;
+}
+
+/* 참여자 칸 — 이름이 먼저 줄고 통 수는 남는다 */
+.thread-table-row__who-line {
+  min-width: 0;
+  display: flex;
+  align-items: center;
+  gap: var(--space-6);
+}
+
+.thread-table-row__who {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  font-weight: 450;
+  color: var(--color-text-strong);
+}
+
+.thread-table-row__count {
+  flex: 0 0 auto;
+  font-size: var(--font-size-small);
+  font-weight: 500;
+  color: var(--color-text-muted);
+  font-variant-numeric: tabular-nums;
+}
+
+.thread-table-row__subject-line {
+  min-width: 0;
+  display: flex;
+  align-items: center;
+  gap: var(--space-6);
+}
+
+.thread-table-row__link {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  color: var(--color-text);
+  text-decoration: none;
+}
+
+.thread-table-row__link:hover {
+  color: var(--color-text);
+  text-decoration: underline;
+}
+
+.thread-table-row__clip {
+  flex: 0 0 auto;
+  color: var(--color-text-muted);
+}
+
+/* 비어 있는 값 — "(받는 사람 없음)" · 임시 저장본의 "(제목 없음)" (메일 표와 같다) */
+.thread-table-row__who.is-placeholder,
+.thread-table-row__link.is-placeholder {
+  color: var(--color-text-muted);
+}
+
+/* 안 읽음 — 뱃지 대신 굵기·색으로만 구분 */
+.thread-table-row.is-unread .thread-table-row__who,
+.thread-table-row.is-unread .thread-table-row__link {
+  font-weight: 650;
+  color: var(--color-text);
+}
+
+.thread-table-row.is-unread .mail-table__date {
+  font-weight: 600;
+  color: var(--color-text);
+}
+
+.thread-table-row .mail-table__date.is-pending {
+  font-weight: 600;
+  color: var(--color-brand-strong);
+}
+</style>
diff --git a/frontend/src/components/mail/HighlightedText.vue b/frontend/src/components/mail/HighlightedText.vue
new file mode 100644
index 0000000..b5618b0
--- /dev/null
+++ b/frontend/src/components/mail/HighlightedText.vue
@@ -0,0 +1,50 @@
+<script setup lang="ts">
+// 검색 강조가 든 글 (디자인 원본 Search14 · README 「14단계 › 검색 · 조건 검색 · 강조」) — 서버가 준 맞은 곳을 <mark>(노랑 · 글자색 그대로)로 그린다.
+// v-html 없이 조각(search-highlight.ts)으로 그린다. 맞은 곳이 없으면 글 그대로다(엔진 방식 검색 · 메일함 목록).
+// 뿌리 요소가 없다 — 부르는 쪽의 글 자리(span · h2 · a) 안에 넣는다.
+import { computed } from 'vue'
+
+import type { SearchRange } from '@/shared/types/mail'
+import { highlightSegments } from '@/shared/utils/search-highlight'
+
+interface Props {
+  text: string
+  /** 맞은 곳 [시작, 끝) — UTF-16, 서버가 NFC 로 맞춘 글 기준 */
+  ranges?: readonly SearchRange[] | null
+}
+
+const props = withDefaults(defineProps<Props>(), {
+  ranges: null,
+})
+
+const segments = computed(() => highlightSegments(props.text, props.ranges))
+</script>
+
+<template>
+  <template
+    v-for="(segment, index) in segments"
+    :key="index"
+  >
+    <mark
+      v-if="segment.mark"
+      class="search-mark"
+      data-search-mark
+    >{{ segment.text }}</mark>
+    <template v-else>
+      {{ segment.text }}
+    </template>
+  </template>
+</template>
+
+<style scoped>
+/*
+ * 맞은 말 — 노랑 · 글자색 그대로 · 모서리 2 · 좌우 1 (디자인 원본 Search14).
+ * 흐린 글자 위면 부르는 쪽이 글자색을 진하게 한다 — 검색 결과의 미리 보기 줄(MessageListItem — 대비 4.5:1, 2026-11-07)
+ */
+.search-mark {
+  padding: 0 var(--space-1);
+  border-radius: calc(var(--radius-xs) / 2);
+  background: var(--color-search-mark);
+  color: inherit;
+}
+</style>
diff --git a/frontend/src/components/mail/ListReadNav.spec.ts b/frontend/src/components/mail/ListReadNav.spec.ts
index 1359f17..f5f992b 100644
--- a/frontend/src/components/mail/ListReadNav.spec.ts
+++ b/frontend/src/components/mail/ListReadNav.spec.ts
@@ -158,3 +158,114 @@ describe('ListReadNav (목록 보기에서 연 메일의 이동)', () => {
     expect(router.currentRoute.value.fullPath).toBe(`/mail/search?${query}`)
   })
 })
+
+describe('ListReadNav — 14단계 검색의 빈 쪽', () => {
+  let pinia: Pinia
+
+  beforeEach(() => {
+    pinia = createPinia()
+    setActivePinia(pinia)
+    useAuthStore().markAuthenticated({ email: 'ara.kim@arasystem.test', name: '김아라' })
+  })
+
+  afterEach(() => {
+    useToastStore().clear()
+    restoreApiAdapter()
+  })
+
+  it('[다음]은 빈 쪽에 멈추지 않는다 — 다음 메일이 나올 때까지 커서로 이어 묻고 그 메일로 간다', async () => {
+    const requests = installMockApi(({ params }) => {
+      if (params.cursor === 'c2') return ok({ items: [], pageInfo: { hasNext: true, nextCursor: 'c3', total: null } })
+      return ok({ items: [summary('m4')], pageInfo: { hasNext: false, nextCursor: null, total: null } })
+    })
+    const store = useMailStore()
+    store.listSource = { kind: 'search', q: '회의', scope: 'all' }
+    store.messages = [summary('m1'), summary('m2'), summary('m3')]
+    store.pageInfo = { hasNext: true, nextCursor: 'c2', total: null }
+    store.listStatus = 'ready'
+    const query = `q=${encodeURIComponent('회의')}&in=all`
+    const router = createTestRouter()
+    await router.push(`/mail/search?${query}`)
+    await router.push(`/mail/search/m3?${query}`)
+    await router.isReady()
+    const wrapper = mount(ListReadNav, { props: { messageId: 'm3' }, global: { plugins: [pinia, router] } })
+
+    // 전체 수를 모르면 "n / 전체" 를 보이지 않는다
+    expect(wrapper.find('.nav-position').exists()).toBe(false)
+
+    await wrapper.get('button[aria-label="다음 메일"]').trigger('click')
+    await flushPromises()
+
+    expect(requests.filter((request) => request.url === '/messages').map((request) => request.params.cursor)).toEqual([
+      'c2',
+      'c3',
+    ])
+    expect(router.currentRoute.value.fullPath).toBe(`/mail/search/m4?${query}`)
+  })
+
+  it('뒤에서 결과를 이어 받는 중에 누른 [다음]은 그 일을 기다렸다가 넘어간다 — 기다리는 동안 꺼지고 aria-busy, 새로 묻지 않는다', async () => {
+    let resolveSecond: (value: ReturnType<typeof ok>) => void = () => undefined
+    const second = new Promise<ReturnType<typeof ok>>((done) => {
+      resolveSecond = done
+    })
+    const requests = installMockApi(({ url, params }) => {
+      if (url === '/search-index') return ok({ status: 'ready', done: 1, total: 1 })
+      if (!params.cursor) {
+        return ok({ items: [summary('m1'), summary('m2'), summary('m3')], pageInfo: { hasNext: true, nextCursor: 'c2', total: null } })
+      }
+      return second
+    })
+    const store = useMailStore()
+    const opening = store.openSearch('회의', 'all')
+    await flushPromises()
+    expect(store.isLoadingMore).toBe(true)
+    const query = `q=${encodeURIComponent('회의')}&in=all`
+    const router = createTestRouter()
+    await router.push(`/mail/search?${query}`)
+    await router.push(`/mail/search/m3?${query}`)
+    await router.isReady()
+    const wrapper = mount(ListReadNav, { props: { messageId: 'm3' }, global: { plugins: [pinia, router] } })
+    const next = wrapper.get('button[aria-label="다음 메일"]')
+    // 이어 받는 중이면 끝에 있어도 [다음]을 누를 수 있다
+    expect(next.attributes('disabled')).toBeUndefined()
+
+    await next.trigger('click')
+    await flushPromises()
+    expect(next.attributes('disabled')).toBeDefined()
+    expect(next.attributes('aria-busy')).toBe('true')
+    expect(router.currentRoute.value.fullPath).toBe(`/mail/search/m3?${query}`)
+
+    resolveSecond(ok({ items: [summary('m4')], pageInfo: { hasNext: false, nextCursor: null, total: null } }))
+    await opening
+    await flushPromises()
+
+    expect(router.currentRoute.value.fullPath).toBe(`/mail/search/m4?${query}`)
+    expect(requests.filter((request) => request.url === '/messages').map((request) => request.params.cursor)).toEqual([
+      undefined,
+      'c2',
+    ])
+  })
+
+  it('목록을 보이는 채로 새로 고치는 동안 받아야 할 [다음]은 꺼지고 aria-busy — 끝나면 다시 누를 수 있다', async () => {
+    const store = useMailStore()
+    store.currentMailboxId = 'inbox'
+    store.messages = [summary('m1'), summary('m2'), summary('m3')]
+    store.pageInfo = { hasNext: true, nextCursor: 'c2', total: 5 }
+    store.listStatus = 'ready'
+    store.isRefreshing = true
+    const router = createTestRouter()
+    await router.push('/mail/inbox')
+    await router.push('/mail/inbox/m3')
+    await router.isReady()
+    const wrapper = mount(ListReadNav, { props: { messageId: 'm3' }, global: { plugins: [pinia, router] } })
+    const next = wrapper.get('button[aria-label="다음 메일"]')
+
+    expect(next.attributes('disabled')).toBeDefined()
+    expect(next.attributes('aria-busy')).toBe('true')
+
+    store.isRefreshing = false
+    await flushPromises()
+    expect(next.attributes('disabled')).toBeUndefined()
+    expect(next.attributes('aria-busy')).toBe('false')
+  })
+})
diff --git a/frontend/src/components/mail/ListReadNav.vue b/frontend/src/components/mail/ListReadNav.vue
index 4af15da..0ef43bb 100644
--- a/frontend/src/components/mail/ListReadNav.vue
+++ b/frontend/src/components/mail/ListReadNav.vue
@@ -2,6 +2,8 @@
 // 목록 보기에서 연 메일의 이동 도구 — 목록으로 · 이전/다음 · 위치 "n / 전체" (디자인 원본 MainListRead)
 // 본문 툴바의 앞쪽에 들어간다 (MessageReader 의 toolbar-start 슬롯).
 // 목록은 메일함 또는 검색 결과다 — 검색 결과에서 연 메일이면 "목록으로"는 결과로, 이전/다음은 결과 안에서 옮긴다.
+// 대화로 묶은 메일함(14단계)은 줄(대화) 사이를 옮긴다 — 이전/다음은 앞뒤 줄의 마지막 메일, 위치는 "n번째 대화 / 대화 수".
+// 연 메일이 줄의 마지막 메일이 아니어도([이 메일만 열기]로 연 더 오래된 메일) 그 메일이 든 줄을 기준으로 한다
 import { computed, ref } from 'vue'
 import { useRouter } from 'vue-router'
 
@@ -32,45 +34,60 @@ const listHref = computed(() => {
   const source = mailStore.listSource
   return source ? router.resolve(listLocationOf(source)).href : router.resolve({ name: 'mail' }).href
 })
-/** 불러온 목록에서의 위치 — 목록 밖의 메일(주소로 바로 연 경우 등)이면 -1 */
-const index = computed(() => mailStore.messages.findIndex((message) => message.id === props.messageId))
-/** 전체 — 서버가 준 total, 없으면 메일함 개수(메일함 목록일 때만), 그것도 없으면 불러온 수 */
-const total = computed(
-  () =>
-    mailStore.pageInfo?.total ??
-    (mailStore.search ? null : mailStore.currentMailbox?.totalCount) ??
-    mailStore.messages.length,
-)
+/** 불러온 목록에서의 위치(줄) — 목록 밖의 메일(주소로 바로 연 경우 등)이면 -1 */
+const index = computed(() => mailStore.rowIndexOfMessage(props.messageId))
+/**
+ * 전체 — 서버가 준 total, 없으면 메일함 개수(메일함 목록일 때만), 그것도 없으면 불러온 수.
+ * 검색 결과의 total 이 null 이면(1,000통 넘음 · 다 세지 못함 — 14단계) 모른다 — 위치 "n / 전체"를 보이지 않는다.
+ * 대화 목록은 대화 수 — 모르면 다 받았을 때만 불러온 줄 수 (메일함의 통 수는 대화 수가 아니다)
+ */
+const total = computed<number | null>(() => {
+  const known = mailStore.pageInfo?.total ?? null
+  if (known !== null) return known
+  if (mailStore.search) return null
+  if (mailStore.isConversationList) return mailStore.hasMore ? null : mailStore.rowCount
+  return mailStore.currentMailbox?.totalCount ?? mailStore.messages.length
+})
 const position = computed(() =>
-  index.value === -1 ? '' : `${formatCount(index.value + 1)} / ${formatCount(total.value)}`,
+  index.value === -1 || total.value === null ? '' : `${formatCount(index.value + 1)} / ${formatCount(total.value)}`,
 )
 const hasPrev = computed(() => index.value > 0)
-/** 불러온 범위의 끝이어도 서버에 더 있으면(hasNext) 다음으로 갈 수 있다 */
+/** 불러온 범위의 끝이어도 서버에 더 있거나(hasNext) 뒤에서 이어 받는 중이면 다음으로 갈 수 있다 */
 const hasNext = computed(
   () =>
-    index.value !== -1 && (index.value < mailStore.messages.length - 1 || mailStore.hasMore),
+    index.value !== -1 && (index.value < mailStore.rowCount - 1 || mailStore.hasMore || mailStore.isLoadingMore),
+)
+/** 다음 메일을 받아야 하는데 목록을 보이는 채로 새로 고치는 중 — 끝날 때까지 [다음]을 막는다 (옛 커서로 붙이지 않게) */
+const nextWaiting = computed(
+  () => index.value !== -1 && mailStore.rowMessageIdAt(index.value + 1) === null && mailStore.isRefreshing,
 )
 
 async function goPrev() {
-  const previous = mailStore.messages[index.value - 1]
+  const previous = mailStore.rowMessageIdAt(index.value - 1)
   const source = mailStore.listSource
-  if (previous && source) await showSiblingIn(source, previous.id)
+  if (previous && source) await showSiblingIn(source, previous)
 }
 
+/**
+ * 다음 메일 — 불러온 범위의 끝이면 더 받는다. 검색 결과를 뒤에서 이어 받는 중(14단계)이면 그 일이 끝나기를 기다리고,
+ * 그 안에 다음 메일이 없었으면 이번 누름의 차례로 한 번 더 받는다. 기다리는 동안 단추는 꺼지고 aria-busy
+ */
 async function goNext() {
-  if (loadingNext.value || index.value === -1) return
+  if (loadingNext.value || nextWaiting.value || index.value === -1) return
   const current = index.value
-  if (!mailStore.messages[current + 1] && mailStore.hasMore) {
+  if (mailStore.rowMessageIdAt(current + 1) === null && (mailStore.hasMore || mailStore.isLoadingMore)) {
     loadingNext.value = true
     try {
+      const waited = mailStore.isLoadingMore
       await mailStore.loadMore()
+      if (waited && mailStore.rowMessageIdAt(current + 1) === null && mailStore.hasMore) await mailStore.loadMore()
     } finally {
       loadingNext.value = false
     }
   }
-  const next = mailStore.messages[current + 1]
+  const next = mailStore.rowMessageIdAt(current + 1)
   const source = mailStore.listSource
-  if (next && source) await showSiblingIn(source, next.id)
+  if (next && source) await showSiblingIn(source, next)
 }
 
 /** 목록으로 — 불러온 페이지·스크롤 위치는 그대로, 초점은 보던 메일의 행으로 돌려준다 */
@@ -80,7 +97,8 @@ function onBackToList(event: MouseEvent) {
   event.preventDefault()
   const source = mailStore.listSource
   if (!source) return
-  viewStore.setReturnFocus(props.messageId)
+  // 대화 목록은 줄의 링크가 마지막 메일을 가리킨다 — 그 줄로 초점을 돌려준다
+  viewStore.setReturnFocus(mailStore.rowMessageIdAt(index.value) ?? props.messageId)
   void backToSourceList(source)
 }
 </script>
@@ -115,8 +133,8 @@ function onBackToList(event: MouseEvent) {
     type="button"
     class="nav-button"
     aria-label="다음 메일"
-    :disabled="!hasNext || loadingNext"
-    :aria-busy="loadingNext"
+    :disabled="!hasNext || loadingNext || nextWaiting"
+    :aria-busy="loadingNext || nextWaiting"
     @click="goNext"
   >
     <AppIcon
diff --git a/frontend/src/components/mail/MailBodyFrame.vue b/frontend/src/components/mail/MailBodyFrame.vue
index 5762877..2ce18f5 100644
--- a/frontend/src/components/mail/MailBodyFrame.vue
+++ b/frontend/src/components/mail/MailBodyFrame.vue
@@ -14,8 +14,10 @@
 // (<출처>/api/mail-images/ — 'self' 전체가 아니다)를 더하고 정화가 중계 주소의 그림을 남긴다 — sandbox 는 그대로다 (mail-html.ts).
 // 내용 높이를 잴 때마다 measured 를 알린다 — 인쇄 화면이 다 잰 뒤(그림까지 받은 뒤 — iframe 의 load) 인쇄 창을 띄운다
 // 대용량 첨부 덩이(11단계)는 foldLargeFiles 면 접어 그린다 — 본문 틀 안의 details 를 열고 닫으면(toggle) 높이를 다시 잰다
+// 검색 결과에서 연 메일(14단계)은 맞은 말이 노랑으로 보인다 — 서식 본문은 서버가 넣은 <mark>, 글 본문은 textHighlights 의 위치로 (mail-html.ts)
 import { computed, onBeforeUnmount, onMounted, ref, watch } from 'vue'
 
+import type { SearchRange } from '@/shared/types/mail'
 import { buildMailDocument } from '@/shared/utils/mail-html'
 
 interface Props {
@@ -29,6 +31,8 @@ interface Props {
   title?: string
   /** 대용량 첨부 덩이를 접는다 — 읽기 화면이 첨부 칸에 그 파일을 보일 때 (인쇄 화면은 펼친 채) */
   foldLargeFiles?: boolean
+  /** 글 본문의 검색에서 맞은 곳 — 서버의 searchHighlight.textBody (14단계 — 글 본문을 보일 때만 쓴다) */
+  textHighlights?: readonly SearchRange[] | null
 }
 
 interface Emits {
@@ -47,6 +51,7 @@ const props = withDefaults(defineProps<Props>(), {
   imagesShown: false,
   title: '메일 본문',
   foldLargeFiles: false,
+  textHighlights: null,
 })
 const emit = defineEmits<Emits>()
 
@@ -63,6 +68,7 @@ const srcdoc = computed(() =>
     textBody: props.textBody,
     imagesShown: props.imagesShown,
     foldLargeFiles: props.foldLargeFiles,
+    textHighlights: props.textHighlights,
   }),
 )
 
diff --git a/frontend/src/components/mail/MailConversationToggle.vue b/frontend/src/components/mail/MailConversationToggle.vue
new file mode 100644
index 0000000..75d5964
--- /dev/null
+++ b/frontend/src/components/mail/MailConversationToggle.vue
@@ -0,0 +1,82 @@
+<script setup lang="ts">
+// 목록 머리 오른쪽의 [대화로 묶기] (14단계 — 디자인 원본 ListThreads14): 눌림 단추(aria-pressed) · 높이 36(--size-notice-action — 안내 줄 단추의
+// 밀도 예외를 새 토큰 없이 다시 쓴다). 누르면 설정(groupByConversation)을 PATCH 한다 — 화면을 먼저 바꾸고(메일함 화면이 바로 묶거나 푼다)
+// 끝내 실패하면 서버가 확인한 값으로 되돌린다(mail-settings.store — 칸마다 저장은 한 번에 하나, 알림은 인터셉터).
+// 분할 보기의 목록 칸(384)은 머리가 좁아 아이콘만(36×36 — 이름은 title · 화면 낭독, MailboxEmptyButton 과 같은 결), 목록 보기는 아이콘 + 이름.
+// 이름까지 보이면 99px 이라 1440 분할 보기에서도 "받은편지함" 뒤 개수 글 자리가 11px 만 남는다(2026-11-06 쟀다) — 그래서 아이콘만 두고
+// 설정 › 보내기 · 읽기의 설명이 "말풍선 모양 [대화로 묶기] 단추"라고 모양을 말한다(MAIL_SETTINGS_TEXT.groupHint)
+// 켠 모양은 보기 전환의 고른 칸과 같다(청록 옅은 바탕 · 진한 청록 글자 — 테두리는 그대로, 보드의 #9FD3D7 테두리는 새 색이라 두지 않았다)
+import { computed } from 'vue'
+
+import AppIcon from '@/components/AppIcon.vue'
+import { MAIL_CONVERSATION_LIST_TEXT } from '@/shared/constants/mail-conversation'
+import { useMailSettingsStore } from '@/stores/mail-settings.store'
+
+interface Props {
+  variant: 'split' | 'list'
+}
+
+const props = defineProps<Props>()
+
+const settingsStore = useMailSettingsStore()
+
+const pressed = computed(() => settingsStore.groupByConversation)
+const iconOnly = computed(() => props.variant === 'split')
+
+function toggle() {
+  void settingsStore.update('groupByConversation', !pressed.value)
+}
+</script>
+
+<template>
+  <button
+    type="button"
+    :class="['group-toggle', { 'is-on': pressed, 'group-toggle--icon': iconOnly }]"
+    :aria-pressed="pressed"
+    :title="iconOnly ? MAIL_CONVERSATION_LIST_TEXT.toggle : undefined"
+    data-group-toggle
+    @click="toggle"
+  >
+    <AppIcon
+      name="message-square"
+      :size="14"
+      :stroke-width="1.9"
+    />
+    <span :class="{ 'visually-hidden': iconOnly }">{{ MAIL_CONVERSATION_LIST_TEXT.toggle }}</span>
+  </button>
+</template>
+
+<style scoped>
+/* 높이 36(밀도 예외 --size-notice-action) · 테두리 · 12.5px 굵게 (디자인 원본 ListThreads14) */
+.group-toggle {
+  flex: 0 0 auto;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: var(--space-6);
+  min-height: var(--size-notice-action);
+  padding: 0 var(--space-10);
+  border: var(--border-width) solid var(--color-border-strong);
+  border-radius: var(--radius-md);
+  background: var(--color-surface);
+  color: var(--color-text-strong);
+  font-size: var(--font-size-label);
+  font-weight: 600;
+  white-space: nowrap;
+}
+
+.group-toggle:hover:not(.is-on) {
+  background: var(--color-surface-muted);
+}
+
+.group-toggle.is-on {
+  background: var(--color-brand-subtle);
+  color: var(--color-brand-strong);
+}
+
+/* 분할 보기 — 아이콘만, 정사각형 36 */
+.group-toggle--icon {
+  width: var(--size-notice-action);
+  padding: 0;
+}
+</style>
diff --git a/frontend/src/components/mail/MailListFrame.vue b/frontend/src/components/mail/MailListFrame.vue
index 9f8595f..056bcfa 100644
--- a/frontend/src/components/mail/MailListFrame.vue
+++ b/frontend/src/components/mail/MailListFrame.vue
@@ -4,8 +4,11 @@
 //   그 아래 휴지통 · 스팸메일함의 30일 줄(13단계 — 메일이 있을 때만, 없으면 빈 상태 글에 붙인다 · 검색 결과 · 다른 메일함에는 없다),
 //   바탕화면 알림 권하기(메일함 목록에서만 · 한 번 — MailNotifyOffer, 5단계), "새 메일 N통 · 맨 위로"(useListArrivalNotice)
 // - 상태: 불러오는 중(뼈대) · 못 불러옴 · 행(slot) + 메일 더 보기 · 빈 메일함 · 검색 결과 없음 · 예약한 메일 없음(9단계 — 예약됨에는 알림 권하기 줄이 없다)
+// - 검색 결과(14단계 — 디자인 원본 Search14): 찾을 곳 줄 아래 조건 줄(조건이 걸렸을 때) · 안내 줄(검색 준비 중 · 한 글자 안내).
+//   결과 없음은 더 찾을 것이 없을 때만 — 이어 찾을 것이 남았는데 아직 하나도 못 찾았으면 [더 찾기](MailSearchMore)
 // - Esc 는 고른 것을 푼다 — 이 칸 안의 키만 받는다 (전역 단축키가 아니다 · 메뉴 · 대화상자 안의 Esc 는 그쪽 것이다)
 // - 목록 보기는 메일을 열면 이 칸이 사라진다 — 스크롤을 기억해 "목록으로" 돌아오면 되살리고 보던 메일로 초점을 돌려준다
+// - 대화로 묶은 메일함(14단계)도 같은 틀이다 — 줄 수 · 빈 상태는 메일 목록과 같은 규칙(줄이 대화일 뿐)
 import { computed, nextTick, ref, watch } from 'vue'
 
 import AppIcon from '@/components/AppIcon.vue'
@@ -14,8 +17,11 @@ import MailListHeader from '@/components/mail/MailListHeader.vue'
 import MailLoadError from '@/components/mail/MailLoadError.vue'
 import MailNewNotice from '@/components/mail/MailNewNotice.vue'
 import MailNotifyOffer from '@/components/mail/MailNotifyOffer.vue'
+import MailSearchConditionLine from '@/components/mail/MailSearchConditionLine.vue'
 import MailSearchEmpty from '@/components/mail/MailSearchEmpty.vue'
 import MailSearchHeader from '@/components/mail/MailSearchHeader.vue'
+import MailSearchMore from '@/components/mail/MailSearchMore.vue'
+import MailSearchNotices from '@/components/mail/MailSearchNotices.vue'
 import MailSearchScope from '@/components/mail/MailSearchScope.vue'
 import MailSelectionToolbar from '@/components/mail/MailSelectionToolbar.vue'
 import MessageListSkeleton from '@/components/mail/MessageListSkeleton.vue'
@@ -26,7 +32,8 @@ import { useMailSearchNavigation } from '@/composables/useMailSearchNavigation'
 import { MAIL_SEARCH_TEXT, MAILBOX_RETENTION_NOTICES, SEARCH_SCOPE_ALL } from '@/shared/constants/mail'
 import { SEND_LATER_TEXT } from '@/shared/constants/mail-send-later'
 import { isImeComposing } from '@/shared/utils/keyboard-shortcut'
-import { isScheduledSource } from '@/shared/utils/mail-list-source'
+import { isScheduledSource, isSearchTooLong } from '@/shared/utils/mail-list-source'
+import { hasSearchConditions, skipsBodySearch } from '@/shared/utils/mail-search'
 import { emptyMailboxText, mailboxIcon } from '@/shared/utils/mailbox'
 import { useMailStore } from '@/stores/mail.store'
 
@@ -69,15 +76,39 @@ const retentionNotice = computed(() => {
   const role = mailbox.value?.role ?? null
   const text = role ? (MAILBOX_RETENTION_NOTICES[role] ?? null) : null
   if (text === null) return null
-  return mailStore.listStatus === 'ready' && mailStore.messages.length === 0 ? null : text
+  return mailStore.listStatus === 'ready' && mailStore.rowCount === 0 ? null : text
 })
+/** 검색 조건 — 조건 줄은 걸렸을 때만 (14단계) */
+const searchConditions = computed(() =>
+  search.value && hasSearchConditions(search.value.conditions) ? (search.value.conditions ?? null) : null,
+)
+/** 검색어와 조건의 낱말이 한도를 넘는 주소 — 찾지 않았다, 결과 없음 자리에 그 까닭을 보인다 (14단계) */
+const searchTooLong = computed(() => isSearchTooLong(search.value))
+/** 지난 메일의 색인을 만드는 중 — 결과 머리 아래 "검색 준비 중" 줄 · 결과 없음의 한계 안내 (14단계) */
+const indexing = computed(() => mailStore.searchIndexStatus === 'building')
+/** 한 글자 낱말뿐이라 본문을 찾지 않았다 — 색인 방식(준비가 끝남)일 때만 알린다 (14단계) */
+const singleChar = computed(
+  () =>
+    Boolean(search.value) &&
+    !searchTooLong.value &&
+    mailStore.searchIndexStatus === 'ready' &&
+    skipsBodySearch(search.value?.q ?? '', search.value?.conditions),
+)
+/** 더 받는 중 · 보이는 채로 새로 고치는 중 — [메일 더 보기] · [더 찾기]를 막는다 (새로 고치는 동안 옛 커서로 붙이지 않게) */
+const loadingMore = computed(() => mailStore.isLoadingMore || mailStore.isRefreshing)
+/** 결과가 아직 없지만 이어 찾을 것이 남았다 — 결과 없음 대신 [더 찾기] */
+const searchPending = computed(
+  () => Boolean(search.value) && mailStore.listStatus === 'ready' && mailStore.rowCount === 0 && mailStore.hasMore,
+)
 /** 없는 주소(RES_001)일 때 — 메일함은 받은편지함으로, 없는 메일함 안의 검색은 전체 메일함에서 */
 const leaveLabel = computed(() => (search.value ? MAIL_SEARCH_TEXT.searchAll : '받은편지함으로'))
 
 function retry() {
   const current = search.value
-  if (current) void mailStore.openSearch(current.q, current.scope, { force: true })
+  const source = mailStore.listSource
+  if (current) void mailStore.openSearch(current.q, current.scope, { force: true, conditions: current.conditions })
   else if (scheduled.value) void mailStore.openScheduled()
+  else if (source?.kind === 'conversations') void mailStore.openConversations(source.mailboxId)
   else if (mailStore.currentMailboxId) void mailStore.openMailbox(mailStore.currentMailboxId)
 }
 
@@ -107,6 +138,18 @@ function onKeydown(event: KeyboardEvent) {
   mailStore.clearChecked()
 }
 
+// 조건 줄의 [조건 지우기] · 결과를 기다리던 [더 찾기]는 누르면 그 자리가 사라진다 — 초점을 잃었으면 목록 칸으로 (14단계)
+watch(
+  [() => searchConditions.value !== null, searchPending],
+  ([hasConditions, pending], [hadConditions, wasPending]) => {
+    if ((hadConditions && !hasConditions) || (wasPending && !pending)) {
+      const active = document.activeElement
+      if (active === null || active === document.body) focusSection()
+    }
+  },
+  { flush: 'post' },
+)
+
 // 고른 것을 다 풀면 도구 줄이 사라진다 — 초점이 그 안에 있었으면(갈 곳을 잃으면) 목록 칸으로
 watch(
   () => mailStore.checkedCount,
@@ -159,7 +202,17 @@ watch(
         />
         <span>{{ retentionNotice }}</span>
       </p>
-      <MailSearchScope v-if="search" />
+      <template v-if="search">
+        <MailSearchScope />
+        <MailSearchConditionLine
+          v-if="searchConditions"
+          :conditions="searchConditions"
+        />
+        <MailSearchNotices
+          :indexing="indexing"
+          :single-char="singleChar"
+        />
+      </template>
       <MailNotifyOffer
         v-else-if="!scheduled"
         :variant="variant"
@@ -190,7 +243,7 @@ watch(
       @leave="leave"
     />
 
-    <template v-else-if="mailStore.messages.length > 0">
+    <template v-else-if="mailStore.rowCount > 0">
       <slot />
       <div
         v-if="mailStore.hasMore"
@@ -199,18 +252,27 @@ watch(
         <button
           type="button"
           class="mail-list-frame__more-button"
-          :disabled="mailStore.isLoadingMore"
+          :disabled="loadingMore"
           @click="mailStore.loadMore()"
         >
-          {{ mailStore.isLoadingMore ? '불러오는 중…' : '메일 더 보기' }}
+          {{ loadingMore ? '불러오는 중…' : '메일 더 보기' }}
         </button>
       </div>
     </template>
 
+    <MailSearchMore
+      v-else-if="searchPending"
+      :busy="loadingMore"
+      @more="mailStore.loadMore()"
+    />
+
     <MailSearchEmpty
       v-else-if="mailStore.listStatus === 'ready' && search"
       :query="search.q"
-      :offer-all="search.scope !== SEARCH_SCOPE_ALL"
+      :has-conditions="searchConditions !== null"
+      :offer-all="search.scope !== SEARCH_SCOPE_ALL && !searchTooLong"
+      :word-limit="indexing && !searchTooLong"
+      :too-many-words="searchTooLong"
       @search-all="setScope(SEARCH_SCOPE_ALL)"
     />
 
diff --git a/frontend/src/components/mail/MailListHeader.vue b/frontend/src/components/mail/MailListHeader.vue
index 5f7cbff..ef07d27 100644
--- a/frontend/src/components/mail/MailListHeader.vue
+++ b/frontend/src/components/mail/MailListHeader.vue
@@ -1,5 +1,12 @@
 <script setup lang="ts">
-// 목록 머리 — 메일함 이름 · 개수("전체 N · 안 읽음 M") · [휴지통 비우기 · 스팸메일함 비우기] · 보기 전환 · 새로고침
+// 목록 머리 — 메일함 이름 · 개수 · [대화로 묶기](14단계) · [휴지통 비우기 · 스팸메일함 비우기] · 보기 전환 · 새로고침
+// 개수(14단계 — 디자인 원본 ListThreads14): 묶지 않았으면 "메일 9통, 안 읽은 메일 2통"(메일함의 통 수), 묶었으면 "대화 6개, 안 읽은 메일 2통"
+// (대화 수는 목록의 total — 모르면 그 부분을 뺀다). 안 읽은 메일이 없으면 뒤를 뺀다.
+// 분할 보기(좁은 머리)는 안 읽은 메일이 있으면 "안 읽은 메일 2통"만, 없으면 "메일 9통"(묶었으면 "대화 6개")을 보이고 전체 글은 title · 화면 낭독에 둔다.
+// 칸 사이도 조금 좁힌다(이름↔개수 6 · 머리↔단추 4 · 단추 사이 4) — 1440 의 목록 칸(384)에서 "받은편지함" 뒤 "안 읽은 메일 99통"(86px)까지 다 보이게
+// (2026-11-06 실사용 시험 — 원래 자리 74px 로 "메일 6통, 안 …"처럼 안 읽은 수가 늘 잘렸다)
+// [대화로 묶기]는 메일함 목록(묶었든 아니든)에서만 — 검색 결과 · 예약됨은 묶지 않는다. 설정을 받는 동안은 숨기고(그사이 고른 것은 받기가 덮는다),
+// 받았거나 받지 못했으면 보인다 — 받지 못했으면 짐작 위에서 고르고 그 칸만 저장한다 (mail-settings.store — 리뷰 L4)
 // 예약됨(9단계)은 "예약됨" · "2통 · 보낼 시각 차례" (디자인 원본 MailSendLater)
 // 분할 보기(MessageList)와 목록 보기(MessageTable)가 함께 쓴다. 안쪽 여백만 보기마다 다르다 (디자인 원본).
 // 비우기는 휴지통 · 스팸메일함에 메일이 있을 때만 (디자인 원본 MailboxManage — MailboxEmptyButton). 좁으면 이름 · 개수가 먼저 줄어든다.
@@ -7,12 +14,15 @@
 import { computed } from 'vue'
 
 import AppIcon from '@/components/AppIcon.vue'
+import MailConversationToggle from '@/components/mail/MailConversationToggle.vue'
 import MailboxEmptyButton from '@/components/mail/MailboxEmptyButton.vue'
 import ViewModeSwitch from '@/components/mail/ViewModeSwitch.vue'
 import { SEND_LATER_TEXT } from '@/shared/constants/mail-send-later'
 import { formatCount } from '@/shared/utils/format'
-import { isScheduledSource } from '@/shared/utils/mail-list-source'
+import { listHeadCountText, listHeadShortCountText } from '@/shared/utils/mail-conversation-list'
+import { isScheduledSource, mailboxListIdOf } from '@/shared/utils/mail-list-source'
 import { isEmptiableMailbox } from '@/shared/utils/mailbox'
+import { useMailSettingsStore } from '@/stores/mail-settings.store'
 import { useMailStore } from '@/stores/mail.store'
 
 interface Props {
@@ -21,24 +31,40 @@ interface Props {
   variant?: 'split' | 'list'
 }
 
-withDefaults(defineProps<Props>(), {
+const props = withDefaults(defineProps<Props>(), {
   variant: 'split',
 })
 
 const mailStore = useMailStore()
+const settingsStore = useMailSettingsStore()
 
 const scheduled = computed(() => isScheduledSource(mailStore.listSource))
 const title = computed(() => (scheduled.value ? SEND_LATER_TEXT.mailbox : (mailStore.currentMailbox?.name ?? '메일함')))
+/** 메일함 목록의 개수 칸 — 묶었으면 대화 수(목록의 total), 아니면 메일함의 통 수. 예약됨 · 메일함을 모르면 null */
+const countInput = computed(() => {
+  const box = scheduled.value ? null : mailStore.currentMailbox
+  if (!box) return null
+  return mailStore.isConversationList
+    ? { grouped: true, total: mailStore.pageInfo?.total ?? null, unread: box.unreadCount }
+    : { grouped: false, total: box.totalCount, unread: box.unreadCount }
+})
 const countText = computed(() => {
   if (scheduled.value) {
     if (mailStore.listStatus !== 'ready') return ''
     return SEND_LATER_TEXT.listCount(formatCount(mailStore.pageInfo?.total ?? mailStore.messages.length))
   }
-  const box = mailStore.currentMailbox
-  if (!box) return ''
-  const total = `전체 ${formatCount(box.totalCount)}`
-  return box.unreadCount > 0 ? `${total} · 안 읽음 ${formatCount(box.unreadCount)}` : total
+  return countInput.value ? listHeadCountText(countInput.value) : ''
 })
+/** 보이는 개수 — 분할 보기(좁은 머리)의 메일함 목록은 줄인 글(안 읽은 메일이 있으면 그 수만), 그 밖은 전체 글 */
+const shownCountText = computed(() =>
+  props.variant === 'split' && countInput.value ? listHeadShortCountText(countInput.value) : countText.value,
+)
+/** [대화로 묶기] — 메일함 목록에서만, 설정을 받았거나 받지 못했을 때 (14단계 — 받는 중 · 받기 전에는 숨긴다) */
+const groupable = computed(
+  () =>
+    mailboxListIdOf(mailStore.listSource) !== null &&
+    (settingsStore.status === 'ready' || settingsStore.status === 'error'),
+)
 const busy = computed(() => mailStore.listStatus === 'loading' || mailStore.isRefreshing)
 /** 비울 수 있는 메일함 — 휴지통 · 스팸메일함에 메일이 있을 때 */
 const emptiable = computed(() => {
@@ -49,14 +75,32 @@ const emptiable = computed(() => {
 
 <template>
   <div :class="['list-header', `list-header--${variant}`]">
-    <h1
-      :id="titleId"
-      class="list-header__title"
-    >
-      {{ title }}
-    </h1>
-    <span class="list-header__count">{{ countText }}</span>
+    <div class="list-header__heading">
+      <h1
+        :id="titleId"
+        class="list-header__title"
+      >
+        {{ title }}
+      </h1>
+      <!--
+        분할 보기는 줄인 글을 보이고 전체 글은 title · 화면 낭독에 둔다. 그래도 좁으면 줄어 잘릴 수 있다 — 마우스를 올리면 다 보인다
+      -->
+      <span
+        class="list-header__count"
+        :title="countText || undefined"
+      >
+        <template v-if="shownCountText !== countText">
+          <span aria-hidden="true">{{ shownCountText }}</span>
+          <span class="visually-hidden">{{ countText }}</span>
+        </template>
+        <template v-else>{{ countText }}</template>
+      </span>
+    </div>
     <div class="list-header__end">
+      <MailConversationToggle
+        v-if="groupable"
+        :variant="variant"
+      />
       <MailboxEmptyButton
         v-if="emptiable"
         :mailbox="emptiable"
@@ -92,7 +136,35 @@ const emptiable = computed(() => {
   padding: var(--space-4) var(--space-8) var(--space-4) var(--space-20);
 }
 
+/* 분할 보기의 목록 칸(384) — 개수 글이 들 자리를 내려고 칸 사이를 조금 좁힌다 (머리말) */
+.list-header--split {
+  gap: var(--space-4);
+}
+
+.list-header--split .list-header__heading {
+  gap: var(--space-6);
+}
+
+.list-header--split .list-header__end {
+  gap: var(--space-4);
+}
+
+/*
+ * 이름 · 개수 — 오른쪽 단추들이 남긴 자리를 쓴다. 좁으면 개수가 먼저 줄고(사라질 때까지) 그다음에 이름이 준다
+ * (14단계 — [대화로 묶기]가 더해져 분할 보기 칸에서 이름이 1px 모자라 "색인 …"으로 잘렸다)
+ */
+.list-header__heading {
+  flex: 1 1 auto;
+  min-width: 0;
+  display: flex;
+  align-items: center;
+  gap: var(--space-8);
+  overflow: hidden;
+}
+
 .list-header__title {
+  flex: 0 0 auto;
+  max-width: 100%;
   min-width: 0;
   margin: 0;
   overflow: hidden;
@@ -105,7 +177,7 @@ const emptiable = computed(() => {
 
 /* 좁으면 이름보다 먼저 줄어든다 */
 .list-header__count {
-  flex: 0 100 auto;
+  flex: 0 1 auto;
   min-width: 0;
   overflow: hidden;
   font-size: var(--font-size-small);
diff --git a/frontend/src/components/mail/MailPurgeDialog.vue b/frontend/src/components/mail/MailPurgeDialog.vue
index 044c1ca..18b3d59 100644
--- a/frontend/src/components/mail/MailPurgeDialog.vue
+++ b/frontend/src/components/mail/MailPurgeDialog.vue
@@ -1,17 +1,22 @@
 <script setup lang="ts">
 // 영구 삭제 확인 — 휴지통에서만 (디자인 원본 BulkSelect · ListStates "휴지통 · 영구 삭제 확인")
 // 제목 "메일 N통을 영구 삭제할까요?" · 글 "휴지통에서 지운 메일은 되돌릴 수 없습니다." · [영구 삭제](빨강 채움) [취소]
+// 대화로 묶은 휴지통에서 줄을 골랐으면(from) 제목은 "휴지통에 있는 메일 N통을 영구 삭제할까요?" — 줄의 통 수는 대화 전체라서 (14단계, 2026-11-07)
 // 열리면 「취소」에 초점이 간다 — 실수로 Enter · Space 를 눌러도 지워지지 않게. Esc 는 취소와 같다.
-// 쓰는 곳: 여러 통 처리 도구 줄 · 읽기 화면(한 통) — 둘이 함께 보일 수 있어 id 앞부분(idPrefix)을 따로 받는다
+// 쓰는 곳: 여러 통 처리 도구 줄 · 읽기 화면(한 통 — from 없이 지금 글) — 둘이 함께 보일 수 있어 id 앞부분(idPrefix)을 따로 받는다
+import { computed } from 'vue'
+
 import ModalDialog from '@/components/feedback/ModalDialog.vue'
 import { MAIL_BULK_TEXT } from '@/shared/constants/mail'
-import { formatCount } from '@/shared/utils/format'
+import { purgeTitleText } from '@/shared/utils/mail-bulk'
 
 interface Props {
   open: boolean
   count: number
   /** 제목 · 글의 id 앞부분 — 화면에 하나뿐인 값 */
   idPrefix: string
+  /** 대화로 묶은 목록에서 고른 줄이면 그 메일함 이름 ("휴지통") — 없으면 "메일 N통을 …" */
+  from?: string | null
 }
 
 interface Emits {
@@ -19,15 +24,19 @@ interface Emits {
   (e: 'cancel'): void
 }
 
-defineProps<Props>()
+const props = withDefaults(defineProps<Props>(), {
+  from: null,
+})
 const emit = defineEmits<Emits>()
+
+const title = computed(() => purgeTitleText(props.count, { from: props.from }))
 </script>
 
 <template>
   <ModalDialog
     :open="open"
     role="alertdialog"
-    :title="MAIL_BULK_TEXT.purgeTitle(formatCount(count))"
+    :title="title"
     :message="MAIL_BULK_TEXT.purgeMessage"
     :title-id="`${idPrefix}-title`"
     :message-id="`${idPrefix}-message`"
diff --git a/frontend/src/components/mail/MailSearchBox.spec.ts b/frontend/src/components/mail/MailSearchBox.spec.ts
index e8d32ae..b6791f8 100644
--- a/frontend/src/components/mail/MailSearchBox.spec.ts
+++ b/frontend/src/components/mail/MailSearchBox.spec.ts
@@ -1,12 +1,14 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { mount } from '@vue/test-utils'
+import { mount, type VueWrapper } from '@vue/test-utils'
 import { createPinia, setActivePinia, type Pinia } from 'pinia'
 
+import { CLOCK } from '@/composables/useClock'
 import { ERROR_CODE_MESSAGES } from '@/shared/constants/error-codes.generated'
 import type { Mailbox } from '@/shared/types/mail'
 import { useAuthStore } from '@/stores/auth.store'
 import { useMailStore } from '@/stores/mail.store'
 import { useToastStore } from '@/stores/toast.store'
+import { createManualClock } from '@/test-utils/manual-clock'
 import { flushPromises, installMockApi, ok, restoreApiAdapter } from '@/test-utils/mock-api'
 import { createTestRouter } from '@/test-utils/router'
 import MailSearchBox from './MailSearchBox.vue'
@@ -51,8 +53,10 @@ describe('MailSearchBox (메일 검색)', () => {
     expect(input.attributes('aria-label')).toBe('메일 검색')
     expect(input.attributes('placeholder')).toBe('메일 검색')
     expect(wrapper.get('form').attributes('role')).toBe('search')
-    expect(wrapper.find('button').exists()).toBe(false)
+    expect(wrapper.find('[data-search-clear]').exists()).toBe(false)
     expect(wrapper.get('form').classes()).not.toContain('is-active')
+    // [조건]은 늘 있다 (14단계)
+    expect(wrapper.get('[data-search-conditions-toggle]').text()).toBe('조건')
   })
 
   it('치는 동안에는 찾지 않고, Enter 로 보던 메일함에서 찾는다 (기록을 쌓는다 — 뒤로 가기로 메일함)', async () => {
@@ -123,7 +127,7 @@ describe('MailSearchBox (메일 검색)', () => {
 
     expect((input.element as HTMLInputElement).value).toBe('회의')
     expect(wrapper.get('form').classes()).toContain('is-active')
-    const clear = wrapper.get('button')
+    const clear = wrapper.get('[data-search-clear]')
     expect(clear.attributes('aria-label')).toBe('검색어 지우기')
     expect(clear.attributes('title')).toBe('검색어 지우기 (Esc)')
 
@@ -165,3 +169,405 @@ describe('MailSearchBox (메일 검색)', () => {
     expect(push).not.toHaveBeenCalled()
   })
 })
+
+describe('MailSearchBox — [조건] · 「조건으로 찾기」 (14단계 디자인 원본 Search14)', () => {
+  let pinia: Pinia
+  /** 2026년 11월 6일 오전 9시(브라우저 시간대) — 최근 1달은 10월 6일부터 */
+  const clock = createManualClock(new Date(2026, 10, 6, 9).getTime())
+
+  beforeEach(() => {
+    pinia = createPinia()
+    setActivePinia(pinia)
+    useAuthStore().markAuthenticated({ email: 'ara.kim@arasystem.test', name: '김아라' })
+    useMailStore().mailboxes = MAILBOXES
+    installMockApi(() => ok({ items: [], pageInfo: { hasNext: false, nextCursor: null, total: 0 } }))
+  })
+
+  /** 문서에 붙여 그린 칸 — 테스트마다 떼어 낸다 (열린 패널의 문서 pointerdown 처리가 다음 테스트에 남지 않게) */
+  let mounted: VueWrapper[] = []
+
+  afterEach(() => {
+    for (const wrapper of mounted) wrapper.unmount()
+    mounted = []
+    vi.restoreAllMocks()
+    vi.useRealTimers()
+    useToastStore().clear()
+    restoreApiAdapter()
+    document.body.innerHTML = ''
+  })
+
+  async function mountAt(path: string) {
+    const router = createTestRouter()
+    await router.push(path)
+    await router.isReady()
+    const wrapper = mount(MailSearchBox, {
+      attachTo: document.body,
+      global: { plugins: [pinia, router], provide: { [CLOCK as symbol]: clock } },
+    })
+    mounted.push(wrapper)
+    return { wrapper, router, input: wrapper.get<HTMLInputElement>('input[type="search"]') }
+  }
+
+  async function openPanel(wrapper: VueWrapper) {
+    await wrapper.get('[data-search-conditions-toggle]').trigger('click')
+    await flushPromises()
+    return wrapper.get('[data-search-conditions]')
+  }
+
+  const field = (wrapper: VueWrapper, name: string) => wrapper.get(`[data-search-condition="${name}"]`)
+
+  it('[조건]은 칸 안(✕ 앞)에 있고 누르면 칸 아래에 패널이 열린다 — aria-expanded · 청록 바탕, 첫 칸(보낸 사람)으로 초점', async () => {
+    const { wrapper } = await mountAt('/mail/inbox')
+    const toggle = wrapper.get('[data-search-conditions-toggle]')
+    expect(toggle.attributes('aria-expanded')).toBe('false')
+    expect(toggle.classes()).not.toContain('is-on')
+
+    const panel = await openPanel(wrapper)
+
+    expect(toggle.attributes('aria-expanded')).toBe('true')
+    expect(toggle.attributes('aria-controls')).toBe(panel.attributes('id'))
+    expect(toggle.classes()).toContain('is-on')
+    expect(panel.attributes('role')).toBe('group')
+    expect(panel.get('h2').text()).toBe('조건으로 찾기')
+    expect(panel.findAll('label').map((label) => label.text())).toEqual([
+      '보낸 사람',
+      '받는 사람',
+      '제목',
+      '내용',
+      '기간',
+      '첨부 파일이 있는 메일만',
+    ])
+    expect(panel.findAll('option').map((option) => option.text())).toEqual([
+      '전체 기간',
+      '최근 1주',
+      '최근 1달',
+      '최근 3달',
+      '최근 1년',
+      '날짜 고르기',
+    ])
+    expect(panel.text()).toContain(
+      '검색 칸의 말과 이 조건에 모두 맞는 메일을 찾습니다. 받는 사람에는 참조로 받은 사람도 들어갑니다.',
+    )
+    // 칸 안내 — 내용 칸은 칸 이름과 같은 말로 (2026-11-06 실사용 시험)
+    expect(['from', 'to', 'subject', 'body'].map((name) => field(wrapper, name).attributes('placeholder'))).toEqual([
+      '이름이나 메일 주소',
+      '이름이나 메일 주소',
+      '제목에 든 말',
+      '내용에 든 말',
+    ])
+    expect(document.activeElement).toBe(field(wrapper, 'from').element)
+  })
+
+  it('검색 칸이 비어도 조건만으로 찾는다 — 최근 1달은 그 날짜로 바꿔 주소에 싣는다, 패널은 닫히고 검색 칸으로', async () => {
+    const { wrapper, router, input } = await mountAt('/mail/inbox')
+    await openPanel(wrapper)
+    await field(wrapper, 'from').setValue('  이도윤 ')
+    await field(wrapper, 'period').setValue('month')
+    await field(wrapper, 'attachment').setValue(true)
+
+    await wrapper.get('[data-search-conditions-apply]').trigger('click')
+    await flushPromises()
+
+    expect(router.currentRoute.value.fullPath).toBe(
+      `/mail/search?in=inbox&from=${encodeURIComponent('이도윤')}&since=2026-10-06&until=2026-11-06&attachment=1`,
+    )
+    expect(wrapper.find('[data-search-conditions]').exists()).toBe(false)
+    expect(document.activeElement).toBe(input.element)
+  })
+
+  it('패널이 열린 동안 검색 칸의 Enter 는 [찾기]와 같다 — 검색어와 조건을 함께', async () => {
+    const { wrapper, router, input } = await mountAt('/mail/inbox')
+    await openPanel(wrapper)
+    await field(wrapper, 'subject').setValue('견적')
+    await input.setValue('계약')
+
+    await input.trigger('keydown', { key: 'Enter' })
+    await flushPromises()
+
+    expect(router.currentRoute.value.fullPath).toBe(
+      `/mail/search?q=${encodeURIComponent('계약')}&in=inbox&subject=${encodeURIComponent('견적')}`,
+    )
+  })
+
+  it('검색어와 조건을 합친 낱말이 8개를 넘으면 찾지 않고 VAL_001 사전 문구 — 패널 · 친 글자는 그대로', async () => {
+    // 같은 코드의 알림은 3초 안에 다시 띄우지 않는다(useApi) — 앞 테스트의 알림과 떨어뜨린다
+    vi.useFakeTimers({ toFake: ['Date'] })
+    vi.setSystemTime(Date.now() + 60_000)
+    const { wrapper, router, input } = await mountAt('/mail/inbox')
+    await input.setValue('하나 둘 셋 넷 다섯')
+    await openPanel(wrapper)
+    await field(wrapper, 'body').setValue('여섯 일곱 여덟 아홉')
+
+    await wrapper.get('[data-search-conditions-apply]').trigger('click')
+    await flushPromises()
+
+    expect(router.currentRoute.value.fullPath).toBe('/mail/inbox')
+    expect(useToastStore().toasts.map((toast) => toast.message)).toEqual([ERROR_CODE_MESSAGES.VAL_001])
+    expect(wrapper.find('[data-search-conditions]').exists()).toBe(true)
+    expect((field(wrapper, 'body').element as HTMLInputElement).value).toBe('여섯 일곱 여덟 아홉')
+  })
+
+  it('날짜 고르기의 시작이 끝보다 늦으면 찾지 않고 칸 아래에 알린다 — 끝 날짜 칸으로 초점', async () => {
+    const { wrapper, router } = await mountAt('/mail/inbox')
+    await openPanel(wrapper)
+    await field(wrapper, 'period').setValue('custom')
+    await field(wrapper, 'since').setValue('2026-11-05')
+    await field(wrapper, 'until').setValue('2026-10-01')
+
+    await wrapper.get('[data-search-conditions-apply]').trigger('click')
+    await flushPromises()
+
+    expect(router.currentRoute.value.fullPath).toBe('/mail/inbox')
+    const error = wrapper.get('[role="alert"]')
+    expect(error.text()).toBe('끝 날짜를 시작 날짜와 같거나 그 뒤로 골라 주세요.')
+    expect(field(wrapper, 'until').attributes('aria-invalid')).toBe('true')
+    expect(field(wrapper, 'until').attributes('aria-describedby')).toBe(error.attributes('id'))
+    expect(document.activeElement).toBe(field(wrapper, 'until').element)
+
+    // 고쳐서 찾으면 그 날짜로
+    await field(wrapper, 'until').setValue('2026-11-05')
+    await wrapper.get('[data-search-conditions-apply]').trigger('click')
+    await flushPromises()
+    expect(router.currentRoute.value.query).toMatchObject({ since: '2026-11-05', until: '2026-11-05' })
+  })
+
+  it('날짜는 1970년 1월 1일 ~ 9999년 12월 30일만 고른다 — 그 밖의 날짜는 찾지 않고 칸 아래에 알린다 (그 칸으로 초점)', async () => {
+    const { wrapper, router } = await mountAt('/mail/inbox')
+    await openPanel(wrapper)
+    await field(wrapper, 'period').setValue('custom')
+    expect(field(wrapper, 'since').attributes()).toMatchObject({ min: '1970-01-01', max: '9999-12-30' })
+    expect(field(wrapper, 'until').attributes()).toMatchObject({ min: '1970-01-01', max: '9999-12-30' })
+
+    await field(wrapper, 'since').setValue('1969-12-31')
+    await field(wrapper, 'until').setValue('2026-11-05')
+    // 고른 끝 날짜가 시작 날짜 칸의 끝이 된다
+    expect(field(wrapper, 'since').attributes('max')).toBe('2026-11-05')
+    await wrapper.get('[data-search-conditions-apply]').trigger('click')
+    await flushPromises()
+
+    expect(router.currentRoute.value.fullPath).toBe('/mail/inbox')
+    const error = wrapper.get('[role="alert"]')
+    expect(error.text()).toBe('날짜는 1970년 1월 1일부터 9999년 12월 30일 사이에서 골라 주세요.')
+    expect(field(wrapper, 'since').attributes('aria-invalid')).toBe('true')
+    expect(field(wrapper, 'since').attributes('aria-describedby')).toBe(error.attributes('id'))
+    expect(field(wrapper, 'until').attributes('aria-invalid')).toBe('false')
+    expect(document.activeElement).toBe(field(wrapper, 'since').element)
+
+    // 날짜를 고치면 알림을 지우고, 고른 시작 날짜가 끝 날짜 칸의 처음이 된다
+    await field(wrapper, 'since').setValue('2026-11-01')
+    expect(wrapper.find('[role="alert"]').exists()).toBe(false)
+    expect(field(wrapper, 'until').attributes('min')).toBe('2026-11-01')
+    await wrapper.get('[data-search-conditions-apply]').trigger('click')
+    await flushPromises()
+    expect(router.currentRoute.value.query).toMatchObject({ since: '2026-11-01', until: '2026-11-05' })
+  })
+
+  it('미리 정한 기간에서 날짜 고르기로 바꾸면 그 기간의 날짜로 칸을 채워 둔다', async () => {
+    const { wrapper } = await mountAt('/mail/inbox')
+    await openPanel(wrapper)
+
+    await field(wrapper, 'period').setValue('week')
+    await field(wrapper, 'period').setValue('custom')
+
+    expect((field(wrapper, 'since').element as HTMLInputElement).value).toBe('2026-10-30')
+    expect((field(wrapper, 'until').element as HTMLInputElement).value).toBe('2026-11-06')
+  })
+
+  it('Esc 는 패널만 닫고 [조건]으로 초점을 돌린다 — 바깥을 누르면 닫는다', async () => {
+    const { wrapper, router } = await mountAt(`/mail/search?q=${Q}&in=inbox`)
+    await openPanel(wrapper)
+
+    await field(wrapper, 'to').trigger('keydown', { key: 'Escape' })
+    await flushPromises()
+
+    expect(wrapper.find('[data-search-conditions]').exists()).toBe(false)
+    expect(document.activeElement).toBe(wrapper.get('[data-search-conditions-toggle]').element)
+    // 검색은 그대로
+    expect(router.currentRoute.value.fullPath).toBe(`/mail/search?q=${Q}&in=inbox`)
+
+    await openPanel(wrapper)
+    document.body.dispatchEvent(new Event('pointerdown', { bubbles: true }))
+    await flushPromises()
+    expect(wrapper.find('[data-search-conditions]').exists()).toBe(false)
+  })
+
+  it('패널이 열린 채 검색 칸에서 Esc 를 누르면 패널만 닫고 초점은 검색 칸에 남는다 — 검색은 그대로', async () => {
+    const { wrapper, router, input } = await mountAt(`/mail/search?q=${Q}&in=inbox`)
+    await openPanel(wrapper)
+    input.element.focus()
+    await flushPromises()
+    expect(wrapper.find('[data-search-conditions]').exists()).toBe(true)
+
+    await input.trigger('keydown', { key: 'Escape' })
+    await flushPromises()
+
+    expect(wrapper.find('[data-search-conditions]').exists()).toBe(false)
+    expect(document.activeElement).toBe(input.element)
+    expect(router.currentRoute.value.fullPath).toBe(`/mail/search?q=${Q}&in=inbox`)
+  })
+
+  it('키보드로 검색 칸 밖으로 나가면(focusout) 패널을 닫는다 — 검색 칸 안으로 옮기는 초점은 그대로', async () => {
+    const { wrapper, input } = await mountAt('/mail/inbox')
+    const outside = document.createElement('button')
+    document.body.append(outside)
+    await openPanel(wrapper)
+    const from = field(wrapper, 'from').element
+
+    from.dispatchEvent(new FocusEvent('focusout', { bubbles: true, relatedTarget: input.element }))
+    await flushPromises()
+    expect(wrapper.find('[data-search-conditions]').exists()).toBe(true)
+
+    from.dispatchEvent(new FocusEvent('focusout', { bubbles: true, relatedTarget: outside }))
+    await flushPromises()
+    expect(wrapper.find('[data-search-conditions]').exists()).toBe(false)
+    // 나간 곳의 초점을 [조건]으로 끌어오지 않는다
+    expect(document.activeElement).not.toBe(wrapper.get('[data-search-conditions-toggle]').element)
+  })
+
+  it('다른 화면으로 가면(뒤로 가기 등) 열어 둔 패널을 닫는다', async () => {
+    const { wrapper, router } = await mountAt('/mail/inbox')
+    await openPanel(wrapper)
+
+    await router.push('/mail/trash')
+    await flushPromises()
+
+    expect(wrapper.find('[data-search-conditions]').exists()).toBe(false)
+    expect(wrapper.get('[data-search-conditions-toggle]').attributes('aria-expanded')).toBe('false')
+  })
+
+  it('조건이 걸린 검색 — [조건]이 청록이고, 열면 걸린 조건으로 칸을 채운다(오늘 기준 최근 1달)', async () => {
+    const { wrapper } = await mountAt(
+      `/mail/search?q=${Q}&in=inbox&from=${encodeURIComponent('이도윤')}&since=2026-10-06&until=2026-11-06&attachment=1`,
+    )
+    const toggle = wrapper.get('[data-search-conditions-toggle]')
+    expect(toggle.classes()).toContain('is-on')
+    expect(toggle.attributes('aria-expanded')).toBe('false')
+    expect(toggle.text()).toContain('조건이 걸려 있음')
+
+    await openPanel(wrapper)
+
+    expect((field(wrapper, 'from').element as HTMLInputElement).value).toBe('이도윤')
+    expect((field(wrapper, 'period').element as HTMLSelectElement).value).toBe('month')
+    expect((field(wrapper, 'attachment').element as HTMLInputElement).checked).toBe(true)
+  })
+
+  it('패널을 닫은 채 누른 Enter 는 걸린 조건을 그대로 두고 검색어만 바꾼다 (기록을 쌓지 않는다)', async () => {
+    const { router, input } = await mountAt(`/mail/search?q=${Q}&in=all&from=${encodeURIComponent('이도윤')}`)
+    const push = vi.spyOn(router, 'push')
+
+    await input.setValue('견적')
+    await input.trigger('keydown', { key: 'Enter' })
+    await flushPromises()
+
+    expect(router.currentRoute.value.fullPath).toBe(
+      `/mail/search?q=${encodeURIComponent('견적')}&in=all&from=${encodeURIComponent('이도윤')}`,
+    )
+    expect(push).not.toHaveBeenCalled()
+  })
+
+  describe('패널의 [조건 지우기] — 패널의 칸만 비운다 (2026-11-07 사용자 관점 점검)', () => {
+    const textValues = (wrapper: VueWrapper) =>
+      ['from', 'to', 'subject', 'body'].map((name) => (field(wrapper, name).element as HTMLInputElement).value)
+
+    it('칸 · 기간 · 날짜 · 첨부 체크를 비우고 패널은 열어 둔다 — 찾지 않고 초점은 그 단추에, 걸린 조건(주소 · [조건])은 그대로', async () => {
+      const path = `/mail/search?q=${Q}&in=inbox&from=${encodeURIComponent('이도윤')}&subject=${encodeURIComponent('견적')}&since=2026-10-01&until=2026-11-05&attachment=1`
+      const { wrapper, router, input } = await mountAt(path)
+      const push = vi.spyOn(router, 'push')
+      const replace = vi.spyOn(router, 'replace')
+      await openPanel(wrapper)
+      expect(textValues(wrapper)).toEqual(['이도윤', '', '견적', ''])
+      expect((field(wrapper, 'period').element as HTMLSelectElement).value).toBe('custom')
+
+      const clear = wrapper.get<HTMLButtonElement>('[data-search-conditions-clear]')
+      clear.element.focus()
+      await clear.trigger('click')
+      await flushPromises()
+
+      expect(textValues(wrapper)).toEqual(['', '', '', ''])
+      expect((field(wrapper, 'period').element as HTMLSelectElement).value).toBe('all')
+      expect(wrapper.find('[data-search-condition="since"]').exists()).toBe(false)
+      expect((field(wrapper, 'attachment').element as HTMLInputElement).checked).toBe(false)
+      expect(wrapper.find('[data-search-conditions]').exists()).toBe(true)
+      expect(document.activeElement).toBe(clear.element)
+      // 찾지 않는다 — 주소 · 검색 칸 · [조건]의 "조건이 걸려 있음"은 그대로
+      expect(router.currentRoute.value.fullPath).toBe(path)
+      expect(push).not.toHaveBeenCalled()
+      expect(replace).not.toHaveBeenCalled()
+      expect(input.element.value).toBe('회의')
+      expect(wrapper.get('[data-search-conditions-toggle]').text()).toContain('조건이 걸려 있음')
+      // 다시 눌러도 그대로다 (비운 칸)
+      await clear.trigger('click')
+      await flushPromises()
+      expect(textValues(wrapper)).toEqual(['', '', '', ''])
+      expect(document.activeElement).toBe(clear.element)
+    })
+
+    it('칸 아래 알림(날짜가 거꾸로)도 지운다', async () => {
+      const { wrapper } = await mountAt('/mail/inbox')
+      await openPanel(wrapper)
+      await field(wrapper, 'period').setValue('custom')
+      await field(wrapper, 'since').setValue('2026-11-05')
+      await field(wrapper, 'until').setValue('2026-10-01')
+      await wrapper.get('[data-search-conditions-apply]').trigger('click')
+      await flushPromises()
+      expect(wrapper.find('[role="alert"]').exists()).toBe(true)
+
+      await wrapper.get('[data-search-conditions-clear]').trigger('click')
+      await flushPromises()
+
+      expect(wrapper.find('[role="alert"]').exists()).toBe(false)
+      expect((field(wrapper, 'period').element as HTMLSelectElement).value).toBe('all')
+      expect(wrapper.find('[data-search-conditions]').exists()).toBe(true)
+    })
+
+    it('[찾기] 없이 닫으면 아무것도 바뀌지 않는다 — 다시 열면 걸린 조건으로 다시 채운다', async () => {
+      const path = `/mail/search?q=${Q}&in=inbox&from=${encodeURIComponent('이도윤')}&attachment=1`
+      const { wrapper, router } = await mountAt(path)
+      await openPanel(wrapper)
+      await wrapper.get('[data-search-conditions-clear]').trigger('click')
+      await flushPromises()
+
+      await field(wrapper, 'to').trigger('keydown', { key: 'Escape' })
+      await flushPromises()
+      expect(wrapper.find('[data-search-conditions]').exists()).toBe(false)
+      expect(router.currentRoute.value.fullPath).toBe(path)
+
+      await openPanel(wrapper)
+      expect(textValues(wrapper)).toEqual(['이도윤', '', '', ''])
+      expect((field(wrapper, 'attachment').element as HTMLInputElement).checked).toBe(true)
+    })
+
+    it('비운 뒤 [찾기] — 검색어가 있으면 조건만 빼고 다시 찾고, 조건만 걸린 검색이면 검색을 닫는다(조건 줄의 [조건 지우기]와 같다)', async () => {
+      useMailStore().rememberSearchOrigin({ mailboxId: 'inbox', location: '/mail/inbox' })
+      const { wrapper, router } = await mountAt(`/mail/search?q=${Q}&in=inbox&subject=${encodeURIComponent('견적')}`)
+      await openPanel(wrapper)
+      await wrapper.get('[data-search-conditions-clear]').trigger('click')
+      await wrapper.get('[data-search-conditions-apply]').trigger('click')
+      await flushPromises()
+
+      expect(router.currentRoute.value.fullPath).toBe(`/mail/search?q=${Q}&in=inbox`)
+      expect(wrapper.find('[data-search-conditions]').exists()).toBe(false)
+
+      await router.replace('/mail/search?in=inbox&attachment=1')
+      await flushPromises()
+      await openPanel(wrapper)
+      await wrapper.get('[data-search-conditions-clear]').trigger('click')
+      await wrapper.get('[data-search-conditions-apply]').trigger('click')
+      await flushPromises()
+      expect(router.currentRoute.value.fullPath).toBe('/mail/inbox')
+      expect(wrapper.find('[data-search-conditions]').exists()).toBe(false)
+    })
+
+    it('검색어도 조건도 없는 [찾기]는 조건이 걸리지 않았으면 아무것도 하지 않는다 — 패널은 그대로', async () => {
+      const { wrapper, router, input } = await mountAt(`/mail/search?q=${Q}&in=inbox`)
+      await input.setValue('')
+      await openPanel(wrapper)
+
+      await wrapper.get('[data-search-conditions-apply]').trigger('click')
+      await flushPromises()
+
+      expect(router.currentRoute.value.fullPath).toBe(`/mail/search?q=${Q}&in=inbox`)
+      expect(wrapper.find('[data-search-conditions]').exists()).toBe(true)
+    })
+  })
+})
diff --git a/frontend/src/components/mail/MailSearchBox.vue b/frontend/src/components/mail/MailSearchBox.vue
index 9e19d69..68e0977 100644
--- a/frontend/src/components/mail/MailSearchBox.vue
+++ b/frontend/src/components/mail/MailSearchBox.vue
@@ -1,28 +1,65 @@
 <script setup lang="ts">
-// 상단 검색 칸 — 메일 화면에서는 "메일 검색" (디자인 원본 Search · BulkSelect 머리 · README "3단계 › 검색")
+// 상단 검색 칸 — 메일 화면에서는 "메일 검색" (디자인 원본 Search · Search14 · BulkSelect 머리 · README "3단계 › 검색" · "14단계 › 검색 · 조건 검색 · 강조")
 // - Enter 로 찾는다. 치는 동안에는 찾지 않는다 — 한글 조합 중의 Enter 는 글자 확정이다(isImeComposing, Safari · macOS 의 keyCode 229 포함)
 // - 검색 중(검색 화면)에는 테두리가 강조색(1px 테두리 + 1px 그림자)이고 끝에 ✕(40×38 · "검색어 지우기" — 밀도 예외).
 //   ✕ · Esc 는 검색을 닫고 검색 전 메일함으로 돌아간다. 검색 화면이 아니면 Esc 는 친 글자만 지운다
 // - 검색 화면에서는 칸에 지금 검색어를 보인다 (뒤로 가기로 결과에 돌아와도)
-import { ref, watch } from 'vue'
+// - 칸 안 오른쪽(✕ 앞)의 [조건](MailSearchConditionsToggle)이 칸 바로 아래에 「조건으로 찾기」 패널을 연다 (14단계 — 열고 닫기는 useSearchConditionsPopup).
+//   패널이 열린 동안 검색 칸의 Enter 는 [찾기]와 같고, 검색 칸의 Esc 는 패널만 닫는다(초점은 검색 칸에 남는다).
+//   검색 칸이 비어도 조건만으로 찾는다. 패널이 닫힌 채 누른 Enter 는 걸려 있는 조건을 그대로 둔다.
+//   패널의 [조건 지우기]는 패널의 칸만 비운다(MailSearchConditions) — 걸린 조건은 [찾기]를 누르거나 결과의 조건 줄 [조건 지우기]로 뺀다
+import { computed, nextTick, ref, watch } from 'vue'
 
 import AppIcon from '@/components/AppIcon.vue'
+import MailSearchConditions from '@/components/mail/MailSearchConditions.vue'
+import MailSearchConditionsToggle from '@/components/mail/MailSearchConditionsToggle.vue'
 import { useMailSearchNavigation } from '@/composables/useMailSearchNavigation'
+import { useSearchConditionsPopup } from '@/composables/useSearchConditionsPopup'
 import { MAIL_SEARCH_MAX_LENGTH, MAIL_SEARCH_TEXT } from '@/shared/constants/mail'
 import { isImeComposing } from '@/shared/utils/keyboard-shortcut'
+import { hasSearchConditions, type SearchConditions } from '@/shared/utils/mail-search'
+
+const PANEL_ID = 'mail-search-conditions'
 
 const { isSearching, routeSearch, startSearch, closeSearch } = useMailSearchNavigation()
 
 const text = ref<string>('')
+const inputRef = ref<HTMLInputElement | null>(null)
+const formRef = ref<HTMLFormElement | null>(null)
+const toggleRef = ref<InstanceType<typeof MailSearchConditionsToggle> | null>(null)
+const panelRef = ref<InstanceType<typeof MailSearchConditions> | null>(null)
+
+const {
+  isOpen: conditionsOpen,
+  close: closeConditions,
+  toggle: toggleConditions,
+  onFocusOut,
+} = useSearchConditionsPopup({
+  container: formRef,
+  toggle: toggleRef,
+  onOpened: () => panelRef.value?.focusFirst(),
+})
+
+/** 지금 걸린 조건 — 검색 화면의 주소에서 */
+const appliedConditions = computed<SearchConditions | null>(() => routeSearch.value?.conditions ?? null)
+const conditionsApplied = computed(() => hasSearchConditions(appliedConditions.value))
 
 function onKeydown(event: KeyboardEvent) {
   if (isImeComposing(event)) return
   if (event.key === 'Enter') {
     event.preventDefault()
-    void startSearch(text.value)
+    // 패널이 열린 동안은 [찾기]와 같다 — 패널의 조건과 함께
+    if (conditionsOpen.value) void panelRef.value?.apply()
+    else void startSearch(text.value)
     return
   }
   if (event.key !== 'Escape') return
+  if (conditionsOpen.value) {
+    // 패널만 닫는다 — 치던 검색 칸에 초점을 둔다
+    event.preventDefault()
+    closeConditions({ restoreFocus: false })
+    return
+  }
   if (isSearching.value) {
     event.preventDefault()
     void closeSearch()
@@ -32,12 +69,23 @@ function onKeydown(event: KeyboardEvent) {
   }
 }
 
+/**
+ * [찾기] — 검색 칸의 말과 패널의 조건으로. 찾았으면(조건을 다 비워 검색을 닫았어도) 패널을 닫고 검색 칸으로
+ * (낱말이 너무 많으면 알림만 — 패널은 그대로)
+ */
+async function onApply(conditions: SearchConditions) {
+  if (!(await startSearch(text.value, conditions))) return
+  closeConditions({ restoreFocus: false })
+  await nextTick()
+  inputRef.value?.focus()
+}
+
 // 검색 화면에서는 주소의 검색어를 보이고, 검색을 닫으면(검색 화면을 떠나면) 비운다
 watch(
-  () => routeSearch.value?.q ?? null,
+  () => (routeSearch.value ? routeSearch.value.q : null),
   (query, previous) => {
     if (query !== null) text.value = query
-    else if (previous) text.value = ''
+    else if (previous !== null && previous !== undefined) text.value = ''
   },
   { immediate: true },
 )
@@ -45,15 +93,18 @@ watch(
 
 <template>
   <form
+    ref="formRef"
     role="search"
     :class="['mail-search', { 'is-active': isSearching }]"
     @submit.prevent
+    @focusout="onFocusOut"
   >
     <AppIcon
       name="search"
       class="mail-search__icon"
     />
     <input
+      ref="inputRef"
       v-model="text"
       type="search"
       class="mail-search__input"
@@ -64,12 +115,20 @@ watch(
       enterkeyhint="search"
       @keydown="onKeydown"
     >
+    <MailSearchConditionsToggle
+      ref="toggleRef"
+      :expanded="conditionsOpen"
+      :applied="conditionsApplied"
+      :panel-id="PANEL_ID"
+      @toggle="toggleConditions"
+    />
     <button
       v-if="isSearching"
       type="button"
       class="mail-search__clear"
       :aria-label="MAIL_SEARCH_TEXT.clear"
       :title="MAIL_SEARCH_TEXT.clearTitle"
+      data-search-clear
       @click="closeSearch"
     >
       <AppIcon
@@ -78,11 +137,20 @@ watch(
         :stroke-width="1.9"
       />
     </button>
+    <MailSearchConditions
+      v-if="conditionsOpen"
+      ref="panelRef"
+      :panel-id="PANEL_ID"
+      :applied="appliedConditions"
+      @apply="onApply"
+      @close="closeConditions()"
+    />
   </form>
 </template>
 
 <style scoped>
 .mail-search {
+  position: relative;
   flex: 1 1 17.5rem;
   max-width: 32.5rem;
   display: flex;
@@ -90,7 +158,7 @@ watch(
   gap: var(--space-8);
   height: var(--size-search-box);
   margin: 0;
-  padding: 0 var(--space-12);
+  padding: 0 var(--space-4) 0 var(--space-12);
   border: var(--border-width) solid var(--color-border-input);
   border-radius: var(--radius-md);
   background: var(--color-surface);
diff --git a/frontend/src/components/mail/MailSearchConditionFields.vue b/frontend/src/components/mail/MailSearchConditionFields.vue
new file mode 100644
index 0000000..24f0137
--- /dev/null
+++ b/frontend/src/components/mail/MailSearchConditionFields.vue
@@ -0,0 +1,169 @@
+<script setup lang="ts">
+// 「조건으로 찾기」 패널의 칸 묶음 (14단계 — 디자인 원본 Search14): 보낸 사람 · 받는 사람(참조도) · 제목 · 내용 · 기간(MailSearchPeriodField) · 첨부.
+// 이름 76 · 칸, 칸 높이 40 — 필터 조건 칸의 밀도 예외(--size-filter-control)를 다시 쓴다.
+// 칸 값은 useSearchConditionsDraft — 처음 그릴 때 걸린 조건(applied)으로 채우고, 부르는 쪽이 take() 로 넘길 조건을 받는다
+// (기간이 잘못됐으면 null — 칸 아래에 알리고 그 날짜 칸으로 초점), clear() 로 칸을 모두 비운다([조건 지우기]).
+// 글 칸의 Enter 는 submit 으로 알린다 (조합 중 Enter 는 글자 확정 — isImeComposing)
+import { nextTick, onMounted, ref } from 'vue'
+
+import MailSearchPeriodField from '@/components/mail/MailSearchPeriodField.vue'
+import { useClock } from '@/composables/useClock'
+import { useSearchConditionsDraft } from '@/composables/useSearchConditionsDraft'
+import { MAIL_SEARCH_MAX_LENGTH } from '@/shared/constants/mail'
+import { SEARCH_CONDITIONS_TEXT } from '@/shared/constants/mail-search'
+import { isImeComposing } from '@/shared/utils/keyboard-shortcut'
+import type { SearchConditions, SearchConditionTextField } from '@/shared/utils/mail-search'
+
+interface Props {
+  /** 칸 id 의 앞 — 패널의 id */
+  idPrefix: string
+  /** 지금 걸린 조건 — 처음 그릴 때 칸을 채운다 (없으면 빈 칸) */
+  applied: SearchConditions | null
+}
+
+interface Emits {
+  (e: 'submit'): void
+}
+
+const props = defineProps<Props>()
+const emit = defineEmits<Emits>()
+
+const { draft, periodProblem, fill, clear, changePeriod, changeDay, take } = useSearchConditionsDraft(useClock())
+
+const TEXT_FIELDS: readonly { field: SearchConditionTextField; label: string; placeholder: string }[] = [
+  { field: 'from', label: SEARCH_CONDITIONS_TEXT.from, placeholder: SEARCH_CONDITIONS_TEXT.fromPlaceholder },
+  { field: 'to', label: SEARCH_CONDITIONS_TEXT.to, placeholder: SEARCH_CONDITIONS_TEXT.toPlaceholder },
+  { field: 'subject', label: SEARCH_CONDITIONS_TEXT.subject, placeholder: SEARCH_CONDITIONS_TEXT.subjectPlaceholder },
+  { field: 'body', label: SEARCH_CONDITIONS_TEXT.body, placeholder: SEARCH_CONDITIONS_TEXT.bodyPlaceholder },
+]
+
+const fieldId = (name: string) => `${props.idPrefix}-${name}`
+
+const rootRef = ref<HTMLElement | null>(null)
+const periodRef = ref<InstanceType<typeof MailSearchPeriodField> | null>(null)
+
+function onTextKeydown(event: KeyboardEvent) {
+  if (event.key !== 'Enter' || isImeComposing(event)) return
+  event.preventDefault()
+  emit('submit')
+}
+
+/** 넘길 조건 — 기간이 잘못됐으면 null 이고, 칸 아래에 알린 뒤 그 날짜 칸으로 */
+async function takeConditions(): Promise<SearchConditions | null> {
+  const conditions = take()
+  if (conditions) return conditions
+  await nextTick()
+  periodRef.value?.focusInvalid()
+  return null
+}
+
+defineExpose({
+  take: takeConditions,
+  /** 칸을 모두 비운다 — 기간 · 날짜 · 첨부 체크 · 칸 아래 알림도 (찾지 않는다) */
+  clear,
+  /** 첫 칸(보낸 사람)으로 */
+  focusFirst: () => rootRef.value?.querySelector<HTMLInputElement>('input')?.focus(),
+})
+
+onMounted(() => fill(props.applied))
+</script>
+
+<template>
+  <div
+    ref="rootRef"
+    class="condition-fields"
+  >
+    <template
+      v-for="item in TEXT_FIELDS"
+      :key="item.field"
+    >
+      <label
+        :for="fieldId(item.field)"
+        class="condition-fields__label"
+      >{{ item.label }}</label>
+      <input
+        :id="fieldId(item.field)"
+        v-model="draft[item.field]"
+        class="form-input condition-fields__control"
+        type="text"
+        :maxlength="MAIL_SEARCH_MAX_LENGTH"
+        :placeholder="item.placeholder"
+        autocomplete="off"
+        :data-search-condition="item.field"
+        @keydown="onTextKeydown"
+      >
+    </template>
+
+    <label
+      :for="fieldId('period')"
+      class="condition-fields__label condition-fields__label--top"
+    >{{ SEARCH_CONDITIONS_TEXT.period }}</label>
+    <MailSearchPeriodField
+      ref="periodRef"
+      :select-id="fieldId('period')"
+      :period="draft.period"
+      :since="draft.since"
+      :until="draft.until"
+      :problem="periodProblem"
+      @period="changePeriod"
+      @day="changeDay"
+    />
+
+    <span class="condition-fields__label">{{ SEARCH_CONDITIONS_TEXT.attachment }}</span>
+    <label class="condition-fields__check">
+      <input
+        v-model="draft.hasAttachment"
+        type="checkbox"
+        data-search-condition="attachment"
+      >
+      <span>{{ SEARCH_CONDITIONS_TEXT.attachmentOnly }}</span>
+    </label>
+  </div>
+</template>
+
+<style scoped>
+/* 이름 76 · 칸 (디자인 원본 Search14) */
+.condition-fields {
+  display: grid;
+  grid-template-columns: 4.75rem minmax(0, 1fr);
+  align-items: center;
+  gap: var(--space-10) var(--space-12);
+}
+
+.condition-fields__label {
+  font-size: var(--font-size-label);
+  font-weight: 600;
+  color: var(--color-text-secondary);
+}
+
+/* 기간 — 칸 아래에 날짜 · 안내가 더해져도 이름은 첫 줄(기간 고르기)에 맞춘다 */
+.condition-fields__label--top {
+  align-self: start;
+  display: flex;
+  align-items: center;
+  min-height: var(--size-filter-control);
+}
+
+/* 칸 높이 40 — 밀도 예외 (필터 조건 칸과 같다) */
+.condition-fields__control {
+  min-width: 0;
+  min-height: var(--size-filter-control);
+  height: var(--size-filter-control);
+  padding: 0 var(--space-10);
+}
+
+.condition-fields__check {
+  display: inline-flex;
+  align-items: center;
+  gap: var(--space-8);
+  min-height: var(--size-filter-control);
+  cursor: pointer;
+}
+
+.condition-fields__check input {
+  width: var(--size-option-input);
+  height: var(--size-option-input);
+  margin: 0;
+  accent-color: var(--color-brand);
+}
+</style>
diff --git a/frontend/src/components/mail/MailSearchConditionLine.vue b/frontend/src/components/mail/MailSearchConditionLine.vue
new file mode 100644
index 0000000..1562e9e
--- /dev/null
+++ b/frontend/src/components/mail/MailSearchConditionLine.vue
@@ -0,0 +1,79 @@
+<script setup lang="ts">
+// 조건이 걸린 검색 결과의 조건 줄 (디자인 원본 Search14 "조건으로 찾음") — 찾을 곳 줄 아래 한 줄(최소 40)
+// "조건: 이도윤 님이 보낸 메일, 최근 1달, 첨부 있음" + [조건 지우기](36 — 안내 줄 단추의 밀도 예외 --size-notice-action).
+// 조건은 쉼표로 잇는다 — 꼬리표 · 알약을 쓰지 않는다. 기간은 오늘 기준의 미리 정한 기간과 같으면 그 이름, 아니면 날짜(하루면 "… 하루"),
+// 보낸 사람 · 받는 사람이 내 이름이나 주소면 "내가 보낸 메일" · "내가 받은 메일" (mail-search.ts)
+// [조건 지우기]는 조건만 빼고 다시 찾는다 — 검색어도 없으면 검색을 닫는다
+import { computed } from 'vue'
+
+import { useClock } from '@/composables/useClock'
+import { useMailSearchNavigation } from '@/composables/useMailSearchNavigation'
+import { SEARCH_CONDITION_LINE_TEXT } from '@/shared/constants/mail-search'
+import { searchConditionsSummary, type SearchConditions } from '@/shared/utils/mail-search'
+import { useAuthStore } from '@/stores/auth.store'
+
+interface Props {
+  conditions: SearchConditions
+}
+
+const props = defineProps<Props>()
+
+const clock = useClock()
+const authStore = useAuthStore()
+const { clearConditions } = useMailSearchNavigation()
+
+const summary = computed(() => searchConditionsSummary(props.conditions, new Date(clock.now()), authStore.user))
+</script>
+
+<template>
+  <div
+    class="search-condition-line"
+    data-search-condition-line
+  >
+    <span class="search-condition-line__text">{{ summary }}</span>
+    <button
+      type="button"
+      class="search-condition-line__clear"
+      data-search-condition-line-clear
+      @click="clearConditions"
+    >
+      {{ SEARCH_CONDITION_LINE_TEXT.clear }}
+    </button>
+  </div>
+</template>
+
+<style scoped>
+.search-condition-line {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: var(--space-2) var(--space-8);
+  min-height: var(--size-row-min);
+  padding: var(--space-2) var(--space-8) var(--space-2) var(--space-16);
+  border-bottom: var(--border-width) solid var(--color-border-subtle);
+}
+
+.search-condition-line__text {
+  min-width: 0;
+  font-size: var(--font-size-label);
+  color: var(--color-text-strong);
+  overflow-wrap: anywhere;
+}
+
+/* 36 — 안내 줄 단추의 밀도 예외 (tokens.css) */
+.search-condition-line__clear {
+  flex: 0 0 auto;
+  min-height: var(--size-notice-action);
+  padding: 0 var(--space-8);
+  border: 0;
+  border-radius: var(--radius-sm);
+  background: transparent;
+  color: var(--color-brand);
+  font-size: var(--font-size-label);
+  font-weight: 600;
+}
+
+.search-condition-line__clear:hover {
+  background: var(--color-brand-subtle);
+}
+</style>
diff --git a/frontend/src/components/mail/MailSearchConditions.vue b/frontend/src/components/mail/MailSearchConditions.vue
new file mode 100644
index 0000000..3cc7ef1
--- /dev/null
+++ b/frontend/src/components/mail/MailSearchConditions.vue
@@ -0,0 +1,168 @@
+<script setup lang="ts">
+// 「조건으로 찾기」 패널 (디자인 원본 Search14 "조건 열림" · README 「14단계 › 검색 · 조건 검색 · 강조」) — 검색 칸 바로 아래, 검색 칸 폭.
+// 칸 묶음(칸 값 · 기간 검사)은 MailSearchConditionFields. 단추 높이 40 — 칸과 같은 밀도 예외(--size-filter-control)
+// - 열 때 지금 걸린 조건(applied)으로 칸을 채운다
+// - [찾기] · 글 칸의 Enter: 조건을 apply 로 넘긴다. 날짜 고르기가 잘못됐으면(거꾸로 · 고를 수 없는 날짜) 넘기지 않는다 — 칸 아래에 알리고 그 칸으로
+// - [조건 지우기]: 패널의 칸만 비운다 — 기간 · 날짜 · 첨부 체크 · 칸 아래 알림까지. 패널은 열린 채이고 찾지 않으며 초점은 그 단추에 남는다.
+//   걸린 조건 · 조건 줄 · 결과는 [찾기]를 누를 때까지 그대로이고, [찾기] 없이 닫았다 다시 열면 걸린 조건으로 다시 채운다.
+//   걸린 조건을 빼는 일은 결과의 조건 줄 [조건 지우기](MailSearchConditionLine)가 한다 (2026-11-07 사용자 관점 점검)
+// - Esc: close (부르는 쪽이 [조건]으로 초점을 돌린다 — 조합 중 Esc 는 글자 확정)
+import { computed, ref } from 'vue'
+
+import MailSearchConditionFields from '@/components/mail/MailSearchConditionFields.vue'
+import { SEARCH_CONDITIONS_TEXT } from '@/shared/constants/mail-search'
+import { isImeComposing } from '@/shared/utils/keyboard-shortcut'
+import type { SearchConditions } from '@/shared/utils/mail-search'
+
+interface Props {
+  /** 패널의 id — [조건] 단추가 aria-controls 로 가리킨다 */
+  panelId: string
+  /** 지금 걸린 조건 — 열 때 칸을 채운다 (없으면 빈 칸) */
+  applied: SearchConditions | null
+}
+
+interface Emits {
+  (e: 'apply', conditions: SearchConditions): void
+  (e: 'close'): void
+}
+
+const props = defineProps<Props>()
+const emit = defineEmits<Emits>()
+
+const titleId = computed(() => `${props.panelId}-title`)
+const fieldsRef = ref<InstanceType<typeof MailSearchConditionFields> | null>(null)
+
+/** [찾기] — 기간이 잘못됐으면 넘기지 않는다 (칸이 알린다) */
+async function apply() {
+  const conditions = await fieldsRef.value?.take()
+  if (conditions) emit('apply', conditions)
+}
+
+/** [조건 지우기] — 칸만 비운다 (머리말 — 찾지 않고, 패널과 초점은 그대로) */
+function clearFields() {
+  fieldsRef.value?.clear()
+}
+
+function onKeydown(event: KeyboardEvent) {
+  if (event.key !== 'Escape' || isImeComposing(event)) return
+  event.preventDefault()
+  event.stopPropagation()
+  emit('close')
+}
+
+defineExpose({
+  apply,
+  /** 연 뒤 첫 칸(보낸 사람)으로 */
+  focusFirst: () => fieldsRef.value?.focusFirst(),
+})
+</script>
+
+<template>
+  <div
+    :id="panelId"
+    class="search-conditions"
+    role="group"
+    :aria-labelledby="titleId"
+    data-search-conditions
+    @keydown="onKeydown"
+  >
+    <h2
+      :id="titleId"
+      class="search-conditions__title"
+    >
+      {{ SEARCH_CONDITIONS_TEXT.title }}
+    </h2>
+    <MailSearchConditionFields
+      ref="fieldsRef"
+      :id-prefix="panelId"
+      :applied="applied"
+      @submit="apply"
+    />
+    <p class="search-conditions__hint">
+      {{ SEARCH_CONDITIONS_TEXT.hint }}
+    </p>
+    <div class="search-conditions__actions">
+      <button
+        type="button"
+        class="search-conditions__button"
+        data-search-conditions-clear
+        @click="clearFields"
+      >
+        {{ SEARCH_CONDITIONS_TEXT.clear }}
+      </button>
+      <button
+        type="button"
+        class="search-conditions__button search-conditions__button--primary"
+        data-search-conditions-apply
+        @click="apply"
+      >
+        {{ SEARCH_CONDITIONS_TEXT.apply }}
+      </button>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+/* 검색 칸 바로 아래 · 검색 칸 폭 — 위 16 · 좌우 18 · 아래 14, 칸 사이 14 (디자인 원본 Search14) */
+.search-conditions {
+  position: absolute;
+  top: calc(100% + var(--space-6));
+  left: calc(var(--border-width) * -2);
+  right: calc(var(--border-width) * -2);
+  z-index: 20;
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-14);
+  padding: var(--space-16) var(--space-18) var(--space-14);
+  border: var(--border-width) solid var(--color-border-strong);
+  border-radius: var(--radius-lg);
+  background: var(--color-surface);
+  box-shadow: var(--shadow-dialog);
+  color: var(--color-text);
+}
+
+.search-conditions__title {
+  margin: 0;
+  font-size: var(--font-size-emphasis);
+  font-weight: 700;
+}
+
+.search-conditions__hint {
+  margin: 0;
+  font-size: var(--font-size-small);
+  color: var(--color-text-muted);
+}
+
+.search-conditions__actions {
+  display: flex;
+  justify-content: flex-end;
+  gap: var(--space-8);
+}
+
+/* 단추 높이 40 — 칸과 같은 밀도 예외 */
+.search-conditions__button {
+  min-height: var(--size-filter-control);
+  padding: 0 var(--space-14);
+  border: var(--border-width) solid var(--color-border-strong);
+  border-radius: var(--radius-md);
+  background: var(--color-surface);
+  color: var(--color-text-strong);
+  font-weight: 600;
+}
+
+.search-conditions__button:hover {
+  background: var(--color-surface-muted);
+}
+
+.search-conditions__button--primary {
+  padding: 0 var(--space-18);
+  border-color: var(--color-brand);
+  background: var(--color-brand);
+  color: var(--color-on-brand);
+}
+
+.search-conditions__button--primary:hover {
+  border-color: var(--color-brand-strong);
+  background: var(--color-brand-strong);
+}
+</style>
diff --git a/frontend/src/components/mail/MailSearchConditionsToggle.vue b/frontend/src/components/mail/MailSearchConditionsToggle.vue
new file mode 100644
index 0000000..8e8dba1
--- /dev/null
+++ b/frontend/src/components/mail/MailSearchConditionsToggle.vue
@@ -0,0 +1,83 @@
+<script setup lang="ts">
+// 검색 칸 안 오른쪽(✕ 앞)의 [조건] (14단계 — 디자인 원본 Search14): 높이 32 · 밀도 예외(--size-compact-control — 새 토큰 없이 다시 쓴다).
+// 「조건으로 찾기」 패널을 열고 닫는다(aria-expanded · 열린 동안만 aria-controls). 패널이 열렸거나 조건이 걸려 있으면 청록 바탕이고,
+// 걸려 있으면 화면 낭독기에 ", 조건이 걸려 있음"을 더한다
+import { ref } from 'vue'
+
+import AppIcon from '@/components/AppIcon.vue'
+import { SEARCH_CONDITIONS_TEXT } from '@/shared/constants/mail-search'
+
+interface Props {
+  /** 패널이 열렸다 */
+  expanded: boolean
+  /** 조건이 걸려 있다 */
+  applied: boolean
+  /** 패널의 id */
+  panelId: string
+}
+
+interface Emits {
+  (e: 'toggle'): void
+}
+
+defineProps<Props>()
+const emit = defineEmits<Emits>()
+
+const buttonRef = ref<HTMLButtonElement | null>(null)
+
+defineExpose({
+  focus: () => buttonRef.value?.focus(),
+})
+</script>
+
+<template>
+  <button
+    ref="buttonRef"
+    type="button"
+    :class="['conditions-toggle', { 'is-on': expanded || applied }]"
+    :title="SEARCH_CONDITIONS_TEXT.toggleTitle"
+    :aria-expanded="expanded"
+    :aria-controls="expanded ? panelId : undefined"
+    data-search-conditions-toggle
+    @click="emit('toggle')"
+  >
+    <AppIcon
+      name="sliders"
+      :size="14"
+      :stroke-width="1.9"
+    />
+    <span>{{ SEARCH_CONDITIONS_TEXT.toggle }}</span>
+    <span
+      v-if="applied"
+      class="visually-hidden"
+    >, {{ SEARCH_CONDITIONS_TEXT.toggleApplied }}</span>
+  </button>
+</template>
+
+<style scoped>
+/* 높이 32 · 밀도 예외(--size-compact-control), 패널이 열렸거나 조건이 걸리면 청록 바탕 (디자인 원본 Search14) */
+.conditions-toggle {
+  flex: 0 0 auto;
+  display: inline-flex;
+  align-items: center;
+  gap: var(--space-4);
+  height: var(--size-compact-control);
+  padding: 0 var(--space-9);
+  border: 0;
+  border-radius: var(--radius-sm);
+  background: transparent;
+  color: var(--color-text-secondary);
+  font-size: var(--font-size-label);
+  font-weight: 600;
+}
+
+.conditions-toggle:hover {
+  background: var(--color-surface-muted);
+  color: var(--color-text);
+}
+
+.conditions-toggle.is-on {
+  background: var(--color-brand-subtle);
+  color: var(--color-brand-strong);
+}
+</style>
diff --git a/frontend/src/components/mail/MailSearchEmpty.vue b/frontend/src/components/mail/MailSearchEmpty.vue
index 9049fb4..e59248b 100644
--- a/frontend/src/components/mail/MailSearchEmpty.vue
+++ b/frontend/src/components/mail/MailSearchEmpty.vue
@@ -1,30 +1,65 @@
 <script setup lang="ts">
-// 검색 결과 없음 (디자인 원본 Search "결과 없음") — 검색 아이콘 · "‘…’에 맞는 메일이 없습니다" · 찾는 방법의 한계 한 줄
+// 검색 결과 없음 (디자인 원본 Search · Search14 "결과 없음") — 더 찾을 것이 없을 때(hasNext false)만 보인다(이어 찾을 것이 남았으면 MailSearchMore)
+// 검색 아이콘 · "‘계약’에 맞는 메일이 없습니다"(조건만으로 찾았으면 "조건에 맞는 메일이 없습니다") · 도움말 —
+// 검색어와 조건이 함께면 "다른 말로 찾거나 조건을 줄여 보세요.", 조건만이면 "조건을 바꾸거나 줄여 보세요.", 걸린 조건이 없으면 "다른 말로 찾아 보세요."
+// 지난 메일을 검색할 수 있게 준비하는 동안(엔진 방식 — 낱말 단위)은 그 한계를 한 줄 더한다 — 준비가 끝나면 뺀다 (14단계)
 // 한 메일함에서 찾았으면 [전체 메일함에서 찾기]
+// 검색어와 조건의 낱말이 한도를 넘는 주소(손으로 고친 주소 — 14단계)면 찾지 않았다 — "찾을 말이 너무 많습니다"와 줄이는 방법 (tooManyWords)
+import { computed } from 'vue'
+
 import StateMessage from '@/components/feedback/StateMessage.vue'
-import { MAIL_SEARCH_TEXT } from '@/shared/constants/mail'
+import { MAIL_SEARCH_MAX_WORDS, MAIL_SEARCH_TEXT } from '@/shared/constants/mail'
+import { SEARCH_NOTICE_TEXT } from '@/shared/constants/mail-search'
 
 interface Props {
+  /** 검색어 — 조건만으로 찾았으면 빈 글 */
   query: string
+  /** 걸린 조건이 있다 — 없으면 조건을 줄이라고 하지 않는다 */
+  hasConditions?: boolean
   /** 한 메일함에서 찾았다 — 전체 메일함에서 찾기를 권한다 */
   offerAll: boolean
+  /** 낱말 단위로 찾는 동안(지난 메일 색인을 준비하는 중)이다 — 그 한계를 알린다 */
+  wordLimit?: boolean
+  /** 검색어와 조건의 낱말이 한도를 넘어 찾지 않았다 */
+  tooManyWords?: boolean
 }
 
 interface Emits {
   (e: 'search-all'): void
 }
 
-defineProps<Props>()
+const props = withDefaults(defineProps<Props>(), {
+  hasConditions: false,
+  wordLimit: false,
+  tooManyWords: false,
+})
 const emit = defineEmits<Emits>()
+
+const title = computed(() =>
+  props.tooManyWords ? SEARCH_NOTICE_TEXT.tooManyWordsTitle : MAIL_SEARCH_TEXT.emptyTitle(props.query),
+)
+const hint = computed(() => {
+  if (props.tooManyWords) return SEARCH_NOTICE_TEXT.tooManyWordsHint(MAIL_SEARCH_MAX_WORDS)
+  if (!props.query) return MAIL_SEARCH_TEXT.emptyConditionsHint
+  return props.hasConditions ? MAIL_SEARCH_TEXT.emptyHint : MAIL_SEARCH_TEXT.emptyWordsHint
+})
 </script>
 
 <template>
   <StateMessage
     class="search-empty"
-    icon="search"
-    :title="MAIL_SEARCH_TEXT.emptyTitle(query)"
-    :hint="MAIL_SEARCH_TEXT.emptyHint"
+    :icon="tooManyWords ? 'alert-circle' : 'search'"
+    :title="title"
+    :hint="hint"
+    :data-search-too-many-words="tooManyWords ? '' : undefined"
   >
+    <p
+      v-if="wordLimit"
+      class="search-empty__limit"
+      data-search-word-limit
+    >
+      {{ MAIL_SEARCH_TEXT.wordLimitHint }}
+    </p>
     <button
       v-if="offerAll"
       type="button"
@@ -41,9 +76,18 @@ const emit = defineEmits<Emits>()
   padding: var(--space-72) var(--space-28);
 }
 
-/* 한계 안내는 좁게 두 줄로 (디자인 원본 300px) */
-.search-empty :deep(.state-message__hint) {
+/* 도움말은 좁게 두 줄로 (디자인 원본 300px) — 한국어는 낱말 가운데에서 줄을 바꾸지 않는다(keep-all · 긴 영문은 anywhere) */
+.search-empty :deep(.state-message__hint),
+.search-empty__limit {
   max-width: 18.75rem;
+  word-break: keep-all;
+  overflow-wrap: anywhere;
+}
+
+.search-empty__limit {
+  margin: 0;
+  font-size: var(--font-size-label);
+  color: var(--color-text-muted);
 }
 
 .search-empty__all {
diff --git a/frontend/src/components/mail/MailSearchHeader.vue b/frontend/src/components/mail/MailSearchHeader.vue
index ff39e26..378b35c 100644
--- a/frontend/src/components/mail/MailSearchHeader.vue
+++ b/frontend/src/components/mail/MailSearchHeader.vue
@@ -2,6 +2,7 @@
 // 검색 결과 머리(52) — [←] 검색 닫기(40×44) · "검색 결과"(15px 굵게) · "‘회의’ · 6통"(12px 흐린 글자) · 보기 전환
 // 디자인 원본 Search(분할 보기) · ListStates(목록 보기 표). 안쪽 여백만 보기마다 다르다.
 // 검색 닫기는 검색 전 메일함으로 돌아간다 — 툴팁에 돌아갈 메일함 이름("검색 닫기 — 받은편지함으로")
+// 통 수는 서버의 total 이다 — null 이면(1,000통 넘음 · 다 세지 못함 — 14단계) 수를 보이지 않는다. 조건만으로 찾았으면 검색어 없이 수만
 import { computed } from 'vue'
 
 import AppIcon from '@/components/AppIcon.vue'
@@ -26,12 +27,12 @@ const mailStore = useMailStore()
 const { originMailbox, closeSearch } = useMailSearchNavigation()
 
 const countText = computed(() => {
-  const query = mailStore.search?.q
-  if (!query) return ''
+  const search = mailStore.search
+  if (!search) return ''
+  const query = search.q
   if (mailStore.listStatus === 'loading') return MAIL_SEARCH_TEXT.searching(query)
-  if (mailStore.listStatus !== 'ready') return MAIL_SEARCH_TEXT.quoted(query)
-  const total = mailStore.pageInfo?.total ?? mailStore.messages.length
-  return MAIL_SEARCH_TEXT.count(query, formatCount(total))
+  const total = mailStore.listStatus === 'ready' ? (mailStore.pageInfo?.total ?? null) : null
+  return total === null ? MAIL_SEARCH_TEXT.quoted(query) : MAIL_SEARCH_TEXT.count(query, formatCount(total))
 })
 
 const closeTitle = computed(() => {
diff --git a/frontend/src/components/mail/MailSearchMore.vue b/frontend/src/components/mail/MailSearchMore.vue
new file mode 100644
index 0000000..e703b72
--- /dev/null
+++ b/frontend/src/components/mail/MailSearchMore.vue
@@ -0,0 +1,75 @@
+<script setup lang="ts">
+// 이어 찾을 것이 남았는데 아직 하나도 찾지 못한 검색 (14단계 — 계약 2절 "검색 — 14단계" › hasNext 인데 빈 쪽)
+// 서버는 한 요청에 확인하는 메일 수에 상한이 있다 — 목록 스토어가 정한 횟수(MAIL_SEARCH_FILL_MAX_REQUESTS)까지 이어 묻고도 못 찾았으면
+// 결과 없음 대신 이 안내와 [더 찾기]를 보인다. 누르면 같은 횟수만큼 더 이어 묻는다(목록 스토어의 loadMore). 찾는 동안 단추는 aria-busy
+import StateMessage from '@/components/feedback/StateMessage.vue'
+import { SEARCH_NOTICE_TEXT } from '@/shared/constants/mail-search'
+
+interface Props {
+  busy: boolean
+}
+
+interface Emits {
+  (e: 'more'): void
+}
+
+const props = defineProps<Props>()
+const emit = defineEmits<Emits>()
+
+function onMore() {
+  if (!props.busy) emit('more')
+}
+</script>
+
+<template>
+  <StateMessage
+    class="search-more"
+    icon="search"
+    :title="SEARCH_NOTICE_TEXT.partialTitle"
+    :hint="SEARCH_NOTICE_TEXT.partialHint"
+  >
+    <button
+      type="button"
+      class="search-more__button"
+      :aria-busy="busy"
+      :aria-disabled="busy ? 'true' : undefined"
+      data-search-more
+      @click="onMore"
+    >
+      {{ busy ? SEARCH_NOTICE_TEXT.moreBusy : SEARCH_NOTICE_TEXT.more }}
+    </button>
+  </StateMessage>
+</template>
+
+<style scoped>
+.search-more {
+  padding: var(--space-72) var(--space-28);
+}
+
+/* 한국어는 낱말 가운데에서 줄을 바꾸지 않는다(keep-all · 긴 영문은 anywhere) */
+.search-more :deep(.state-message__hint) {
+  max-width: 18.75rem;
+  word-break: keep-all;
+  overflow-wrap: anywhere;
+}
+
+.search-more__button {
+  margin-top: var(--space-8);
+  min-height: var(--size-touch);
+  padding: 0 var(--space-16);
+  border: 0;
+  border-radius: var(--radius-md);
+  background: transparent;
+  color: var(--color-brand);
+  font-weight: 600;
+}
+
+.search-more__button:hover:not([aria-disabled='true']) {
+  background: var(--color-brand-subtle);
+}
+
+.search-more__button[aria-disabled='true'] {
+  color: var(--color-text-muted);
+  cursor: default;
+}
+</style>
diff --git a/frontend/src/components/mail/MailSearchNotices.vue b/frontend/src/components/mail/MailSearchNotices.vue
new file mode 100644
index 0000000..21f63b5
--- /dev/null
+++ b/frontend/src/components/mail/MailSearchNotices.vue
@@ -0,0 +1,73 @@
+<script setup lang="ts">
+// 검색 결과 머리 아래 안내 줄 (디자인 원본 Search14 "검색 준비 중" — 옅은 청록 바탕 · 12.5px · info 아이콘) — 14단계
+// - 검색 준비 중: 지난 메일의 색인을 만드는 동안(GET /search-index 의 building) — 그동안의 검색은 낱말이 통째로 같을 때만 맞는다
+// - 한 글자 안내: 낱말이 모두 한 글자라 본문은 찾지 않았을 때(색인 방식 — 서버와 같은 낱말 나누기, search-match.ts 의 isSingleCharSearch)
+// 둘을 감싼 칸이 role="status" 라 줄이 생기면 화면 낭독기가 읽는다 (감싼 칸은 검색 화면이면 늘 있다)
+import AppIcon from '@/components/AppIcon.vue'
+import { SEARCH_NOTICE_TEXT } from '@/shared/constants/mail-search'
+
+interface Props {
+  indexing: boolean
+  singleChar: boolean
+}
+
+defineProps<Props>()
+</script>
+
+<template>
+  <div
+    class="search-notices"
+    role="status"
+  >
+    <p
+      v-if="indexing"
+      class="search-notices__line"
+      data-search-notice="indexing"
+    >
+      <AppIcon
+        name="info"
+        :size="15"
+        :stroke-width="1.9"
+        class="search-notices__icon"
+      />
+      <span>{{ SEARCH_NOTICE_TEXT.indexing }}</span>
+    </p>
+    <p
+      v-if="singleChar"
+      class="search-notices__line"
+      data-search-notice="single-char"
+    >
+      <AppIcon
+        name="info"
+        :size="15"
+        :stroke-width="1.9"
+        class="search-notices__icon"
+      />
+      <span>{{ SEARCH_NOTICE_TEXT.singleChar }}</span>
+    </p>
+  </div>
+</template>
+
+<style scoped>
+/* 옅은 청록 바탕 · 아래 선 #E3EEEF · 위아래 10 · 좌우 16 (디자인 원본 Search14) */
+.search-notices__line {
+  display: flex;
+  align-items: flex-start;
+  gap: var(--space-8);
+  margin: 0;
+  padding: var(--space-10) var(--space-16);
+  border-bottom: var(--border-width) solid var(--color-brand-tint-border);
+  background: var(--color-brand-tint);
+  font-size: var(--font-size-label);
+  color: var(--color-text-strong);
+  /* 한국어는 낱말 가운데에서 줄을 바꾸지 않는다 */
+  word-break: keep-all;
+  overflow-wrap: anywhere;
+}
+
+.search-notices__icon {
+  flex: 0 0 auto;
+  margin-top: var(--space-2);
+  color: var(--color-brand);
+}
+</style>
diff --git a/frontend/src/components/mail/MailSearchPeriodField.vue b/frontend/src/components/mail/MailSearchPeriodField.vue
new file mode 100644
index 0000000..69c8da4
--- /dev/null
+++ b/frontend/src/components/mail/MailSearchPeriodField.vue
@@ -0,0 +1,190 @@
+<script setup lang="ts">
+// 「조건으로 찾기」 패널의 기간 칸 (14단계 — 디자인 원본 Search14): 기간 고르기(전체 기간 · 최근 1주 · 1달 · 3달 · 1년 · 날짜 고르기)와
+// 날짜 고르기의 시작 ~ 끝. 날짜 칸은 고를 수 있는 날짜(SEARCH_DAY_MIN ~ SEARCH_DAY_MAX)와 서로의 날짜로 범위를 둔다 —
+// 손으로 친 날짜는 [찾기] 때 다시 본다(useSearchConditionsDraft 의 take).
+// 잘못(problem)은 칸 아래에 알리고(role=alert) 그 날짜 칸을 aria-invalid 로 — 넘기지 못했으면 부르는 쪽이 focusInvalid() 로 그 칸에 초점을 둔다.
+// 칸 높이 40 — 필터 조건 칸의 밀도 예외(--size-filter-control)를 다시 쓴다
+import { computed, ref } from 'vue'
+
+import AppIcon from '@/components/AppIcon.vue'
+import type { SearchPeriodProblem } from '@/composables/useSearchConditionsDraft'
+import {
+  SEARCH_CONDITIONS_TEXT,
+  SEARCH_DAY_MAX,
+  SEARCH_DAY_MIN,
+  SEARCH_PERIOD_LABELS,
+  SEARCH_PERIOD_ORDER,
+  type SearchPeriod,
+} from '@/shared/constants/mail-search'
+import { isSearchDay } from '@/shared/utils/mail-search'
+
+interface Props {
+  /** 기간 고르기의 id — 부르는 쪽의 이름(label for)이 가리킨다 */
+  selectId: string
+  period: SearchPeriod
+  /** 날짜 고르기의 시작 · 끝 (YYYY-MM-DD, 비면 '') */
+  since: string
+  until: string
+  /** 알릴 잘못 — 없으면 null */
+  problem: SearchPeriodProblem | null
+}
+
+interface Emits {
+  (e: 'period', period: SearchPeriod): void
+  (e: 'day', edge: 'since' | 'until', value: string): void
+}
+
+const props = defineProps<Props>()
+const emit = defineEmits<Emits>()
+
+const sinceRef = ref<HTMLInputElement | null>(null)
+const untilRef = ref<HTMLInputElement | null>(null)
+
+const periodModel = computed<SearchPeriod>({
+  get: () => props.period,
+  set: (value) => emit('period', value),
+})
+const sinceModel = computed<string>({
+  get: () => props.since,
+  set: (value) => emit('day', 'since', value),
+})
+const untilModel = computed<string>({
+  get: () => props.until,
+  set: (value) => emit('day', 'until', value),
+})
+
+const errorId = computed(() => `${props.selectId}-error`)
+const errorText = computed(() =>
+  props.problem === 'range' ? SEARCH_CONDITIONS_TEXT.periodRange : SEARCH_CONDITIONS_TEXT.periodOrder,
+)
+
+/** 고를 수 없는 날짜 — 비었으면 아니다 */
+const outOfRange = (value: string) => value !== '' && !isSearchDay(value)
+/** 순서가 거꾸로면 두 칸 모두, 고를 수 없는 날짜면 그 칸만 */
+const sinceInvalid = computed(
+  () => props.problem === 'order' || (props.problem === 'range' && outOfRange(props.since)),
+)
+const untilInvalid = computed(
+  () => props.problem === 'order' || (props.problem === 'range' && outOfRange(props.until)),
+)
+/** 날짜 칸의 범위 — 고를 수 있는 날짜 안에서 시작은 끝을, 끝은 시작을 넘지 않게 */
+const sinceMax = computed(() => (isSearchDay(props.until) ? props.until : SEARCH_DAY_MAX))
+const untilMin = computed(() => (isSearchDay(props.since) ? props.since : SEARCH_DAY_MIN))
+
+defineExpose({
+  /** 넘기지 못한 까닭의 칸으로 — 고를 수 없는 시작 날짜면 시작, 그 밖은 끝 날짜 */
+  focusInvalid: () => {
+    if (props.problem === 'range' && outOfRange(props.since)) sinceRef.value?.focus()
+    else untilRef.value?.focus()
+  },
+})
+</script>
+
+<template>
+  <div class="period-field">
+    <div class="period-field__row">
+      <select
+        :id="selectId"
+        v-model="periodModel"
+        class="form-input period-field__control period-field__select"
+        data-search-condition="period"
+      >
+        <option
+          v-for="option in SEARCH_PERIOD_ORDER"
+          :key="option"
+          :value="option"
+        >
+          {{ SEARCH_PERIOD_LABELS[option] }}
+        </option>
+      </select>
+      <span
+        v-if="period === 'custom'"
+        class="period-field__dates"
+      >
+        <input
+          ref="sinceRef"
+          v-model="sinceModel"
+          class="form-input period-field__control"
+          type="date"
+          :min="SEARCH_DAY_MIN"
+          :max="sinceMax"
+          :aria-label="SEARCH_CONDITIONS_TEXT.since"
+          :aria-invalid="sinceInvalid ? 'true' : 'false'"
+          :aria-describedby="sinceInvalid ? errorId : undefined"
+          data-search-condition="since"
+        >
+        <span
+          class="period-field__tilde"
+          aria-hidden="true"
+        >~</span>
+        <input
+          ref="untilRef"
+          v-model="untilModel"
+          class="form-input period-field__control"
+          type="date"
+          :min="untilMin"
+          :max="SEARCH_DAY_MAX"
+          :aria-label="SEARCH_CONDITIONS_TEXT.until"
+          :aria-invalid="untilInvalid ? 'true' : 'false'"
+          :aria-describedby="untilInvalid ? errorId : undefined"
+          data-search-condition="until"
+        >
+      </span>
+    </div>
+    <p
+      v-if="problem"
+      :id="errorId"
+      class="form-message form-message--error"
+      role="alert"
+      :data-search-period-problem="problem"
+    >
+      <AppIcon
+        name="alert-circle"
+        :size="14"
+        :stroke-width="2"
+      />
+      <span>{{ errorText }}</span>
+    </p>
+  </div>
+</template>
+
+<style scoped>
+.period-field {
+  min-width: 0;
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-6);
+}
+
+.period-field__row {
+  min-width: 0;
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: var(--space-8);
+}
+
+/* 칸 높이 40 — 밀도 예외 (필터 조건 칸과 같다) */
+.period-field__control {
+  min-width: 0;
+  min-height: var(--size-filter-control);
+  height: var(--size-filter-control);
+  padding: 0 var(--space-10);
+}
+
+.period-field__select {
+  min-width: 8.75rem;
+}
+
+.period-field__dates {
+  min-width: 0;
+  display: inline-flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: var(--space-6);
+}
+
+.period-field__tilde {
+  color: var(--color-text-muted);
+}
+</style>
diff --git a/frontend/src/components/mail/MailSelectionToolbar.spec.ts b/frontend/src/components/mail/MailSelectionToolbar.spec.ts
index ebb859b..fa9b6ca 100644
--- a/frontend/src/components/mail/MailSelectionToolbar.spec.ts
+++ b/frontend/src/components/mail/MailSelectionToolbar.spec.ts
@@ -164,7 +164,7 @@ describe('여러 통 처리 도구 줄', () => {
     expect(store.checkedCount).toBe(1)
   })
 
-  it('옮기면 옮긴 메일만 빼고 "메일 N통을 보관함으로 옮겼습니다." + [되돌리기] — 되돌리면 원래 메일함으로 옮기고 알린다', async () => {
+  it('옮기면 옮긴 메일만 빼고 "메일 N통을 보관함으로 옮겼습니다." + [되돌리기] — 되돌리면 원래 메일함으로 옮기고 그 메일함 이름으로 알린다', async () => {
     const { wrapper, store } = await mountView()
     store.toggleCheck('m1')
     store.toggleCheck('m3')
@@ -186,6 +186,31 @@ describe('여러 통 처리 도구 줄', () => {
     if (toast?.action && 'run' in toast.action) toast.action.run()
     await flushPromises()
     expect(bulkPatches()[1]).toEqual({ ids: ['m1', 'm3'], mailboxId: 'inbox' })
+    // 한 메일함으로 되돌렸다 — 어디로 되돌렸는지 말한다 (2026-11-06 실사용 시험)
+    expect(toastTexts()).toContain('메일 2통을 받은편지함으로 되돌렸습니다.')
+  })
+
+  it('여러 메일함으로 되돌렸으면 메일함 이름 없이 "메일 N통을 되돌렸습니다."', async () => {
+    const { wrapper, store } = await mountView({
+      messages: [summary('m1'), summary('m2', { mailboxIds: ['sent'] }), summary('m3')],
+    })
+    store.toggleCheck('m1')
+    store.toggleCheck('m2')
+    await flushPromises()
+
+    await wrapper.get('[data-tool="move"]').trigger('click')
+    await flushPromises()
+    await wrapper.findAll('[role="menuitem"]').find((item) => item.text() === '보관함')?.trigger('click')
+    await flushPromises()
+    const [toast] = useToastStore().toasts
+    expect(toast?.message).toBe('메일 2통을 보관함으로 옮겼습니다.')
+
+    if (toast?.action && 'run' in toast.action) toast.action.run()
+    await flushPromises()
+    expect(bulkPatches().slice(1)).toEqual([
+      { ids: ['m1'], mailboxId: 'inbox' },
+      { ids: ['m2'], mailboxId: 'sent' },
+    ])
     expect(toastTexts()).toContain('메일 2통을 되돌렸습니다.')
   })
 
@@ -398,7 +423,7 @@ describe('여러 통 처리 도구 줄', () => {
       if (toast?.action && 'run' in toast.action) toast.action.run()
       await flushPromises()
       expect(bulkPatches()[1]).toEqual({ ids: ['m1', 'm2'], mailboxId: 'inbox', isJunk: false })
-      expect(toastTexts()).toContain('메일 2통을 되돌렸습니다.')
+      expect(toastTexts()).toContain('메일 2통을 받은편지함으로 되돌렸습니다.')
     })
 
     it('스팸메일함에서는 「스팸 아님」(강조) — 받은편지함으로 · isJunk: false, "스팸이 아닌 메일로 표시해 …" 알림 · 되돌리면 스팸메일함으로 · isJunk: true', async () => {
diff --git a/frontend/src/components/mail/MailSelectionToolbar.vue b/frontend/src/components/mail/MailSelectionToolbar.vue
index 9c8e011..52c90cc 100644
--- a/frontend/src/components/mail/MailSelectionToolbar.vue
+++ b/frontend/src/components/mail/MailSelectionToolbar.vue
@@ -8,6 +8,10 @@
 // - role="toolbar": Tab 한 번에 들어와 화살표 · Home · End 로 옮긴다(로빙 tabindex). 이동 메뉴는 MailBulkMoveButton.
 //   옮기기 · 지우기를 하는 동안 눌리지 않는 단추(이동 · 삭제)는 건너뛰고, Tab 자리 · 초점이 그 단추에 있었으면 다음 누를 수 있는 단추로 옮긴다
 // - 영구 삭제는 확인 대화상자(MailPurgeDialog — 처음 초점은 「취소」)를 거친다
+// - 대화로 묶은 메일함(14단계)은 "대화 N개 선택됨"이고 하는 일은 고른 줄의 메일 모두(붙잡힌 메일은 빼고) — 영구 삭제 확인의 수는 그 메일 수다
+//   ("휴지통에 있는 메일 N통을 영구 삭제할까요?" — 줄의 통 수는 대화 전체라서, useBulkMailActions 의 conversationFrom).
+//   분할 보기는 보이는 글만 "N개 선택됨"으로 줄이고 화면 낭독은 "대화 N개 선택됨"을 읽는다 — 목록 칸(384)에서 단추 일곱(280)과 한 줄에 들게
+//   (2026-11-06 실사용 시험: "대화 1개 선택됨" 88px 이면 도구가 두 줄 · 97px 로 넘쳤다. "N개 선택됨"은 세 자리까지 79px — 1440 의 자리 83px)
 import { computed, nextTick, ref, watch } from 'vue'
 
 import MailBulkButton from '@/components/mail/MailBulkButton.vue'
@@ -16,6 +20,7 @@ import MailPurgeDialog from '@/components/mail/MailPurgeDialog.vue'
 import { useBulkMailActions } from '@/composables/useBulkMailActions'
 import type { IconName } from '@/shared/constants/icons'
 import { MAIL_BULK_TEXT, MAIL_SPAM_TEXT } from '@/shared/constants/mail'
+import { MAIL_CONVERSATION_LIST_TEXT } from '@/shared/constants/mail-conversation'
 import { formatCount } from '@/shared/utils/format'
 import { useMailStore } from '@/stores/mail.store'
 
@@ -70,7 +75,16 @@ const rovingTool = computed<ToolId>(() => {
 
 /** 분할 보기의 목록 칸은 아이콘만, 목록 보기는 폭 1100 이상에서 이름까지 */
 const labelMode = computed(() => (props.variant === 'split' ? 'never' : 'wide'))
-const countText = computed(() => MAIL_BULK_TEXT.selected(formatCount(mailStore.checkedCount)))
+const countText = computed(() => {
+  const count = formatCount(mailStore.checkedCount)
+  return mailStore.isConversationList ? MAIL_CONVERSATION_LIST_TEXT.selected(count) : MAIL_BULK_TEXT.selected(count)
+})
+/** 분할 보기에서 보이는 고른 수 — 대화 목록만 줄인다("1개 선택됨"). 줄이지 않으면 null (화면 낭독은 늘 countText) */
+const shortCountText = computed(() =>
+  props.variant === 'split' && mailStore.isConversationList
+    ? MAIL_CONVERSATION_LIST_TEXT.selectedShort(formatCount(mailStore.checkedCount))
+    : null,
+)
 const deleteLabel = computed(() => (bulk.inTrash.value ? MAIL_BULK_TEXT.purge : MAIL_BULK_TEXT.delete))
 const spamLabel = computed(() => (bulk.inJunk.value ? MAIL_SPAM_TEXT.notSpam : MAIL_SPAM_TEXT.report))
 const leadingTools = computed<LeadingTool[]>(() => [
@@ -162,7 +176,13 @@ watch(disabledTools, (disabled) => {
       :id="titleId"
       class="bulk-bar__count"
     >
-      {{ countText }}
+      <template v-if="shortCountText">
+        <span aria-hidden="true">{{ shortCountText }}</span>
+        <span class="visually-hidden">{{ countText }}</span>
+      </template>
+      <template v-else>
+        {{ countText }}
+      </template>
     </h1>
     <div
       ref="toolsRef"
@@ -231,7 +251,8 @@ watch(disabledTools, (disabled) => {
     </div>
     <MailPurgeDialog
       :open="purgeOpen"
-      :count="mailStore.checkedCount"
+      :count="mailStore.checkedActionIds.length"
+      :from="bulk.conversationFrom.value"
       id-prefix="bulk-purge"
       @confirm="onPurgeConfirm"
       @cancel="purgeOpen = false"
diff --git a/frontend/src/components/mail/MessageAttachments.vue b/frontend/src/components/mail/MessageAttachments.vue
index 0933f60..a152ddd 100644
--- a/frontend/src/components/mail/MessageAttachments.vue
+++ b/frontend/src/components/mail/MessageAttachments.vue
@@ -6,16 +6,18 @@
 // 대용량 첨부(11단계 — MessageDetail.largeFiles)도 같은 칸에 첨부처럼 — 「첨부 파일 N개」는 둘을 합한 수 (MessageLargeFileItem).
 // 보낸 사람 자신(링크 주인)에게는 칸 아래에 링크 줄 — 받은 수 · [링크 복사] · [링크 끊기] (MessageLargeFileLinkBar — 끝난 링크는 없다)
 // 보안 검사 중인 대용량 첨부가 있는 동안은 상태를 가끔 다시 묻고, 막힌 [다운로드]를 누르면 한 번 바로 묻는다 (useLargeFileScanRefresh)
+// 검색 결과에서 연 메일(14단계)은 첨부 이름의 맞은 말을 <mark> 로 (nameHighlights — 첨부 id → 맞은 곳, 맞은 첨부만)
 import { computed, nextTick, ref } from 'vue'
 
 import AppIcon from '@/components/AppIcon.vue'
+import HighlightedText from '@/components/mail/HighlightedText.vue'
 import MessageLargeFileItem from '@/components/mail/MessageLargeFileItem.vue'
 import MessageLargeFileLinkBar from '@/components/mail/MessageLargeFileLinkBar.vue'
 import { useClock } from '@/composables/useClock'
 import { useLargeFileScanRefresh } from '@/composables/useLargeFileScanRefresh'
 import { useMail } from '@/composables/useMail'
 import type { MessageLargeFile } from '@/shared/types/large-file'
-import type { Attachment } from '@/shared/types/mail'
+import type { Attachment, SearchRange } from '@/shared/types/mail'
 import { formatFileSize } from '@/shared/utils/format'
 import { isEndedLinkStatus } from '@/shared/utils/large-file-status'
 import { useMailStore } from '@/stores/mail.store'
@@ -25,10 +27,13 @@ interface Props {
   attachments: Attachment[]
   /** 대용량 첨부 — 링크 주인이 이 메일의 보낸 사람일 때만 온다 */
   largeFiles?: MessageLargeFile[]
+  /** 첨부 이름의 검색에서 맞은 곳 — 서버의 searchHighlight.attachments (14단계) */
+  nameHighlights?: Readonly<Record<string, readonly SearchRange[]>> | null
 }
 
 const props = withDefaults(defineProps<Props>(), {
   largeFiles: () => [],
+  nameHighlights: null,
 })
 
 const { attachmentDownloadUrl, downloadAttachment } = useMail()
@@ -126,7 +131,12 @@ function onDownload(event: MouseEvent, attachmentId: string) {
           <AppIcon name="file" />
         </span>
         <div class="attachments__meta">
-          <span class="attachments__name">{{ attachment.name }}</span>
+          <span class="attachments__name">
+            <HighlightedText
+              :text="attachment.name"
+              :ranges="nameHighlights?.[attachment.id] ?? null"
+            />
+          </span>
           <span class="attachments__size">{{ formatFileSize(attachment.size) }}</span>
         </div>
         <a
diff --git a/frontend/src/components/mail/MessageConversation.spec.ts b/frontend/src/components/mail/MessageConversation.spec.ts
new file mode 100644
index 0000000..7c7baae
--- /dev/null
+++ b/frontend/src/components/mail/MessageConversation.spec.ts
@@ -0,0 +1,951 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { mount, type VueWrapper } from '@vue/test-utils'
+import { createPinia, setActivePinia, type Pinia } from 'pinia'
+
+import { CLOCK, type Clock } from '@/composables/useClock'
+import { ERROR_CODE_MESSAGES } from '@/shared/constants/error-codes.generated'
+import { MAIL_BODY_NOTICES } from '@/shared/constants/mail'
+import { MAIL_CONVERSATION_PAGE_SIZE, MAIL_CONVERSATION_REFRESH_GAP_MS } from '@/shared/constants/mail-conversation'
+import type { Mailbox, MessageDetail, MessageSummary } from '@/shared/types/mail'
+import type { MailListSource } from '@/shared/utils/mail-list-source'
+import { useAuthStore } from '@/stores/auth.store'
+import { useMailStore } from '@/stores/mail.store'
+import { useToastStore } from '@/stores/toast.store'
+import { createManualClock, type ManualClock } from '@/test-utils/manual-clock'
+import {
+  fail,
+  flushPromises,
+  installMockApi,
+  ok,
+  restoreApiAdapter,
+  type MockRequest,
+  type MockResult,
+} from '@/test-utils/mock-api'
+import { createTestRouter } from '@/test-utils/router'
+import MessageReader from './MessageReader.vue'
+
+// 읽기 화면의 "같은 대화" 칸 (14단계 — 디자인 원본 Thread14 · README "읽기 화면 — 같은 대화" · 계약 2절 "대화 — 14단계")
+// 시각은 지역 시각으로 만든다 — 시간대(KST · UTC)와 상관없이 같은 글이 된다. 시간은 손으로 돌리는 시계로 넘긴다
+
+const USER = { email: 'ara.kim@arasystem.test', name: '김아라' }
+const INBOX: Mailbox = { id: 'inbox', name: '받은편지함', role: 'inbox', parentId: null, sortOrder: 0, totalCount: 3, unreadCount: 1 }
+const SENT: Mailbox = { ...INBOX, id: 'sent', name: '보낸편지함', role: 'sent', unreadCount: 0 }
+const DRAFTS: Mailbox = { ...INBOX, id: 'drafts', name: '임시보관함', role: 'drafts', unreadCount: 0 }
+const MAILBOXES = [INBOX, SENT, DRAFTS]
+/** 2026년 11월 6일(금) 오후 3시 — 브라우저 시간대 */
+const NOW = new Date(2026, 10, 6, 15).getTime()
+const at = (...parts: [number, number, number, number, number]) => new Date(...parts).toISOString()
+
+function summary(id: string, partial: Partial<MessageSummary> = {}): MessageSummary {
+  return {
+    id,
+    threadId: 't1',
+    mailboxIds: ['inbox'],
+    from: { name: '이도윤', email: 'doyun.lee@arasystem.test' },
+    to: [{ name: '김아라', email: USER.email }],
+    subject: '회신: 유지보수 계약 갱신 건',
+    preview: '네, 확인했습니다. 단가와 기간을 정리해서 보내 드리겠습니다.',
+    receivedAt: at(2026, 9, 29, 9, 30),
+    isRead: true,
+    isFlagged: false,
+    hasAttachment: false,
+    size: 100,
+    pendingSend: null,
+    ...partial,
+  }
+}
+
+function detail(base: MessageSummary, partial: Partial<MessageDetail> = {}): MessageDetail {
+  return {
+    ...base,
+    cc: [],
+    bcc: [],
+    replyTo: [],
+    sentAt: null,
+    messageId: null,
+    references: [],
+    htmlBody: null,
+    textBody: `${base.id} 본문`,
+    hasBlockedImages: false,
+    attachments: [],
+    ...partial,
+  }
+}
+
+/** 내가 보낸 처음 메일 · 이도윤의 회신(안 읽음) · 지금 보는 메일 */
+const ORIGINAL = summary('m1', {
+  mailboxIds: ['sent'],
+  from: { name: '김아라', email: USER.email },
+  to: [{ name: '이도윤', email: 'doyun.lee@arasystem.test' }],
+  subject: '유지보수 계약 갱신 건',
+  preview: '다음 달에 끝나는 유지보수 계약을 1년 더 이어 가려고 합니다.',
+  receivedAt: at(2026, 9, 27, 14, 10),
+})
+const REPLY = summary('m2', { isRead: false })
+const CURRENT = summary('m3', {
+  subject: 'Re: 유지보수 계약 갱신 건',
+  receivedAt: at(2026, 10, 6, 10, 42),
+  hasAttachment: true,
+})
+const THREAD = [ORIGINAL, REPLY, CURRENT]
+
+function page(items: MessageSummary[], nextCursor: string | null = null, total: number | null = items.length): MockResult {
+  return ok({ items, pageInfo: { hasNext: nextCursor !== null, nextCursor, total }, basis: 'index' })
+}
+
+function deferred() {
+  let resolve: (result: MockResult) => void = () => undefined
+  const promise = new Promise<MockResult>((settle) => {
+    resolve = settle
+  })
+  return { promise, resolve }
+}
+
+interface Server {
+  conversation?: (request: MockRequest) => MockResult | Promise<MockResult>
+  detail?: (request: MockRequest) => MockResult | Promise<MockResult>
+  /** 읽음 · 중요 표시 — 한 통(PATCH /messages/{id}) · 여러 통(PATCH /messages) */
+  patch?: (request: MockRequest) => MockResult | Promise<MockResult>
+}
+
+describe('MessageConversation — 읽기 화면의 같은 대화', () => {
+  let pinia: Pinia
+  let clock: ManualClock
+  let requests: MockRequest[]
+  const mounted: VueWrapper[] = []
+
+  beforeEach(() => {
+    pinia = createPinia()
+    setActivePinia(pinia)
+    useAuthStore().markAuthenticated(USER)
+    clock = createManualClock(NOW)
+  })
+
+  afterEach(() => {
+    for (const wrapper of mounted.splice(0)) {
+      if (!wrapper.vm.$.isUnmounted) wrapper.unmount()
+    }
+    vi.restoreAllMocks()
+    useToastStore().clear()
+    restoreApiAdapter()
+    document.body.innerHTML = ''
+  })
+
+  function serve(server: Server = {}) {
+    requests = installMockApi((request) => {
+      if (request.url.endsWith('/conversation')) return server.conversation?.(request) ?? page(THREAD)
+      if (request.method === 'PATCH') return server.patch?.(request) ?? ok({ ...REPLY, isRead: true })
+      if (request.url === '/mailboxes') return ok({ items: MAILBOXES, pageInfo: { hasNext: false, nextCursor: null, total: 3 } })
+      if (request.url.startsWith('/messages/')) {
+        if (server.detail) return server.detail(request)
+        const id = request.url.split('/').pop() ?? ''
+        return ok(detail(THREAD.find((item) => item.id === id) ?? summary(id)))
+      }
+      return ok(null)
+    })
+  }
+
+  async function mountReader(
+    options: {
+      path?: string
+      source?: MailListSource
+      current?: MessageSummary
+      layout?: 'split' | 'list'
+      /** 손으로 돌리는 시계 대신 줄 시계 (시계가 뒤로 가는 경우) */
+      clock?: Clock
+    } = {},
+  ) {
+    const store = useMailStore()
+    const current = options.current ?? CURRENT
+    store.mailboxes = MAILBOXES
+    store.listSource = options.source ?? { kind: 'mailbox', mailboxId: 'inbox' }
+    store.messages = [REPLY, CURRENT]
+    store.pageInfo = { hasNext: false, nextCursor: null, total: 2 }
+    store.listStatus = 'ready'
+    store.selected = detail(current, {
+      attachments: [{ id: 'a1', name: '유지보수_계약서_수정본.docx', type: 'application/msword', size: 52_000 }],
+    })
+    store.selectedId = current.id
+    store.selectedStatus = 'ready'
+    const router = createTestRouter()
+    await router.push(options.path ?? `/mail/inbox/${current.id}`)
+    await router.isReady()
+    const wrapper = mount(MessageReader, {
+      props: { layout: options.layout ?? 'split' },
+      attachTo: document.body,
+      global: { plugins: [pinia, router], provide: { [CLOCK as symbol]: options.clock ?? clock } },
+    })
+    mounted.push(wrapper)
+    await flushPromises()
+    return { wrapper, router, store }
+  }
+
+  const conversationRequests = () => requests.filter((request) => request.url.endsWith('/conversation'))
+  const section = (wrapper: VueWrapper) => wrapper.get('[data-conversation]')
+  const rowOf = (wrapper: VueWrapper, id: string) => wrapper.get(`[data-conversation-row="${id}"]`)
+
+  describe('칸 모양 (디자인 원본 Thread14)', () => {
+    it('본문 · 첨부 아래 "같은 대화 3통" — 테두리 상자 안의 줄, 오래된 차례', async () => {
+      serve()
+      const { wrapper } = await mountReader()
+
+      expect(conversationRequests().map((request) => [request.url, request.params])).toEqual([
+        ['/messages/m3/conversation', { limit: MAIL_CONVERSATION_PAGE_SIZE }],
+      ])
+      // 본문 · 첨부 다음이 칸 — 화면 낭독용 상태 영역은 늘 그 뒤에 있다(보이지 않는다)
+      const content = wrapper.get('.reader__content')
+      const order = [...content.element.children].map((child) => child.className.split(' ')[0])
+      expect(order.slice(-4)).toEqual(['mail-body-frame', 'attachments', 'conversation', 'visually-hidden'])
+      expect(content.element.lastElementChild?.getAttribute('role')).toBe('status')
+
+      expect(section(wrapper).get('h3').text()).toBe('같은 대화 3통')
+      expect(section(wrapper).get('h3').attributes('tabindex')).toBe('-1')
+      expect(section(wrapper).attributes('aria-labelledby')).toBe(section(wrapper).get('h3').attributes('id'))
+      expect(section(wrapper).findAll('ol > li').map((row) => row.attributes('data-conversation-row'))).toEqual([
+        'm1',
+        'm2',
+        'm3',
+      ])
+    })
+
+    it('내가 보낸 메일은 "나" + 회색 "보낸편지함"(머리글자도 회색) · 다른 줄은 이름 · 미리 보기 한 줄 · 시각', async () => {
+      serve()
+      const { wrapper } = await mountReader()
+
+      const mine = rowOf(wrapper, 'm1')
+      expect(mine.get('.conversation-row__who').text()).toBe('나')
+      expect(mine.get('.conversation-row__mailbox').text()).toBe('보낸편지함')
+      expect(mine.get('.conversation-row__avatar').text()).toBe('김')
+      expect(mine.get('.conversation-row__avatar').classes()).toContain('conversation-row__avatar--mine')
+      expect(mine.get('.conversation-row__preview').text()).toBe(ORIGINAL.preview)
+      expect(mine.get('time').text()).toBe('10월 27일 (화) 오후 2:10')
+
+      // 안 읽은 줄이다 — 화면 낭독용 "안 읽음, "이 이름 앞에 든다 (아래 "안 읽은 줄")
+      const other = rowOf(wrapper, 'm2')
+      expect(other.get('.conversation-row__who').text()).toBe('안 읽음, 이도윤')
+      expect(other.find('.conversation-row__mailbox').exists()).toBe(false)
+      expect(other.get('.conversation-row__avatar').classes()).not.toContain('conversation-row__avatar--mine')
+      expect(other.get('time').text()).toBe('10월 29일 (목) 오전 9:30')
+      // 강조 · 뱃지 없이 글로만
+      expect(section(wrapper).findAll('mark')).toHaveLength(0)
+    })
+
+    it('지금 보는 메일의 줄은 "지금 보고 있는 메일"(aria-current)이고 누를 수 없다 — 다른 줄은 접힌 단추(aria-expanded="false")', async () => {
+      serve()
+      const { wrapper } = await mountReader()
+
+      const current = rowOf(wrapper, 'm3')
+      expect(current.find('button').exists()).toBe(false)
+      expect(current.get('[aria-current="true"]').text()).toContain('지금 보고 있는 메일')
+      expect(current.get('time').text()).toBe('오늘 오전 10:42')
+      for (const id of ['m1', 'm2']) {
+        const button = rowOf(wrapper, id).get('button')
+        expect(button.attributes('aria-expanded')).toBe('false')
+        expect(button.attributes('aria-controls')).toBeUndefined()
+      }
+    })
+
+    it('한 통뿐이면 칸이 없다', async () => {
+      serve({ conversation: () => page([CURRENT]) })
+      const { wrapper } = await mountReader()
+
+      expect(conversationRequests()).toHaveLength(1)
+      expect(wrapper.find('[data-conversation]').exists()).toBe(false)
+      expect(wrapper.find('[data-conversation-failed]').exists()).toBe(false)
+    })
+
+    it('통 수를 모르면(남은 쪽이 있고 total null) 수 없이 "같은 대화" — 상자 아래 [더 보기]', async () => {
+      const full = Array.from({ length: MAIL_CONVERSATION_PAGE_SIZE - 1 }, (_, index) => summary(`p${index}`))
+      serve({
+        conversation: ({ params }) => (params.cursor ? page([REPLY], null, null) : page([...full, CURRENT], 'c2', null)),
+      })
+      const { wrapper } = await mountReader()
+
+      expect(section(wrapper).get('h3').text()).toBe('같은 대화')
+      const more = wrapper.get('[data-conversation-more]')
+      expect(more.text()).toBe('더 보기')
+
+      await more.trigger('click')
+      expect(more.attributes('aria-busy')).toBe('true')
+      expect(more.text()).toBe('불러오는 중…')
+      await flushPromises()
+
+      expect(conversationRequests().at(-1)?.params).toEqual({ limit: MAIL_CONVERSATION_PAGE_SIZE, cursor: 'c2' })
+      expect(wrapper.find('[data-conversation-more]').exists()).toBe(false)
+      expect(section(wrapper).get('h3').text()).toBe(`같은 대화 ${MAIL_CONVERSATION_PAGE_SIZE + 1}통`)
+    })
+
+    it('붙잡힌 메일은 시각 자리에 목록과 같은 "예약 · …" · "보내는 중"', async () => {
+      const sendAt = new Date(2026, 10, 7, 9, 0).toISOString()
+      serve({
+        conversation: () =>
+          page([
+            ...THREAD,
+            summary('s1', { mailboxIds: ['sent'], from: USER, pendingSend: { kind: 'scheduled', sendAt } }),
+            summary('s2', { mailboxIds: ['sent'], from: USER, pendingSend: { kind: 'undo', sendAt } }),
+          ]),
+      })
+      const { wrapper } = await mountReader()
+
+      expect(rowOf(wrapper, 's1').get('time').text()).toBe('예약 · 11월 7일 오전 9:00')
+      expect(rowOf(wrapper, 's1').get('time').classes()).toContain('is-pending')
+      expect(rowOf(wrapper, 's2').get('time').text()).toBe('보내는 중')
+      expect(rowOf(wrapper, 's2').get('time').attributes('datetime')).toBe(sendAt)
+    })
+  })
+
+  describe('줄의 차례 · 미리 보기 (2026-11-06 실사용 시험)', () => {
+    it('보내기를 기다리는 메일은 받은 줄의 맨 끝 — 서버가 저장한 시각 차례로 주어도 그 뒤에 온 답장보다 앞에 서지 않는다', async () => {
+      const sendAt = new Date(2026, 10, 6, 23, 38).toISOString()
+      const scheduled = summary('s1', {
+        mailboxIds: ['sent'],
+        from: USER,
+        receivedAt: at(2026, 9, 29, 10, 0),
+        pendingSend: { kind: 'scheduled', sendAt },
+      })
+      serve({ conversation: () => page([ORIGINAL, scheduled, REPLY, CURRENT]) })
+      const { wrapper } = await mountReader()
+
+      expect(section(wrapper).findAll('ol > li').map((row) => row.attributes('data-conversation-row'))).toEqual([
+        'm1',
+        'm2',
+        'm3',
+        's1',
+      ])
+    })
+
+    it('미리 보기에서 우리 원문 인용("> 원본 메일")부터 뒤는 뺀다 — 남는 글이 없으면 제목', async () => {
+      serve({
+        conversation: () =>
+          page([
+            { ...ORIGINAL, preview: '도윤님, 금요일까지 정하겠습니다. > 원본 메일 > 보낸 사람: 이도윤' },
+            { ...REPLY, preview: '> 원본 메일 > 보낸 사람: 김아라 > 날짜: 2026. 10. 27.' },
+            CURRENT,
+          ]),
+      })
+      const { wrapper } = await mountReader()
+
+      expect(rowOf(wrapper, 'm1').get('.conversation-row__preview').text()).toBe('도윤님, 금요일까지 정하겠습니다.')
+      expect(rowOf(wrapper, 'm2').get('.conversation-row__preview').text()).toBe(REPLY.subject)
+    })
+  })
+
+  describe('펼치기 · 접기', () => {
+    it('다른 줄을 누르면 그 자리에서 펼친다 — 받는 사람 · 제목 · 본문(강조 쿼리 없이) · [답장] · [이 메일만 열기], 안 읽은 메일이면 읽음으로', async () => {
+      serve()
+      const { wrapper, store } = await mountReader()
+      const button = rowOf(wrapper, 'm2').get('button')
+
+      await button.trigger('click')
+      expect(button.attributes('aria-expanded')).toBe('true')
+      const panelId = button.attributes('aria-controls')
+      expect(panelId).toBe('conversation-panel-m2')
+      expect(rowOf(wrapper, 'm2').find('[data-conversation-detail-loading]').attributes('aria-busy')).toBe('true')
+      await flushPromises()
+
+      const panel = wrapper.get(`#${panelId}`)
+      expect(panel.findAll('.conversation-panel__meta').map((line) => line.text())).toEqual([
+        '받는 사람 김아라 <ara.kim@arasystem.test>',
+        '제목 회신: 유지보수 계약 갱신 건',
+      ])
+      const frame = panel.get('iframe')
+      expect(frame.attributes('srcdoc')).toContain('m2 본문')
+      expect(frame.attributes('title')).toBe('메일 본문: 이도윤, 10월 29일 (목) 오전 9:30')
+      expect(panel.get('[data-conversation-reply]').attributes('href')).toBe('/mail/compose?replyTo=m2')
+      expect(panel.get('[data-conversation-reply]').text()).toBe('답장')
+      expect(panel.get('[data-conversation-open]').attributes('href')).toBe('/mail/inbox/m2')
+      expect(panel.get('[data-conversation-open]').text()).toBe('이 메일만 열기')
+
+      expect(requests.find((request) => request.method === 'GET' && request.url === '/messages/m2')?.params).toEqual({})
+      expect(requests.filter((request) => request.method === 'PATCH').map((request) => [request.url, request.data])).toEqual([
+        ['/messages/m2', { isRead: true }],
+      ])
+      // 목록의 그 줄도 읽음으로 — 읽기 화면에서 연 것과 같은 길
+      expect(store.messages.find((message) => message.id === 'm2')?.isRead).toBe(true)
+
+      await button.trigger('click')
+      expect(button.attributes('aria-expanded')).toBe('false')
+      expect(wrapper.find(`#${panelId}`).exists()).toBe(false)
+    })
+
+    it('내가 보낸 메일의 [이 메일만 열기]는 그 메일이 든 보낸편지함으로 — 누르면 기록에 쌓아 옮긴다', async () => {
+      serve()
+      const { wrapper, router } = await mountReader()
+      const push = vi.spyOn(router, 'push')
+
+      await rowOf(wrapper, 'm1').get('button').trigger('click')
+      await flushPromises()
+      const open = rowOf(wrapper, 'm1').get('[data-conversation-open]')
+      expect(open.attributes('href')).toBe('/mail/sent/m1')
+
+      await open.trigger('click')
+      await flushPromises()
+      expect(push).toHaveBeenCalled()
+      expect(router.currentRoute.value.fullPath).toBe('/mail/sent/m1')
+    })
+
+    it('임시 저장본 · 예약한 메일에는 [답장]이 없다 — 임시 저장본의 [이 메일만 열기]는 쓰기 화면에서 이어 쓴다', async () => {
+      const sendAt = new Date(2026, 10, 7, 9, 0).toISOString()
+      const draft = summary('d1', { mailboxIds: ['drafts'], from: USER })
+      const scheduled = summary('s1', { mailboxIds: ['sent'], from: USER, pendingSend: { kind: 'scheduled', sendAt } })
+      serve({ conversation: () => page([...THREAD, draft, scheduled]) })
+      const { wrapper } = await mountReader()
+
+      expect(rowOf(wrapper, 'd1').get('.conversation-row__mailbox').text()).toBe('임시보관함')
+      await rowOf(wrapper, 'd1').get('button').trigger('click')
+      await rowOf(wrapper, 's1').get('button').trigger('click')
+      await flushPromises()
+
+      expect(rowOf(wrapper, 'd1').find('[data-conversation-reply]').exists()).toBe(false)
+      expect(rowOf(wrapper, 'd1').get('[data-conversation-open]').attributes('href')).toBe('/mail/compose?draft=d1')
+      expect(rowOf(wrapper, 's1').find('[data-conversation-reply]').exists()).toBe(false)
+      expect(rowOf(wrapper, 's1').get('[data-conversation-open]').attributes('href')).toBe('/mail/sent/s1')
+    })
+
+    it('첨부가 있으면 본문 아래 · [답장] 위에 "첨부 파일 N개는 [이 메일만 열기]를 누르면 볼 수 있습니다." — 본문 그림은 세지 않는다', async () => {
+      serve({
+        detail: (request) => {
+          const id = request.url.split('/').pop() ?? ''
+          const base = THREAD.find((item) => item.id === id) ?? summary(id)
+          if (id !== 'm2') return ok(detail(base))
+          return ok(
+            detail(base, {
+              attachments: [
+                { id: 'a1', name: '견적_수정안.csv', type: 'text/csv', size: 44 },
+                { id: 'a2', name: '단가표.xlsx', type: 'application/vnd.ms-excel', size: 9_000 },
+                { id: 'i1', name: 'logo.png', type: 'image/png', size: 1_200, isInline: true },
+              ],
+            }),
+          )
+        },
+      })
+      const { wrapper } = await mountReader()
+
+      await rowOf(wrapper, 'm2').get('button').trigger('click')
+      await rowOf(wrapper, 'm1').get('button').trigger('click')
+      await flushPromises()
+
+      const panel = rowOf(wrapper, 'm2').get('.conversation-panel')
+      const note = panel.get('[data-conversation-attachments]')
+      expect(note.text()).toBe('첨부 파일 2개는 [이 메일만 열기]를 누르면 볼 수 있습니다.')
+      // 본문 아래 · [답장] 위
+      const order = [...panel.element.children].map((child) => child.className.split(' ')[0])
+      expect(order.indexOf('conversation-panel__attachments')).toBe(order.indexOf('mail-body-frame') + 1)
+      expect(order.indexOf('conversation-panel__actions')).toBe(order.indexOf('conversation-panel__attachments') + 1)
+      // 첨부가 없는 메일에는 없다
+      expect(rowOf(wrapper, 'm1').find('[data-conversation-attachments]').exists()).toBe(false)
+    })
+
+    it('본문을 못 받으면 줄 안에 사전 문구 + [다시 시도] — 알리지 않는다', async () => {
+      let failing = true
+      serve({ detail: (request) => (failing ? fail(503, 'MAIL_001') : ok(detail(summary(request.url.split('/').pop() ?? '')))) })
+      const { wrapper } = await mountReader()
+
+      await rowOf(wrapper, 'm2').get('button').trigger('click')
+      await flushPromises()
+      const error = rowOf(wrapper, 'm2').get('[data-conversation-detail-error]')
+      expect(error.text()).toContain('메일 서비스에 연결할 수 없습니다.')
+      expect(useToastStore().toasts).toEqual([])
+      // 읽지 못했으니 읽음으로 바꾸지 않는다
+      expect(requests.some((request) => request.method === 'PATCH')).toBe(false)
+
+      failing = false
+      await error.get('button').trigger('click')
+      await flushPromises()
+      expect(rowOf(wrapper, 'm2').find('iframe').exists()).toBe(true)
+    })
+  })
+
+  describe('안 읽은 줄 (2026-11-07 사용자 관점 점검)', () => {
+    it('안 읽은 줄은 목록 줄처럼 굵게(is-unread) — 화면 낭독은 이름 앞에 목록과 같은 "안 읽음, ", 읽은 줄 · 임시 저장본은 아니다', async () => {
+      const draft = summary('d1', {
+        mailboxIds: ['drafts'],
+        from: { name: '김아라', email: USER.email },
+        isRead: false,
+        receivedAt: at(2026, 10, 6, 11, 0),
+      })
+      serve({ conversation: () => page([ORIGINAL, REPLY, CURRENT, draft]) })
+      const { wrapper } = await mountReader()
+
+      const unread = rowOf(wrapper, 'm2')
+      expect(unread.classes()).toContain('is-unread')
+      expect(unread.get('.conversation-row__who .visually-hidden').element.textContent).toBe('안 읽음, ')
+      // 펼침 단추의 이름에서 머리글자는 읽지 않으니(aria-hidden) "안 읽음, 이도윤 …"이 된다
+      expect(unread.get('.conversation-row__who').text()).toBe('안 읽음, 이도윤')
+      expect(unread.get('.conversation-row__avatar').attributes('aria-hidden')).toBe('true')
+      for (const id of ['m1', 'm3', 'd1']) {
+        expect(rowOf(wrapper, id).classes()).not.toContain('is-unread')
+        expect(rowOf(wrapper, id).find('.conversation-row__who .visually-hidden').exists()).toBe(false)
+      }
+    })
+
+    it('펼쳐 읽음이 되면 바로 굵기를 푼다 — 읽음으로 바꾸지 못하면 다시 굵게', async () => {
+      const reply = deferred()
+      serve({ patch: () => reply.promise })
+      const { wrapper } = await mountReader()
+      const row = () => rowOf(wrapper, 'm2')
+
+      await row().get('button').trigger('click')
+      await flushPromises()
+      // 본문을 받았고 읽음을 보내는 중 — 줄은 이미 읽은 모양
+      expect(requests.filter((request) => request.method === 'PATCH').map((request) => request.url)).toEqual([
+        '/messages/m2',
+      ])
+      expect(row().classes()).not.toContain('is-unread')
+      expect(row().find('.conversation-row__who .visually-hidden').exists()).toBe(false)
+
+      reply.resolve(fail(503, 'MAIL_001'))
+      await flushPromises()
+      expect(row().classes()).toContain('is-unread')
+      expect(row().get('.conversation-row__who').text()).toBe('안 읽음, 이도윤')
+    })
+
+    it('목록 · 여러 통 처리에서 바꾼 읽음 · 안 읽음도 줄에 바로 — 바꾸지 못한 메일은 줄도 되돌린다, 지금 보는 메일도 같다', async () => {
+      const first = deferred()
+      let firstBulk: Promise<MockResult> | null = first.promise
+      serve({
+        patch: (request) => {
+          if (request.url !== '/messages') return ok({ ...REPLY, isRead: true })
+          const reply = firstBulk ?? ok({ updatedIds: (request.data as { ids: string[] }).ids, failedIds: [] })
+          firstBulk = null
+          return reply
+        },
+      })
+      const { wrapper, store } = await mountReader()
+      expect(rowOf(wrapper, 'm2').classes()).toContain('is-unread')
+
+      // 목록에서 골라 읽음 표시 — 보내는 동안 줄도 읽은 모양, 서버가 바꾸지 못했으면 다시 굵게
+      store.toggleCheck('m2')
+      const marking = store.patchChecked({ isRead: true })
+      await flushPromises()
+      expect(rowOf(wrapper, 'm2').classes()).not.toContain('is-unread')
+      first.resolve(ok({ updatedIds: [], failedIds: ['m2'] }))
+      await marking
+      await flushPromises()
+      expect(rowOf(wrapper, 'm2').classes()).toContain('is-unread')
+
+      // 지금 보는 메일을 안 읽음으로 — 그 줄도 굵게 ("지금 보고 있는 메일" 줄)
+      store.clearChecked()
+      store.toggleCheck('m3')
+      await store.patchChecked({ isRead: false })
+      await flushPromises()
+      const current = rowOf(wrapper, 'm3')
+      expect(current.classes()).toContain('is-unread')
+      expect(current.get('[aria-current="true"] .conversation-row__who').text()).toBe('안 읽음, 이도윤')
+    })
+
+    it('다른 탭 · 기기에서 바꾼 읽음은 다음에 칸을 다시 받을 때 보인다 — 목록을 맞춰도 줄은 그대로', async () => {
+      let thread = THREAD
+      serve({ conversation: () => page(thread) })
+      const { wrapper, store } = await mountReader()
+
+      // 다른 탭에서 m2 를 읽었다 — 목록 맞추기가 서버의 값을 가져왔다 (이 탭이 바꾼 것이 아니다)
+      thread = [ORIGINAL, { ...REPLY, isRead: true }, CURRENT]
+      store.messages = [{ ...REPLY, isRead: true }, CURRENT]
+      await flushPromises()
+      expect(rowOf(wrapper, 'm2').classes()).toContain('is-unread')
+
+      // 다시 받으면(새 메일 · 지움 · 옮김으로 통 수가 바뀜 · 쓰기 화면에서 돌아옴) 보인다
+      await store.refreshConversation()
+      await flushPromises()
+      expect(rowOf(wrapper, 'm2').classes()).not.toContain('is-unread')
+    })
+  })
+
+  describe('받지 못했을 때 — 읽기 화면은 그대로', () => {
+    it('칸 자리에 "같은 대화를 불러오지 못했습니다." + [다시 시도] · 문의 코드 — 알리지 않는다, 누르면 다시 받는다', async () => {
+      let failing = true
+      serve({ conversation: () => (failing ? fail(503, 'MAIL_001') : page(THREAD)) })
+      const { wrapper } = await mountReader()
+
+      expect(wrapper.find('#reader-subject').exists()).toBe(true)
+      const notice = wrapper.get('[data-conversation-failed]')
+      expect(notice.text()).toContain('같은 대화를 불러오지 못했습니다.')
+      expect(notice.text()).toContain('문의 코드 3f1c0a2e')
+      expect(useToastStore().toasts).toEqual([])
+      // 화면 낭독용 상태 영역은 늘 있고 글만 바뀐다 — 안내 줄 자체에는 role 이 없다(두 번 읽지 않게)
+      expect(notice.attributes('role')).toBeUndefined()
+      const status = wrapper.get('[data-conversation-status]')
+      expect(status.attributes('role')).toBe('status')
+      expect(status.text()).toBe('같은 대화를 불러오지 못했습니다.')
+
+      failing = false
+      await notice.get('[data-conversation-retry]').trigger('click')
+      await flushPromises()
+      expect(wrapper.find('[data-conversation-failed]').exists()).toBe(false)
+      expect(section(wrapper).get('h3').text()).toBe('같은 대화 3통')
+      expect(wrapper.get('[data-conversation-status]').text()).toBe('')
+    })
+
+    it('없는 메일(404 RES_001 — 이 경로가 없는 옛 서버 포함) · 모양이 틀린 응답이면 칸 없이', async () => {
+      serve({ conversation: () => fail(404, 'RES_001') })
+      const missing = await mountReader()
+      expect(missing.wrapper.find('[data-conversation]').exists()).toBe(false)
+      expect(missing.wrapper.find('[data-conversation-failed]').exists()).toBe(false)
+      missing.wrapper.unmount()
+
+      setActivePinia((pinia = createPinia()))
+      useAuthStore().markAuthenticated(USER)
+      serve({ conversation: () => ok({ usedBytes: 0 }) })
+      const odd = await mountReader()
+      expect(odd.wrapper.find('[data-conversation]').exists()).toBe(false)
+      expect(odd.wrapper.find('[data-conversation-failed]').exists()).toBe(false)
+      expect(useToastStore().toasts).toEqual([])
+    })
+
+    it('보호 화면을 쓸 수 없는 세션(로그인 전 · 제한된 세션)에는 묻지 않는다', async () => {
+      useAuthStore().clearAuth()
+      serve()
+      await mountReader()
+      expect(conversationRequests()).toEqual([])
+    })
+
+    it('제한된 세션(새 비밀번호를 정하기 전 — 13단계)이면 묻지 않고, 제한이 풀리면 그때 받는다', async () => {
+      const auth = useAuthStore()
+      auth.markAuthenticated(USER, { restriction: 'passwordChange', twoFactorDeadline: null })
+      serve()
+      const { wrapper } = await mountReader()
+      expect(auth.canUseApp).toBe(false)
+      expect(conversationRequests()).toEqual([])
+
+      auth.markAuthenticated(USER)
+      await flushPromises()
+      expect(conversationRequests()).toHaveLength(1)
+      expect(section(wrapper).get('h3').text()).toBe('같은 대화 3통')
+    })
+  })
+
+  describe('다시 받기 — 바뀜 소식은 모아서 · 돌아오면 바로', () => {
+    it(`다시 받아 달라는 소식이 오면 다시 받는다 — 마지막으로 받기가 끝난 지 ${MAIL_CONVERSATION_REFRESH_GAP_MS}ms 안이면 그때까지 모아 한 번`, async () => {
+      let thread = THREAD
+      serve({ conversation: () => page(thread) })
+      const { wrapper, store } = await mountReader()
+      expect(conversationRequests()).toHaveLength(1)
+
+      clock.advance(1000)
+      store.requestConversationRefresh()
+      await flushPromises()
+      store.requestConversationRefresh()
+      await flushPromises()
+      expect(conversationRequests()).toHaveLength(1)
+
+      thread = [...THREAD, summary('m4', { mailboxIds: ['sent'], from: USER, receivedAt: at(2026, 10, 6, 14, 0) })]
+      clock.advance(MAIL_CONVERSATION_REFRESH_GAP_MS - 1000)
+      await flushPromises()
+      expect(conversationRequests()).toHaveLength(2)
+      expect(conversationRequests()[1]?.config.silent).toBe(true)
+      expect(section(wrapper).get('h3').text()).toBe('같은 대화 4통')
+
+      // 간격이 지난 뒤의 소식은 바로
+      clock.advance(MAIL_CONVERSATION_REFRESH_GAP_MS)
+      store.requestConversationRefresh()
+      await flushPromises()
+      expect(conversationRequests()).toHaveLength(3)
+    })
+
+    it('받아 둔 대화로 돌아오면(쓰기 화면에서 답장을 보내고) 보이는 채로 바로 다시 받는다', async () => {
+      serve()
+      const first = await mountReader()
+      first.wrapper.unmount()
+      expect(conversationRequests()).toHaveLength(1)
+
+      const back = mount(MessageReader, {
+        attachTo: document.body,
+        global: { plugins: [pinia, first.router], provide: { [CLOCK as symbol]: clock } },
+      })
+      mounted.push(back)
+      expect(back.find('[data-conversation]').exists()).toBe(true)
+      await flushPromises()
+
+      expect(conversationRequests()).toHaveLength(2)
+      expect(conversationRequests()[1]?.config.silent).toBe(true)
+    })
+
+    it('메일을 바꾸면 그 메일로 새로 받고, 앞 메일의 늦은 응답은 버린다', async () => {
+      const late = deferred()
+      serve({
+        conversation: ({ url }) =>
+          url === '/messages/m3/conversation' ? late.promise : page([summary('x1'), summary('x2', { subject: '다른 대화' })]),
+      })
+      const { wrapper, store } = await mountReader()
+
+      store.selected = detail(summary('x2', { subject: '다른 대화' }))
+      store.selectedId = 'x2'
+      await flushPromises()
+      late.resolve(page(THREAD))
+      await flushPromises()
+
+      expect(conversationRequests().map((request) => request.url)).toEqual([
+        '/messages/m3/conversation',
+        '/messages/x2/conversation',
+      ])
+      expect(section(wrapper).findAll('ol > li').map((row) => row.attributes('data-conversation-row'))).toEqual(['x1', 'x2'])
+    })
+  })
+
+  describe('검색 결과에서 연 메일 (/mail/search/:id)', () => {
+    it('칸이 보이지만 강조가 없다 — 대화 · 펼친 본문 모두 검색 쿼리 없이 받는다', async () => {
+      serve()
+      const { wrapper, store } = await mountReader({
+        path: `/mail/search/m3?q=${encodeURIComponent('계약')}&in=all`,
+        source: { kind: 'search', q: '계약', scope: 'all' },
+      })
+      store.selectedHighlight = { q: '계약' }
+
+      expect(section(wrapper).get('h3').text()).toBe('같은 대화 3통')
+      expect(conversationRequests()[0]?.params).toEqual({ limit: MAIL_CONVERSATION_PAGE_SIZE })
+
+      await rowOf(wrapper, 'm2').get('button').trigger('click')
+      await flushPromises()
+      expect(requests.find((request) => request.method === 'GET' && request.url === '/messages/m2')?.params).toEqual({})
+      expect(section(wrapper).findAll('mark')).toHaveLength(0)
+      // 받아 둔 결과에 있는 메일은 검색 결과 안에서 연다
+      expect(rowOf(wrapper, 'm2').get('[data-conversation-open]').attributes('href')).toBe(
+        `/mail/search/m2?q=${encodeURIComponent('계약')}&in=all`,
+      )
+    })
+  })
+
+  describe('초점 — 누른 단추 · 초점이 있던 줄이 다시 그리며 사라지면', () => {
+    const focusOn = (element: Element) => (element as HTMLElement).focus()
+
+    it('칸의 [다시 시도] — 또 못 받으면 새로 그린 [다시 시도]로, 받으면(받는 동안은 기다렸다가) 칸 제목(h3)으로', async () => {
+      let failing = true
+      const retried = deferred()
+      serve({ conversation: () => (failing ? fail(503, 'MAIL_001') : retried.promise) })
+      const { wrapper } = await mountReader()
+
+      focusOn(wrapper.get('[data-conversation-retry]').element)
+      await wrapper.get('[data-conversation-retry]').trigger('click')
+      await flushPromises()
+      expect(document.activeElement).toBe(wrapper.get('[data-conversation-retry]').element)
+
+      failing = false
+      focusOn(wrapper.get('[data-conversation-retry]').element)
+      await wrapper.get('[data-conversation-retry]').trigger('click')
+      await flushPromises()
+      expect(document.activeElement).toBe(document.body)
+
+      retried.resolve(page(THREAD))
+      await flushPromises()
+      expect(document.activeElement).toBe(section(wrapper).get('h3').element)
+    })
+
+    it('[더 보기] — 받는 동안은 그 단추에 남고(aria-busy), 마지막 쪽을 받아 단추가 사라지면 칸 제목으로', async () => {
+      const full = Array.from({ length: MAIL_CONVERSATION_PAGE_SIZE - 1 }, (_, index) => summary(`p${index}`))
+      serve({
+        conversation: ({ params }) => (params.cursor ? page([REPLY], null, null) : page([...full, CURRENT], 'c2', null)),
+      })
+      const { wrapper } = await mountReader()
+      const more = wrapper.get('[data-conversation-more]')
+
+      focusOn(more.element)
+      await more.trigger('click')
+      expect(document.activeElement).toBe(more.element)
+      await flushPromises()
+
+      expect(wrapper.find('[data-conversation-more]').exists()).toBe(false)
+      expect(document.activeElement).toBe(section(wrapper).get('h3').element)
+    })
+
+    it('펼친 줄의 [다시 시도] — 본문을 받으면 그 줄의 펼침 단추로', async () => {
+      let failing = true
+      serve({
+        detail: (request) => (failing ? fail(503, 'MAIL_001') : ok(detail(summary(request.url.split('/').pop() ?? '')))),
+      })
+      const { wrapper } = await mountReader()
+      await rowOf(wrapper, 'm2').get('[data-conversation-toggle]').trigger('click')
+      await flushPromises()
+
+      failing = false
+      const retry = rowOf(wrapper, 'm2').get('[data-conversation-detail-error] button')
+      focusOn(retry.element)
+      await retry.trigger('click')
+      await flushPromises()
+
+      expect(rowOf(wrapper, 'm2').find('iframe').exists()).toBe(true)
+      expect(document.activeElement).toBe(rowOf(wrapper, 'm2').get('[data-conversation-toggle]').element)
+    })
+
+    it('다시 받아 초점이 있던 줄이 빠지면 칸 제목으로, 칸이 없어지면(한 통만 남음) 읽기 화면의 본문으로', async () => {
+      let thread = THREAD
+      serve({ conversation: () => page(thread) })
+      const { wrapper, store } = await mountReader()
+      async function refreshWith(next: MessageSummary[]) {
+        thread = next
+        clock.advance(MAIL_CONVERSATION_REFRESH_GAP_MS)
+        store.requestConversationRefresh()
+        await flushPromises()
+      }
+
+      focusOn(rowOf(wrapper, 'm2').get('[data-conversation-toggle]').element)
+      await refreshWith([ORIGINAL, CURRENT])
+      expect(wrapper.find('[data-conversation-row="m2"]').exists()).toBe(false)
+      expect(document.activeElement).toBe(section(wrapper).get('h3').element)
+
+      focusOn(rowOf(wrapper, 'm1').get('[data-conversation-toggle]').element)
+      await refreshWith([CURRENT])
+      expect(wrapper.find('[data-conversation]').exists()).toBe(false)
+      expect(document.activeElement).toBe(wrapper.get('.reader__content iframe').element)
+    })
+
+    it('초점이 칸 밖에 있으면 다시 받아 줄이 빠져도 건드리지 않는다', async () => {
+      let thread = THREAD
+      serve({ conversation: () => page(thread) })
+      const { wrapper, store } = await mountReader()
+      const star = wrapper.get('.reader__star')
+      focusOn(star.element)
+
+      thread = [ORIGINAL, CURRENT]
+      clock.advance(MAIL_CONVERSATION_REFRESH_GAP_MS)
+      store.requestConversationRefresh()
+      await flushPromises()
+
+      expect(wrapper.find('[data-conversation-row="m2"]').exists()).toBe(false)
+      expect(document.activeElement).toBe(star.element)
+    })
+  })
+
+  describe('다시 받기의 때 — 받는 중에 온 소식 · 시계가 뒤로 감', () => {
+    it('처음 받는 중에 온 소식은 버리지 않는다 — 받기가 끝난 때부터 간격을 세어 한 번 더 받는다', async () => {
+      const first = deferred()
+      let calls = 0
+      serve({
+        conversation: () => {
+          calls += 1
+          return calls === 1 ? first.promise : page(THREAD)
+        },
+      })
+      const { store } = await mountReader()
+      store.requestConversationRefresh()
+      await flushPromises()
+      expect(conversationRequests()).toHaveLength(1)
+
+      // 받는 동안 흐른 시간은 세지 않는다
+      clock.advance(MAIL_CONVERSATION_REFRESH_GAP_MS)
+      first.resolve(page(THREAD))
+      await flushPromises()
+      expect(conversationRequests()).toHaveLength(1)
+
+      clock.advance(MAIL_CONVERSATION_REFRESH_GAP_MS - 1)
+      await flushPromises()
+      expect(conversationRequests()).toHaveLength(1)
+      clock.advance(1)
+      await flushPromises()
+      expect(conversationRequests()).toHaveLength(2)
+    })
+
+    it('이 PC 시계가 뒤로 가도 간격보다 오래 기다리지 않는다', async () => {
+      let offset = 0
+      const skewed: Clock = {
+        now: () => clock.now() + offset,
+        setTimeout: (callback, ms) => clock.setTimeout(callback, ms),
+        clearTimeout: (timer) => clock.clearTimeout(timer),
+      }
+      serve()
+      const { store } = await mountReader({ clock: skewed })
+
+      offset = -60 * 60 * 1000
+      store.requestConversationRefresh()
+      await flushPromises()
+      expect(conversationRequests()).toHaveLength(1)
+
+      clock.advance(MAIL_CONVERSATION_REFRESH_GAP_MS)
+      await flushPromises()
+      expect(conversationRequests()).toHaveLength(2)
+    })
+  })
+
+  describe('펼친 줄의 본문 안내 · 그사이 지워진 메일', () => {
+    it('서식을 뺐거나 잘린 본문이면 읽기 화면과 같은 안내 줄을 본문 위에 둔다', async () => {
+      serve({ detail: () => ok(detail(REPLY, { isHtmlBodyOmitted: true, isBodyTruncated: true, textBody: '글자 본문' })) })
+      const { wrapper } = await mountReader()
+
+      await rowOf(wrapper, 'm2').get('[data-conversation-toggle]').trigger('click')
+      await flushPromises()
+
+      const row = rowOf(wrapper, 'm2')
+      expect(row.findAll('[data-notice]').map((notice) => [notice.attributes('data-notice'), notice.text()])).toEqual([
+        ['htmlOmitted', MAIL_BODY_NOTICES.htmlOmitted],
+        ['truncated', MAIL_BODY_NOTICES.truncated],
+      ])
+      expect(row.find('iframe').exists()).toBe(true)
+    })
+
+    it('본문이 404 RES_001(그사이 지워짐)이면 [다시 시도] · [답장] · [이 메일만 열기] 없이 알리고, 대화를 다시 받아 그 줄을 뺀다', async () => {
+      const refreshed = deferred()
+      let calls = 0
+      serve({
+        conversation: () => {
+          calls += 1
+          return calls === 1 ? page(THREAD) : refreshed.promise
+        },
+        detail: () => fail(404, 'RES_001'),
+      })
+      const { wrapper } = await mountReader()
+
+      await rowOf(wrapper, 'm2').get('[data-conversation-toggle]').trigger('click')
+      await flushPromises()
+      const row = rowOf(wrapper, 'm2')
+      expect(row.get('[data-conversation-detail-error]').text()).toContain(ERROR_CODE_MESSAGES.RES_001)
+      expect(row.find('[data-conversation-detail-error] button').exists()).toBe(false)
+      expect(row.find('[data-conversation-reply]').exists()).toBe(false)
+      expect(row.find('[data-conversation-open]').exists()).toBe(false)
+      expect(row.get('[data-conversation-detail-status]').text()).toBe(ERROR_CODE_MESSAGES.RES_001)
+      expect(conversationRequests()).toHaveLength(2)
+
+      refreshed.resolve(page([ORIGINAL, CURRENT]))
+      await flushPromises()
+      expect(wrapper.find('[data-conversation-row="m2"]').exists()).toBe(false)
+      expect(section(wrapper).get('h3').text()).toBe('같은 대화 2통')
+      expect(useToastStore().toasts).toEqual([])
+    })
+  })
+
+  describe('펼친 본문 안의 Ctrl+P — 그 펼친 메일의 인쇄 화면', () => {
+    it('펼친 본문 안에서 누른 Ctrl+P 는 읽기 화면의 메일이 아니라 펼친 메일의 인쇄 화면을 연다 — 다른 글쇠와 함께면 브라우저에 맡긴다', async () => {
+      const opened: unknown[][] = []
+      vi.spyOn(window, 'open').mockImplementation((...args: unknown[]) => {
+        opened.push(args)
+        return null
+      })
+      serve()
+      const { wrapper } = await mountReader()
+      await rowOf(wrapper, 'm2').get('[data-conversation-toggle]').trigger('click')
+      await flushPromises()
+
+      const frame = rowOf(wrapper, 'm2').get('iframe').element as HTMLIFrameElement
+      frame.dispatchEvent(new Event('load'))
+      const press = new KeyboardEvent('keydown', { key: 'p', ctrlKey: true, bubbles: true, cancelable: true })
+      frame.contentDocument?.dispatchEvent(press)
+      expect(press.defaultPrevented).toBe(true)
+      expect(opened).toEqual([['/mail/print/m2', '_blank', 'noopener']])
+
+      const withShift = new KeyboardEvent('keydown', { key: 'p', ctrlKey: true, shiftKey: true, bubbles: true, cancelable: true })
+      frame.contentDocument?.dispatchEvent(withShift)
+      expect(withShift.defaultPrevented).toBe(false)
+      expect(opened).toHaveLength(1)
+    })
+  })
+
+  describe('[이 메일만 열기] — 분할 보기는 기록에 쌓고, 목록 보기는 이전 · 다음처럼 바꿔 끼운다', () => {
+    it.each([
+      ['split', 'push'],
+      ['list', 'replace'],
+    ] as const)('%s 보기 → router.%s', async (layout, method) => {
+      serve()
+      const { wrapper, router } = await mountReader({ layout })
+      const push = vi.spyOn(router, 'push')
+      const replace = vi.spyOn(router, 'replace')
+      await rowOf(wrapper, 'm2').get('[data-conversation-toggle]').trigger('click')
+      await flushPromises()
+
+      await rowOf(wrapper, 'm2').get('[data-conversation-open]').trigger('click')
+      await flushPromises()
+
+      expect(router.currentRoute.value.fullPath).toBe('/mail/inbox/m2')
+      expect(method === 'push' ? push : replace).toHaveBeenCalled()
+      expect(method === 'push' ? replace : push).not.toHaveBeenCalled()
+    })
+  })
+})
diff --git a/frontend/src/components/mail/MessageConversation.vue b/frontend/src/components/mail/MessageConversation.vue
new file mode 100644
index 0000000..c7c78e4
--- /dev/null
+++ b/frontend/src/components/mail/MessageConversation.vue
@@ -0,0 +1,308 @@
+<script setup lang="ts">
+// 읽기 화면의 "같은 대화" 칸 (14단계 — 디자인 원본 Thread14 · README "읽기 화면 — 같은 대화", 계약 2절 "대화 — 14단계")
+// - 본문 · 첨부 아래 "같은 대화 N통" — N 은 total, 모르면 다 받았을 때의 받은 수, 그것도 모르면 수 없이 "같은 대화". 한 통뿐이면 칸이 없다
+// - 테두리 상자 안의 줄(ConversationMessageRow — 48), 오래된 차례. 지금 보는 메일의 줄은 "지금 보고 있는 메일"이고 다른 줄은 그 자리에서 펼친다
+// - 안 읽은 줄은 목록 줄처럼 굵게(2026-11-07). 이 탭에서 바꾼 읽음은 바로 바뀌고, 다른 탭 · 기기에서 바꾼 것은 다음에 받을 때 보인다(stores/mail/conversation.ts)
+// - 받을 쪽이 남았으면 상자 아래 [더 보기](44) — 받는 동안 "불러오는 중…"(aria-busy, 초점을 잃지 않게 꺼짐 없이)
+// - 받지 못하면 칸 자리에 "같은 대화를 불러오지 못했습니다." + [다시 시도] — 읽기 화면은 그대로다. 없는 메일(RES_001)이면 칸 없이.
+//   화면 낭독용 상태 영역은 늘 두고 글만 바꾼다(나중에 생긴 영역은 읽어 주지 않는다)
+// - 검색 결과에서 연 메일에도 보이지만 칸 안의 줄 · 본문에는 검색 강조를 넣지 않는다
+// - 초점: 누른 단추 · 초점이 있던 줄이 다시 그리며 사라지면(받은 [다시 시도] · 마지막 쪽을 받은 [더 보기] · 펼친 줄의 [다시 시도] ·
+//   다시 받아 빠진 줄) 그 줄이 남았으면 그 줄의 펼침 단추로, 아니면 칸 제목(h3 — tabindex -1)으로. 받는 중이면 다 받을 때까지 기다리고,
+//   칸이 없어졌으면 읽기 화면에 맡긴다(settled — 본문으로). 초점이 칸 밖에 있었으면 건드리지 않는다
+// 받는 때(메일이 바뀜 · 쓰기 화면에서 돌아옴 · 메일함들의 통 수가 바뀜을 모아서)는 useConversationSync 가 정한다
+import { computed, nextTick, ref, watch } from 'vue'
+
+import AppIcon from '@/components/AppIcon.vue'
+import ConversationMessageRow from '@/components/mail/ConversationMessageRow.vue'
+import { useClock } from '@/composables/useClock'
+import { useConversationSync } from '@/composables/useConversationSync'
+import { MAIL_CONVERSATION_TEXT } from '@/shared/constants/mail-conversation'
+import { formatCount, formatTraceCode } from '@/shared/utils/format'
+import { conversationRowsOf } from '@/shared/utils/mail-conversation'
+import { useAuthStore } from '@/stores/auth.store'
+import { useMailStore } from '@/stores/mail.store'
+
+interface Props {
+  /** 읽기 화면에 연 메일 */
+  messageId: string
+  /** split: 분할 보기 · list: 목록 보기 — [이 메일만 열기]를 기록에 쌓을지(목록 보기는 바꿔 끼운다) */
+  layout?: 'split' | 'list'
+}
+
+interface Emits {
+  /** 초점이 있던 칸이 없어졌다 — 읽기 화면이 초점을 옮긴다 (본문으로) */
+  (e: 'settled'): void
+}
+
+const props = withDefaults(defineProps<Props>(), {
+  layout: 'split',
+})
+const emit = defineEmits<Emits>()
+
+const mailStore = useMailStore()
+const authStore = useAuthStore()
+const clock = useClock()
+useConversationSync({ messageId: () => props.messageId, clock })
+
+const sectionRef = ref<HTMLElement | null>(null)
+const titleRef = ref<HTMLHeadingElement | null>(null)
+const failureRef = ref<HTMLElement | null>(null)
+/** 화면 낭독용 상태 — 받지 못했을 때의 안내 (영역은 늘 있다) */
+const announcement = ref<string>('')
+
+/** 칸이 이 메일의 대화를 가리킬 때만 그린다 — 메일을 바꾼 직후 앞 메일의 대화가 잠깐 보이지 않게 */
+const forThisMessage = computed(() => mailStore.conversationMessageId === props.messageId)
+const visible = computed(() => forThisMessage.value && mailStore.conversationVisible)
+const failed = computed(() => forThisMessage.value && mailStore.conversationFailed)
+const showMore = computed(() => mailStore.hasMoreConversation || mailStore.conversationLoadingMore)
+const title = computed(() => {
+  const count = mailStore.conversationCount
+  return count === null ? MAIL_CONVERSATION_TEXT.title : MAIL_CONVERSATION_TEXT.titleCount(formatCount(count))
+})
+const traceCode = computed(() => formatTraceCode(mailStore.conversationError?.traceId))
+const listedIds = computed<ReadonlySet<string>>(() => new Set(mailStore.listedSummaries.map((message) => message.id)))
+const rows = computed(() =>
+  conversationRowsOf(mailStore.conversationItems, {
+    currentId: props.messageId,
+    me: authStore.user,
+    mailboxes: mailStore.mailboxes,
+    source: mailStore.listSource,
+    listedIds: listedIds.value,
+    now: new Date(clock.now()),
+  }),
+)
+
+function loadMore() {
+  if (!mailStore.conversationLoadingMore) void mailStore.loadMoreConversation()
+}
+
+// ── 초점 지키기 ─────────────────────────────────────────
+
+/** 다시 그릴 때 바뀌는 것 — 칸 · 안내 · [더 보기] · 줄 · 펼친 줄과 그 본문의 상태 */
+const renderKey = computed(() => {
+  const details = mailStore.conversationDetails
+  const expanded = [...mailStore.conversationExpandedIds].map((id) => `${id}=${details.get(id)?.status ?? ''}`)
+  return [
+    visible.value,
+    failed.value,
+    showMore.value,
+    mailStore.conversationStatus,
+    mailStore.conversationItems.map((item) => item.id).join(','),
+    expanded.join(','),
+  ].join('|')
+})
+
+/** 칸 안에서 잃은 초점 — 초점이 있던 줄(없으면 null). 받는 중이면 다 받을 때까지 남는다 */
+let lostFocus: { rowId: string | null } | null = null
+
+function isInside(element: Element | null): boolean {
+  if (!element) return false
+  return Boolean(sectionRef.value?.contains(element) || failureRef.value?.contains(element))
+}
+
+function rowToggle(rowId: string): HTMLElement | null {
+  const rowElement = [...(sectionRef.value?.querySelectorAll<HTMLElement>('[data-conversation-row]') ?? [])].find(
+    (element) => element.dataset.conversationRow === rowId,
+  )
+  return rowElement?.querySelector<HTMLElement>('[data-conversation-toggle]') ?? null
+}
+
+/** 그린 뒤 — 초점을 잃었으면(body) 갈 곳으로 옮긴다 */
+function settleFocus() {
+  if (!lostFocus) return
+  const active = document.activeElement
+  if (active !== null && active !== document.body) {
+    // 초점이 남아 있거나 사용자가 다른 곳으로 옮겼다
+    lostFocus = null
+    return
+  }
+  const target =
+    (lostFocus.rowId ? rowToggle(lostFocus.rowId) : null) ??
+    failureRef.value?.querySelector<HTMLElement>('[data-conversation-retry]') ??
+    titleRef.value
+  if (target) {
+    lostFocus = null
+    target.focus()
+    return
+  }
+  // 받는 중 — 칸이 다시 생길 때까지 기다린다
+  if (mailStore.conversationStatus === 'loading' && forThisMessage.value) return
+  lostFocus = null
+  emit('settled')
+}
+
+// 그리기 전에 초점이 칸 안에 있었는지 적어 둔다 (pre — 아직 옛 화면이다)
+watch(
+  renderKey,
+  () => {
+    const active = document.activeElement
+    if (isInside(active)) {
+      const row = active?.closest<HTMLElement>('[data-conversation-row]')
+      lostFocus = { rowId: row?.dataset.conversationRow ?? null }
+    }
+    void nextTick(settleFocus)
+  },
+  { flush: 'pre' },
+)
+
+// 받지 못했을 때만 읽어 준다 — 비웠다가 넣어 다시 못 받아도 다시 읽게
+watch(failed, async (isFailed) => {
+  announcement.value = ''
+  if (!isFailed) return
+  await nextTick()
+  announcement.value = MAIL_CONVERSATION_TEXT.loadFailed
+})
+</script>
+
+<template>
+  <section
+    v-if="visible"
+    ref="sectionRef"
+    class="conversation"
+    aria-labelledby="reader-conversation-title"
+    data-conversation
+  >
+    <h3
+      id="reader-conversation-title"
+      ref="titleRef"
+      class="conversation__title"
+      tabindex="-1"
+    >
+      {{ title }}
+    </h3>
+    <ol class="conversation__list">
+      <ConversationMessageRow
+        v-for="row in rows"
+        :key="row.message.id"
+        :row="row"
+        :layout="layout"
+        :expanded="mailStore.conversationExpandedIds.has(row.message.id)"
+        :detail="mailStore.conversationDetails.get(row.message.id) ?? null"
+        @toggle="mailStore.toggleConversationMessage"
+        @retry-detail="mailStore.retryConversationDetail"
+      />
+    </ol>
+    <div
+      v-if="showMore"
+      class="conversation__more"
+    >
+      <button
+        type="button"
+        class="conversation__text-button"
+        :aria-busy="mailStore.conversationLoadingMore"
+        data-conversation-more
+        @click="loadMore"
+      >
+        {{ mailStore.conversationLoadingMore ? MAIL_CONVERSATION_TEXT.moreBusy : MAIL_CONVERSATION_TEXT.more }}
+      </button>
+    </div>
+  </section>
+
+  <div
+    v-else-if="failed"
+    ref="failureRef"
+    class="conversation conversation--failed"
+    data-conversation-failed
+  >
+    <p class="conversation__failure">
+      <AppIcon
+        name="alert-circle"
+        class="conversation__failure-icon"
+      />
+      <span>{{ MAIL_CONVERSATION_TEXT.loadFailed }}</span>
+      <button
+        type="button"
+        class="conversation__text-button"
+        data-conversation-retry
+        @click="mailStore.retryConversation()"
+      >
+        {{ MAIL_CONVERSATION_TEXT.retry }}
+      </button>
+      <span
+        v-if="traceCode"
+        class="conversation__trace"
+      >{{ MAIL_CONVERSATION_TEXT.traceCode(traceCode) }}</span>
+    </p>
+  </div>
+
+  <p
+    class="visually-hidden"
+    role="status"
+    data-conversation-status
+  >
+    {{ announcement }}
+  </p>
+</template>
+
+<style scoped>
+/* 첨부 칸과 같은 칸 머리 — 위 선 · 12.5px 회색 제목 (디자인 원본 Thread14) */
+.conversation {
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-8);
+  padding-top: var(--space-16);
+  border-top: var(--border-width) solid var(--color-border-subtle);
+}
+
+.conversation__title {
+  margin: 0;
+  outline-offset: var(--focus-ring-offset);
+  font-size: var(--font-size-label);
+  font-weight: 600;
+  color: var(--color-text-secondary);
+}
+
+/* 테두리 상자 — 줄 사이는 옅은 선 (ConversationMessageRow) */
+.conversation__list {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+  border: var(--border-width) solid var(--color-border);
+  border-radius: var(--radius-md);
+  overflow: hidden;
+}
+
+.conversation__more {
+  display: flex;
+}
+
+/* [더 보기] · [다시 시도] 44 — 글자 단추 */
+.conversation__text-button {
+  min-height: var(--size-touch);
+  padding: 0 var(--space-12);
+  border: 0;
+  border-radius: var(--radius-md);
+  background: transparent;
+  color: var(--color-brand);
+  font-weight: 600;
+}
+
+.conversation__text-button:hover {
+  background: var(--color-brand-subtle);
+}
+
+.conversation__text-button[aria-busy='true'] {
+  color: var(--color-text-muted);
+}
+
+.conversation__failure {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: var(--space-4) var(--space-8);
+  margin: 0;
+  font-size: var(--font-size-label);
+  color: var(--color-text-secondary);
+}
+
+.conversation__failure-icon {
+  color: var(--color-danger);
+}
+
+.conversation__trace {
+  font-size: var(--font-size-small);
+  color: var(--color-text-muted);
+  font-variant-numeric: tabular-nums;
+}
+</style>
diff --git a/frontend/src/components/mail/MessageList.vue b/frontend/src/components/mail/MessageList.vue
index 35e6ed7..33975be 100644
--- a/frontend/src/components/mail/MessageList.vue
+++ b/frontend/src/components/mail/MessageList.vue
@@ -2,13 +2,17 @@
 // 분할 보기의 목록 칸 — 2줄 행 (디자인 원본 Main 가운데 · Search 왼쪽 · ListStates "분할 보기에서 여러 통 고르기")
 // 머리 · 상태(불러오는 중 · 못 불러옴 · 빈 메일함 · 검색 결과 없음) · 메일 더 보기는 목록 틀(MailListFrame)이 맡는다.
 // 목록은 메일함 또는 검색 결과다 — 행 규칙은 useMailListRows.
+// 대화로 묶은 메일함(14단계 — 디자인 원본 ListThreads14)은 한 줄이 대화 하나다 — 줄 규칙은 useConversationRows, 줄은 ConversationListItem
+import ConversationListItem from '@/components/mail/ConversationListItem.vue'
 import MailListFrame from '@/components/mail/MailListFrame.vue'
 import MessageListItem from '@/components/mail/MessageListItem.vue'
+import { useConversationRows } from '@/composables/useConversationRows'
 import { useMailListRows } from '@/composables/useMailListRows'
 import { useMailStore } from '@/stores/mail.store'
 
 const mailStore = useMailStore()
 const rows = useMailListRows()
+const conversationRows = useConversationRows()
 
 /** Shift 면 범위, 아니면 하나 */
 function onCheck(id: string, range: boolean) {
@@ -24,20 +28,40 @@ function onCheck(id: string, range: boolean) {
     title-id="message-list-title"
   >
     <ul class="message-list__items">
-      <MessageListItem
-        v-for="message in mailStore.messages"
-        :key="message.id"
-        :message="message"
-        :to="rows.locationOf(message)"
-        :role="rows.roleOf(message)"
-        :mixed="rows.mixed.value"
-        :mailbox-name="rows.mailboxNameOf(message)"
-        :selected="message.id === mailStore.selectedId"
-        :checked="mailStore.checkedIds.has(message.id)"
-        :checking="mailStore.checkedCount > 0"
-        @toggle-flag="mailStore.toggleFlag"
-        @check="onCheck"
-      />
+      <template v-if="mailStore.isConversationList">
+        <ConversationListItem
+          v-for="row in mailStore.conversations"
+          :key="row.id"
+          :row="row"
+          :who="conversationRows.whoOf(row, 'split')"
+          :to="conversationRows.locationOf(row)"
+          :unread="conversationRows.isUnread(row)"
+          :draft="conversationRows.isDraft.value"
+          :held="conversationRows.isHeld(row)"
+          :selected="conversationRows.isSelected(row)"
+          :checked="mailStore.checkedIds.has(row.id)"
+          :checking="mailStore.checkedCount > 0"
+          @toggle-flag="conversationRows.toggleFlag"
+          @check="onCheck"
+        />
+      </template>
+      <template v-else>
+        <MessageListItem
+          v-for="message in mailStore.messages"
+          :key="message.id"
+          :message="message"
+          :to="rows.locationOf(message)"
+          :role="rows.roleOf(message)"
+          :mixed="rows.mixed.value"
+          :mailbox-name="rows.mailboxNameOf(message)"
+          :selected="message.id === mailStore.selectedId"
+          :checked="mailStore.checkedIds.has(message.id)"
+          :checking="mailStore.checkedCount > 0"
+          :search="Boolean(mailStore.search)"
+          @toggle-flag="mailStore.toggleFlag"
+          @check="onCheck"
+        />
+      </template>
     </ul>
   </MailListFrame>
 </template>
diff --git a/frontend/src/components/mail/MessageListItem.vue b/frontend/src/components/mail/MessageListItem.vue
index 62177db..cbec462 100644
--- a/frontend/src/components/mail/MessageListItem.vue
+++ b/frontend/src/components/mail/MessageListItem.vue
@@ -3,6 +3,8 @@
 // 보낸 사람 자리 · 읽음 표시 · 누르면 갈 곳은 메일함 규칙을 따른다 (mail-list-row.ts — 임시보관함은 받는 사람 · 쓰기 화면에서 이어 쓰기)
 // 전체 메일함 검색 결과면 첫 줄 시각 앞에 "보낸편지함 ·" (디자인 원본 Search)
 // 아직 보내지 않은 내 메일(9단계)은 시각 자리에 "예약 · 10월 30일 오전 9:00" · "보내는 중"(청록 — 디자인 원본 MailSendLater)
+// 검색 결과(14단계 — 디자인 원본 Search14)는 세 줄(최소 64): 보낸 사람 · 시각 / 제목(+ 첨부) / 미리 보기 한 줄.
+//   서버가 준 searchHighlight 의 위치로 제목 · 미리 보기의 맞은 말을 <mark>(HighlightedText — v-html 없음)로 그린다. 강조가 없으면(엔진 방식) 글 그대로
 // 여러 통 고르기 (디자인 원본 ListStates "분할 보기에서 여러 통 고르기"):
 // - 마우스를 올리거나 초점이 가면 왼쪽 36px 에 고르기 상자가 나타나고, 하나라도 고르면 모든 행에 보인다 (숨긴 동안에도 Tab 으로 닿는다)
 // - 행을 누르면 지금처럼 메일을 연다. Ctrl(⌘)+클릭은 하나씩, Shift+클릭은 범위로 고른다 (새 탭 · 새 창으로 열지 않는다)
@@ -12,16 +14,17 @@ import { computed } from 'vue'
 import type { RouteLocationRaw } from 'vue-router'
 
 import AppIcon from '@/components/AppIcon.vue'
+import HighlightedText from '@/components/mail/HighlightedText.vue'
 import MailCheckbox from '@/components/mail/MailCheckbox.vue'
 import { MAIL_BULK_TEXT, MAIL_NO_SUBJECT } from '@/shared/constants/mail'
 import { SEND_LATER_TEXT } from '@/shared/constants/mail-send-later'
-import type { MailboxRole, MessageSummary } from '@/shared/types/mail'
+import type { MailboxRole, MessageListItem } from '@/shared/types/mail'
 import { formatMailListTime } from '@/shared/utils/format'
 import { isDraftRole, isRowUnread, pendingSendLabel, rowWho } from '@/shared/utils/mail-list-row'
 import { isHeldMessage } from '@/shared/utils/pending-send'
 
 interface Props {
-  message: MessageSummary
+  message: MessageListItem
   /** 누르면 갈 곳 — 임시 저장본은 쓰기 화면, 그 밖은 읽기 화면 */
   to: RouteLocationRaw
   /** 이 행의 메일함 역할 — 보낸 사람 자리 · 읽음 표시 규칙 */
@@ -36,6 +39,8 @@ interface Props {
   checked?: boolean
   /** 하나라도 골랐다 — 모든 행에 고르기 상자를 보인다 */
   checking?: boolean
+  /** 검색 결과의 줄 — 미리 보기 줄을 더하고 맞은 말을 강조한다 (14단계) */
+  search?: boolean
 }
 
 interface Emits {
@@ -50,6 +55,7 @@ const props = withDefaults(defineProps<Props>(), {
   selected: false,
   checked: false,
   checking: false,
+  search: false,
 })
 
 const emit = defineEmits<Emits>()
@@ -63,6 +69,11 @@ const unread = computed(() => isRowUnread(props.message, props.role))
 const draft = computed(() => isDraftRole(props.role))
 /** 아직 보내지 않은 메일 — 고를 수 없다 */
 const held = computed(() => isHeldMessage(props.message))
+/** 검색 강조 (14단계) — 제목이 비었으면 "(제목 없음)"에는 강조가 없다 */
+const subjectRanges = computed(() => (props.message.subject ? (props.message.searchHighlight?.subject ?? null) : null))
+/** 검색 결과의 미리 보기 — 본문에서 맞았으면 맞은 말 둘레, 아니면 미리 보기 */
+const preview = computed(() => props.message.searchHighlight?.preview.text ?? props.message.preview)
+const previewRanges = computed(() => props.message.searchHighlight?.preview.ranges ?? null)
 
 /**
  * Ctrl(⌘) · Shift + 클릭은 메일을 열지 않고 고른다 (RouterLink 는 수정 글쇠가 있으면 이동하지 않는다 — 브라우저의 새 탭도 막는다).
@@ -84,7 +95,13 @@ function onMouseDown(event: MouseEvent) {
   <li
     :class="[
       'message-row',
-      { 'is-selected': selected, 'is-unread': unread, 'is-checked': checked, 'is-checking': checking },
+      {
+        'is-selected': selected,
+        'is-unread': unread,
+        'is-checked': checked,
+        'is-checking': checking,
+        'message-row--search': search,
+      },
     ]"
     :data-row-id="message.id"
     @mousedown="onMouseDown"
@@ -119,9 +136,14 @@ function onMouseDown(event: MouseEvent) {
           :datetime="message.pendingSend?.sendAt ?? message.receivedAt"
         >{{ time }}</time>
       </span>
-      <!-- 본문 미리보기는 넣지 않는다 (디자인 원칙) — 제목 뒤에 첨부 클립만 -->
+      <!-- 본문 미리보기는 넣지 않는다 (디자인 원칙) — 제목 뒤에 첨부 클립만. 검색 결과만 미리 보기 한 줄 (14단계) -->
       <span class="message-row__bottom">
-        <span :class="['message-row__subject', { 'is-placeholder': draft && !message.subject }]">{{ subject }}</span>
+        <span :class="['message-row__subject', { 'is-placeholder': draft && !message.subject }]">
+          <HighlightedText
+            :text="subject"
+            :ranges="search ? subjectRanges : null"
+          />
+        </span>
         <AppIcon
           v-if="message.hasAttachment"
           name="paperclip"
@@ -131,6 +153,16 @@ function onMouseDown(event: MouseEvent) {
           class="message-row__clip"
         />
       </span>
+      <span
+        v-if="search"
+        class="message-row__preview"
+        data-row-preview
+      >
+        <HighlightedText
+          :text="preview"
+          :ranges="previewRanges"
+        />
+      </span>
     </RouterLink>
     <button
       type="button"
@@ -226,6 +258,11 @@ function onMouseDown(event: MouseEvent) {
   padding-left: var(--space-10);
 }
 
+/* 검색 결과 — 세 줄 최소 64 (디자인 원본 Search14 — 분할 보기 2줄 행 --size-list-row 의 검색판) */
+.message-row--search .message-row__main {
+  min-height: 4rem;
+}
+
 .message-row__main:hover {
   color: inherit;
 }
@@ -290,6 +327,24 @@ function onMouseDown(event: MouseEvent) {
   color: var(--color-text);
 }
 
+/* 검색 결과의 미리 보기 한 줄 — 12.5px 흐린 글자 (디자인 원본 Search14) */
+.message-row__preview {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  font-size: var(--font-size-label);
+  color: var(--color-text-muted);
+}
+
+/*
+ * 미리 보기 줄의 맞은 말만 글자색을 진하게 — 흐린 글자(#667085)는 노랑(#FCE7A4) 위에서 4.05:1 이라 4.5:1 에 못 미친다(#4A5363 은 6.3:1, 2026-11-07).
+ * 제목 줄 · 읽기 화면 · 본문 틀의 강조는 진한 글자 위라 글자색 그대로다 (HighlightedText)
+ */
+.message-row__preview :deep(.search-mark) {
+  color: var(--color-text-secondary);
+}
+
 /* 비어 있는 값 — "(받는 사람 없음)" · "(제목 없음)" (디자인 원본 ComposeAssist #667085) */
 .message-row__who.is-placeholder,
 .message-row__subject.is-placeholder {
diff --git a/frontend/src/components/mail/MessageMoreMenu.vue b/frontend/src/components/mail/MessageMoreMenu.vue
index 9857fe1..53e29fb 100644
--- a/frontend/src/components/mail/MessageMoreMenu.vue
+++ b/frontend/src/components/mail/MessageMoreMenu.vue
@@ -215,7 +215,7 @@ async function onBlock(target: string, moveToJunk: boolean) {
   const nextId = mailStore.neighborAfterRemoval(message.id)
   const outcome = await senderBlock.block(message, target, moveToJunk)
   if (!outcome.moved || outcome.stale) return
-  const removed = !mailStore.messages.some((item) => item.id === message.id)
+  const removed = !mailStore.isListedMessage(message.id)
   await removal.leaveRemoved({ removed, nextId: removed ? nextId : null }, source, props.layout, message.id)
 }
 
diff --git a/frontend/src/components/mail/MessageReader.spec.ts b/frontend/src/components/mail/MessageReader.spec.ts
index dd84415..989cba8 100644
--- a/frontend/src/components/mail/MessageReader.spec.ts
+++ b/frontend/src/components/mail/MessageReader.spec.ts
@@ -9,7 +9,7 @@ import { createMailContactDialog, MAIL_CONTACT_DIALOG } from '@/composables/useM
 import { ERROR_CODE_MESSAGES } from '@/shared/constants/error-codes.generated'
 import { MAIL_BODY_NOTICES } from '@/shared/constants/mail'
 import type { Contact } from '@/shared/types/contacts'
-import type { Mailbox, MailFilterRule, MailFilterSet, MessageDetail, MessagesPatch } from '@/shared/types/mail'
+import type { Mailbox, MailFilterRule, MailFilterSet, MessageDetail, MessagesPatch, MessageSummary } from '@/shared/types/mail'
 import type { PaginatedResult } from '@/shared/types/pagination'
 import type { MailListSource } from '@/shared/utils/mail-list-source'
 import { useAuthStore } from '@/stores/auth.store'
@@ -338,7 +338,7 @@ describe('MessageReader 삭제 · 영구 삭제 — DELETE /messages/{id} 를 
     store.mailboxes = [INBOX, TRASH]
     store.listSource = options.source ?? { kind: 'mailbox', mailboxId: 'inbox' }
     const open = { ...DETAIL, mailboxIds: options.mailboxIds ?? ['inbox'] }
-    store.messages = [open, { ...DETAIL, id: 'm2', subject: '다음 메일' }]
+    store.messages = [open, { ...DETAIL, id: 'm2', subject: '다음 메일' }] as MessageSummary[]
     store.pageInfo = { hasNext: false, nextCursor: null, total: 2 }
     store.listStatus = 'ready'
     store.selected = open
@@ -380,7 +380,7 @@ describe('MessageReader 삭제 · 영구 삭제 — DELETE /messages/{id} 를 
     if (toast?.action && 'run' in toast.action) toast.action.run()
     await flushPromises()
     expect(requests.filter((request) => request.method === 'PATCH').at(-1)?.data).toEqual({ ids: ['m1'], mailboxId: 'inbox' })
-    expect(useToastStore().toasts.map((item) => item.message)).toContain('메일 1통을 되돌렸습니다.')
+    expect(useToastStore().toasts.map((item) => item.message)).toContain('메일 1통을 받은편지함으로 되돌렸습니다.')
   })
 
   it('목록 보기에서는 지우면 목록으로 돌아간다', async () => {
@@ -537,7 +537,7 @@ describe('MessageReader 스팸 신고 · 원문 내려받기 (4단계 — 디자
     store.mailboxes = mailboxes
     store.listSource = { kind: 'mailbox', mailboxId: box }
     const open = { ...DETAIL, mailboxIds: [box], from: options.from === undefined ? DETAIL.from : options.from }
-    store.messages = [open, { ...DETAIL, id: 'm2', mailboxIds: [box], subject: '다음 메일' }]
+    store.messages = [open, { ...DETAIL, id: 'm2', mailboxIds: [box], subject: '다음 메일' }] as MessageSummary[]
     store.pageInfo = { hasNext: false, nextCursor: null, total: 2 }
     store.listStatus = 'ready'
     store.selected = open
@@ -636,8 +636,9 @@ describe('MessageReader 스팸 신고 · 원문 내려받기 (4단계 — 디자
     await items[1]?.trigger('click')
     await flushPromises()
 
-    // 메뉴를 열 때 필터(50개인지) · 주소록(보낸 사람이 있는지 · 연락처 수)을 알림 없이 한 번 받아 본다
+    // 읽기 화면은 열릴 때 같은 대화를 받는다(14단계). 메뉴를 열 때 필터(50개인지) · 주소록(보낸 사람이 있는지 · 연락처 수)을 알림 없이 한 번 받아 본다
     expect(requests.map((request) => `${request.method} ${request.url}`)).toEqual([
+      'GET /messages/m1/conversation',
       'GET /mail-filters',
       'GET /contacts',
       'GET /contacts',
diff --git a/frontend/src/components/mail/MessageReader.stage9.spec.ts b/frontend/src/components/mail/MessageReader.stage9.spec.ts
index 25a180a..60cb74b 100644
--- a/frontend/src/components/mail/MessageReader.stage9.spec.ts
+++ b/frontend/src/components/mail/MessageReader.stage9.spec.ts
@@ -2,7 +2,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { mount, type VueWrapper } from '@vue/test-utils'
 import { createPinia, setActivePinia, type Pinia } from 'pinia'
 
-import type { BlockedSender, Mailbox, MessageDetail, MessagesPatch } from '@/shared/types/mail'
+import type { BlockedSender, Mailbox, MessageDetail, MessagesPatch, MessageSummary } from '@/shared/types/mail'
 import { formatScheduleTime } from '@/shared/utils/format'
 import type { MailListSource } from '@/shared/utils/mail-list-source'
 import { useAuthStore } from '@/stores/auth.store'
@@ -144,7 +144,7 @@ describe('MessageReader — 9단계', () => {
     const store = useMailStore()
     store.mailboxes = MAILBOXES
     store.listSource = source
-    store.messages = [message, { ...message, id: 'm2', subject: '다음 메일', pendingSend: message.pendingSend }]
+    store.messages = [message, { ...message, id: 'm2', subject: '다음 메일', pendingSend: message.pendingSend }] as MessageSummary[]
     store.pageInfo = { hasNext: false, nextCursor: null, total: 2 }
     store.listStatus = 'ready'
     store.selected = message
@@ -288,11 +288,11 @@ describe('MessageReader — 9단계', () => {
   describe('예약한 메일 — 청록 안내 줄 · 답장 · 전달 · 스팸 신고 없음 · 삭제는 예약 취소 뒤 휴지통 (디자인 원본 MailSendLater)', () => {
     const cancels = () => requests.filter((request) => request.method === 'DELETE' && request.url.startsWith('/scheduled-messages/'))
 
-    it('머리 아래 "10월 30일 (금) 오전 9:00 에 보낼 메일입니다." + [고치기] [예약 취소] — 도구 줄은 삭제 · ⋯ 뿐이다', async () => {
+    it('머리 아래 "10월 30일 (금) 오전 9:00에 보낼 메일입니다."(조사는 붙여 쓴다) + [고치기] [예약 취소] — 도구 줄은 삭제 · ⋯ 뿐이다', async () => {
       const { wrapper } = await mountWith({ message: SCHEDULED, source: { kind: 'scheduled' } })
       const notice = wrapper.get('[data-notice="scheduled"]')
 
-      expect(notice.get('.reader__notice-text').text()).toBe(`${formatScheduleTime(SEND_AT)} 에 보낼 메일입니다.`)
+      expect(notice.get('.reader__notice-text').text()).toBe(`${formatScheduleTime(SEND_AT)}에 보낼 메일입니다.`)
       expect(notice.findAll('button').map((button) => button.text())).toEqual(['고치기', '예약 취소'])
       expect(wrapper.findAll('.reader__toolbar .tool-button').map((button) => button.text())).toEqual(['삭제'])
       expect(wrapper.find('[data-reader-more]').exists()).toBe(true)
@@ -426,7 +426,7 @@ describe('MessageReader — 9단계', () => {
       await wrapper.get('[data-scheduled-cancel]').trigger('click')
       // 기다리는 사이 받은편지함의 다른 메일을 연다
       store.listSource = { kind: 'mailbox', mailboxId: 'inbox' }
-      store.messages = [{ ...NEWSLETTER, id: 'i1' }]
+      store.messages = [{ ...NEWSLETTER, id: 'i1' }] as MessageSummary[]
       store.selectedId = 'i1'
       await router.push('/mail/inbox/i1')
       cancel.resolve(ok({ draftId: 's1' }))
@@ -445,7 +445,7 @@ describe('MessageReader — 9단계', () => {
         extra: (request) => (request.method === 'DELETE' ? (cancel.promise as unknown as MockResult) : undefined),
       })
 
-      store.messages = [...store.messages, { ...NEWSLETTER, id: 'm3', mailboxIds: ['sent'] }]
+      store.messages = [...store.messages, { ...NEWSLETTER, id: 'm3', mailboxIds: ['sent'] }] as MessageSummary[]
       await wrapper.get('[data-reader-delete]').trigger('click')
       await flushPromises()
       await wrapper.get('[data-scheduled-delete-confirm]').trigger('click')
@@ -587,7 +587,7 @@ describe('MessageReader — 9단계', () => {
       expect(wrapper.get('#block-dialog-title').text()).toBe('보낸 사람 차단')
       expect((dialog.get('[data-block-scope="address"]').element as HTMLInputElement).checked).toBe(true)
       expect(dialog.text()).toContain('news@cloudbrief.example')
-      expect(dialog.text()).toContain('@cloudbrief.example 에서 오는 메일 모두')
+      expect(dialog.text()).toContain('@cloudbrief.example에서 오는 메일 모두')
       expect((dialog.get('[data-block-move]').element as HTMLInputElement).checked).toBe(true)
       expect(document.activeElement).toBe(wrapper.get('[data-block-confirm]').element)
 
@@ -629,7 +629,7 @@ describe('MessageReader — 9단계', () => {
       await wrapper.get('[data-block-confirm]').trigger('click')
       // 기다리는 사이 보낸편지함의 메일을 연다
       store.listSource = { kind: 'mailbox', mailboxId: 'sent' }
-      store.messages = [{ ...SCHEDULED, id: 'x1', pendingSend: null }]
+      store.messages = [{ ...SCHEDULED, id: 'x1', pendingSend: null }] as MessageSummary[]
       store.selectedId = 'x1'
       await router.push('/mail/sent/x1')
       blocking.resolve(ok({ address: 'news@cloudbrief.example', blockedAt: '2026-10-29T06:00:00.000Z' }, 201))
diff --git a/frontend/src/components/mail/MessageReader.vue b/frontend/src/components/mail/MessageReader.vue
index 5a6efb3..8148a58 100644
--- a/frontend/src/components/mail/MessageReader.vue
+++ b/frontend/src/components/mail/MessageReader.vue
@@ -13,22 +13,27 @@
 // Ctrl+P(맥 ⌘P)는 브라우저 인쇄 대신 인쇄 화면을 새 탭에 연다(⋯ › 인쇄와 같다 — 본문을 눌러 초점이 본문 안에 있어도).
 // 삭제 뒤 · 없는 메일에서 돌아가는 곳은 지금 목록(메일함 · 검색 결과 · 예약됨)이다.
 // 대용량 첨부(11단계 — largeFiles)는 첨부 칸에 첨부처럼 보이고, 본문의 덩이는 접는다(본문 틀 안 — 스크립트 없이 열고 닫는다).
+// 검색 결과에서 연 메일(14단계)은 제목 · 본문 · 첨부 이름의 맞은 말이 노랑이다 — 서버의 searchHighlight(제목 · 첨부 이름 · 글 본문의 위치)와
+// 서식 본문 안의 <mark>. 강조가 든 응답은 여기서 보이기만 한다 — [답장] · [전달] · 인쇄는 그 메일을 검색 쿼리 없이 따로 받는다 (계약 2절 "검색 — 14단계")
+// 본문 · 첨부 아래에 "같은 대화 N통"(14단계 — MessageConversation, 한 통뿐이면 없다). 칸 안에는 검색 강조가 없다
 import { computed, onBeforeUnmount, onMounted, ref } from 'vue'
 
 import AppIcon from '@/components/AppIcon.vue'
 import StateMessage from '@/components/feedback/StateMessage.vue'
+import HighlightedText from '@/components/mail/HighlightedText.vue'
 import MailBodyFrame from '@/components/mail/MailBodyFrame.vue'
 import MailLoadError from '@/components/mail/MailLoadError.vue'
 import MailToolButton from '@/components/mail/MailToolButton.vue'
 import MailToolbarDivider from '@/components/mail/MailToolbarDivider.vue'
 import MessageAttachments from '@/components/mail/MessageAttachments.vue'
+import MessageConversation from '@/components/mail/MessageConversation.vue'
 import MessageDeleteButton from '@/components/mail/MessageDeleteButton.vue'
 import MessageMoreMenu from '@/components/mail/MessageMoreMenu.vue'
 import MessageReaderNotices from '@/components/mail/MessageReaderNotices.vue'
 import MessageSpamButton from '@/components/mail/MessageSpamButton.vue'
 import { useMailNavigation } from '@/composables/useMailNavigation'
 import { useMailPrint } from '@/composables/useMailPrint'
-import { MAIL_SEARCH_TEXT } from '@/shared/constants/mail'
+import { MAIL_NO_SENDER, MAIL_SEARCH_TEXT } from '@/shared/constants/mail'
 import { formatMailDateTime, initialOf } from '@/shared/utils/format'
 import { displayName, formatAddressList } from '@/shared/utils/mail-address'
 import { listedAttachments } from '@/shared/utils/mail-attachment'
@@ -64,18 +69,21 @@ const searchMailboxName = computed(() => {
   if (!mailStore.search || !message.value) return null
   return mailboxOfMessage(message.value, mailStore.mailboxes, mailStore.currentMailboxId)?.name ?? null
 })
-const fromName = computed(() => displayName(message.value?.from) || '(보낸 사람 없음)')
+const fromName = computed(() => displayName(message.value?.from) || MAIL_NO_SENDER)
 const fromEmail = computed(() => message.value?.from?.email ?? '')
 const initial = computed(() => initialOf(message.value?.from?.name, fromEmail.value))
 const subject = computed(() => message.value?.subject || '(제목 없음)')
+/** 검색 강조 (14단계) — 검색 결과에서 연 메일만 온다. "(제목 없음)"에는 없다 */
+const subjectRanges = computed(() => (message.value?.subject ? (message.value.searchHighlight?.subject ?? null) : null))
 const receivedAt = computed(() => (message.value ? formatMailDateTime(message.value.receivedAt) : ''))
 /** 첨부 목록 — 본문 안에 그림으로 보인 것(서명 그림 · 본문 그림, isInline)은 뺀다 */
 const attachments = computed(() => (message.value ? listedAttachments(message.value.attachments) : []))
 /** 대용량 첨부 — 링크 주인이 이 메일의 보낸 사람일 때만 서버가 준다 (필드가 없는 서버면 없다) */
 const largeFiles = computed(() => message.value?.largeFiles ?? [])
 
+/** 다시 시도 — 검색 결과에서 연 메일이면 같은 강조 쿼리로 */
 function retry() {
-  if (mailStore.selectedId) void mailStore.openMessage(mailStore.selectedId)
+  if (mailStore.selectedId) void mailStore.openMessage(mailStore.selectedId, mailStore.selectedHighlight)
 }
 
 /** 없는 메일(RES_001 — 지워졌거나 주소가 틀림) — 목록으로 돌아간다 (뒤로 가기 또는 바꿔 끼우기) */
@@ -92,7 +100,7 @@ function onPrintKey(event: KeyboardEvent) {
   print.openPrint(current)
 }
 
-/** 안내 줄의 단추가 줄과 함께 사라졌다 — 초점을 잃었으면 본문으로 */
+/** 안내 줄의 단추가 줄과 함께 사라졌다 · 초점이 있던 같은 대화 칸이 없어졌다(14단계) — 초점을 잃었으면 본문으로 */
 function onNoticeSettled() {
   const active = document.activeElement
   if (active !== null && active !== document.body) return
@@ -194,7 +202,10 @@ onBeforeUnmount(() => {
             id="reader-subject"
             class="reader__subject"
           >
-            {{ subject }}
+            <HighlightedText
+              :text="subject"
+              :ranges="subjectRanges"
+            />
           </h2>
           <button
             type="button"
@@ -265,6 +276,7 @@ onBeforeUnmount(() => {
           :text-body="message.textBody"
           :images-shown="message.imagesShown === true"
           :fold-large-files="largeFiles.length > 0"
+          :text-highlights="message.searchHighlight?.textBody ?? null"
           :title="`메일 본문: ${subject}`"
           @frame-keydown="onPrintKey"
         />
@@ -274,6 +286,14 @@ onBeforeUnmount(() => {
           :message-id="message.id"
           :attachments="attachments"
           :large-files="largeFiles"
+          :name-highlights="message.searchHighlight?.attachments ?? null"
+        />
+
+        <!-- 같은 대화 (14단계) — 한 통뿐이거나 아직 받지 못했으면 아무것도 그리지 않는다. 초점이 있던 칸이 없어지면 본문으로 -->
+        <MessageConversation
+          :message-id="message.id"
+          :layout="layout"
+          @settled="onNoticeSettled"
         />
       </div>
     </article>
diff --git a/frontend/src/components/mail/MessageTable.spec.ts b/frontend/src/components/mail/MessageTable.spec.ts
index 0d80784..1dd8c0d 100644
--- a/frontend/src/components/mail/MessageTable.spec.ts
+++ b/frontend/src/components/mail/MessageTable.spec.ts
@@ -93,10 +93,10 @@ describe('MessageTable (목록 보기)', () => {
     expect(wrapper.findAll('thead th').every((th) => th.attributes('scope') === 'col')).toBe(true)
   })
 
-  it('머리에 "전체 N · 안 읽음 M" 과 보기 전환이 있다', async () => {
+  it('머리에 "메일 N통, 안 읽은 메일 M통"(14단계 — 디자인 원본 ListThreads14) 과 보기 전환이 있다', async () => {
     const { wrapper } = await mountTable()
 
-    expect(wrapper.get('.list-header__count').text()).toBe('전체 15 · 안 읽음 2')
+    expect(wrapper.get('.list-header__count').text()).toBe('메일 15통, 안 읽은 메일 2통')
     expect(wrapper.find('[role="group"][aria-label="보기 방식"]').exists()).toBe(true)
   })
 
diff --git a/frontend/src/components/mail/MessageTable.vue b/frontend/src/components/mail/MessageTable.vue
index 375268c..70299d7 100644
--- a/frontend/src/components/mail/MessageTable.vue
+++ b/frontend/src/components/mail/MessageTable.vue
@@ -3,23 +3,35 @@
 // 칸: 고르기 32 · 별 32 · 보낸 사람 168 · [메일함 96 — 전체 메일함 검색 결과] · 제목(나머지) · 날짜 84 · 크기 64 (칸 사이 12)
 // — tokens.css 의 --table-* 값. 머리 줄은 MessageTableHead, 행은 MessageTableRow.
 // 머리 · 상태 · 메일 더 보기 · 표 위치 기억(메일을 열었다 돌아올 때)은 목록 틀(MailListFrame)이 맡는다.
+// 대화로 묶은 메일함(14단계 — 보드 ListThreads14 에 표가 없어 정했다)은 한 줄이 대화 하나다(ConversationTableRow):
+// 고르기 · 별 · 참여자(+ 통 수 — 칸 머리도 "참여자") · 제목 · 날짜 — 크기 칸은 없다(대화의 크기는 마지막 메일의 크기가 아니다)
 import { computed } from 'vue'
 import { useRouter, type RouteLocationRaw } from 'vue-router'
 
+import ConversationTableRow from '@/components/mail/ConversationTableRow.vue'
 import MailListFrame from '@/components/mail/MailListFrame.vue'
 import MessageTableHead from '@/components/mail/MessageTableHead.vue'
 import MessageTableRow from '@/components/mail/MessageTableRow.vue'
+import { useConversationRows } from '@/composables/useConversationRows'
 import { useMailListRows } from '@/composables/useMailListRows'
 import { MAIL_SEARCH_TEXT } from '@/shared/constants/mail'
+import { MAIL_CONVERSATION_LIST_TEXT } from '@/shared/constants/mail-conversation'
 import { useMailStore } from '@/stores/mail.store'
 
 const router = useRouter()
 const mailStore = useMailStore()
 const rows = useMailListRows()
+const conversationRows = useConversationRows()
 
-const caption = computed(() =>
-  mailStore.search ? MAIL_SEARCH_TEXT.title : `${mailStore.currentMailbox?.name ?? '메일함'} 메일 목록`,
-)
+/** 대화로 묶은 메일함 — 크기 칸이 없고 사람 칸에 참여자를 보인다 */
+const threads = computed(() => mailStore.isConversationList)
+const caption = computed(() => {
+  if (mailStore.search) return MAIL_SEARCH_TEXT.title
+  const name = mailStore.currentMailbox?.name ?? '메일함'
+  return threads.value ? MAIL_CONVERSATION_LIST_TEXT.tableCaption(name) : `${name} 메일 목록`
+})
+/** 사람 칸 머리 — 대화는 줄이 참여자라 어느 메일함이든 "참여자", 메일은 "보낸 사람"(보낸편지함 · 임시보관함은 "받는 사람") */
+const whoHeader = computed(() => (threads.value ? MAIL_CONVERSATION_LIST_TEXT.participantsColumn : rows.whoHeader.value))
 
 /** Shift 면 범위, 아니면 하나 */
 function onCheck(id: string, range: boolean) {
@@ -40,7 +52,7 @@ function open(location: RouteLocationRaw) {
   >
     <!-- 표 최소 폭(440px · 메일함 칸이 있으면 더 넓다)보다 좁으면 가로로 스크롤한다 -->
     <div class="message-table__scroll">
-      <table :class="['mail-table', { 'mail-table--mixed': rows.mixed.value }]">
+      <table :class="['mail-table', { 'mail-table--mixed': rows.mixed.value, 'mail-table--threads': threads }]">
         <caption class="visually-hidden">
           {{ caption }}
         </caption>
@@ -54,26 +66,48 @@ function open(location: RouteLocationRaw) {
           >
           <col class="mail-table__col-subject">
           <col class="mail-table__col-date">
-          <col class="mail-table__col-size">
+          <col
+            v-if="!threads"
+            class="mail-table__col-size"
+          >
         </colgroup>
         <MessageTableHead
-          :who-header="rows.whoHeader.value"
+          :who-header="whoHeader"
           :mixed="rows.mixed.value"
+          :threads="threads"
         />
         <tbody>
-          <MessageTableRow
-            v-for="message in mailStore.messages"
-            :key="message.id"
-            :message="message"
-            :to="rows.locationOf(message)"
-            :role="rows.roleOf(message)"
-            :mixed="rows.mixed.value"
-            :mailbox-name="rows.mailboxNameOf(message)"
-            :checked="mailStore.checkedIds.has(message.id)"
-            @open="open"
-            @toggle-flag="mailStore.toggleFlag"
-            @check="onCheck"
-          />
+          <template v-if="threads">
+            <ConversationTableRow
+              v-for="row in mailStore.conversations"
+              :key="row.id"
+              :row="row"
+              :who="conversationRows.whoOf(row, 'table')"
+              :to="conversationRows.locationOf(row)"
+              :unread="conversationRows.isUnread(row)"
+              :draft="conversationRows.isDraft.value"
+              :held="conversationRows.isHeld(row)"
+              :checked="mailStore.checkedIds.has(row.id)"
+              @open="open"
+              @toggle-flag="conversationRows.toggleFlag"
+              @check="onCheck"
+            />
+          </template>
+          <template v-else>
+            <MessageTableRow
+              v-for="message in mailStore.messages"
+              :key="message.id"
+              :message="message"
+              :to="rows.locationOf(message)"
+              :role="rows.roleOf(message)"
+              :mixed="rows.mixed.value"
+              :mailbox-name="rows.mailboxNameOf(message)"
+              :checked="mailStore.checkedIds.has(message.id)"
+              @open="open"
+              @toggle-flag="mailStore.toggleFlag"
+              @check="onCheck"
+            />
+          </template>
         </tbody>
       </table>
     </div>
@@ -171,6 +205,13 @@ function open(location: RouteLocationRaw) {
   font-variant-numeric: tabular-nums;
 }
 
+/* 대화로 묶은 메일함 — 크기 칸이 없어 날짜 칸이 마지막 칸이다 (14단계 — 1100px 미만은 아래 규칙이 같은 폭을 준다) */
+@media (min-width: 68.75rem) {
+  .mail-table--threads .mail-table__col-date {
+    width: calc(var(--table-col-date) + var(--space-8));
+  }
+}
+
 /* 1100px 미만 — 크기 칸을 숨기고 날짜 칸이 마지막 칸이 된다 (tokens.css 화면 폭 기준) */
 @media (max-width: 68.6875rem) {
   .mail-table__col-size,
diff --git a/frontend/src/components/mail/MessageTableHead.vue b/frontend/src/components/mail/MessageTableHead.vue
index 70844f4..7069ecd 100644
--- a/frontend/src/components/mail/MessageTableHead.vue
+++ b/frontend/src/components/mail/MessageTableHead.vue
@@ -1,10 +1,12 @@
 <script setup lang="ts">
 // 목록 보기 표의 머리 줄(32) — 고르기 · 별 · 보낸 사람(받는 사람) · [메일함] · 제목 · 날짜 · 크기 (디자인 원본 BulkSelect · ListStates)
 // 머리의 고르기 상자는 불러온 메일 모두 고르기 · 풀기 — 일부만 골랐으면 – 표시 (aria-checked="mixed")
+// 대화로 묶은 메일함(14단계)은 불러온 대화 모두 고르기이고 크기 칸이 없다
 // 칸 폭 · 칸 사이 여백은 표(MessageTable)가 정한다.
 import AppIcon from '@/components/AppIcon.vue'
 import MailCheckbox from '@/components/mail/MailCheckbox.vue'
 import { MAIL_BULK_TEXT, MAIL_SEARCH_TEXT } from '@/shared/constants/mail'
+import { MAIL_CONVERSATION_LIST_TEXT } from '@/shared/constants/mail-conversation'
 import { useMailStore } from '@/stores/mail.store'
 
 interface Props {
@@ -12,10 +14,13 @@ interface Props {
   whoHeader: string
   /** 전체 메일함 검색 결과 — 메일함 칸이 생긴다 */
   mixed?: boolean
+  /** 대화로 묶은 메일함 — 크기 칸이 없다 */
+  threads?: boolean
 }
 
 withDefaults(defineProps<Props>(), {
   mixed: false,
+  threads: false,
 })
 
 const mailStore = useMailStore()
@@ -33,7 +38,7 @@ const mailStore = useMailStore()
           class="mail-table-head__check"
           :checked="mailStore.checkState === 'all'"
           :mixed="mailStore.checkState === 'some'"
-          :label="MAIL_BULK_TEXT.selectAll"
+          :label="threads ? MAIL_CONVERSATION_LIST_TEXT.selectAll : MAIL_BULK_TEXT.selectAll"
           @toggle="mailStore.toggleCheckAll()"
         />
       </th>
@@ -66,6 +71,7 @@ const mailStore = useMailStore()
         날짜
       </th>
       <th
+        v-if="!threads"
         scope="col"
         class="mail-table__size"
       >
diff --git a/frontend/src/components/mail/MessageTableRow.vue b/frontend/src/components/mail/MessageTableRow.vue
index b241aec..678a353 100644
--- a/frontend/src/components/mail/MessageTableRow.vue
+++ b/frontend/src/components/mail/MessageTableRow.vue
@@ -5,21 +5,23 @@
 // - 보낸 사람 자리 · 읽음 표시 · 누르면 갈 곳은 메일함 규칙을 따른다 (mail-list-row.ts)
 // - 아직 보내지 않은 내 메일(9단계)은 날짜 칸이 "예약 · 10월 30일 오전 9:00" · "보내는 중"(청록) — 칸(84)보다 길면 줄이고 전체는 title 로.
 //   고를 수 없다 — 고르기 상자는 꺼진 모양(aria-disabled · 까닭은 title), Ctrl · Shift + 클릭도 고르지 않는다 (옮기거나 지워도 엔진은 그 시각에 보낸다)
+// - 검색 결과(14단계)는 제목의 맞은 말을 <mark>(HighlightedText — searchHighlight 의 위치)로 그린다. 행 높이(38)는 그대로 — 미리 보기 줄은 분할 보기만
 // 칸 폭 · 칸 공통 여백은 표(MessageTable)가 정한다.
 import { computed } from 'vue'
 import type { RouteLocationRaw } from 'vue-router'
 
 import AppIcon from '@/components/AppIcon.vue'
+import HighlightedText from '@/components/mail/HighlightedText.vue'
 import MailCheckbox from '@/components/mail/MailCheckbox.vue'
 import { MAIL_BULK_TEXT, MAIL_NO_SUBJECT } from '@/shared/constants/mail'
 import { SEND_LATER_TEXT } from '@/shared/constants/mail-send-later'
-import type { MailboxRole, MessageSummary } from '@/shared/types/mail'
+import type { MailboxRole, MessageListItem } from '@/shared/types/mail'
 import { formatFileSize, formatMailTableDate } from '@/shared/utils/format'
 import { isDraftRole, isRowUnread, pendingSendLabel, rowWho } from '@/shared/utils/mail-list-row'
 import { isHeldMessage } from '@/shared/utils/pending-send'
 
 interface Props {
-  message: MessageSummary
+  message: MessageListItem
   to: RouteLocationRaw
   role: MailboxRole | null
   /** 전체 메일함 검색 결과 — 메일함 칸이 생기고, 보낸편지함 · 임시보관함의 메일은 "받는 사람: 이름" */
@@ -51,6 +53,8 @@ const draft = computed(() => isDraftRole(props.role))
 const pendingLabel = computed(() => pendingSendLabel(props.message))
 /** 아직 보내지 않은 메일 — 고를 수 없다 */
 const held = computed(() => isHeldMessage(props.message))
+/** 검색 강조 (14단계) — "(제목 없음)"에는 없다 */
+const subjectRanges = computed(() => (props.message.subject ? (props.message.searchHighlight?.subject ?? null) : null))
 
 /** 행 어디를 눌러도 연다 — 버튼을 누른 경우 · 제목 링크(스스로 연다) · 글자를 고르는 중이면 그대로 둔다 */
 function onRowClick(event: MouseEvent) {
@@ -125,7 +129,10 @@ function onMouseDown(event: MouseEvent) {
           :to="to"
           :data-message-id="message.id"
         >
-          {{ subject }}
+          <HighlightedText
+            :text="subject"
+            :ranges="subjectRanges"
+          />
         </RouterLink>
         <AppIcon
           v-if="message.hasAttachment"
diff --git a/frontend/src/composables/useBulkMailActions.ts b/frontend/src/composables/useBulkMailActions.ts
index 1122647..28251e1 100644
--- a/frontend/src/composables/useBulkMailActions.ts
+++ b/frontend/src/composables/useBulkMailActions.ts
@@ -13,6 +13,9 @@ import { useMailStore, type MailBulkResult, type MoveOptions } from '@/stores/ma
 // - 스팸 신고(스팸메일함으로 + 스팸 표시) · 스팸 아님(스팸메일함에서 — 받은편지함으로 + "스팸 아님" 표시): 옮기기와 같은 길에 isJunk 를 함께 보낸다
 // - 열어 둔 메일을 옮기거나 지워 목록에서 빠졌으면 목록 주소로 바꿔 끼운다 (본문 칸이 없는 메일을 붙들지 않게).
 //   끝났을 때 다른 목록으로 옮겨 가 있으면(stale) 그 목록에 기대어 움직이지 않는다
+// - 대화로 묶은 메일함(14단계)은 고른 줄의 메일 모두에 한다(붙잡힌 메일은 빼고 — 스토어). "중요 해제"는 고른 줄이 모두 중요 표시가 있을 때.
+//   옮기기 · 삭제 · 스팸 알림은 "받은편지함에 있는 메일 2통을 휴지통으로 옮겼습니다." — 줄의 "4통"은 대화 전체라서 (2026-11-06 실사용 시험).
+//   휴지통의 영구 삭제도 확인 창 · 알림이 "휴지통에 있는 메일 2통을 영구 삭제할까요? · …했습니다." (2026-11-07 — conversationFrom)
 
 export function useBulkMailActions() {
   const mailStore = useMailStore()
@@ -22,16 +25,24 @@ export function useBulkMailActions() {
   /** 옮기기 · 지우기를 하는 중 — 끝날 때까지 다시 누르지 못한다 (읽음 · 중요 표시는 막지 않는다) */
   const busy = ref<boolean>(false)
 
-  /** 고른 메일이 모두 중요 표시 — 단추가 "중요 해제"가 된다 */
-  const allFlagged = computed<boolean>(
-    () => mailStore.checkedMessages.length > 0 && mailStore.checkedMessages.every((message) => message.isFlagged),
-  )
+  /** 고른 메일이 모두 중요 표시 — 단추가 "중요 해제"가 된다 (대화 목록은 고른 줄이 모두 중요 표시가 있을 때) */
+  const allFlagged = computed<boolean>(() => {
+    const rows = mailStore.isConversationList ? mailStore.checkedConversations : mailStore.checkedMessages
+    return rows.length > 0 && rows.every((row) => row.isFlagged)
+  })
   /** 휴지통을 보는 중 — "삭제"가 "영구 삭제"가 된다 (휴지통 안의 검색 포함) */
   const inTrash = computed<boolean>(() => mailStore.currentMailbox?.role === 'trash')
   /** 스팸메일함을 보는 중 — 「스팸 신고」가 「스팸 아님」이 된다 (스팸메일함 안의 검색 포함) */
   const inJunk = computed<boolean>(() => mailStore.currentMailbox?.role === 'junk')
   /** 스팸 단추가 옮길 곳 — 스팸 신고는 스팸메일함, 스팸 아님은 받은편지함. 그 메일함을 모르면 단추를 그리지 않는다 */
   const spamTarget = computed<Mailbox | null>(() => mailStore.mailboxByRole(inJunk.value ? 'inbox' : 'junk'))
+  /**
+   * 대화로 묶은 목록이면 지금 메일함의 이름 — 줄의 통 수는 대화 전체라 알림 · 영구 삭제 확인이 그 메일함의 메일임을 밝힌다
+   * ("받은편지함에 있는 메일 2통을 …" · "휴지통에 있는 메일 2통을 영구 삭제할까요?"). 묶지 않은 목록이면 null (지금 글 그대로)
+   */
+  const conversationFrom = computed<string | null>(() =>
+    mailStore.isConversationList ? (mailStore.currentMailbox?.name ?? null) : null,
+  )
   /** 이동 메뉴 — 지금 메일함 · 임시보관함 · 휴지통을 뺀 메일함 (메일함 패널 순서) */
   const moveTargets = computed<Mailbox[]>(() =>
     mailStore.orderedMailboxes
@@ -56,17 +67,19 @@ export function useBulkMailActions() {
     const openId = mailStore.selectedId
     const source = mailStore.listSource
     if (result.stale || !openId || !source || !result.doneIds.includes(openId)) return
-    if (mailStore.messages.some((message) => message.id === openId)) return
+    if (mailStore.isListedMessage(openId)) return
     await router.replace(listLocationOf(source))
   }
 
   async function moveTo(mailbox: Mailbox, options: MoveOptions = {}): Promise<void> {
     if (busy.value || mailStore.checkedCount === 0) return
+    // 대화로 묶은 목록은 줄의 통 수가 대화 전체라 알림이 지금 메일함의 메일임을 밝힌다 — 시작할 때의 메일함 (기다리는 사이 목록이 바뀔 수 있다)
+    const from = conversationFrom.value
     busy.value = true
     try {
       const result = await mailStore.moveChecked(mailbox.id, options)
       await leaveRemovedMessage(result)
-      feedback.announceMove(result, mailbox.name)
+      feedback.announceMove(result, mailbox.name, { from })
     } finally {
       busy.value = false
     }
@@ -98,11 +111,13 @@ export function useBulkMailActions() {
   /** 영구 삭제 — 확인 대화상자에서 「영구 삭제」를 누른 뒤에만 부른다 */
   async function purge(): Promise<void> {
     if (busy.value || mailStore.checkedCount === 0) return
+    // 옮기기와 같은 까닭 — 대화로 묶은 휴지통이면 "휴지통에 있는 메일 N통을 영구 삭제했습니다." (시작할 때의 메일함)
+    const from = conversationFrom.value
     busy.value = true
     try {
       const result = await mailStore.purgeChecked()
       await leaveRemovedMessage(result)
-      feedback.announcePurge(result)
+      feedback.announcePurge(result, { from })
     } finally {
       busy.value = false
     }
@@ -114,6 +129,7 @@ export function useBulkMailActions() {
     inTrash,
     inJunk,
     spamTarget,
+    conversationFrom,
     moveTargets,
     markRead,
     toggleFlagged,
diff --git a/frontend/src/composables/useConversationRows.ts b/frontend/src/composables/useConversationRows.ts
new file mode 100644
index 0000000..c6c4198
--- /dev/null
+++ b/frontend/src/composables/useConversationRows.ts
@@ -0,0 +1,61 @@
+import { computed } from 'vue'
+import type { RouteLocationRaw } from 'vue-router'
+
+import { useToast } from './useToast'
+import { MAIL_CONVERSATION_LIST_TEXT } from '@/shared/constants/mail-conversation'
+import type { ConversationSummary, MailboxRole } from '@/shared/types/mail'
+import { conversationWho, isConversationHeld } from '@/shared/utils/mail-conversation-list'
+import { isDraftRole, isRowUnread, type RowWho } from '@/shared/utils/mail-list-row'
+import { messageLocationOf } from '@/shared/utils/mail-list-source'
+import { useAuthStore } from '@/stores/auth.store'
+import { useMailStore } from '@/stores/mail.store'
+
+/**
+ * 대화로 묶은 메일함의 줄마다 필요한 값 (14단계 — 디자인 원본 ListThreads14) — 분할 보기 줄(ConversationListItem)과 목록 보기 표(ConversationTableRow)가 함께 쓴다.
+ * - 이름 자리: 참여자(내 주소는 "나" — 끝에), 보낸편지함 · 임시보관함에서 나뿐이면 "받는 사람: …" (mail-conversation-list.ts 의 conversationWho)
+ * - 안 읽음: 하나라도 안 읽었으면 굵게 — 임시보관함은 메일 목록처럼 굵게 하지 않는다
+ * - 누르면 갈 곳: 그 메일함의 마지막 메일 — 임시보관함이면 쓰기 화면에서 이어 쓴다(메일 목록과 같다)
+ * - 열린 메일이 든 줄: 마지막 메일이거나 줄에 든 메일([이 메일만 열기]로 연 더 오래된 메일)
+ * - 별: 줄의 메일 모두(붙잡힌 메일은 빼고 — 스토어). 줄의 중요 표시가 붙잡힌 메일에만 있어 풀리지 않았으면 그 까닭을 알린다
+ */
+export function useConversationRows() {
+  const mailStore = useMailStore()
+  const authStore = useAuthStore()
+  const toast = useToast()
+
+  /** 목록의 메일함 역할 — 묶은 목록은 늘 메일함 하나다 */
+  const role = computed<MailboxRole | null>(() => mailStore.currentMailbox?.role ?? null)
+  /** 임시보관함 — 제목 없는 저장본을 흐린 글자로 */
+  const isDraft = computed<boolean>(() => isDraftRole(role.value))
+
+  function whoOf(row: ConversationSummary, view: 'split' | 'table'): RowWho {
+    return conversationWho(row, { myEmail: authStore.user?.email, role: role.value, view })
+  }
+
+  function isUnread(row: ConversationSummary): boolean {
+    return isRowUnread({ isRead: row.isRead }, role.value)
+  }
+
+  /** 줄의 메일이 모두 붙잡힌 메일 — 고르기 · 별을 쓸 수 없다 */
+  function isHeld(row: ConversationSummary): boolean {
+    return isConversationHeld(row)
+  }
+
+  function locationOf(row: ConversationSummary): RouteLocationRaw {
+    if (isDraftRole(role.value)) return { name: 'mail-compose', query: { draft: row.latest.id } }
+    const source = mailStore.listSource
+    return source ? messageLocationOf(source, row.latest.id) : { name: 'mail' }
+  }
+
+  function isSelected(row: ConversationSummary): boolean {
+    const id = mailStore.selectedId
+    return id !== null && (row.latest.id === id || row.messageIds.includes(id))
+  }
+
+  async function toggleFlag(rowId: string): Promise<void> {
+    const { heldFlagged } = await mailStore.toggleConversationFlag(rowId)
+    if (heldFlagged) toast.error(MAIL_CONVERSATION_LIST_TEXT.heldFlagNote)
+  }
+
+  return { role, isDraft, whoOf, isUnread, isHeld, locationOf, isSelected, toggleFlag }
+}
diff --git a/frontend/src/composables/useConversationSync.ts b/frontend/src/composables/useConversationSync.ts
new file mode 100644
index 0000000..3461f12
--- /dev/null
+++ b/frontend/src/composables/useConversationSync.ts
@@ -0,0 +1,112 @@
+import { onScopeDispose, watch } from 'vue'
+
+import { systemClock, type Clock, type ClockTimer } from './useClock'
+import { MAIL_CONVERSATION_REFRESH_GAP_MS } from '@/shared/constants/mail-conversation'
+import { useAuthStore } from '@/stores/auth.store'
+import { useMailStore } from '@/stores/mail.store'
+
+// 읽기 화면의 "같은 대화" 칸을 언제 받을지 (14단계 — 계약 2절 "대화 — 14단계"). 칸(MessageConversation)이 시작하고, 칸이 사라지면 멈춘다
+// - 메일이 바뀌면 그 메일의 대화를 받는다(스토어의 loadConversation — 같은 대화의 다른 메일이면 보이던 줄을 둔 채)
+// - 그 메일의 대화를 이미 받아 두었으면(쓰기 화면에서 답장을 보내고 돌아옴 · 보기 방식을 바꿈) 보이는 채로 바로 다시 받는다
+// - 다시 받아 달라는 소식(conversationRefreshSeq — 메일함들의 통 수가 바뀌었을 때만 오른다, mail.store.ts)이 오면 다시 받는다 —
+//   마지막으로 받기가 끝난 지 MAIL_CONVERSATION_REFRESH_GAP_MS 가 지나지 않았으면 그때까지 모았다가 한 번에 (잦지 않게).
+//   끝난 때는 스토어가 실제로 물었을 때만 센다(conversationBusy 가 꺼질 때). 묻는 중에 온 소식은 끝난 뒤 한 번 더(그때부터 간격)
+// - 기다림은 간격보다 길지 않다 — 이 PC 시계가 뒤로 가도 오래 멈추지 않게
+// - 보호 화면을 쓸 수 있는 세션(canUseApp)일 때만 묻는다 — 로그인 전 · 제한된 세션(13단계)에는 묻지 않는다
+// 시계를 주입받는다 — 테스트는 손으로 돌리는 시계로 시간을 넘긴다 (test-utils/manual-clock.ts)
+
+export interface ConversationSyncOptions {
+  /** 읽기 화면에 연 메일 */
+  messageId: () => string
+  clock?: Clock
+}
+
+export function useConversationSync(options: ConversationSyncOptions): void {
+  const mailStore = useMailStore()
+  const authStore = useAuthStore()
+  const clock = options.clock ?? systemClock
+
+  /** 마지막으로 받기가 끝난 때 — 이 칸이 뜬 뒤 실제로 물은 것만 */
+  let lastFinishedAt: number | null = null
+  let timer: ClockTimer | null = null
+  /** 묻는 중에 온 소식 — 끝난 뒤 한 번 더 */
+  let pending = false
+  let stopped = false
+
+  function cancelTimer() {
+    if (timer !== null) clock.clearTimeout(timer)
+    timer = null
+  }
+
+  /** 지금 다시 받는다 — 묻는 중이면 끝난 뒤로 미룬다 */
+  function refreshNow() {
+    if (stopped || !authStore.canUseApp) return
+    if (mailStore.conversationBusy) {
+      pending = true
+      return
+    }
+    void mailStore.refreshConversation()
+  }
+
+  /**
+   * 다시 받아 달라 — 묻는 중이면 끝난 뒤로 미루고, 간격이 지났으면 바로, 아니면 간격이 끝날 때 한 번 (그사이 온 요청은 함께).
+   * 간격이 끝나면 다시 재지 않고 받는다 — 시계가 뒤로 가도 간격보다 오래 기다리지 않게
+   */
+  function requestRefresh() {
+    if (stopped || !authStore.canUseApp) return
+    if (mailStore.conversationBusy) {
+      pending = true
+      return
+    }
+    if (timer !== null) return
+    const wait =
+      lastFinishedAt === null
+        ? 0
+        : Math.min(MAIL_CONVERSATION_REFRESH_GAP_MS, lastFinishedAt + MAIL_CONVERSATION_REFRESH_GAP_MS - clock.now())
+    if (wait <= 0) {
+      refreshNow()
+      return
+    }
+    timer = clock.setTimeout(() => {
+      timer = null
+      refreshNow()
+    }, wait)
+  }
+
+  // 받기가 끝날 때마다(받기 · 다시 받기 · [더 보기] · 붙잡힌 메일 다시 보기) 그때부터 간격을 센다 — 묻는 중에 온 소식은 그때 한 번 더
+  watch(
+    () => mailStore.conversationBusy,
+    (busy, wasBusy) => {
+      if (stopped || busy || !wasBusy) return
+      lastFinishedAt = clock.now()
+      if (!pending) return
+      pending = false
+      requestRefresh()
+    },
+  )
+
+  watch(
+    [() => options.messageId(), () => authStore.canUseApp],
+    ([messageId, usable]) => {
+      cancelTimer()
+      pending = false
+      if (!usable) return
+      if (mailStore.conversationMessageId === messageId && mailStore.conversationStatus === 'ready') {
+        requestRefresh()
+        return
+      }
+      void mailStore.loadConversation(messageId)
+    },
+    { immediate: true },
+  )
+
+  watch(
+    () => mailStore.conversationRefreshSeq,
+    () => requestRefresh(),
+  )
+
+  onScopeDispose(() => {
+    stopped = true
+    cancelTimer()
+  })
+}
diff --git a/frontend/src/composables/useLargeFileUploads.spec.ts b/frontend/src/composables/useLargeFileUploads.spec.ts
index 569a51d..df97bcb 100644
--- a/frontend/src/composables/useLargeFileUploads.spec.ts
+++ b/frontend/src/composables/useLargeFileUploads.spec.ts
@@ -336,7 +336,7 @@ describe('useLargeFileUploads', () => {
 
     expect(uploads.items.value.map((item) => [item.name, item.phase, item.errorText])).toEqual([
       // 한도 글은 MB · GB 로 적는다 — 이 테스트의 12바이트 한도는 "0MB" 로 보인다
-      ['too-big.zip', 'rejected', '파일 하나는 0MB 까지 보낼 수 있습니다.'],
+      ['too-big.zip', 'rejected', '파일 하나는 0MB까지 보낼 수 있습니다.'],
       ['first.zip', 'ready', null],
       ['second.zip', 'rejected', '링크로 보내는 파일은 메일 한 통에 1개까지입니다.'],
       ['setup.exe', 'rejected', '허용되지 않는 파일 형식입니다. 파일을 확인해 주세요.'],
diff --git a/frontend/src/composables/useMail.ts b/frontend/src/composables/useMail.ts
index da7515c..38aae4b 100644
--- a/frontend/src/composables/useMail.ts
+++ b/frontend/src/composables/useMail.ts
@@ -10,8 +10,12 @@ import {
   MAIL_SEND_TIMEOUT_MS,
   MAIL_UPLOAD_TIMEOUT_MS,
 } from '@/shared/constants/mail'
+import { MAIL_CONVERSATION_TIMEOUT_MS } from '@/shared/constants/mail-conversation'
 import type {
   Attachment,
+  ConversationListPage,
+  ConversationListQuery,
+  ConversationPage,
   Draft,
   DraftPayload,
   DraftSaved,
@@ -32,6 +36,8 @@ import type {
   MessageDeletionRequest,
   MessageDeletionResult,
   MessageDetail,
+  MessageHighlightQuery,
+  MessageListItem,
   MessageListQuery,
   MessageSummary,
   MessagesPatch,
@@ -40,12 +46,15 @@ import type {
   RecipientSuggestionQuery,
   SaveSignaturePayload,
   ScheduledMessageCancel,
+  SearchIndexState,
   SendMessagePayload,
   SentMessage,
   SignatureImage,
   UpdateMessagePayload,
 } from '@/shared/types/mail'
 import type { CursorPaginationQuery, PaginatedResult } from '@/shared/types/pagination'
+import { conversationPageOf } from '@/shared/utils/mail-conversation'
+import { conversationListPageOf } from '@/shared/utils/mail-conversation-list'
 import { pendingSendOf } from '@/shared/utils/pending-send'
 
 /** 호출부가 정할 수 있는 요청 옵션 — 화면이 오류를 직접 그릴 때 silent, 취소가 필요하면 signal */
@@ -54,6 +63,11 @@ export type MailRequestOptions = Pick<AxiosRequestConfig, 'silent' | 'signal'>
 /** 메일 한 통 읽기의 옵션 — showImages 면 외부 이미지를 보이는 본문(`images=show` — 9단계 "외부 이미지 보기") */
 export interface GetMessageOptions extends MailRequestOptions {
   showImages?: boolean
+  /**
+   * 검색 결과에서 연 메일의 강조 쿼리 (14단계 — q · from · to · subject · body 만, mail-search.ts 의 messageHighlightQueryOf).
+   * ⚠️ 읽기 화면(스토어의 열린 메일)만 넘긴다 — 답장 · 전달의 원문 · 인쇄는 넘기지 않는다(강조가 든 응답은 보이기만 한다 — 계약 2절)
+   */
+  highlight?: MessageHighlightQuery | null
 }
 
 export interface SendMessageOptions extends MailRequestOptions {
@@ -225,31 +239,81 @@ export function useMail() {
 
   /**
    * 받은 시각 내림차순. cursor 는 pageInfo.nextCursor 를 해석하지 말고 그대로 넘긴다.
-   * 검색(q)은 mailboxId 가 있으면 그 메일함, 없으면 휴지통 · 스팸메일함을 뺀 모든 메일함에서 찾는다
+   * 검색(q · 조건 — 14단계)은 mailboxId 가 있으면 그 메일함, 없으면 휴지통 · 스팸메일함을 뺀 모든 메일함에서 찾는다.
+   * 색인으로 찾은 검색은 hasNext 인데 항목이 적거나 0개일 수 있다 — 이어 묻는 것은 부르는 쪽(목록 스토어)이다
    */
   function listMessages(
     query: MessageListQuery,
     options?: MailRequestOptions,
-  ): Promise<PaginatedResult<MessageSummary>> {
-    return api.get<PaginatedResult<MessageSummary>, PaginatedResult<MessageSummary>>('/messages', {
+  ): Promise<PaginatedResult<MessageListItem>> {
+    return api.get<PaginatedResult<MessageListItem>, PaginatedResult<MessageListItem>>('/messages', {
       ...options,
       params: query,
     })
   }
 
+  /**
+   * 지난 메일 색인의 상태 (14단계 — 계약 2절 "검색 색인") — 조회지만 상태 줄을 만들고 멈춤을 푼다(멱등).
+   * 검색을 시작할 때 조용히 묻는다 — building 이면 결과 머리 아래 "검색 준비 중" 줄
+   */
+  function getSearchIndex(options?: MailRequestOptions): Promise<SearchIndexState> {
+    return api.get<SearchIndexState, SearchIndexState>('/search-index', options)
+  }
+
   /**
    * 조회만으로는 읽음 처리되지 않는다 — 읽음은 updateMessage 로 따로 보낸다.
    * showImages 면 `?images=show` — 외부 이미지를 중계 주소로 바꿔 넣은 본문(imagesShown: true). 주지 않으면 서버가 설정을 따른다
-   * (늘 묻기 · 주소록과 사내 직원은 늘 보기 · 늘 보기 — 스팸메일함의 메일은 늘 지운다, 계약 2절 "외부 이미지 보기")
+   * (늘 묻기 · 주소록과 사내 직원은 늘 보기 · 늘 보기 — 스팸메일함의 메일은 늘 지운다, 계약 2절 "외부 이미지 보기").
+   * highlight 면 그 검색의 맞은 곳을 강조한 본문(searchHighlight · htmlBody 의 <mark> — 14단계)
    */
   function getMessage(id: string, options: GetMessageOptions = {}): Promise<MessageDetail> {
-    const { showImages, ...requestOptions } = options
+    const { showImages, highlight, ...requestOptions } = options
+    const params: Record<string, string> = {}
+    if (showImages) params[MAIL_IMAGES_PARAM] = MAIL_IMAGES_SHOW
+    for (const [name, value] of Object.entries(highlight ?? {})) {
+      if (typeof value === 'string' && value !== '') params[name] = value
+    }
     return api.get<MessageDetail, MessageDetail>(`/messages/${segment(id)}`, {
       ...requestOptions,
-      ...(showImages ? { params: { [MAIL_IMAGES_PARAM]: MAIL_IMAGES_SHOW } } : {}),
+      ...(Object.keys(params).length > 0 ? { params } : {}),
     })
   }
 
+  /**
+   * 그 메일의 같은 대화 — 오래된 차례, 한 통뿐이면 그 메일 하나 (14단계 — 계약 2절 "대화 — 14단계").
+   * hasNext 인데 항목이 적거나 0개인 쪽이 올 수 있다(엔진 방식) — 이어 묻는 것은 부르는 쪽(스토어의 conversation.ts)이다.
+   * 커서는 그 메일에서만 통한다. 응답은 모양을 맞춰 돌려준다 — 틀리면 빈 대화(칸이 없다)
+   */
+  async function getConversation(
+    id: string,
+    query: CursorPaginationQuery,
+    options?: MailRequestOptions,
+  ): Promise<ConversationPage> {
+    const page = await api.get<unknown, unknown>(`/messages/${segment(id)}/conversation`, {
+      timeout: MAIL_CONVERSATION_TIMEOUT_MS,
+      ...options,
+      params: query,
+    })
+    return conversationPageOf(page)
+  }
+
+  /**
+   * 그 메일함을 대화로 묶은 목록 — 한 줄이 대화 하나, 그 메일함 안 마지막 받은 시각 최신부터 (14단계 — 계약 2절 "대화로 묶어 보기").
+   * 커서는 그 메일함 · 그 기준에서만 통한다. 엔진 방식은 한 요청이 15초까지 걸릴 수 있어 같은 대화와 같은 시간 한도를 쓴다.
+   * 응답은 모양을 맞춰 돌려준다 — 모양이 틀린 줄은 빼고, 마지막 메일은 늘 messageIds 에 든다
+   */
+  async function listConversations(
+    query: ConversationListQuery,
+    options?: MailRequestOptions,
+  ): Promise<ConversationListPage> {
+    const page = await api.get<unknown, unknown>('/conversations', {
+      timeout: MAIL_CONVERSATION_TIMEOUT_MS,
+      ...options,
+      params: query,
+    })
+    return conversationListPageOf(page)
+  }
+
   function updateMessage(
     id: string,
     changes: UpdateMessagePayload,
@@ -453,7 +517,10 @@ export function useMail() {
     downloadMessageSource,
     getMailState,
     listMessages,
+    getSearchIndex,
     getMessage,
+    getConversation,
+    listConversations,
     updateMessage,
     updateMessages,
     deleteMessages,
diff --git a/frontend/src/composables/useMailMoveFeedback.ts b/frontend/src/composables/useMailMoveFeedback.ts
index 97be0c6..e391e98 100644
--- a/frontend/src/composables/useMailMoveFeedback.ts
+++ b/frontend/src/composables/useMailMoveFeedback.ts
@@ -6,15 +6,18 @@ import {
   purgedMessageText,
   restoredMessageText,
   type BulkOrigin,
+  type BulkTextOptions,
 } from '@/shared/utils/mail-bulk'
 import { useMailStore, type BulkMoveResult, type MailBulkResult, type MoveOptions } from '@/stores/mail.store'
 
 /**
  * 옮기기 · 영구 삭제의 결과 알림 (디자인 README "3단계 › 여러 통 처리" · "4단계 › 스팸 · 원문") — 도구 줄과 읽기 화면의 「삭제」 · 「스팸 신고」가 함께 쓴다.
- * - "메일 N통을 X으로 옮겼습니다." + [되돌리기](10초 — 원래 메일함별로 다시 옮기고 "메일 N통을 되돌렸습니다.")
- *   스팸 신고는 같은 문구("…스팸메일함으로 옮겼습니다."), 스팸 아님은 "메일 N통을 받은편지함으로 옮겼습니다 (스팸 아님)."
+ * - "메일 N통을 X으로 옮겼습니다." + [되돌리기](10초 — 원래 메일함별로 다시 옮기고, 한 메일함으로 되돌렸으면 "메일 N통을 X으로 되돌렸습니다.",
+ *   여러 곳이면 "메일 N통을 되돌렸습니다.")
+ *   스팸 신고는 같은 문구("…스팸메일함으로 옮겼습니다."), 스팸 아님은 "메일 N통을 스팸이 아닌 메일로 표시해 받은편지함으로 옮겼습니다."
  *   — 스팸 신고 · 스팸 아님의 되돌리기는 원래 메일함으로 옮기며 표시도 되돌린다(보낸 값의 반대)
- * - "메일 N통을 영구 삭제했습니다."
+ * - 대화로 묶은 목록에서 줄에 한 일(14단계)은 "받은편지함에 있는 메일 2통을 휴지통으로 옮겼습니다." — 줄의 통 수는 대화 전체라서 (options.from)
+ * - "메일 N통을 영구 삭제했습니다." — 대화로 묶은 휴지통에서 줄에 한 일이면 "휴지통에 있는 메일 N통을 영구 삭제했습니다." (같은 까닭 · options.from)
  * - 일부만 처리했으면 뒤에 "N통은 그사이 옮겨졌거나 지워져 그대로 두었습니다." (하나도 못 했으면 그 문장만)
  * - 하나도 보내지 못했으면(요청 실패 — 인터셉터가 알렸다) 알리지 않는다
  * 되돌리기는 알림을 띄운 세션에서만 움직인다 (useToast)
@@ -23,31 +26,42 @@ export function useMailMoveFeedback() {
   const mailStore = useMailStore()
   const toast = useToast()
 
+  /** 되돌린 메일함의 이름 — 한 메일함으로 되돌릴 때만(여러 곳이면 null), 메일함 목록에 없으면 null */
+  function restoredPlaceOf(origins: readonly BulkOrigin[]): string | null {
+    if (origins.length !== 1) return null
+    const mailboxId = origins[0]?.mailboxId
+    return mailStore.mailboxes.find((mailbox) => mailbox.id === mailboxId)?.name ?? null
+  }
+
   async function undo(origins: readonly BulkOrigin[], options: MoveOptions): Promise<void> {
     const result = await mailStore.restoreMoved(origins, options)
     const done = result.doneIds.length
     const skipped = result.skippedIds.length
-    if (done > 0 || skipped > 0) toast.success(restoredMessageText(done, skipped))
+    if (done > 0 || skipped > 0) toast.success(restoredMessageText(done, skipped, restoredPlaceOf(origins)))
   }
 
-  function announceMove(result: BulkMoveResult, mailboxName: string) {
+  /** textOptions.from — 대화로 묶은 목록에서 줄에 한 일이면 그 목록의 메일함 이름 ("받은편지함에 있는 메일 2통을 …") */
+  function announceMove(result: BulkMoveResult, mailboxName: string, textOptions: BulkTextOptions = {}) {
     const done = result.doneIds.length
     const skipped = result.skippedIds.length
     if (done === 0 && skipped === 0) return
     const origins = result.origins
     const undoOptions: MoveOptions = result.isJunk === undefined ? {} : { isJunk: !result.isJunk }
     const text =
-      result.isJunk === false ? notSpamMovedText(done, mailboxName, skipped) : movedMessageText(done, mailboxName, skipped)
+      result.isJunk === false
+        ? notSpamMovedText(done, mailboxName, skipped, textOptions)
+        : movedMessageText(done, mailboxName, skipped, textOptions)
     toast.success(
       text,
       origins.length > 0 ? { label: DRAFT_UNDO_LABEL, run: () => void undo(origins, undoOptions) } : undefined,
     )
   }
 
-  function announcePurge(result: MailBulkResult) {
+  /** textOptions.from — 대화로 묶은 휴지통에서 줄에 한 일이면 그 메일함 이름 ("휴지통에 있는 메일 2통을 영구 삭제했습니다.") */
+  function announcePurge(result: MailBulkResult, textOptions: BulkTextOptions = {}) {
     const done = result.doneIds.length
     const skipped = result.skippedIds.length
-    if (done > 0 || skipped > 0) toast.success(purgedMessageText(done, skipped))
+    if (done > 0 || skipped > 0) toast.success(purgedMessageText(done, skipped, textOptions))
   }
 
   return { announceMove, announcePurge }
diff --git a/frontend/src/composables/useMailSearchNavigation.ts b/frontend/src/composables/useMailSearchNavigation.ts
index 66a6e2f..2e8ab80 100644
--- a/frontend/src/composables/useMailSearchNavigation.ts
+++ b/frontend/src/composables/useMailSearchNavigation.ts
@@ -6,14 +6,21 @@ import { useMailNavigation } from './useMailNavigation'
 import { SEARCH_SCOPE_ALL } from '@/shared/constants/mail'
 import type { Mailbox } from '@/shared/types/mail'
 import {
-  exceedsSearchWords,
   isSearchRouteName,
   listLocationOf,
   normalizeSearchText,
+  sameListSource,
   scopeMailboxIdOf,
   searchSourceFromQuery,
+  searchSourceOf,
   type SearchListSource,
 } from '@/shared/utils/mail-list-source'
+import {
+  exceedsCombinedSearchWords,
+  hasSearchConditions,
+  normalizeSearchConditions,
+  type SearchConditions,
+} from '@/shared/utils/mail-search'
 import { useMailStore, type SearchOrigin } from '@/stores/mail.store'
 
 /** 메일함 화면(목록 · 연 메일)의 라우트 */
@@ -24,9 +31,12 @@ function paramOf(value: unknown): string | null {
 }
 
 /**
- * 검색 화면 오가기 (계약 2절 "검색" · 디자인 README "3단계 › 검색")
- * - 상단 검색 칸의 Enter: 메일함에서 시작하면 그 메일함에서 찾고(휴지통 · 스팸메일함에서 시작해도 그 안에서), 검색 화면에서는 지금 범위 그대로
- * - 결과 머리의 범위 전환: "그 메일함 | 전체 메일함" — 기록을 쌓지 않고 바꿔 끼운다
+ * 검색 화면 오가기 (계약 2절 "검색" · "검색 — 14단계" · 디자인 README "3단계 › 검색" · "14단계 › 검색 · 조건 검색 · 강조")
+ * - 상단 검색 칸의 Enter · 「조건으로 찾기」의 [찾기]: 메일함에서 시작하면 그 메일함에서 찾고(휴지통 · 스팸메일함에서 시작해도 그 안에서),
+ *   검색 화면에서는 지금 범위 그대로. 검색 칸이 비어도 조건만으로 찾는다. Enter 는 걸려 있는 조건을 그대로 둔다.
+ *   검색어도 패널의 조건도 없는 [찾기]는 조건이 걸린 검색이면 검색을 닫는다(조건 줄의 [조건 지우기]와 같다)
+ * - 결과 머리의 범위 전환: "그 메일함 | 전체 메일함" — 기록을 쌓지 않고 바꿔 끼운다 (조건은 그대로)
+ * - 조건 줄의 [조건 지우기]: 조건만 빼고 다시 찾는다 — 검색어도 없으면 검색을 닫는다
  * - ✕ · Esc · "검색 닫기": 검색 전 메일함(화면)으로 — 바로 앞 기록이 그곳이면 뒤로 가기 (뒤로 가기: 메일 → 결과 → 검색 전 메일함)
  */
 export function useMailSearchNavigation() {
@@ -70,28 +80,50 @@ export function useMailSearchNavigation() {
   }
 
   /**
-   * Enter — 빈 검색어는 아무것도 하지 않는다. 같은 검색어로 다시 누르면 보이는 채로 다시 찾는다.
-   * 낱말이 서버 한도(8개)를 넘으면 찾지 않고 서버와 같은 코드(VAL_001)의 사전 문구로 알린다 — 칸에 친 글자는 그대로 둔다
+   * Enter · [찾기] — 검색어도 조건도 없으면 아무것도 하지 않는다. 같은 검색으로 다시 누르면 보이는 채로 다시 찾는다.
+   * conditions 를 주면(「조건으로 찾기」) 그 조건으로, 주지 않으면(검색 칸의 Enter) 걸려 있는 조건 그대로 찾는다.
+   * 조건이 걸린 검색에서 패널의 칸을 모두 비우고 검색어도 없이 [찾기]를 누르면 조건 줄의 [조건 지우기]처럼 검색을 닫는다
+   * (2026-11-07 — 패널의 [조건 지우기]가 칸만 비우게 되어, 조건만 걸린 검색은 [찾기]로도 조건을 뺄 수 있게).
+   * 검색어와 조건 넷을 합친 낱말이 서버 한도(8개)를 넘으면 찾지 않고 서버와 같은 코드(VAL_001)의 사전 문구로 알린다 — 친 글자는 그대로 둔다.
+   * 찾았으면(검색을 닫았으면) true (패널이 닫힌다)
    */
-  async function startSearch(text: string): Promise<void> {
+  async function startSearch(text: string, conditions?: Partial<SearchConditions> | null): Promise<boolean> {
     const q = normalizeSearchText(text)
-    if (!q) return
-    if (exceedsSearchWords(q)) {
-      notifyApiError({ code: 'VAL_001', message: getErrorMessage('VAL_001') })
-      return
-    }
     const current = routeSearch.value
+    const nextConditions = conditions === undefined ? (current?.conditions ?? null) : normalizeSearchConditions(conditions)
+    if (!q && !hasSearchConditions(nextConditions)) {
+      if (!current || !hasSearchConditions(current.conditions)) return false
+      await closeSearch()
+      return true
+    }
+    if (exceedsCombinedSearchWords(q, nextConditions)) {
+      notifyApiError({ code: 'VAL_001', message: getErrorMessage('VAL_001') })
+      return false
+    }
     if (current) {
-      if (current.q === q) {
-        await mailStore.openSearch(q, current.scope, { force: true })
-        return
+      const next = searchSourceOf(q, current.scope, nextConditions)
+      if (sameListSource(current, next)) {
+        await mailStore.openSearch(q, current.scope, { force: true, conditions: next.conditions })
+        return true
       }
-      await router.replace(listLocationOf({ ...current, q }))
-      return
+      await router.replace(listLocationOf(next))
+      return true
     }
     const origin = originOfCurrentScreen()
     mailStore.rememberSearchOrigin(origin)
-    await router.push(listLocationOf({ kind: 'search', q, scope: origin.mailboxId ?? SEARCH_SCOPE_ALL }))
+    await router.push(listLocationOf(searchSourceOf(q, origin.mailboxId ?? SEARCH_SCOPE_ALL, nextConditions)))
+    return true
+  }
+
+  /** 조건 줄의 [조건 지우기] — 조건만 빼고 같은 검색어 · 범위로 다시 찾는다. 검색어가 없으면 검색을 닫는다 */
+  async function clearConditions(): Promise<void> {
+    const current = routeSearch.value
+    if (!current || !hasSearchConditions(current.conditions)) return
+    if (!current.q) {
+      await closeSearch()
+      return
+    }
+    await router.replace(listLocationOf(searchSourceOf(current.q, current.scope)))
   }
 
   /** 범위 전환 — 결과에서 연 메일이 있었으면 결과로 돌아간다 */
@@ -106,5 +138,5 @@ export function useMailSearchNavigation() {
     await backOrReplace(returnLocation())
   }
 
-  return { isSearching, routeSearch, originMailbox, startSearch, setScope, closeSearch }
+  return { isSearching, routeSearch, originMailbox, startSearch, clearConditions, setScope, closeSearch }
 }
diff --git a/frontend/src/composables/useMailSettings.ts b/frontend/src/composables/useMailSettings.ts
index 6d9bf35..8c73f16 100644
--- a/frontend/src/composables/useMailSettings.ts
+++ b/frontend/src/composables/useMailSettings.ts
@@ -9,20 +9,35 @@ export type MailSettingsRequestOptions = Pick<AxiosRequestConfig, 'silent' | 'si
 /** 경로에 넣는 값은 항상 인코딩한다 — 도메인 차단 "@spam.example" 은 "%40spam.example" */
 const segment = (value: string) => encodeURIComponent(value)
 
+/** GET · PATCH /mail-settings 가 실제로 주는 모양 — 14단계 앞의 서버는 groupByConversation 이 없다 */
+type MailSettingsReply = Omit<MailSettings, 'groupByConversation'> & { groupByConversation?: unknown }
+
+/** 설정 응답 → 화면의 값. groupByConversation 이 불리언 true 가 아니면 묶지 않는 것으로 본다 (처음 값 — 계약 2절 "보내기 · 읽기 설정") */
+function mailSettingsOf(reply: MailSettingsReply): MailSettings {
+  // 응답을 바꾼 게이트웨이 등으로 객체가 아닐 수도 있다 — 그때도 던지지 않고 묶지 않는 것으로 본다
+  const value: unknown = reply
+  const grouped =
+    typeof value === 'object' && value !== null && (value as { groupByConversation?: unknown }).groupByConversation === true
+  return { ...reply, groupByConversation: grouped }
+}
+
 // 보내기 · 읽기 설정 · 보낸 사람 차단 API Composable — docs/mail/api-contract.md 2절 "보내기 · 읽기 설정" · "보낸 사람 차단" (9단계, 모두 로그인 필요)
 // 인터셉터가 { success, data } 를 언래핑하므로 각 호출의 응답 타입(R)을 data 타입으로 지정한다.
 // 컴포넌트는 이것을 직접 부르지 않고 스토어(mail-settings.store · mail-block.store)를 거친다
 export function useMailSettings() {
   const api = useApi()
 
-  /** 직원의 설정 — 저장한 적 없으면 처음 값(10초 · 늘 묻기) */
-  function getSettings(options?: MailSettingsRequestOptions): Promise<MailSettings> {
-    return api.get<MailSettings, MailSettings>('/mail-settings', options)
+  /** 직원의 설정 — 저장한 적 없으면 처음 값(10초 · 늘 묻기 · 묶지 않음) */
+  async function getSettings(options?: MailSettingsRequestOptions): Promise<MailSettings> {
+    return mailSettingsOf(await api.get<MailSettingsReply, MailSettingsReply>('/mail-settings', options))
   }
 
-  /** 고른 칸만 보낸다(하나 이상) — 응답은 저장한 뒤의 설정 전체 */
-  function updateSettings(patch: Partial<MailSettings>, options?: MailSettingsRequestOptions): Promise<MailSettings> {
-    return api.patch<MailSettings, MailSettings>('/mail-settings', patch, options)
+  /** 고른 칸만 보낸다(하나 이상) — 응답은 저장한 뒤의 설정 전체. groupByConversation 은 불리언만 받는다(그 밖은 400 VAL_001) */
+  async function updateSettings(
+    patch: Partial<MailSettings>,
+    options?: MailSettingsRequestOptions,
+  ): Promise<MailSettings> {
+    return mailSettingsOf(await api.patch<MailSettingsReply, MailSettingsReply>('/mail-settings', patch, options))
   }
 
   /** 차단한 주소 · 도메인 — 최근에 차단한 것부터 500개까지 */
diff --git a/frontend/src/composables/useMailSettingsRefresh.spec.ts b/frontend/src/composables/useMailSettingsRefresh.spec.ts
new file mode 100644
index 0000000..d94fcc4
--- /dev/null
+++ b/frontend/src/composables/useMailSettingsRefresh.spec.ts
@@ -0,0 +1,135 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { createPinia, setActivePinia } from 'pinia'
+import { effectScope, type EffectScope } from 'vue'
+
+import { useMailSettingsRefresh } from '@/composables/useMailSettingsRefresh'
+import { MAIL_SETTINGS_REFRESH_AFTER_MS } from '@/shared/constants/mail-settings'
+import type { MailSettings } from '@/shared/types/mail'
+import { useAuthStore } from '@/stores/auth.store'
+import { useMailSettingsStore } from '@/stores/mail-settings.store'
+import { useToastStore } from '@/stores/toast.store'
+import { createManualClock, type ManualClock } from '@/test-utils/manual-clock'
+import { fail, flushPromises, installMockApi, ok, restoreApiAdapter, type MockRequest, type MockResult } from '@/test-utils/mock-api'
+
+// 메일 화면이 탭으로 돌아올 때 보내기 · 읽기 설정을 다시 받는다 (14단계 — 2026-11-06 실사용 시험: 다른 탭에서 끈 묶기가 열어 둔 탭에 남았다)
+// 손으로 돌리는 시계와 화면 보임 상태로 확인한다 (고정 대기 없이)
+
+const USER = { email: 'ara.kim@arasystem.test', name: '김아라' }
+const SETTINGS: MailSettings = { undoSendSeconds: 10, externalImages: 'ask', groupByConversation: true }
+
+describe('useMailSettingsRefresh (탭으로 돌아오면 설정 다시 받기)', () => {
+  let scope: EffectScope
+  let clock: ManualClock
+  let visibility: DocumentVisibilityState
+  let server: MailSettings
+  let load: () => MockResult
+  let requests: MockRequest[]
+
+  beforeEach(async () => {
+    setActivePinia(createPinia())
+    useAuthStore().markAuthenticated(USER)
+    scope = effectScope()
+    clock = createManualClock()
+    visibility = 'visible'
+    Object.defineProperty(document, 'visibilityState', { configurable: true, get: () => visibility })
+    server = SETTINGS
+    load = () => ok(server)
+    requests = installMockApi((request) => (request.method === 'GET' ? load() : ok(server)))
+    // 메일 화면에 들어올 때 받아 둔다 (MailLayout 의 ensureLoaded)
+    await useMailSettingsStore().load()
+  })
+
+  afterEach(() => {
+    scope.stop()
+    Reflect.deleteProperty(document, 'visibilityState')
+    useToastStore().clear()
+    restoreApiAdapter()
+  })
+
+  function start() {
+    scope.run(() => useMailSettingsRefresh({ clock }))
+  }
+
+  async function comeBack(afterMs: number) {
+    visibility = 'hidden'
+    document.dispatchEvent(new Event('visibilitychange'))
+    clock.advance(afterMs)
+    visibility = 'visible'
+    document.dispatchEvent(new Event('visibilitychange'))
+    await flushPromises()
+  }
+
+  const fetched = () => requests.filter((request) => request.method === 'GET' && request.url === '/mail-settings').length
+
+  it('마지막으로 받은 지 60초가 지난 뒤 탭으로 돌아오면 조용히 다시 받아 그 값을 쓴다 — 묶기 · 보내기 취소 초 · 외부 이미지', async () => {
+    start()
+    server = { undoSendSeconds: 30, externalImages: 'always', groupByConversation: false }
+
+    await comeBack(MAIL_SETTINGS_REFRESH_AFTER_MS)
+
+    expect(fetched()).toBe(2)
+    expect(requests.at(-1)?.config.silent).toBe(true)
+    const store = useMailSettingsStore()
+    expect(store.groupByConversation).toBe(false)
+    expect(store.knownUndoSendSeconds).toBe(30)
+    expect(store.settings?.externalImages).toBe('always')
+    expect(useToastStore().toasts).toEqual([])
+  })
+
+  it('60초가 안 됐으면 다시 받지 않는다 — 받은 뒤에는 또 60초를 센다', async () => {
+    start()
+    await comeBack(MAIL_SETTINGS_REFRESH_AFTER_MS - 1)
+    expect(fetched()).toBe(1)
+
+    await comeBack(1)
+    expect(fetched()).toBe(2)
+
+    await comeBack(MAIL_SETTINGS_REFRESH_AFTER_MS - 1)
+    expect(fetched()).toBe(2)
+  })
+
+  it('숨는 때에는 받지 않는다 — 다시 보일 때만', async () => {
+    start()
+    clock.advance(MAIL_SETTINGS_REFRESH_AFTER_MS * 2)
+    visibility = 'hidden'
+    document.dispatchEvent(new Event('visibilitychange'))
+    await flushPromises()
+
+    expect(fetched()).toBe(1)
+  })
+
+  it('세션을 쓸 수 없으면(제한된 세션 · 로그아웃) 받지 않는다', async () => {
+    start()
+    // 같은 직원의 세션에 제한이 붙었다 — 받아 둔 설정은 그대로지만 묻지 않는다
+    useAuthStore().markAuthenticated(USER, { restriction: 'passwordChange', twoFactorDeadline: null })
+    await comeBack(MAIL_SETTINGS_REFRESH_AFTER_MS)
+    expect(useMailSettingsStore().status).toBe('ready')
+    expect(fetched()).toBe(1)
+
+    useAuthStore().clearAuth()
+    await comeBack(MAIL_SETTINGS_REFRESH_AFTER_MS)
+    expect(fetched()).toBe(1)
+  })
+
+  it('받지 못하면 알리지 않고 지금 값을 둔다 — 60초 뒤 다시 보일 때 또 해 본다', async () => {
+    start()
+    load = () => fail(503, 'SYS_001')
+    await comeBack(MAIL_SETTINGS_REFRESH_AFTER_MS)
+
+    expect(fetched()).toBe(2)
+    expect(useMailSettingsStore().settings).toEqual(SETTINGS)
+    expect(useToastStore().toasts).toEqual([])
+
+    load = () => ok({ ...SETTINGS, groupByConversation: false })
+    await comeBack(MAIL_SETTINGS_REFRESH_AFTER_MS)
+    expect(fetched()).toBe(3)
+    expect(useMailSettingsStore().groupByConversation).toBe(false)
+  })
+
+  it('화면이 사라지면 그만 본다', async () => {
+    start()
+    scope.stop()
+    await comeBack(MAIL_SETTINGS_REFRESH_AFTER_MS)
+    expect(fetched()).toBe(1)
+  })
+})
diff --git a/frontend/src/composables/useMailSettingsRefresh.ts b/frontend/src/composables/useMailSettingsRefresh.ts
new file mode 100644
index 0000000..0a81c67
--- /dev/null
+++ b/frontend/src/composables/useMailSettingsRefresh.ts
@@ -0,0 +1,51 @@
+import { onScopeDispose, watch } from 'vue'
+
+import { systemClock, type Clock } from './useClock'
+import { MAIL_SETTINGS_REFRESH_AFTER_MS } from '@/shared/constants/mail-settings'
+import { useAuthStore } from '@/stores/auth.store'
+import { useMailSettingsStore } from '@/stores/mail-settings.store'
+
+// 보내기 · 읽기 설정을 메일 화면에서 다시 받는 때 (14단계 — 2026-11-06 실사용 시험: 다른 탭에서 끈 [대화로 묶기]가 열어 둔 탭에 남았다)
+// - 메일 화면(MailLayout)이 있는 동안, 탭이 다시 보이게 될 때 설정을 마지막으로 받은 지 60초가 지났으면 조용히 다시 받는다(알리지 않는다)
+//   — 받은 묶기 값이 다르면 메일함 화면이 그 값으로 목록을 다시 열고(MailboxPage), 보내기 취소 초 · 외부 이미지도 받은 값을 쓴다
+// - 마지막으로 받은 때는 화면에 들어온 때(그때 받아 두었거나 지금 받는다)와 받을 때마다(스토어의 fetchSeq)다. 다시 받기를 시작하면 그때로 —
+//   받지 못하면(알리지 않는다) 60초 뒤 다시 보일 때 또 해 본다
+// - 세션이 끝났으면(로그아웃 · 세션 만료 · 제한된 세션) 받지 않는다. 저장하는 중 · 받는 사이 고른 값은 스토어가 지킨다(refresh)
+
+export interface MailSettingsRefreshOptions {
+  /** 테스트는 손으로 돌리는 시계를 넘긴다 (test-utils/manual-clock.ts) */
+  clock?: Clock
+}
+
+function isPageVisible(): boolean {
+  return typeof document === 'undefined' || document.visibilityState === 'visible'
+}
+
+export function useMailSettingsRefresh(options: MailSettingsRefreshOptions = {}): void {
+  const clock = options.clock ?? systemClock
+  const authStore = useAuthStore()
+  const settingsStore = useMailSettingsStore()
+
+  /** 설정을 마지막으로 받은 때 (ms) */
+  let fetchedAt = clock.now()
+
+  function onVisibilityChange() {
+    if (!isPageVisible() || !authStore.canUseApp) return
+    const now = clock.now()
+    if (now - fetchedAt < MAIL_SETTINGS_REFRESH_AFTER_MS) return
+    fetchedAt = now
+    void settingsStore.refresh()
+  }
+
+  watch(
+    () => settingsStore.fetchSeq,
+    () => {
+      fetchedAt = clock.now()
+    },
+  )
+
+  if (typeof document !== 'undefined') {
+    document.addEventListener('visibilitychange', onVisibilityChange)
+    onScopeDispose(() => document.removeEventListener('visibilitychange', onVisibilityChange))
+  }
+}
diff --git a/frontend/src/composables/useMessageRemoval.ts b/frontend/src/composables/useMessageRemoval.ts
index f4a5b8d..e7df937 100644
--- a/frontend/src/composables/useMessageRemoval.ts
+++ b/frontend/src/composables/useMessageRemoval.ts
@@ -21,6 +21,7 @@ import { useMailStore } from '@/stores/mail.store'
 //   이 길에서는 낡은 정보가 해롭지 않다: 이미 휴지통에 있는 메일을 휴지통으로 옮기면 그대로이고, 휴지통을 떠난 메일의 영구 삭제는
 //   서버가 그대로 둔다(skippedIds — 목록을 다시 맞춘다)
 // - 뺀 뒤(leaveRemoved): 분할 보기는 다음 메일(없으면 이전 메일, 그것도 없으면 목록), 목록 보기는 목록으로 (기록을 쌓지 않는다).
+//   대화로 묶은 메일함(14단계)은 같은 결로 그 줄의 다음 칸(더 오래된 메일), 없으면 앞 칸, 줄이 비면 다음 줄의 마지막 메일 (스토어의 neighborAfterRemoval).
 //   그사이 다른 목록으로 옮겨 갔거나 서버가 그대로 두었으면 움직이지 않는다
 
 export interface MessageRemovalOutcome {
@@ -55,7 +56,7 @@ export function useMessageRemoval() {
   }
 
   function outcomeOf(id: string, nextId: string | null, done: boolean, stale: boolean): MessageRemovalOutcome {
-    const removed = done && !stale && !mailStore.messages.some((message) => message.id === id)
+    const removed = done && !stale && !mailStore.isListedMessage(id)
     return { removed, nextId: removed ? nextId : null }
   }
 
diff --git a/frontend/src/composables/usePendingSendRefresh.spec.ts b/frontend/src/composables/usePendingSendRefresh.spec.ts
index 25ca67b..e2f38ed 100644
--- a/frontend/src/composables/usePendingSendRefresh.spec.ts
+++ b/frontend/src/composables/usePendingSendRefresh.spec.ts
@@ -160,4 +160,30 @@ describe('usePendingSendRefresh — 보낼 시각이 지나면 다시 본다', (
     expect(listRequests()).toEqual([])
     expect(clock.pendingCount()).toBe(0)
   })
+
+  it('읽기 화면 "같은 대화" 칸에만 있는 붙잡힌 메일도 지켜본다 — 보낼 시각 + 2초에 그 대화를 알리지 않고 다시 받아 "보내는 중"이 내려간다 (14단계)', async () => {
+    let thread = [summary('m3', null), summary('u1', { kind: 'undo', sendAt: at(10_000) })]
+    requests = installMockApi((request) => {
+      if (request.url === '/scheduled-messages') return page([])
+      if (request.url.endsWith('/conversation')) {
+        return ok({ items: thread, pageInfo: { hasNext: false, nextCursor: null, total: thread.length }, basis: 'index' })
+      }
+      return ok({})
+    })
+    const store = useMailStore()
+    await store.loadConversation('m3')
+    scope.run(() => usePendingSendRefresh({ clock }))
+    const conversations = () => requests.filter((request) => request.url.endsWith('/conversation'))
+    expect(conversations()).toHaveLength(1)
+
+    thread = [summary('m3', null), summary('u1', null)]
+    await advance(11_999)
+    expect(conversations()).toHaveLength(1)
+    await advance(1)
+
+    expect(conversations()).toHaveLength(2)
+    expect(conversations()[1]?.config.silent).toBe(true)
+    expect(store.conversationItems.find((item) => item.id === 'u1')?.pendingSend).toBeNull()
+    expect(clock.pendingCount()).toBe(0)
+  })
 })
diff --git a/frontend/src/composables/usePendingSendRefresh.ts b/frontend/src/composables/usePendingSendRefresh.ts
index e2b21ef..416a63e 100644
--- a/frontend/src/composables/usePendingSendRefresh.ts
+++ b/frontend/src/composables/usePendingSendRefresh.ts
@@ -17,8 +17,9 @@ import { useMailStore } from '@/stores/mail.store'
 // 엔진이 붙잡아 둔 발송을 풀 때(보냄) 화면을 다시 맞춘다 (계약 2절 "보내기 취소 · 예약 발송" — 9단계, 메일 화면 MailLayout 이 시작)
 // 엔진이 풀어도 새 메일 확인(GET /mail-state) · 실시간 알림의 state 는 바뀌지 않는다 — 그대로 두면 보낸편지함의 "보내는 중" · "예약 · 시각",
 // 패널의 「예약됨」 수, 읽기 화면의 청록 줄이 계속 남고, 그 메일의 [고치기] · [예약 취소]가 매번 "이미 보낸 메일"(MAIL_014)이 된다 (2026-10-29 리뷰).
-// - 지켜보는 것: 보이는 목록의 줄 · 열린 메일 · 가장 이른 예약(예약됨 수를 물은 응답의 첫 줄)의 pendingSend.sendAt — 같은 메일은 하나로 본다
-// - 그 가운데 가장 이른 시각 + 2초에 한 번 다시 본다(스토어의 refreshPendingSends — 보이는 목록 · 열린 메일 · 예약됨 수, 알리지 않는다)
+// - 지켜보는 것: 보이는 목록의 줄 · 열린 메일 · 가장 이른 예약(예약됨 수를 물은 응답의 첫 줄) · 읽기 화면 "같은 대화" 칸의 줄(14단계)의
+//   pendingSend.sendAt — 같은 메일은 하나로 본다
+// - 그 가운데 가장 이른 시각 + 2초에 한 번 다시 본다(스토어의 refreshPendingSends — 보이는 목록 · 열린 메일 · 예약됨 수 · 붙잡힌 메일이 든 같은 대화, 알리지 않는다)
 // - 다시 본 뒤에도 시각이 지난 채 남아 있으면(서버가 늦음 · 이 PC 시계가 빠름) 5초마다 세 번까지 더 보고, 그래도 남으면 그 발송은 그만 본다
 //   (다음 새 메일 확인 · 화면 이동이 맞춘다 — 같은 요청을 끝없이 보내지 않게). 처음부터 시각이 지나 보이는 것(시계가 어긋남)도 5초 뒤부터 같다
 // 시계를 주입받는다 — 테스트는 손으로 돌리는 시계로 시간을 넘긴다 (test-utils/manual-clock.ts)
@@ -40,7 +41,13 @@ export function usePendingSendRefresh(options: PendingSendRefreshOptions = {}) {
   const givenUp = new Set<string>()
 
   const watches = computed<PendingWatch[]>(() =>
-    pendingWatchesOf([...mailStore.messages, mailStore.selected, mailStore.nextScheduled]),
+    pendingWatchesOf([
+      // 보이는 목록의 줄 — 대화로 묶은 메일함은 줄마다 마지막 메일 (14단계 — 줄 안의 다른 붙잡힌 메일은 시각을 몰라 다음 맞추기를 기다린다)
+      ...mailStore.listedSummaries,
+      mailStore.selected,
+      mailStore.nextScheduled,
+      ...mailStore.conversationItems,
+    ]),
   )
 
   /** 지금 지켜볼 것 — 그만 보기로 한 것은 빼고, 사라진 것은 잊는다 */
diff --git a/frontend/src/composables/useScheduledMessageActions.ts b/frontend/src/composables/useScheduledMessageActions.ts
index 90e6ec3..d4b5a12 100644
--- a/frontend/src/composables/useScheduledMessageActions.ts
+++ b/frontend/src/composables/useScheduledMessageActions.ts
@@ -74,7 +74,7 @@ export function useScheduledMessageActions() {
 
   /** 목록에서 빠졌는가 — 빠졌으면 삭제처럼 다음 메일(분할 보기) · 목록(목록 보기)으로 */
   function removedFromList(messageId: string): boolean {
-    return !mailStore.messages.some((message) => message.id === messageId)
+    return !mailStore.isListedMessage(messageId)
   }
 
   /** [예약 취소] — 보내지 않고 임시보관함으로 */
diff --git a/frontend/src/composables/useSearchConditionsDraft.ts b/frontend/src/composables/useSearchConditionsDraft.ts
new file mode 100644
index 0000000..09c5462
--- /dev/null
+++ b/frontend/src/composables/useSearchConditionsDraft.ts
@@ -0,0 +1,127 @@
+import { reactive, ref } from 'vue'
+
+import type { Clock } from '@/composables/useClock'
+import type { SearchPeriod } from '@/shared/constants/mail-search'
+import {
+  isReversedPeriod,
+  isSearchDay,
+  normalizeSearchConditions,
+  periodOf,
+  periodRange,
+  type SearchConditions,
+} from '@/shared/utils/mail-search'
+
+/** 기간 칸의 잘못 — 시작이 끝보다 늦음(order) · 고를 수 없는 날짜(range — 1970-01-01 ~ 9999-12-30 밖) */
+export type SearchPeriodProblem = 'order' | 'range'
+
+/** 「조건으로 찾기」 패널의 칸 값 — 날짜는 <input type="date"> 값(YYYY-MM-DD, 비면 '') */
+export interface SearchConditionsDraft {
+  from: string
+  to: string
+  subject: string
+  body: string
+  period: SearchPeriod
+  since: string
+  until: string
+  hasAttachment: boolean
+}
+
+/**
+ * 「조건으로 찾기」 패널의 칸 값 (14단계 — 디자인 원본 Search14). 걸린 조건으로 채우고(fill), 넘길 조건을 만든다(take), 모두 비운다(clear — [조건 지우기]).
+ * - 기간은 오늘 기준의 미리 정한 기간과 같으면 그 고르기, 아니면 날짜 고르기로 채운다. 미리 정한 기간은 넘길 때 그 날짜(그만큼 앞의 같은 날 ~ 오늘)로 바꾼다
+ * - 미리 정한 기간에서 날짜 고르기로 바꾸면 빈 날짜 칸을 그 기간의 날짜로 채워 둔다 — 조금만 고치면 되게
+ * - 날짜 고르기의 시작이 끝보다 늦거나 고를 수 없는 날짜면 넘기지 않고 periodProblem 을 둔다 (칸 아래에 알린다)
+ * 오늘은 주입한 시계로 센다 (테스트는 손으로 돌리는 시계)
+ */
+export function useSearchConditionsDraft(clock: Clock) {
+  const draft = reactive<SearchConditionsDraft>({
+    from: '',
+    to: '',
+    subject: '',
+    body: '',
+    period: 'all',
+    since: '',
+    until: '',
+    hasAttachment: false,
+  })
+  const periodProblem = ref<SearchPeriodProblem | null>(null)
+  /** 바로 전에 고른 기간 — 날짜 고르기로 바꿀 때 그 날짜로 칸을 채운다 */
+  let previousPeriod: SearchPeriod = 'all'
+
+  function today(): Date {
+    return new Date(clock.now())
+  }
+
+  /** 걸린 조건으로 칸을 채운다 (열 때) */
+  function fill(conditions: SearchConditions | null) {
+    const value = normalizeSearchConditions(conditions)
+    draft.from = value.from
+    draft.to = value.to
+    draft.subject = value.subject
+    draft.body = value.body
+    draft.period = periodOf(value.since, value.until, today())
+    draft.since = value.since ?? ''
+    draft.until = value.until ?? ''
+    draft.hasAttachment = value.hasAttachment
+    previousPeriod = draft.period
+    periodProblem.value = null
+  }
+
+  /**
+   * 칸을 모두 비운다 — 패널의 [조건 지우기] (2026-11-07): 글 칸 · 기간(전체 기간) · 날짜 · 첨부 체크 · 칸 아래 알림까지.
+   * 찾지는 않는다 — 걸린 조건은 [찾기]를 누를 때까지 그대로다
+   */
+  function clear() {
+    fill(null)
+  }
+
+  /** 기간 고르기를 바꾼다 */
+  function changePeriod(period: SearchPeriod) {
+    draft.period = period
+    periodProblem.value = null
+    if (period === 'custom' && !draft.since && !draft.until) {
+      const range = periodRange(previousPeriod, today())
+      draft.since = range.since ?? ''
+      draft.until = range.until ?? ''
+    }
+    previousPeriod = period
+  }
+
+  /** 날짜 칸을 바꾼다 — 알리던 잘못을 지운다 */
+  function changeDay(edge: 'since' | 'until', value: string) {
+    draft[edge] = value
+    periodProblem.value = null
+  }
+
+  /** 넘길 조건 — 기간이 잘못됐으면 null (periodProblem 에 까닭) */
+  function take(): SearchConditions | null {
+    let since: string | null
+    let until: string | null
+    if (draft.period === 'custom') {
+      since = draft.since || null
+      until = draft.until || null
+      if ((since !== null && !isSearchDay(since)) || (until !== null && !isSearchDay(until))) {
+        periodProblem.value = 'range'
+        return null
+      }
+      if (isReversedPeriod(since, until)) {
+        periodProblem.value = 'order'
+        return null
+      }
+    } else {
+      ;({ since, until } = periodRange(draft.period, today()))
+    }
+    periodProblem.value = null
+    return normalizeSearchConditions({
+      from: draft.from,
+      to: draft.to,
+      subject: draft.subject,
+      body: draft.body,
+      since,
+      until,
+      hasAttachment: draft.hasAttachment,
+    })
+  }
+
+  return { draft, periodProblem, fill, clear, changePeriod, changeDay, take }
+}
diff --git a/frontend/src/composables/useSearchConditionsPopup.ts b/frontend/src/composables/useSearchConditionsPopup.ts
new file mode 100644
index 0000000..d126668
--- /dev/null
+++ b/frontend/src/composables/useSearchConditionsPopup.ts
@@ -0,0 +1,74 @@
+import { nextTick, onBeforeUnmount, ref, watch, type Ref } from 'vue'
+import { useRoute } from 'vue-router'
+
+/** 닫을 때 초점을 [조건]으로 돌릴지 — 기본은 돌린다 */
+export interface SearchConditionsCloseOptions {
+  restoreFocus?: boolean
+}
+
+interface Options {
+  /** 검색 칸(form) — 이 안을 누르거나 이 안으로 옮기는 초점은 바깥이 아니다 */
+  container: Ref<HTMLElement | null>
+  /** [조건] — 닫을 때 초점을 돌려줄 곳 */
+  toggle: Ref<{ focus: () => void } | null>
+  /** 연 뒤(패널이 그려진 뒤) — 첫 칸으로 초점 */
+  onOpened: () => void
+}
+
+/**
+ * 검색 칸의 「조건으로 찾기」 패널 열고 닫기 (14단계 — 디자인 원본 Search14).
+ * 열린 동안 바깥을 누르거나(pointerdown — 초점은 누른 곳으로 간다) 키보드로 검색 칸 밖으로 나가거나(focusout)
+ * 다른 화면으로 가면(뒤로 가기 등) 닫는다 — 이때는 초점을 옮기지 않는다. 그 밖에 닫을 때는 [조건]으로 초점을 돌린다(restoreFocus 로 끈다).
+ * 패널의 칸은 열 때마다 걸린 조건으로 다시 채운다(패널이 v-if 로 새로 그려진다)
+ */
+export function useSearchConditionsPopup(options: Options) {
+  const route = useRoute()
+  const isOpen = ref<boolean>(false)
+
+  function onDocumentPointerDown(event: PointerEvent) {
+    const target = event.target instanceof Node ? event.target : null
+    if (target && options.container.value?.contains(target)) return
+    close({ restoreFocus: false })
+  }
+
+  function listenOutside(on: boolean) {
+    if (on) document.addEventListener('pointerdown', onDocumentPointerDown, true)
+    else document.removeEventListener('pointerdown', onDocumentPointerDown, true)
+  }
+
+  /** 키보드로 패널 · 검색 칸 밖으로 나가면 닫는다 (마우스로 누른 곳은 pointerdown 이 본다 — relatedTarget 이 없다) */
+  function onFocusOut(event: FocusEvent) {
+    const next = event.relatedTarget instanceof Node ? event.relatedTarget : null
+    if (!isOpen.value || !next || options.container.value?.contains(next)) return
+    close({ restoreFocus: false })
+  }
+
+  async function open() {
+    if (isOpen.value) return
+    isOpen.value = true
+    listenOutside(true)
+    await nextTick()
+    if (isOpen.value) options.onOpened()
+  }
+
+  function close(closeOptions: SearchConditionsCloseOptions = {}) {
+    if (!isOpen.value) return
+    isOpen.value = false
+    listenOutside(false)
+    if (closeOptions.restoreFocus !== false) void nextTick(() => options.toggle.value?.focus())
+  }
+
+  function toggle() {
+    if (isOpen.value) close()
+    else void open()
+  }
+
+  watch(
+    () => route.fullPath,
+    () => close({ restoreFocus: false }),
+  )
+
+  onBeforeUnmount(() => listenOutside(false))
+
+  return { isOpen, open, close, toggle, onFocusOut }
+}
diff --git a/frontend/src/pages/mail/ComposePage.sendlater.spec.ts b/frontend/src/pages/mail/ComposePage.sendlater.spec.ts
index 9c69327..a225fe1 100644
--- a/frontend/src/pages/mail/ComposePage.sendlater.spec.ts
+++ b/frontend/src/pages/mail/ComposePage.sendlater.spec.ts
@@ -262,7 +262,7 @@ describe('ComposePage — 보내기 취소 · 예약 발송 (9단계)', () => {
 
     it('보내기 · 읽기 설정을 받아 두었으면 설정한 초 − 1초에 닫는다 — 이 PC 시계가 늦어 보낼 시각이 멀리 보여도 늘어나지 않는다 (리뷰 #11)', async () => {
       const settings = useMailSettingsStore()
-      settings.settings = { undoSendSeconds: 5, externalImages: 'ask' }
+      settings.settings = { undoSendSeconds: 5, externalImages: 'ask', groupByConversation: false }
       settings.status = 'ready'
       const far = ok({ id: 'sent-1', rejectedRecipients: [], pendingSend: { kind: 'undo', sendAt: new Date(NOW + 600_000).toISOString() } }, 201)
       const { wrapper } = await mountCompose(server([far]))
@@ -322,7 +322,7 @@ describe('ComposePage — 보내기 취소 · 예약 발송 (9단계)', () => {
       expect(wrapper.find('#compose-recipient-error').exists()).toBe(true)
     })
 
-    it('고르기 첫 줄로 [예약] — 발송 본문에 sendAt(UTC) · 알림 "‘시각’ 에 보냅니다." + [예약됨 보기] · 예약한 메일 수를 다시 묻는다', async () => {
+    it('고르기 첫 줄로 [예약] — 발송 본문에 sendAt(UTC) · 알림 "‘시각’에 보냅니다." + [예약됨 보기] · 예약한 메일 수를 다시 묻는다', async () => {
       const preset = schedulePresets(NOW)[0]
       if (!preset) throw new Error('고르기가 없다')
       const sendAt = sendAtOf(preset.at)
@@ -344,7 +344,7 @@ describe('ComposePage — 보내기 취소 · 예약 발송 (9단계)', () => {
       expect(toasts()).toEqual([
         expect.objectContaining({
           kind: 'success',
-          message: `${formatScheduleTime(sendAt)} 에 보냅니다.`,
+          message: `${formatScheduleTime(sendAt)}에 보냅니다.`,
           action: { label: '예약됨 보기', to: { name: 'mail-scheduled' } },
           expiresAt: null,
         }),
diff --git a/frontend/src/pages/mail/ComposePage.spec.ts b/frontend/src/pages/mail/ComposePage.spec.ts
index a64c16e..36db7dc 100644
--- a/frontend/src/pages/mail/ComposePage.spec.ts
+++ b/frontend/src/pages/mail/ComposePage.spec.ts
@@ -181,6 +181,24 @@ describe('ComposePage', () => {
     expect(quote.text()).not.toContain('받는 사람')
   })
 
+  it('검색 결과에서 강조해 연 메일이 스토어에 있어도 답장의 원문은 검색 쿼리 없이 다시 받는다 — 인용에 <mark> 가 없다 (14단계)', async () => {
+    const store = useMailStore()
+    store.selectedId = 'm1'
+    store.selected = {
+      ...ORIGINAL,
+      htmlBody: '<p><mark>계약</mark>서를 보냅니다</p>',
+      searchHighlight: { subject: [[0, 2]], attachments: {}, textBody: [] },
+    }
+    store.selectedHighlight = { q: '계약' }
+    const { wrapper, requests } = await mountCompose('/mail/compose?replyTo=m1', replyApi)
+
+    const originals = requests.filter((request) => request.method === 'GET' && request.url === '/messages/m1')
+    expect(originals).toHaveLength(1)
+    expect(originals[0]?.params).toEqual({})
+    expect(wrapper.get('#compose-body').html()).not.toContain('<mark')
+    expect(wrapper.get('#compose-body').text()).toContain('김아라님, 안녕하세요.')
+  })
+
   it('답장은 커서를 본문 맨 위 첫 줄(인용 위)에 둔다', async () => {
     const { wrapper } = await mountCompose('/mail/compose?replyTo=m1', replyApi, true)
     await vi.waitFor(
@@ -618,7 +636,7 @@ describe('ComposePage', () => {
     ])
     expect(wrapper.get('[data-large-upload]').text()).toContain('도면.pdf')
     expect(wrapper.get('[data-large-switch]').text()).toBe(
-      '‘도면.pdf’(5 MB)는 메일에 담으면 합계가 15MB 를 넘어 링크로 보냅니다.',
+      '‘도면.pdf’(5 MB)는 메일에 담으면 합계가 15MB를 넘어 링크로 보냅니다.',
     )
     expect(requests.filter((request) => request.url === '/mail-attachments')).toHaveLength(1)
     expect(useToastStore().toasts).toEqual([])
diff --git a/frontend/src/pages/mail/MailLayout.conversation.spec.ts b/frontend/src/pages/mail/MailLayout.conversation.spec.ts
new file mode 100644
index 0000000..e1eaac5
--- /dev/null
+++ b/frontend/src/pages/mail/MailLayout.conversation.spec.ts
@@ -0,0 +1,183 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { mount, type VueWrapper } from '@vue/test-utils'
+import { createPinia, setActivePinia, type Pinia } from 'pinia'
+import { h } from 'vue'
+import { createMemoryHistory, createRouter, RouterView } from 'vue-router'
+
+import { CLOCK } from '@/composables/useClock'
+import { routes } from '@/router/routes'
+import { MAIL_STATE_POLL_INTERVAL_MS } from '@/shared/constants/mail'
+import { MAIL_CONVERSATION_REFRESH_GAP_MS } from '@/shared/constants/mail-conversation'
+import type { Mailbox, MessageDetail, MessageSummary } from '@/shared/types/mail'
+import { useAuthStore } from '@/stores/auth.store'
+import { useMailStore } from '@/stores/mail.store'
+import { useToastStore } from '@/stores/toast.store'
+import { createManualClock, type ManualClock } from '@/test-utils/manual-clock'
+import { flushPromises, installMockApi, ok, restoreApiAdapter, type MockRequest } from '@/test-utils/mock-api'
+
+// 메일 화면의 바뀜 소식(1분 확인 · 실시간 — MailLayout 의 onChange) → 메일함 개수 맞추기 → 같은 대화 칸 다시 받기 (14단계).
+// 읽음 · 중요 표시만 바뀐 소식(메일함들의 통 수가 그대로)으로는 대화를 다시 받지 않는다 — 대화 경로의 요청 수 한도를 아끼려고(리뷰 중간 2).
+// 실제 메일 화면(MailLayout → MailboxPage → 읽기 화면 → 같은 대화 칸)을 띄우고 손으로 돌리는 시계로 1분 확인을 넘긴다
+
+const USER = { email: 'ara.kim@arasystem.test', name: '김아라' }
+
+function mailbox(id: string, role: Mailbox['role'], name: string, totalCount: number, unreadCount: number): Mailbox {
+  return { id, name, role, parentId: null, sortOrder: 0, totalCount, unreadCount }
+}
+
+function summary(id: string, partial: Partial<MessageSummary> = {}): MessageSummary {
+  return {
+    id,
+    threadId: 't1',
+    mailboxIds: ['inbox'],
+    from: { name: '이도윤', email: 'doyun.lee@arasystem.test' },
+    to: [{ name: '김아라', email: USER.email }],
+    subject: '회신: 유지보수 계약 갱신 건',
+    preview: `미리 보기 ${id}`,
+    receivedAt: new Date(2026, 10, 5, 9, 30).toISOString(),
+    isRead: true,
+    isFlagged: false,
+    hasAttachment: false,
+    size: 100,
+    pendingSend: null,
+    ...partial,
+  }
+}
+
+function detail(base: MessageSummary): MessageDetail {
+  return {
+    ...base,
+    cc: [],
+    bcc: [],
+    replyTo: [],
+    sentAt: null,
+    messageId: null,
+    references: [],
+    htmlBody: null,
+    textBody: `${base.id} 본문`,
+    hasBlockedImages: false,
+    attachments: [],
+  }
+}
+
+const page = (items: unknown[], total = items.length) => ok({ items, pageInfo: { hasNext: false, nextCursor: null, total } })
+
+describe('MailLayout — 바뀜 소식으로 같은 대화 칸을 다시 받는다 (메일함들의 통 수가 바뀔 때만)', () => {
+  let pinia: Pinia
+  let clock: ManualClock
+  let requests: MockRequest[]
+  let state: string
+  let inboxTotal: number
+  let inboxUnread: number
+  let thread: MessageSummary[]
+  const mounted: VueWrapper[] = []
+
+  beforeEach(() => {
+    window.localStorage.clear()
+    pinia = createPinia()
+    setActivePinia(pinia)
+    useAuthStore().markAuthenticated(USER)
+    clock = createManualClock(new Date(2026, 10, 6, 15).getTime())
+    state = 's1'
+    inboxTotal = 2
+    inboxUnread = 1
+    thread = [summary('m1', { mailboxIds: ['sent'], from: USER }), summary('m3')]
+    requests = installMockApi(({ url, method }) => {
+      if (url === '/mail-state') return ok({ state })
+      if (url === '/mailboxes') {
+        return page([mailbox('inbox', 'inbox', '받은편지함', inboxTotal, inboxUnread), mailbox('sent', 'sent', '보낸편지함', 1, 0)])
+      }
+      if (url === '/mail-quota') {
+        return ok({ usedBytes: 0, limitBytes: null, attachmentMaxBytes: 1, attachmentTotalMaxBytes: 1 })
+      }
+      if (url === '/mail-signature') {
+        return ok({ bodyHtml: null, body: null, isForNew: true, isForReply: true, images: [], updatedAt: null })
+      }
+      if (url === '/mail-vacation') {
+        return ok({ isEnabled: false, fromDate: null, toDate: null, subject: '', textBody: '', isActive: true })
+      }
+      if (url === '/mail-blocks') return ok({ senders: [], isActive: true })
+      if (url === '/mail-settings') return ok({ undoSendSeconds: 10, externalImages: 'ask', groupByConversation: false })
+      if (url === '/scheduled-messages') return page([])
+      if (url === '/messages' && method === 'GET') return page([summary('m3'), summary('m2', { threadId: 't2' })])
+      if (url.endsWith('/conversation')) return ok({ items: thread, pageInfo: { hasNext: false, nextCursor: null, total: thread.length }, basis: 'index' })
+      if (url === '/messages/m3') return ok(detail(summary('m3')))
+      return ok(null)
+    })
+  })
+
+  afterEach(() => {
+    for (const wrapper of mounted.splice(0)) {
+      if (!wrapper.vm.$.isUnmounted) wrapper.unmount()
+    }
+    useToastStore().clear()
+    restoreApiAdapter()
+    document.body.innerHTML = ''
+    document.title = ''
+  })
+
+  async function settle() {
+    for (let round = 0; round < 4; round += 1) await flushPromises()
+  }
+
+  async function mountMail() {
+    const router = createRouter({ history: createMemoryHistory(), routes })
+    await router.push('/mail/inbox/m3')
+    await router.isReady()
+    const wrapper = mount(
+      { render: () => h(RouterView) },
+      { attachTo: document.body, global: { plugins: [pinia, router], provide: { [CLOCK as symbol]: clock } } },
+    )
+    mounted.push(wrapper)
+    await settle()
+    return wrapper
+  }
+
+  const conversationRequests = () => requests.filter((request) => request.url.endsWith('/conversation'))
+  const mailboxRequests = () => requests.filter((request) => request.url === '/mailboxes')
+
+  /** 1분 확인을 넘긴다 — 바뀐 state 면 메일 화면이 메일함 개수 · 보이는 목록을 맞춘다(onChange) */
+  async function nextPoll(nextState: string) {
+    state = nextState
+    clock.advance(MAIL_STATE_POLL_INTERVAL_MS)
+    await settle()
+  }
+
+  it('읽음 표시만 바뀐 소식(통 수 그대로)으로는 다시 받지 않고, 새 메일로 통 수가 바뀌면 다시 받는다', async () => {
+    const wrapper = await mountMail()
+    expect(wrapper.find('[data-conversation]').exists()).toBe(true)
+    expect(conversationRequests()).toHaveLength(1)
+
+    // 다른 곳에서 메일 한 통을 읽었다 — 안 읽은 수만 바뀐다
+    const mailboxLoads = mailboxRequests().length
+    inboxUnread = 0
+    await nextPoll('s2')
+    expect(mailboxRequests().length).toBeGreaterThan(mailboxLoads)
+    clock.advance(MAIL_CONVERSATION_REFRESH_GAP_MS)
+    await settle()
+    expect(conversationRequests()).toHaveLength(1)
+
+    // 같은 대화에 새 메일이 왔다 — 받은편지함의 통 수가 바뀐다
+    inboxTotal = 3
+    thread = [...thread, summary('m4', { receivedAt: new Date(2026, 10, 6, 15, 2).toISOString() })]
+    await nextPoll('s3')
+    expect(conversationRequests()).toHaveLength(2)
+    expect(conversationRequests()[1]?.config.silent).toBe(true)
+    expect(wrapper.get('[data-conversation] h3').text()).toBe('같은 대화 3통')
+  })
+
+  it(`받기가 끝난 지 ${MAIL_CONVERSATION_REFRESH_GAP_MS}ms 안에 온 소식은 그때까지 모았다가 한 번 받는다`, async () => {
+    await mountMail()
+    expect(conversationRequests()).toHaveLength(1)
+
+    // 처음 받기가 끝난 바로 뒤 — 실시간 소식처럼 곧바로 메일함 개수를 맞춘 것으로 본다
+    inboxTotal = 3
+    useMailStore().syncCounts()
+    await settle()
+    expect(conversationRequests()).toHaveLength(1)
+
+    clock.advance(MAIL_CONVERSATION_REFRESH_GAP_MS)
+    await settle()
+    expect(conversationRequests()).toHaveLength(2)
+  })
+})
diff --git a/frontend/src/pages/mail/MailLayout.vue b/frontend/src/pages/mail/MailLayout.vue
index d5e1b3e..a5f3083 100644
--- a/frontend/src/pages/mail/MailLayout.vue
+++ b/frontend/src/pages/mail/MailLayout.vue
@@ -8,7 +8,8 @@
 // 들어올 때 예약한 메일 수(패널의 「예약됨」) · 차단 목록(읽기 화면 ⋯ 의 차단 · 스팸메일함의 안내 줄)을 받아 둔다 (9단계 — 못 받으면 알리지 않는다).
 // 예약한 메일 수는 새 메일 확인 · 실시간 알림이 바뀜을 알릴 때 다시 묻는다 (계약 2절 "보내기 취소 · 예약 발송").
 // 엔진이 붙잡은 발송을 풀 때(보낼 시각)는 새 메일 확인이 알아채지 못한다 — 그 시각이 지나면 보이는 목록 · 열린 메일 · 예약됨 수를 다시 본다
-// (usePendingSendRefresh). 들어올 때 보내기 · 읽기 설정도 받아 둔다 — 쓰기 화면의 [보내기 취소] 알림이 설정한 초로 마감을 센다(못 받으면 알리지 않는다)
+// (usePendingSendRefresh). 들어올 때 보내기 · 읽기 설정도 받아 둔다 — 쓰기 화면의 [보내기 취소] 알림이 설정한 초로 마감을 센다(못 받으면 알리지 않는다).
+// 탭이 다시 보일 때 마지막으로 받은 지 60초가 지났으면 설정을 조용히 다시 받는다 — 다른 탭에서 바꾼 묶기가 남지 않게 (useMailSettingsRefresh, 14단계)
 // 회사가 2단계 인증을 필수로 정한 유예 기간이면 상단 바 바로 아래에 노란 줄 (13단계 — TwoFactorGraceNotice)
 import { provide } from 'vue'
 
@@ -19,6 +20,7 @@ import MailboxPanel from '@/components/mail/MailboxPanel.vue'
 import TwoFactorGraceNotice from '@/components/mail/TwoFactorGraceNotice.vue'
 import { useClock } from '@/composables/useClock'
 import { createMailContactDialog, MAIL_CONTACT_DIALOG } from '@/composables/useMailContactDialog'
+import { useMailSettingsRefresh } from '@/composables/useMailSettingsRefresh'
 import { useMailStatePolling } from '@/composables/useMailStatePolling'
 import { useMailTabTitle } from '@/composables/useMailTabTitle'
 import { usePendingSendRefresh } from '@/composables/usePendingSendRefresh'
@@ -44,8 +46,10 @@ void useMailVacationStore().load()
 void mailStore.loadScheduledCount()
 // 읽기 화면 ⋯ 「보낸 사람 차단」 · 「차단 풀기」와 스팸메일함의 "차단한 보낸 사람의 메일" 줄
 useMailBlockStore().ensureLoaded()
-// 쓰기 화면의 [보내기 취소] 알림 마감 — 설정한 초 (모르면 서버가 준 보낼 시각으로 센다)
+// 쓰기 화면의 [보내기 취소] 알림 마감 — 설정한 초 (모르면 서버가 준 보낼 시각으로 센다). 메일함 목록의 묶기도 이 설정이다
 useMailSettingsStore().ensureLoaded()
+// 탭이 다시 보일 때 — 설정을 마지막으로 받은 지 60초가 지났으면 조용히 다시 받는다 (다른 탭 · PC 에서 바꾼 값)
+useMailSettingsRefresh({ clock })
 
 // 새 메일 확인 — 바뀌었으면 메일함 개수 · 사용량과 보이는 메일함 목록을 맞춘다 (검색 결과는 저절로 바꾸지 않는다 — 스토어가 거른다).
 // 숨은 탭은 받은편지함의 안 읽은 수만 고쳐 탭 제목 "(N) " 을 맞추고, 다시 보일 때 맞춘다
@@ -57,6 +61,7 @@ useMailStatePolling({
     void mailStore.loadScheduledCount()
     // 열린 메일의 대용량 첨부가 보안 검사 중이면 상태를 다시 받는다 (11단계 — 끝나면 받을 수 있다)
     void mailStore.refreshOpenedLargeFiles()
+    // 읽기 화면의 "같은 대화" 칸은 위 syncCounts 로 받은 메일함들의 통 수가 바뀌었을 때만 다시 받는다 (14단계 — mail.store.ts 의 mailboxTotalsKey)
   },
   onHiddenChange: (inboxUnread) => mailStore.setInboxUnread(inboxUnread),
 })
diff --git a/frontend/src/pages/mail/MailPrintPage.spec.ts b/frontend/src/pages/mail/MailPrintPage.spec.ts
index fe2bf10..a3100b4 100644
--- a/frontend/src/pages/mail/MailPrintPage.spec.ts
+++ b/frontend/src/pages/mail/MailPrintPage.spec.ts
@@ -8,6 +8,7 @@ import { routes } from '@/router/routes'
 import { ERROR_CODE_MESSAGES } from '@/shared/constants/error-codes.generated'
 import type { MessageDetail } from '@/shared/types/mail'
 import { useAuthStore } from '@/stores/auth.store'
+import { useMailStore } from '@/stores/mail.store'
 import { useToastStore } from '@/stores/toast.store'
 import { fail, flushPromises, installMockApi, ok, restoreApiAdapter, type MockRequest, type MockResult } from '@/test-utils/mock-api'
 import { createTestRouter } from '@/test-utils/router'
@@ -168,6 +169,16 @@ describe('MailPrintPage', () => {
     expect(wrapper.get('iframe').attributes('srcdoc')).toContain('src="/api/mail-images/t0k"')
   })
 
+  it('검색 결과에서 강조해 연 메일도 인쇄는 검색 쿼리 없이 다시 받는다 — 인쇄 주소에도 싣지 않는다 (14단계)', async () => {
+    const store = useMailStore()
+    store.selected = { ...MESSAGE, htmlBody: '<p><mark>계약</mark></p>', searchHighlight: { subject: [], attachments: {}, textBody: [] } }
+    store.selectedHighlight = { q: '계약' }
+    const { wrapper, requests } = await mountAt('/mail/print/m1')
+
+    expect(requests[0]?.params).toEqual({})
+    expect(wrapper.get('iframe').attributes('srcdoc')).not.toContain('<mark>')
+  })
+
   it('메일을 찾을 수 없으면 "메일을 찾을 수 없습니다" + [닫기] — 인쇄 창은 띄우지 않는다', async () => {
     const close = vi.spyOn(window, 'close').mockImplementation(() => undefined)
     const { wrapper, router } = await mountAt('/mail/print/m1', () => fail(404, 'RES_001'))
diff --git a/frontend/src/pages/mail/MailboxPage.scheduled.spec.ts b/frontend/src/pages/mail/MailboxPage.scheduled.spec.ts
index 7a68de9..e4099d3 100644
--- a/frontend/src/pages/mail/MailboxPage.scheduled.spec.ts
+++ b/frontend/src/pages/mail/MailboxPage.scheduled.spec.ts
@@ -162,7 +162,7 @@ describe('예약됨 · 보낸편지함 (9단계)', () => {
 
     const opened = await mountAt('/mail/scheduled/s1')
     expect(opened.wrapper.find('.scheduled-row').exists()).toBe(false)
-    expect(opened.wrapper.get('[data-notice="scheduled"]').text()).toContain(`${formatScheduleTime(FIRST_SEND_AT)} 에 보낼 메일입니다.`)
+    expect(opened.wrapper.get('[data-notice="scheduled"]').text()).toContain(`${formatScheduleTime(FIRST_SEND_AT)}에 보낼 메일입니다.`)
     expect(opened.wrapper.get('.reader').text()).toContain('목록으로')
   })
 
diff --git a/frontend/src/pages/mail/MailboxPage.search.spec.ts b/frontend/src/pages/mail/MailboxPage.search.spec.ts
index c521b6c..bc94fc9 100644
--- a/frontend/src/pages/mail/MailboxPage.search.spec.ts
+++ b/frontend/src/pages/mail/MailboxPage.search.spec.ts
@@ -1,14 +1,26 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { mount } from '@vue/test-utils'
+import { mount, type VueWrapper } from '@vue/test-utils'
 import { createPinia, setActivePinia, type Pinia } from 'pinia'
 
-import type { Mailbox, MessageDetail, MessageSummary } from '@/shared/types/mail'
+import { CLOCK } from '@/composables/useClock'
+import type { Mailbox, MessageDetail, MessageListItem, MessageSummary } from '@/shared/types/mail'
 import { useAuthStore } from '@/stores/auth.store'
 import { useMailStore } from '@/stores/mail.store'
 import { mailViewModeStorageKey } from '@/stores/mail-view.store'
 import { useToastStore } from '@/stores/toast.store'
-import { flushPromises, installMockApi, ok, restoreApiAdapter, type MockRequest } from '@/test-utils/mock-api'
+import { createManualClock } from '@/test-utils/manual-clock'
+import {
+  fail,
+  flushPromises,
+  installMockApi,
+  ok,
+  restoreApiAdapter,
+  type MockRequest,
+  type MockResult,
+} from '@/test-utils/mock-api'
 import { createTestRouter } from '@/test-utils/router'
+import highlightedTextSource from '@/components/mail/HighlightedText.vue?raw'
+import messageListItemSource from '@/components/mail/MessageListItem.vue?raw'
 import MailboxPage from './MailboxPage.vue'
 
 // 검색 결과 화면 (디자인 원본 Search · ListStates · 계약 2절 "검색")
@@ -60,6 +72,8 @@ describe('MailboxPage — 검색 결과', () => {
   let pinia: Pinia
   let requests: MockRequest[]
   let results: MessageSummary[]
+  /** 지난 메일 색인의 상태 (GET /search-index — 14단계) */
+  let indexStatus: 'building' | 'ready'
 
   beforeEach(() => {
     window.localStorage.clear()
@@ -68,8 +82,10 @@ describe('MailboxPage — 검색 결과', () => {
     useAuthStore().markAuthenticated(USER)
     useMailStore().mailboxes = MAILBOXES
     results = [summary('r1'), summary('r2')]
+    indexStatus = 'ready'
     requests = installMockApi(({ url }) => {
       if (url === '/messages') return ok({ items: results, pageInfo: { hasNext: false, nextCursor: null, total: results.length } })
+      if (url === '/search-index') return ok({ status: indexStatus, done: 10, total: indexStatus === 'ready' ? 10 : 40 })
       return ok(detail(url.split('/').pop() ?? 'r1'))
     })
   })
@@ -107,15 +123,18 @@ describe('MailboxPage — 검색 결과', () => {
     expect(wrapper.findAll('.message-row')).toHaveLength(2)
   })
 
-  it('결과가 없으면 한계 안내 한 줄과 [전체 메일함에서 찾기] — 누르면 전체에서 다시 찾는다(기록을 쌓지 않는다)', async () => {
+  it('결과가 없으면 "다른 말로 찾아 보세요."(걸린 조건이 없다)와 [전체 메일함에서 찾기] — 누르면 전체에서 다시 찾는다(기록을 쌓지 않는다)', async () => {
     results = []
     const { wrapper, router } = await mountAt(`/mail/search?q=${Q}&in=inbox`)
     const push = vi.spyOn(router, 'push')
 
     expect(wrapper.text()).toContain('‘회의’에 맞는 메일이 없습니다')
-    expect(wrapper.text()).toContain(
-      '낱말 단위로 찾습니다. ‘서버이전’의 ‘서버’처럼 붙여 쓴 말의 일부나, 제목 맨 앞의 [공지]나 Re: 같은 말머리로는 찾지 못합니다.',
-    )
+    // 걸린 조건이 없으면 조건을 줄이라고 하지 않는다 (2026-11-06 실사용 시험)
+    expect(wrapper.text()).toContain('다른 말로 찾아 보세요.')
+    expect(wrapper.text()).not.toContain('조건을 줄여')
+    // 색인이 준비됐으면 낱말 단위의 한계 안내 · 검색 준비 중 줄은 없다 (14단계)
+    expect(wrapper.find('[data-search-word-limit]').exists()).toBe(false)
+    expect(wrapper.find('[data-search-notice="indexing"]').exists()).toBe(false)
     await wrapper.get('.search-empty__all').trigger('click')
     await flushPromises()
 
@@ -206,3 +225,441 @@ describe('MailboxPage — 검색 결과', () => {
     expect(store.checkedCount).toBe(0)
   })
 })
+
+describe('MailboxPage — 14단계 검색 (조건 · 강조 · 이어 찾기 · 검색 준비 중)', () => {
+  let pinia: Pinia
+  let requests: MockRequest[]
+  let handler: (request: MockRequest) => MockResult | Promise<MockResult>
+  /** 2026년 11월 6일 오전 9시(브라우저 시간대) */
+  const clock = createManualClock(new Date(2026, 10, 6, 9).getTime())
+
+  const HIGHLIGHTED: MessageListItem = {
+    ...summary('r1', { subject: 'Re: 유지보수 계약 갱신 건', hasAttachment: true }),
+    preview: '지난번 말씀하신 계약서 초안을 첨부했습니다.',
+    searchHighlight: {
+      subject: [[9, 11]],
+      preview: { text: '…말씀하신 계약서 초안을 첨부했습니다.', ranges: [[6, 8]] },
+    },
+  }
+
+  function indexState(status: 'building' | 'ready'): MockResult {
+    return ok({ status, done: 10, total: 40 })
+  }
+
+  beforeEach(() => {
+    window.localStorage.clear()
+    pinia = createPinia()
+    setActivePinia(pinia)
+    useAuthStore().markAuthenticated(USER)
+    useMailStore().mailboxes = MAILBOXES
+    handler = ({ url }) => {
+      if (url === '/search-index') return indexState('ready')
+      if (url === '/messages') return ok({ items: [HIGHLIGHTED], pageInfo: { hasNext: false, nextCursor: null, total: 1 } })
+      return ok(detail(url.split('/').pop() ?? 'r1'))
+    }
+    requests = installMockApi((request) => handler(request))
+  })
+
+  /** 그린 화면 — 테스트마다 떼어 낸다 (초점을 보는 테스트는 문서에 붙여 그린다) */
+  let mounted: VueWrapper[] = []
+
+  afterEach(() => {
+    for (const wrapper of mounted) wrapper.unmount()
+    mounted = []
+    vi.restoreAllMocks()
+    useToastStore().clear()
+    restoreApiAdapter()
+    document.body.innerHTML = ''
+  })
+
+  async function mountAt(path: string, options: { attach?: boolean } = {}) {
+    const router = createTestRouter()
+    await router.push(path)
+    await router.isReady()
+    const wrapper = mount(MailboxPage, {
+      attachTo: options.attach ? document.body : undefined,
+      global: { plugins: [pinia, router], provide: { [CLOCK as symbol]: clock } },
+    })
+    mounted.push(wrapper)
+    await flushPromises()
+    return { wrapper, router }
+  }
+
+  function heldResult() {
+    let resolve: (value: MockResult) => void = () => undefined
+    const promise = new Promise<MockResult>((done) => {
+      resolve = done
+    })
+    return { promise, resolve }
+  }
+
+  const listRequests = () => requests.filter((request) => request.url === '/messages')
+  const CONDITIONS_QUERY = `from=${encodeURIComponent('이도윤')}&since=2026-10-06&until=2026-11-06&attachment=1`
+
+  it('주소의 조건으로 찾고 찾을 곳 줄 아래에 "조건: …" 줄 — [조건 지우기]는 조건만 빼고 다시 찾는다', async () => {
+    const { wrapper, router } = await mountAt(`/mail/search?q=${Q}&in=inbox&${CONDITIONS_QUERY}`)
+
+    expect(listRequests()[0]?.params).toEqual({
+      q: '회의',
+      mailboxId: 'inbox',
+      from: '이도윤',
+      after: new Date(2026, 9, 6).toISOString(),
+      before: new Date(2026, 10, 7).toISOString(),
+      hasAttachment: 'true',
+      limit: 20,
+    })
+    expect(wrapper.get('[data-search-condition-line]').text()).toContain(
+      '조건: 이도윤 님이 보낸 메일, 최근 1달, 첨부 있음',
+    )
+
+    await wrapper.get('[data-search-condition-line-clear]').trigger('click')
+    await flushPromises()
+
+    expect(router.currentRoute.value.fullPath).toBe(`/mail/search?q=${Q}&in=inbox`)
+    expect(wrapper.find('[data-search-condition-line]').exists()).toBe(false)
+    expect(listRequests().at(-1)?.params).toEqual({ q: '회의', mailboxId: 'inbox', limit: 20 })
+  })
+
+  it('조건만으로 찾으면 머리는 검색어 없이 수만 — 결과 없음은 "조건에 맞는 메일이 없습니다"', async () => {
+    handler = ({ url }) =>
+      url === '/search-index' ? indexState('ready') : ok({ items: [], pageInfo: { hasNext: false, nextCursor: null, total: 0 } })
+    const { wrapper } = await mountAt(`/mail/search?in=inbox&${CONDITIONS_QUERY}`)
+
+    expect(wrapper.get('.search-header__count').text()).toBe('0통')
+    expect(wrapper.text()).toContain('조건에 맞는 메일이 없습니다')
+    expect(wrapper.text()).toContain('조건을 바꾸거나 줄여 보세요.')
+  })
+
+  it('검색어와 조건으로 찾아 결과가 없으면 "다른 말로 찾거나 조건을 줄여 보세요."', async () => {
+    handler = ({ url }) =>
+      url === '/search-index' ? indexState('ready') : ok({ items: [], pageInfo: { hasNext: false, nextCursor: null, total: 0 } })
+    const { wrapper } = await mountAt(`/mail/search?q=${Q}&in=inbox&${CONDITIONS_QUERY}`)
+
+    expect(wrapper.text()).toContain('‘회의’에 맞는 메일이 없습니다')
+    expect(wrapper.text()).toContain('다른 말로 찾거나 조건을 줄여 보세요.')
+  })
+
+  it('조건 줄 — 보낸 사람 · 받는 사람이 내 이름이나 주소면 "내가 보낸 메일" · "내가 받은 메일", 하루만 고른 기간은 "… 하루"', async () => {
+    const mine = `from=${encodeURIComponent('김아라')}&to=${encodeURIComponent(USER.email.toUpperCase())}&since=2026-11-06&until=2026-11-06`
+    const { wrapper } = await mountAt(`/mail/search?q=${Q}&in=inbox&${mine}`)
+
+    expect(wrapper.get('[data-search-condition-line]').text()).toContain(
+      '조건: 내가 보낸 메일, 내가 받은 메일, 2026. 11. 6. 하루',
+    )
+  })
+
+  it('total 이 null 이면 통 수를 보이지 않는다', async () => {
+    handler = ({ url }) =>
+      url === '/search-index'
+        ? indexState('ready')
+        : ok({ items: [HIGHLIGHTED], pageInfo: { hasNext: false, nextCursor: null, total: null } })
+    const { wrapper } = await mountAt(`/mail/search?q=${Q}&in=all`)
+
+    expect(wrapper.get('.search-header__count').text()).toBe('‘회의’')
+  })
+
+  it('결과 줄은 세 줄 — 보낸 사람 · 시각 / 제목(+ 첨부) / 미리 보기, 맞은 말은 <mark> (v-html 없이)', async () => {
+    const { wrapper } = await mountAt(`/mail/search?q=${Q}&in=all`)
+
+    const row = wrapper.get('.message-row')
+    expect(row.classes()).toContain('message-row--search')
+    expect(row.get('.message-row__subject').text()).toBe('Re: 유지보수 계약 갱신 건')
+    expect(row.get('.message-row__subject').findAll('mark').map((mark) => mark.text())).toEqual(['계약'])
+    const preview = row.get('[data-row-preview]')
+    expect(preview.text()).toBe('…말씀하신 계약서 초안을 첨부했습니다.')
+    expect(preview.findAll('mark').map((mark) => mark.text())).toEqual(['계약'])
+    expect(row.find('[aria-label="첨부 있음"]').exists()).toBe(true)
+  })
+
+  it('미리 보기 줄의 맞은 말만 글자색을 진하게(--color-text-secondary) — 흐린 글자 위 노랑은 대비가 모자라다, 제목 줄의 강조는 글자색 그대로 (2026-11-07)', () => {
+    // jsdom 은 컴포넌트의 style 을 적용하지 않는다 — 규칙을 원본에서 읽는다 (주석은 뺀다)
+    const rulesOf = (source: string) =>
+      [...source.slice(source.indexOf('<style')).replace(/\/\*[\s\S]*?\*\//g, '').matchAll(/([^{}]+)\{([^}]*)\}/g)].map(
+        ([, selector = '', body = '']) => ({ selector: selector.replace('<style scoped>', '').trim(), body }),
+      )
+
+    // 강조 자체는 글자색을 물려받는다 — 제목 줄 · 읽기 화면 · 첨부 이름은 진한 글자 위다
+    const mark = rulesOf(highlightedTextSource).find((rule) => rule.selector === '.search-mark')
+    expect(mark?.body).toMatch(/color:\s*inherit;/)
+    // 목록 줄은 미리 보기 줄 안의 강조만 바꾼다 (제목 줄의 강조를 바꾸는 규칙은 없다)
+    const overrides = rulesOf(messageListItemSource).filter((rule) => rule.selector.includes('search-mark'))
+    expect(overrides.map((rule) => rule.selector)).toEqual(['.message-row__preview :deep(.search-mark)'])
+    expect(overrides[0]?.body).toMatch(/color:\s*var\(--color-text-secondary\);/)
+  })
+
+  it('강조가 없으면(엔진 방식 — 색인을 준비하는 중) 글 그대로 — 미리 보기는 메일의 미리 보기, 결과 머리 아래 "검색 준비 중" 줄', async () => {
+    handler = ({ url }) => {
+      if (url === '/search-index') return indexState('building')
+      return ok({
+        items: [{ ...HIGHLIGHTED, searchHighlight: null }],
+        pageInfo: { hasNext: false, nextCursor: null, total: 1 },
+      })
+    }
+    const { wrapper } = await mountAt(`/mail/search?q=${Q}&in=all`)
+
+    const row = wrapper.get('.message-row')
+    expect(row.findAll('mark')).toHaveLength(0)
+    expect(row.get('[data-row-preview]').text()).toBe('지난번 말씀하신 계약서 초안을 첨부했습니다.')
+    const notice = wrapper.get('[data-search-notice="indexing"]')
+    // 색인은 밤에만 채운다 — 낮 내내 같은 글이어도 멈춘 줄 알지 않게 (2026-11-06 실사용 시험)
+    expect(notice.text()).toBe(
+      '지난 메일을 검색할 수 있게 밤사이에 준비하고 있습니다. 메일이 많으면 며칠 걸릴 수 있고, 그동안은 낱말이 통째로 같은 메일만 찾습니다.',
+    )
+    expect(notice.element.closest('[role="status"]')).not.toBeNull()
+  })
+
+  it('색인을 준비하는 중의 결과 없음에는 찾지 못하는 예를 더한다 — 위 "검색 준비 중" 줄과 같은 말을 되풀이하지 않는다', async () => {
+    handler = ({ url }) =>
+      url === '/search-index' ? indexState('building') : ok({ items: [], pageInfo: { hasNext: false, nextCursor: null, total: 0 } })
+    const { wrapper } = await mountAt(`/mail/search?q=${Q}&in=all`)
+
+    expect(wrapper.get('[data-search-word-limit]').text()).toBe(
+      '준비가 끝나기 전에는 ‘서버이전’의 ‘서버’처럼 붙여 쓴 말의 일부나, 제목 맨 앞의 [공지]나 Re: 같은 말머리로는 찾지 못합니다.',
+    )
+    expect(wrapper.get('[data-search-word-limit]').text()).not.toContain('통째로')
+  })
+
+  it('색인 상태를 못 받으면 안내 줄 · 한계 안내 없이 지금처럼 — 알리지 않는다', async () => {
+    handler = ({ url }) =>
+      url === '/search-index' ? fail(503, 'SYS_001') : ok({ items: [], pageInfo: { hasNext: false, nextCursor: null, total: 0 } })
+    const { wrapper } = await mountAt(`/mail/search?q=${Q}&in=all`)
+
+    expect(wrapper.find('[data-search-notice]').exists()).toBe(false)
+    expect(wrapper.find('[data-search-word-limit]').exists()).toBe(false)
+    expect(useToastStore().toasts).toEqual([])
+  })
+
+  it('한 글자 낱말뿐이면(색인 방식) 결과 머리에 한 줄 — 본문은 찾지 않았다', async () => {
+    const { wrapper } = await mountAt(`/mail/search?q=${encodeURIComponent('김 a')}&in=all`)
+
+    expect(wrapper.get('[data-search-notice="single-char"]').text()).toBe(
+      '한 글자로만 찾을 때는 본문은 빼고 제목, 보낸 사람과 받는 사람, 첨부 파일 이름에서 찾습니다. 본문까지 찾으려면 두 글자 이상으로 찾아 주세요.',
+    )
+
+    const longer = await mountAt(`/mail/search?q=${encodeURIComponent('김 계약')}&in=all`)
+    expect(longer.wrapper.find('[data-search-notice="single-char"]').exists()).toBe(false)
+  })
+
+  it('색인을 준비하는 중에는 한 글자 안내를 보이지 않는다 — 낱말 단위로 찾는 동안은 "검색 준비 중" 줄만', async () => {
+    handler = ({ url }) =>
+      url === '/search-index'
+        ? indexState('building')
+        : ok({ items: [HIGHLIGHTED], pageInfo: { hasNext: false, nextCursor: null, total: 1 } })
+    const { wrapper } = await mountAt(`/mail/search?q=${encodeURIComponent('김 a')}&in=all`)
+
+    expect(wrapper.find('[data-search-notice="single-char"]').exists()).toBe(false)
+    expect(wrapper.find('[data-search-notice="indexing"]').exists()).toBe(true)
+  })
+
+  it('[더 찾기]는 찾는 동안 aria-busy · "찾는 중…"(다시 눌러도 묻지 않는다) — 찾아서 사라지면 초점을 목록 칸으로', async () => {
+    let next = 0
+    let hold: ReturnType<typeof heldResult> | null = null
+    handler = ({ url }) => {
+      if (url === '/search-index') return indexState('ready')
+      if (url !== '/messages') return ok(detail('r1'))
+      next += 1
+      if (hold) return hold.promise
+      return ok({ items: [], pageInfo: { hasNext: true, nextCursor: `c${next}`, total: null } })
+    }
+    const { wrapper } = await mountAt(`/mail/search?q=${Q}&in=all`, { attach: true })
+    const more = wrapper.get('[data-search-more]')
+    ;(more.element as HTMLButtonElement).focus()
+
+    hold = heldResult()
+    await more.trigger('click')
+    await flushPromises()
+    expect(more.attributes('aria-busy')).toBe('true')
+    expect(more.attributes('aria-disabled')).toBe('true')
+    expect(more.text()).toBe('찾는 중…')
+    const sent = listRequests().length
+    await more.trigger('click')
+    await flushPromises()
+    expect(listRequests().length).toBe(sent)
+
+    hold.resolve(ok({ items: [HIGHLIGHTED], pageInfo: { hasNext: false, nextCursor: null, total: null } }))
+    await flushPromises()
+
+    expect(wrapper.find('[data-search-more]').exists()).toBe(false)
+    expect(wrapper.findAll('.message-row')).toHaveLength(1)
+    expect(document.activeElement).toBe(wrapper.get('section.mail-list-frame').element)
+  })
+
+  it('조건만 걸린 검색에서 조건 줄의 [조건 지우기]는 검색을 닫는다 — 검색 전 메일함으로 (패널의 [조건 지우기]는 칸만 비운다 — 2026-11-07)', async () => {
+    useMailStore().rememberSearchOrigin({ mailboxId: 'inbox', location: '/mail/inbox' })
+    const { wrapper, router } = await mountAt(`/mail/search?in=inbox&${CONDITIONS_QUERY}`)
+
+    await wrapper.get('[data-search-condition-line-clear]').trigger('click')
+    await flushPromises()
+
+    expect(router.currentRoute.value.fullPath).toBe('/mail/inbox')
+  })
+
+  it('조건 줄의 [조건 지우기]를 누르면 줄이 사라진다 — 초점은 목록 칸으로', async () => {
+    const { wrapper } = await mountAt(`/mail/search?q=${Q}&in=inbox&${CONDITIONS_QUERY}`, { attach: true })
+    const clear = wrapper.get('[data-search-condition-line-clear]')
+    ;(clear.element as HTMLButtonElement).focus()
+
+    await clear.trigger('click')
+    await flushPromises()
+
+    expect(wrapper.find('[data-search-condition-line]').exists()).toBe(false)
+    expect(document.activeElement).toBe(wrapper.get('section.mail-list-frame').element)
+  })
+
+  it('검색어와 조건의 낱말이 8개를 넘는 주소(손으로 고친 주소)는 찾지 않고 "찾을 말이 너무 많습니다" — 연 메일은 강조 없이 받는다', async () => {
+    const words = encodeURIComponent('하나 둘 셋 넷 다섯')
+    const body = encodeURIComponent('여섯 일곱 여덟 아홉')
+    const { wrapper } = await mountAt(`/mail/search?q=${words}&in=inbox&body=${body}`)
+
+    expect(listRequests()).toEqual([])
+    const empty = wrapper.get('[data-search-too-many-words]')
+    expect(empty.text()).toContain('찾을 말이 너무 많습니다')
+    expect(empty.text()).toContain(
+      '검색어와 조건에 넣은 낱말은 모두 합쳐 8개까지 찾을 수 있습니다. 검색 칸이나 [조건]에서 낱말을 줄여 주세요.',
+    )
+    // 다른 메일함에서 찾아도 같다 — [전체 메일함에서 찾기]를 권하지 않는다. 조건은 조건 줄에서 지울 수 있다
+    expect(wrapper.find('.search-empty__all').exists()).toBe(false)
+    expect(wrapper.find('[data-search-condition-line-clear]').exists()).toBe(true)
+    expect(useToastStore().toasts).toEqual([])
+    wrapper.unmount()
+    mounted = []
+
+    // 그 주소로 연 메일은 강조 쿼리 없이 받는다 — 서버가 400 으로 거절해 메일을 열지 못하는 일이 없게
+    const opened = await mountAt(`/mail/search/r1?q=${words}&in=inbox&body=${body}`)
+    expect(requests.filter((request) => request.url === '/messages/r1').map((request) => request.params)).toEqual([{}])
+    expect(opened.wrapper.find('#reader-subject').exists()).toBe(true)
+  })
+
+  it('주소의 날짜가 거꾸로면 기간을 버리고, 고를 수 없는 날짜(1970-01-01 ~ 9999-12-30 밖)는 그 날짜만 버린다 — 나머지 조건으로 찾는다', async () => {
+    const reversed = await mountAt(`/mail/search?q=${Q}&in=all&since=2026-11-06&until=2026-10-01&attachment=1`)
+    expect(listRequests()[0]?.params).toEqual({ q: '회의', hasAttachment: 'true', limit: 20 })
+    expect(reversed.wrapper.get('[data-search-condition-line]').text()).toContain('조건: 첨부 있음')
+    reversed.wrapper.unmount()
+    mounted = []
+    requests.length = 0
+
+    await mountAt(`/mail/search?q=${Q}&in=all&since=1969-12-31&until=2026-11-01`)
+    expect(listRequests()[0]?.params).toEqual({ q: '회의', before: new Date(2026, 10, 2).toISOString(), limit: 20 })
+    for (const wrapper of mounted) wrapper.unmount()
+    mounted = []
+    requests.length = 0
+
+    const outside = await mountAt(`/mail/search?q=${Q}&in=all&since=2026-11-01&until=9999-12-31`)
+    expect(listRequests()[0]?.params).toEqual({ q: '회의', after: new Date(2026, 10, 1).toISOString(), limit: 20 })
+    expect(outside.wrapper.get('[data-search-condition-line]').text()).toContain('조건: 2026. 11. 1.부터')
+  })
+
+  it('빈 쪽이 이어져 아직 못 찾았으면 결과 없음 대신 [더 찾기] — 누르면 이어 찾고, 더 없으면 결과 없음', async () => {
+    let next = 0
+    let exhausted = false
+    handler = ({ url, params }) => {
+      if (url === '/search-index') return indexState('ready')
+      if (url !== '/messages') return ok(detail('r1'))
+      next += 1
+      const done = exhausted && params.cursor !== undefined
+      return ok({ items: [], pageInfo: { hasNext: !done, nextCursor: done ? null : `c${next}`, total: null } })
+    }
+    const { wrapper } = await mountAt(`/mail/search?q=${Q}&in=all`)
+
+    expect(wrapper.text()).toContain('아직 맞는 메일을 찾지 못했습니다')
+    expect(wrapper.text()).toContain('메일이 많아 한 번에 다 찾지 못했습니다. [더 찾기]를 누르면 이어서 찾습니다.')
+    expect(wrapper.text()).not.toContain('에 맞는 메일이 없습니다')
+    const sent = listRequests().length
+
+    exhausted = true
+    await wrapper.get('[data-search-more]').trigger('click')
+    await flushPromises()
+
+    expect(listRequests().length).toBe(sent + 1)
+    expect(wrapper.find('[data-search-more]').exists()).toBe(false)
+    expect(wrapper.text()).toContain('‘회의’에 맞는 메일이 없습니다')
+  })
+
+  it('결과에서 연 메일은 검색어와 글 조건 넷만 넘겨 강조를 받는다 — 제목 · 첨부 이름 · 글 본문의 맞은 말', async () => {
+    handler = ({ url, params }) => {
+      if (url === '/search-index') return indexState('ready')
+      if (url === '/messages') return ok({ items: [HIGHLIGHTED], pageInfo: { hasNext: false, nextCursor: null, total: 1 } })
+      const highlighted = params.q !== undefined
+      return ok({
+        ...detail('r1'),
+        subject: 'Re: 유지보수 계약 갱신 건',
+        htmlBody: null,
+        textBody: '계약서 초안을 첨부했습니다.',
+        attachments: [{ id: 'a1', name: '유지보수_계약서.docx', type: 'application/msword', size: 100, isInline: false }],
+        searchHighlight: highlighted ? { subject: [[9, 11]], attachments: { a1: [[5, 7]] }, textBody: [[0, 2]] } : null,
+      })
+    }
+    const { wrapper, router } = await mountAt(`/mail/search/r1?q=${Q}&in=inbox&${CONDITIONS_QUERY}&subject=${encodeURIComponent('갱신')}`)
+
+    const detailRequest = requests.find((request) => request.url === '/messages/r1')
+    expect(detailRequest?.params).toEqual({ q: '회의', from: '이도윤', subject: '갱신' })
+    expect(wrapper.get('#reader-subject').findAll('mark').map((mark) => mark.text())).toEqual(['계약'])
+    expect(wrapper.get('.attachments__name').findAll('mark').map((mark) => mark.text())).toEqual(['계약'])
+    expect(wrapper.get('iframe').attributes('srcdoc')).toContain('<mark>계약</mark>서 초안을 첨부했습니다.')
+
+    // 같은 메일을 메일함에서 열면 강조가 든 본문을 쓰지 않고 쿼리 없이 다시 받는다
+    await router.push('/mail/inbox/r1')
+    await flushPromises()
+    const plain = requests.filter((request) => request.url === '/messages/r1').at(-1)
+    expect(plain?.params).toEqual({})
+    expect(wrapper.get('#reader-subject').findAll('mark')).toHaveLength(0)
+  })
+})
+
+describe('MailboxPage — 14단계 검색 · 목록 보기', () => {
+  let pinia: Pinia
+  let total: number | null
+
+  const HIGHLIGHTED: MessageListItem = {
+    ...summary('r1', { subject: '견적서와 계약 조건 정리' }),
+    searchHighlight: { subject: [[5, 7]], preview: { text: '', ranges: [] } },
+  }
+
+  beforeEach(() => {
+    window.localStorage.clear()
+    pinia = createPinia()
+    setActivePinia(pinia)
+    useAuthStore().markAuthenticated(USER)
+    useMailStore().mailboxes = MAILBOXES
+    window.localStorage.setItem(mailViewModeStorageKey(USER.email), 'list')
+    total = 1
+    installMockApi(({ url }) => {
+      if (url === '/search-index') return ok({ status: 'ready', done: 1, total: 1 })
+      if (url === '/messages') {
+        return ok({ items: [HIGHLIGHTED, summary('r2')], pageInfo: { hasNext: false, nextCursor: null, total } })
+      }
+      return ok(detail(url.split('/').pop() ?? 'r1'))
+    })
+  })
+
+  afterEach(() => {
+    useToastStore().clear()
+    restoreApiAdapter()
+  })
+
+  async function mountAt(path: string) {
+    const router = createTestRouter()
+    await router.push(path)
+    await router.isReady()
+    const wrapper = mount(MailboxPage, { global: { plugins: [pinia, router] } })
+    await flushPromises()
+    return { wrapper, router }
+  }
+
+  it('표의 제목에도 맞은 말을 <mark> 로 — 행 높이는 그대로(미리 보기 줄은 분할 보기만)', async () => {
+    const { wrapper } = await mountAt(`/mail/search?q=${Q}&in=all`)
+
+    const link = wrapper.get('tbody .mail-table__link')
+    expect(link.text()).toBe('견적서와 계약 조건 정리')
+    expect(link.findAll('mark').map((mark) => mark.text())).toEqual(['계약'])
+    expect(wrapper.find('[data-row-preview]').exists()).toBe(false)
+  })
+
+  it('total 이 null 이면 연 메일의 위치 "n / 전체"를 보이지 않는다 — 이전 · 다음은 그대로', async () => {
+    total = null
+    const { wrapper } = await mountAt(`/mail/search/r1?q=${Q}&in=all`)
+
+    expect(wrapper.find('.nav-position').exists()).toBe(false)
+    expect(wrapper.get('button[aria-label="다음 메일"]').attributes('disabled')).toBeUndefined()
+  })
+})
diff --git a/frontend/src/pages/mail/MailboxPage.threads.spec.ts b/frontend/src/pages/mail/MailboxPage.threads.spec.ts
new file mode 100644
index 0000000..d0e59f4
--- /dev/null
+++ b/frontend/src/pages/mail/MailboxPage.threads.spec.ts
@@ -0,0 +1,704 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { mount, type VueWrapper } from '@vue/test-utils'
+import { createPinia, setActivePinia, type Pinia } from 'pinia'
+import { h } from 'vue'
+import { createMemoryHistory, createRouter, RouterView, type Router } from 'vue-router'
+
+import { CLOCK } from '@/composables/useClock'
+import { routes } from '@/router/routes'
+import { MAIL_STATE_POLL_INTERVAL_MS } from '@/shared/constants/mail'
+import { MAIL_SETTINGS_REFRESH_AFTER_MS } from '@/shared/constants/mail-settings'
+import { ERROR_CODE_MESSAGES } from '@/shared/constants/error-codes.generated'
+import type {
+  ConversationSummary,
+  Mailbox,
+  MailSettings,
+  MessageDetail,
+  MessagesPatch,
+  MessageSummary,
+} from '@/shared/types/mail'
+import { useAuthStore } from '@/stores/auth.store'
+import { useMailStore } from '@/stores/mail.store'
+import { groupByConversationHintKey } from '@/stores/mail-settings.store'
+import { mailViewModeStorageKey } from '@/stores/mail-view.store'
+import { useToastStore } from '@/stores/toast.store'
+import { createManualClock, type ManualClock } from '@/test-utils/manual-clock'
+import { fail, flushPromises, installMockApi, ok, restoreApiAdapter, type MockRequest, type MockResult } from '@/test-utils/mock-api'
+
+// 14단계 3차 — 목록의 "대화로 묶어 보기" (디자인 원본 ListThreads14 · 계약 2절 "대화로 묶어 보기")
+// 실제 메일 화면(MailLayout → MailboxPage → 목록 · 읽기 화면)을 띄운다 — 설정(groupByConversation)이 목록 출처를 정한다
+
+const USER = { email: 'ara.kim@arasystem.test', name: '김아라' }
+const ME = { name: '김아라', email: USER.email }
+const DOYUN = { name: '이도윤', email: 'doyun.lee@arasystem.test' }
+const HR = { name: '인사팀', email: 'hr@arasystem.test' }
+const MINSU = { name: '김민수', email: 'minsu.kim@arasystem.test' }
+
+function mailbox(id: string, role: Mailbox['role'], name: string, totalCount: number, unreadCount: number): Mailbox {
+  return { id, name, role, parentId: null, sortOrder: 0, totalCount, unreadCount }
+}
+
+function summary(id: string, partial: Partial<MessageSummary> = {}): MessageSummary {
+  return {
+    id,
+    threadId: `t-${id}`,
+    mailboxIds: ['inbox'],
+    from: DOYUN,
+    to: [ME],
+    subject: `제목 ${id}`,
+    preview: '',
+    // 한국 시간 · UTC 의 날짜가 같은 시각 (시간대와 상관없이 같은 글)
+    receivedAt: '2026-10-20T03:00:00Z',
+    isRead: true,
+    isFlagged: false,
+    hasAttachment: false,
+    size: 100,
+    pendingSend: null,
+    ...partial,
+  }
+}
+
+function detail(base: MessageSummary): MessageDetail {
+  return {
+    ...base,
+    cc: [],
+    bcc: [],
+    replyTo: [],
+    sentAt: null,
+    messageId: null,
+    references: [],
+    htmlBody: null,
+    textBody: `${base.id} 본문`,
+    hasBlockedImages: false,
+    attachments: [],
+  }
+}
+
+function conversation(id: string, messageIds: string[], partial: Partial<ConversationSummary> = {}): ConversationSummary {
+  return {
+    id,
+    latest: summary(messageIds[0] ?? id),
+    participants: [DOYUN],
+    messageCount: messageIds.length,
+    messageIds,
+    pendingSendIds: [],
+    isRead: true,
+    isFlagged: false,
+    hasAttachment: false,
+    ...partial,
+  }
+}
+
+const ROWS: ConversationSummary[] = [
+  conversation('c1', ['m6', 'm5'], {
+    latest: summary('m6', { subject: 'Re: 전사 회의 참석 안내', isRead: false, hasAttachment: true }),
+    participants: [HR, ME, MINSU],
+    messageCount: 6,
+    isRead: false,
+    hasAttachment: true,
+  }),
+  conversation('c2', ['m4'], { latest: summary('m4', { subject: '11월 비용 정산 안내' }) }),
+  conversation('c3', ['m3', 'm2'], { latest: summary('m3', { subject: 'Re: 유지보수 계약 갱신 건' }), participants: [ME, DOYUN] }),
+]
+
+const page = (items: unknown[], total: number | null = items.length) =>
+  ok({ items, pageInfo: { hasNext: false, nextCursor: null, total } })
+
+describe('MailboxPage — 대화로 묶어 보기 (14단계)', () => {
+  let pinia: Pinia
+  let clock: ManualClock
+  let requests: MockRequest[]
+  let settings: MailSettings
+  let rows: ConversationSummary[]
+  let state: string
+  let patchSettings: ((request: MockRequest) => MockResult) | null
+  /** GET /mail-settings 의 응답을 바꾼다 (받지 못함 등) */
+  let loadSettings: (() => MockResult) | null
+  /** GET /messages 의 응답을 바꾼다 (붙잡아 두기 등) */
+  let listMessages: (() => MockResult | Promise<MockResult>) | null
+  /** 읽기 화면이 여는 메일(GET /messages/{id})의 메일함 — 처음은 받은편지함 */
+  let openedMailboxIds: string[]
+  const mounted: VueWrapper[] = []
+
+  beforeEach(() => {
+    window.localStorage.clear()
+    pinia = createPinia()
+    setActivePinia(pinia)
+    useAuthStore().markAuthenticated(USER)
+    clock = createManualClock(new Date(2026, 10, 6, 15).getTime())
+    settings = { undoSendSeconds: 10, externalImages: 'ask', groupByConversation: true }
+    rows = ROWS
+    state = 's1'
+    patchSettings = null
+    loadSettings = null
+    listMessages = null
+    openedMailboxIds = ['inbox']
+    requests = installMockApi((request) => {
+      const { url, method } = request
+      if (url === '/mail-state') return ok({ state })
+      if (url === '/mailboxes') {
+        return page([
+          mailbox('inbox', 'inbox', '받은편지함', 9, 2),
+          mailbox('drafts', 'drafts', '임시보관함', 1, 0),
+          mailbox('trash', 'trash', '휴지통', 0, 0),
+        ])
+      }
+      if (url === '/mail-quota') return ok({ usedBytes: 0, limitBytes: null, attachmentMaxBytes: 1, attachmentTotalMaxBytes: 1 })
+      if (url === '/mail-signature') {
+        return ok({ bodyHtml: null, body: null, isForNew: true, isForReply: true, images: [], updatedAt: null })
+      }
+      if (url === '/mail-vacation') {
+        return ok({ isEnabled: false, fromDate: null, toDate: null, subject: '', textBody: '', isActive: true })
+      }
+      if (url === '/mail-blocks') return ok({ senders: [], isActive: true })
+      if (url === '/mail-settings' && method === 'GET') return loadSettings ? loadSettings() : ok(settings)
+      if (url === '/mail-settings' && method === 'PATCH') {
+        if (patchSettings) return patchSettings(request)
+        settings = { ...settings, ...(request.data as Partial<MailSettings>) }
+        return ok(settings)
+      }
+      if (url === '/scheduled-messages') return page([])
+      if (url === '/messages' && method === 'PATCH') {
+        const data = request.data as MessagesPatch
+        // 옮긴 메일은 서버의 묶은 목록에서도 빠진다 — 다시 맞춘 목록이 옛 줄을 되살리지 않게
+        if (data.mailboxId) {
+          rows = rows
+            .map((row) => {
+              const messageIds = row.messageIds.filter((id) => !data.ids.includes(id))
+              const latestId = messageIds[0]
+              return latestId && latestId !== row.latest.id ? { ...row, messageIds, latest: summary(latestId) } : { ...row, messageIds }
+            })
+            .filter((row) => row.messageIds.length > 0)
+        }
+        return ok({ updatedIds: data.ids, failedIds: [] })
+      }
+      if (url === '/message-deletions') return ok({ deletedIds: (request.data as { ids: string[] }).ids, skippedIds: [] })
+      if (url === '/conversations') return ok({ items: rows, pageInfo: { hasNext: false, nextCursor: null, total: 6 }, basis: 'index' })
+      if (url === '/messages' && method === 'GET') {
+        return listMessages ? listMessages() : page([summary('m6', { isRead: false }), summary('m4')], 9)
+      }
+      if (url.endsWith('/conversation')) return ok({ items: [], pageInfo: { hasNext: false, nextCursor: null, total: 1 }, basis: 'index' })
+      const opened = /^\/messages\/([^/]+)$/.exec(url)?.[1]
+      if (opened && method === 'GET') return ok(detail(summary(opened, { mailboxIds: openedMailboxIds })))
+      return ok(null)
+    })
+  })
+
+  afterEach(() => {
+    for (const wrapper of mounted.splice(0)) {
+      if (!wrapper.vm.$.isUnmounted) wrapper.unmount()
+    }
+    useToastStore().clear()
+    restoreApiAdapter()
+    document.body.innerHTML = ''
+    document.title = ''
+  })
+
+  async function settle() {
+    for (let round = 0; round < 4; round += 1) await flushPromises()
+  }
+
+  async function mountMail(path = '/mail/inbox'): Promise<{ wrapper: VueWrapper; router: Router }> {
+    const router = createRouter({ history: createMemoryHistory(), routes })
+    await router.push(path)
+    await router.isReady()
+    const wrapper = mount(
+      { render: () => h(RouterView) },
+      { attachTo: document.body, global: { plugins: [pinia, router], provide: { [CLOCK as symbol]: clock } } },
+    )
+    mounted.push(wrapper)
+    await settle()
+    return { wrapper, router }
+  }
+
+  /** 이 브라우저가 마지막으로 안 묶어 보기 값 — 설정을 받기 전의 짐작 (mail-settings.store) */
+  function rememberGrouped(grouped = true) {
+    window.localStorage.setItem(groupByConversationHintKey(USER.email), String(grouped))
+  }
+
+  const threadRequests = () => requests.filter((request) => request.url === '/conversations')
+  const messageListRequests = () => requests.filter((request) => request.url === '/messages' && request.method === 'GET')
+  /** 목록 머리의 개수 칸 — 보이는 글 · 화면 낭독 글 · title (분할 보기는 줄인 글을 보인다) */
+  const headCount = (wrapper: VueWrapper) => {
+    const count = wrapper.get('.list-header__count')
+    const shown = count.find('[aria-hidden="true"]')
+    const spoken = count.find('.visually-hidden')
+    return {
+      shown: shown.exists() ? shown.text() : count.text(),
+      spoken: spoken.exists() ? spoken.text() : count.text(),
+      title: count.attributes('title'),
+    }
+  }
+  const rowTexts = (wrapper: VueWrapper) =>
+    wrapper.findAll('.thread-row').map((row) => ({
+      who: row.get('.thread-row__who').text(),
+      count: row.find('[data-thread-count]').exists() ? row.get('[data-thread-count]').text() : null,
+      subject: row.get('.thread-row__subject').text(),
+      unread: row.classes('is-unread'),
+    }))
+
+  it('켜져 있으면 묶은 목록 — 참여자(나는 끝에) · 통 수(한 통이면 없음) · 마지막 메일 제목 · 하나라도 안 읽었으면 굵게, 머리는 대화 수', async () => {
+    rememberGrouped()
+    const { wrapper } = await mountMail()
+
+    expect(threadRequests().map((request) => request.params)).toEqual([{ mailboxId: 'inbox', limit: 20 }])
+    // 짐작(이 브라우저가 마지막으로 안 값)이 있으면 메일 목록을 받았다 버리지 않는다
+    expect(messageListRequests()).toHaveLength(0)
+    expect(rowTexts(wrapper)).toEqual([
+      { who: '안 읽음, 인사팀, 김민수, 나', count: '6통', subject: 'Re: 전사 회의 참석 안내', unread: true },
+      { who: '이도윤', count: null, subject: '11월 비용 정산 안내', unread: false },
+      { who: '이도윤, 나', count: '2통', subject: 'Re: 유지보수 계약 갱신 건', unread: false },
+    ])
+    expect(wrapper.findAll('.thread-row')[0]?.find('[aria-label="첨부 있음"]').exists()).toBe(true)
+    // 분할 보기(좁은 머리)는 안 읽은 메일이 있으면 그 수만 보이고 전체 글은 title · 화면 낭독에 (2026-11-06 실사용 시험)
+    expect(headCount(wrapper)).toEqual({
+      shown: '안 읽은 메일 2통',
+      spoken: '대화 6개, 안 읽은 메일 2통',
+      title: '대화 6개, 안 읽은 메일 2통',
+    })
+    const toggle = wrapper.get('[data-group-toggle]')
+    expect(toggle.attributes('aria-pressed')).toBe('true')
+    // 분할 보기의 목록 칸은 아이콘만 — 이름은 title · 화면 낭독
+    expect(toggle.attributes('title')).toBe('대화로 묶기')
+    expect(toggle.text()).toBe('대화로 묶기')
+  })
+
+  it('처음 이 브라우저(짐작 없음)면 메일 목록으로 열었다가 설정을 받으면 묶은 목록으로 — 받은 값을 짐작으로 기억한다', async () => {
+    const { wrapper } = await mountMail()
+
+    expect(messageListRequests()).toHaveLength(1)
+    expect(threadRequests()).toHaveLength(1)
+    expect(wrapper.findAll('.thread-row')).toHaveLength(3)
+    expect(window.localStorage.getItem(groupByConversationHintKey(USER.email))).toBe('true')
+  })
+
+  it('짐작과 서버 값이 다르면 서버 값이 이긴다 — 다른 PC 에서 껐다', async () => {
+    rememberGrouped()
+    settings = { ...settings, groupByConversation: false }
+    const { wrapper } = await mountMail()
+
+    expect(wrapper.findAll('.thread-row')).toHaveLength(0)
+    expect(wrapper.findAll('.message-row')).toHaveLength(2)
+    expect(window.localStorage.getItem(groupByConversationHintKey(USER.email))).toBe('false')
+  })
+
+  it('[대화로 묶기]를 누르면 저장하고 곧바로 바꾼다 — 끄면 메일 목록과 "메일 9통, 안 읽은 메일 2통", 다시 켜면 처음 쪽부터', async () => {
+    rememberGrouped()
+    const { wrapper } = await mountMail()
+
+    await wrapper.get('[data-group-toggle]').trigger('click')
+    await settle()
+    expect(requests.filter((request) => request.method === 'PATCH').map((request) => request.data)).toEqual([
+      { groupByConversation: false },
+    ])
+    expect(messageListRequests()).toHaveLength(1)
+    expect(wrapper.findAll('.thread-row')).toHaveLength(0)
+    expect(wrapper.findAll('.message-row')).toHaveLength(2)
+    expect(headCount(wrapper)).toEqual({
+      shown: '안 읽은 메일 2통',
+      spoken: '메일 9통, 안 읽은 메일 2통',
+      title: '메일 9통, 안 읽은 메일 2통',
+    })
+    expect(wrapper.get('[data-group-toggle]').attributes('aria-pressed')).toBe('false')
+
+    await wrapper.get('[data-group-toggle]').trigger('click')
+    await settle()
+    expect(threadRequests()).toHaveLength(2)
+    expect(threadRequests()[1]?.params).toEqual({ mailboxId: 'inbox', limit: 20 })
+    expect(wrapper.findAll('.thread-row')).toHaveLength(3)
+  })
+
+  it('저장하지 못하면 묶은 목록으로 되돌린다 — 알림은 인터셉터가', async () => {
+    rememberGrouped()
+    const { wrapper } = await mountMail()
+    patchSettings = () => fail(400, 'VAL_001')
+
+    await wrapper.get('[data-group-toggle]').trigger('click')
+    await settle()
+
+    expect(wrapper.get('[data-group-toggle]').attributes('aria-pressed')).toBe('true')
+    expect(wrapper.findAll('.thread-row')).toHaveLength(3)
+    expect(useToastStore().toasts.map((toast) => toast.message)).toEqual([ERROR_CODE_MESSAGES.VAL_001])
+  })
+
+  it('줄을 누르면 그 메일함의 마지막 메일을 연다 — 연 메일이 든 줄이 골라진 모양', async () => {
+    rememberGrouped()
+    const { wrapper, router } = await mountMail()
+
+    await wrapper.findAll('.thread-row__main')[2]?.trigger('click')
+    await settle()
+
+    expect(router.currentRoute.value.fullPath).toBe('/mail/inbox/m3')
+    expect(wrapper.get('#reader-subject').text()).toBe('제목 m3')
+    expect(wrapper.findAll('.thread-row')[2]?.classes()).toContain('is-selected')
+  })
+
+  it('메일이 모두 보내기를 기다리는 줄은 고를 수 없다 — 고르기 칸 · 별이 aria-disabled 이고 누르면 아무것도 하지 않는다', async () => {
+    rememberGrouped()
+    rows = [conversation('held', ['m9'], { pendingSendIds: ['m9'] }), ...ROWS.slice(1)]
+    const { wrapper } = await mountMail()
+    const heldRow = wrapper.findAll('.thread-row')[0]
+
+    expect(heldRow?.get('[role="checkbox"]').attributes('aria-disabled')).toBe('true')
+    expect(heldRow?.get('[data-thread-star]').attributes('aria-disabled')).toBe('true')
+    await heldRow?.get('[role="checkbox"]').trigger('click')
+    await heldRow?.get('[data-thread-star]').trigger('click')
+    await settle()
+    expect(wrapper.find('.bulk-bar').exists()).toBe(false)
+    expect(requests.filter((request) => request.method === 'PATCH')).toEqual([])
+  })
+
+  it('고르면 도구 줄 "대화 1개 선택됨" — 분할 보기는 "1개 선택됨"만 보이고 화면 낭독은 전체, 하는 일은 그 줄의 메일 모두', async () => {
+    rememberGrouped()
+    const { wrapper } = await mountMail()
+
+    await wrapper.findAll('.thread-row')[0]?.get('[role="checkbox"]').trigger('click')
+    // 단추 일곱과 한 줄에 들게 보이는 글만 줄인다 (2026-11-06 실사용 시험 — "대화 1개 선택됨"이면 두 줄로 넘쳤다)
+    const count = wrapper.get('.bulk-bar__count')
+    expect(count.get('[aria-hidden="true"]').text()).toBe('1개 선택됨')
+    expect(count.get('.visually-hidden').text()).toBe('대화 1개 선택됨')
+    expect(count.attributes('id')).toBe(wrapper.get('.mail-list-frame').attributes('aria-labelledby'))
+    // 단추 차례는 그대로
+    expect(wrapper.findAll('[role="toolbar"] [data-tool]').map((tool) => tool.attributes('data-tool'))).toEqual([
+      'markRead',
+      'markUnread',
+      'flag',
+      'move',
+      'delete',
+      'clear',
+    ])
+
+    await wrapper.get('[data-tool="markRead"]').trigger('click')
+    await settle()
+    expect(requests.filter((request) => request.method === 'PATCH' && request.url === '/messages').map((request) => request.data)).toEqual([
+      { ids: ['m6', 'm5'], isRead: true },
+    ])
+    expect(wrapper.findAll('.thread-row')[0]?.classes()).not.toContain('is-unread')
+  })
+
+  it('줄에 한 삭제의 알림은 "받은편지함에 있는 메일 N통을 휴지통으로 …" — 줄의 통 수는 대화 전체라서, 되돌리면 "메일 N통을 받은편지함으로 되돌렸습니다."', async () => {
+    rememberGrouped()
+    const { wrapper } = await mountMail()
+
+    await wrapper.findAll('.thread-row')[0]?.get('[role="checkbox"]').trigger('click')
+    await wrapper.get('[data-tool="delete"]').trigger('click')
+    await settle()
+
+    expect(requests.filter((request) => request.method === 'PATCH' && request.url === '/messages').map((request) => request.data)).toEqual([
+      { ids: ['m6', 'm5'], mailboxId: 'trash' },
+    ])
+    const [toast] = useToastStore().toasts
+    expect(toast?.message).toBe('받은편지함에 있는 메일 2통을 휴지통으로 옮겼습니다.')
+
+    if (toast?.action && 'run' in toast.action) toast.action.run()
+    await settle()
+    expect(requests.filter((request) => request.method === 'PATCH' && request.url === '/messages').at(-1)?.data).toEqual({
+      ids: ['m6', 'm5'],
+      mailboxId: 'inbox',
+    })
+    expect(useToastStore().toasts.map((item) => item.message)).toContain('메일 2통을 받은편지함으로 되돌렸습니다.')
+  })
+
+  it('휴지통에서 고른 대화를 영구 삭제 — 확인 창 · 알림은 "휴지통에 있는 메일 N통을 …"(줄의 통 수는 대화 전체라서)이고 그 줄의 메일을 POST /message-deletions', async () => {
+    rememberGrouped()
+    rows = [
+      conversation('t1', ['m8', 'm7'], { latest: summary('m8', { mailboxIds: ['trash'] }), messageCount: 5 }),
+      conversation('t2', ['m1']),
+    ]
+    const { wrapper } = await mountMail('/mail/trash')
+    // 줄은 대화 전체의 "5통" — 지우는 것은 휴지통의 2통이다 (2026-11-07)
+    expect(wrapper.findAll('.thread-row')[0]?.get('[data-thread-count]').text()).toBe('5통')
+
+    await wrapper.findAll('.thread-row')[0]?.get('[role="checkbox"]').trigger('click')
+    await wrapper.get('[data-tool="delete"]').trigger('click')
+    await settle()
+    const dialog = wrapper.get('#bulk-purge-title')
+    expect(dialog.text()).toBe('휴지통에 있는 메일 2통을 영구 삭제할까요?')
+    expect(wrapper.get('#bulk-purge-message').text()).toBe('휴지통에서 지운 메일은 되돌릴 수 없습니다.')
+
+    await wrapper.get('[data-purge-confirm]').trigger('click')
+    await settle()
+    expect(requests.filter((request) => request.url === '/message-deletions').map((request) => request.data)).toEqual([
+      { ids: ['m8', 'm7'] },
+    ])
+    expect(useToastStore().toasts.map((toast) => toast.message)).toContain('휴지통에 있는 메일 2통을 영구 삭제했습니다.')
+  })
+
+  it('묶은 휴지통이어도 읽기 화면의 영구 삭제(한 통)는 지금 글 그대로 — "메일 1통을 영구 삭제할까요?" · "메일 1통을 영구 삭제했습니다."', async () => {
+    rememberGrouped()
+    rows = [conversation('t1', ['m8', 'm7'], { latest: summary('m8', { mailboxIds: ['trash'] }), messageCount: 5 })]
+    openedMailboxIds = ['trash']
+    const { wrapper } = await mountMail('/mail/trash/m8')
+
+    const remove = wrapper.get('[data-reader-delete]')
+    expect(remove.text()).toBe('영구 삭제')
+    await remove.trigger('click')
+    await settle()
+    expect(wrapper.get('#reader-purge-title').text()).toBe('메일 1통을 영구 삭제할까요?')
+
+    // 고른 줄이 없어 도구 줄(과 그 확인 창)은 없다 — 확인 단추는 읽기 화면의 것 하나
+    expect(wrapper.find('.bulk-bar').exists()).toBe(false)
+    await wrapper.get('[data-purge-confirm]').trigger('click')
+    await settle()
+    expect(requests.filter((request) => request.url === '/message-deletions').map((request) => request.data)).toEqual([
+      { ids: ['m8'] },
+    ])
+    expect(useToastStore().toasts.map((toast) => toast.message)).toContain('메일 1통을 영구 삭제했습니다.')
+  })
+
+  it('목록 보기 — 크기 칸이 없고 머리 고르기는 "불러온 대화 모두 고르기". 연 메일의 위치는 대화 기준이고 [다음]은 다음 대화의 마지막 메일', async () => {
+    rememberGrouped()
+    window.localStorage.setItem(mailViewModeStorageKey(USER.email), 'list')
+    const { wrapper, router } = await mountMail()
+
+    const heads = wrapper.findAll('table.mail-table thead th').map((th) => th.text())
+    expect(heads).not.toContain('크기')
+    // 사람 칸 머리는 어느 메일함이든 "참여자" — 줄이 대화의 참여자다 (2026-11-06 실사용 시험)
+    expect(heads).toContain('참여자')
+    expect(heads).not.toContain('보낸 사람')
+    // 목록 보기(넓은 머리)는 개수 글을 다 보인다
+    expect(wrapper.get('.list-header__count').text()).toBe('대화 6개, 안 읽은 메일 2통')
+    expect(wrapper.find('.list-header__count .visually-hidden').exists()).toBe(false)
+    expect(wrapper.get('thead th [role="checkbox"]').attributes('aria-label')).toBe('불러온 대화 모두 고르기')
+    expect(wrapper.get('table.mail-table caption').text()).toBe('받은편지함 대화 목록')
+    expect(wrapper.findAll('tbody tr').map((row) => row.get('[data-message-id]').attributes('data-message-id'))).toEqual([
+      'm6',
+      'm4',
+      'm3',
+    ])
+    // 목록 보기에서는 이름까지
+    expect(wrapper.get('[data-group-toggle]').attributes('title')).toBeUndefined()
+
+    await router.push('/mail/inbox/m4')
+    await settle()
+    expect(wrapper.get('.nav-position').text()).toBe('2 / 6')
+    await wrapper.get('button[aria-label="다음 메일"]').trigger('click')
+    await settle()
+    expect(router.currentRoute.value.fullPath).toBe('/mail/inbox/m3')
+  })
+
+  it('새 메일 확인 — 바뀌었으면 묶은 목록을 불러온 줄 수만큼 조용히 다시 받는다', async () => {
+    rememberGrouped()
+    const { wrapper } = await mountMail()
+    expect(threadRequests()).toHaveLength(1)
+
+    rows = [conversation('c9', ['m9'], { latest: summary('m9', { subject: '새 대화' }) }), ...ROWS]
+    state = 's2'
+    clock.advance(MAIL_STATE_POLL_INTERVAL_MS)
+    await settle()
+
+    expect(threadRequests()).toHaveLength(2)
+    expect(threadRequests()[1]?.params).toEqual({ mailboxId: 'inbox', limit: 20 })
+    expect(threadRequests()[1]?.config.silent).toBe(true)
+    expect(messageListRequests()).toHaveLength(0)
+    expect(wrapper.findAll('.thread-row').map((row) => row.attributes('data-row-id'))).toEqual(['c9', 'c1', 'c2', 'c3'])
+  })
+
+  it('다른 탭에서 끈 묶기 — 60초 뒤 탭으로 돌아오면 설정을 조용히 다시 받아 메일 목록으로 다시 연다 (2026-11-06 실사용 시험)', async () => {
+    rememberGrouped()
+    const { wrapper } = await mountMail()
+    expect(wrapper.findAll('.thread-row')).toHaveLength(3)
+    const settingsRequests = () => requests.filter((request) => request.url === '/mail-settings' && request.method === 'GET')
+    expect(settingsRequests()).toHaveLength(1)
+
+    // 다른 탭이 껐다
+    settings = { ...settings, groupByConversation: false }
+    clock.advance(MAIL_SETTINGS_REFRESH_AFTER_MS - 1)
+    document.dispatchEvent(new Event('visibilitychange'))
+    await settle()
+    expect(settingsRequests()).toHaveLength(1)
+
+    clock.advance(1)
+    document.dispatchEvent(new Event('visibilitychange'))
+    await settle()
+    expect(settingsRequests()).toHaveLength(2)
+    expect(settingsRequests()[1]?.config.silent).toBe(true)
+    expect(wrapper.findAll('.thread-row')).toHaveLength(0)
+    expect(wrapper.findAll('.message-row')).toHaveLength(2)
+    expect(wrapper.get('[data-group-toggle]').attributes('aria-pressed')).toBe('false')
+    expect(useToastStore().toasts).toEqual([])
+  })
+
+  describe('세션이 끝나면 목록을 부르지 않는다 (리뷰 M1)', () => {
+    it.each([
+      ['로그아웃', () => useAuthStore().clearAuth()],
+      ['세션 만료', () => useAuthStore().expireSession()],
+    ])('묶기를 켠 채 %s — 메일 목록 · 묶은 목록 요청이 0건이고 비운 목록이 다시 차지 않는다', async (_name, end) => {
+      rememberGrouped()
+      await mountMail()
+      const before = { messages: messageListRequests().length, threads: threadRequests().length }
+
+      end()
+      await settle()
+
+      expect({ messages: messageListRequests().length, threads: threadRequests().length }).toEqual(before)
+      expect(useMailStore().conversations).toEqual([])
+      expect(useMailStore().listSource).toBeNull()
+    })
+  })
+
+  describe('읽기 화면 [삭제] 뒤 갈 곳 — 분할 보기 (리뷰 L3)', () => {
+    it('그 줄에 메일이 남으면 그 줄의 다음 칸(더 오래된 메일), 줄이 비면 다음 줄의 마지막 메일', async () => {
+      rememberGrouped()
+      const { wrapper, router } = await mountMail('/mail/inbox/m6')
+
+      await wrapper.get('[data-reader-delete]').trigger('click')
+      await settle()
+      expect(requests.filter((request) => request.method === 'PATCH' && request.url === '/messages').map((request) => request.data)).toEqual([
+        { ids: ['m6'], mailboxId: 'trash' },
+      ])
+      expect(router.currentRoute.value.fullPath).toBe('/mail/inbox/m5')
+      expect(wrapper.findAll('.thread-row')[0]?.classes()).toContain('is-selected')
+
+      await wrapper.get('[data-reader-delete]').trigger('click')
+      await settle()
+      expect(router.currentRoute.value.fullPath).toBe('/mail/inbox/m4')
+      expect(wrapper.findAll('.thread-row').map((row) => row.attributes('data-row-id'))).toEqual(['c2', 'c3'])
+    })
+  })
+
+  describe('목록 보기의 읽기 화면 — 대화 사이를 오간다', () => {
+    beforeEach(() => {
+      rememberGrouped()
+      window.localStorage.setItem(mailViewModeStorageKey(USER.email), 'list')
+    })
+
+    it('줄의 마지막 메일이 아닌 메일도 그 메일이 든 줄의 위치 — [다음]은 다음 대화, [이전]은 앞 대화의 마지막 메일', async () => {
+      const { wrapper, router } = await mountMail('/mail/inbox/m5')
+
+      expect(wrapper.get('.nav-position').text()).toBe('1 / 6')
+      expect(wrapper.get('button[aria-label="이전 메일"]').attributes('disabled')).toBeDefined()
+      await wrapper.get('button[aria-label="다음 메일"]').trigger('click')
+      await settle()
+      expect(router.currentRoute.value.fullPath).toBe('/mail/inbox/m4')
+
+      await router.push('/mail/inbox/m2')
+      await settle()
+      expect(wrapper.get('.nav-position').text()).toBe('3 / 6')
+      await wrapper.get('button[aria-label="이전 메일"]').trigger('click')
+      await settle()
+      expect(router.currentRoute.value.fullPath).toBe('/mail/inbox/m4')
+    })
+
+    it('[목록으로] — 표로 돌아가 그 메일이 든 줄의 링크(마지막 메일)로 초점을 돌려준다', async () => {
+      const { wrapper, router } = await mountMail('/mail/inbox/m5')
+
+      const back = wrapper.findAll('a').find((link) => link.text() === '목록으로')
+      await back?.trigger('click', { button: 0 })
+      await settle()
+
+      expect(router.currentRoute.value.fullPath).toBe('/mail/inbox')
+      expect(document.activeElement?.getAttribute('data-message-id')).toBe('m6')
+    })
+
+    it('메일이 모두 보내기를 기다리는 줄 — Ctrl · Shift + 클릭으로도 고르지 않고, 날짜 칸은 예약 표시', async () => {
+      rows = [
+        conversation('held', ['m9'], {
+          latest: summary('m9', { pendingSend: { sendAt: '2026-11-10T01:00:00Z', kind: 'scheduled' } }),
+          pendingSendIds: ['m9'],
+        }),
+        ...ROWS,
+      ]
+      const { wrapper } = await mountMail()
+      const heldRow = wrapper.get('tr[data-row-id="held"]')
+
+      await heldRow.get('td.mail-table__subject').trigger('click', { ctrlKey: true })
+      await heldRow.get('td.mail-table__subject').trigger('click', { shiftKey: true })
+      expect(wrapper.find('.bulk-bar').exists()).toBe(false)
+      expect(heldRow.get('td.mail-table__date').text()).toMatch(/^예약 · /)
+
+      // 다른 줄은 Ctrl + 클릭으로 고른다
+      await wrapper.get('tr[data-row-id="c2"] td.mail-table__subject').trigger('click', { ctrlKey: true })
+      expect(wrapper.get('.bulk-bar__count').text()).toBe('대화 1개 선택됨')
+    })
+  })
+
+  it('빠르게 켬 → 끔 → 켬 — 마지막 목록만 남고 버린 메일 목록 요청은 끊는다 (리뷰 L7)', async () => {
+    rememberGrouped()
+    let releaseMessages: (result: MockResult) => void = () => undefined
+    listMessages = () =>
+      new Promise<MockResult>((resolve) => {
+        releaseMessages = resolve
+      })
+    const { wrapper } = await mountMail()
+    const toggle = () => wrapper.get('[data-group-toggle]')
+
+    await toggle().trigger('click')
+    await settle()
+    expect(messageListRequests()).toHaveLength(1)
+    await toggle().trigger('click')
+    await settle()
+
+    expect(messageListRequests()[0]?.config.signal?.aborted).toBe(true)
+    releaseMessages(page([summary('late')], 1))
+    await settle()
+    expect(toggle().attributes('aria-pressed')).toBe('true')
+    expect(wrapper.findAll('.message-row')).toHaveLength(0)
+    expect(wrapper.findAll('.thread-row').map((row) => row.attributes('data-row-id'))).toEqual(['c1', 'c2', 'c3'])
+    expect(settings.groupByConversation).toBe(true)
+  })
+
+  it('설정을 받지 못했으면 짐작대로 묶고 [대화로 묶기]도 쓸 수 있다 — 저장 응답을 받은 설정으로 (리뷰 L4)', async () => {
+    rememberGrouped()
+    loadSettings = () => fail(503, 'SYS_001')
+    const { wrapper } = await mountMail()
+
+    expect(wrapper.findAll('.thread-row')).toHaveLength(3)
+    expect(wrapper.get('[data-group-toggle]').attributes('aria-pressed')).toBe('true')
+
+    await wrapper.get('[data-group-toggle]').trigger('click')
+    await settle()
+    expect(requests.filter((request) => request.method === 'PATCH' && request.url === '/mail-settings').map((request) => request.data)).toEqual([
+      { groupByConversation: false },
+    ])
+    expect(wrapper.findAll('.message-row')).toHaveLength(2)
+    expect(wrapper.get('[data-group-toggle]').attributes('aria-pressed')).toBe('false')
+  })
+
+  it('줄의 중요 표시가 보내기를 기다리는 메일에만 있으면 별로 풀리지 않는다 — 다시 맞춰 보고 그 까닭을 알린다', async () => {
+    rememberGrouped()
+    rows = [conversation('hf', ['m9', 'm8'], { isFlagged: true, pendingSendIds: ['m9'] }), ...ROWS.slice(1)]
+    const { wrapper } = await mountMail()
+    const syncs = threadRequests().length
+
+    await wrapper.get('.thread-row[data-row-id="hf"] [data-thread-star]').trigger('click')
+    await settle()
+
+    expect(requests.filter((request) => request.method === 'PATCH' && request.url === '/messages').map((request) => request.data)).toEqual([
+      { ids: ['m8'], isFlagged: false },
+    ])
+    expect(threadRequests().length).toBe(syncs + 1)
+    expect(wrapper.get('.thread-row[data-row-id="hf"] [data-thread-star]').attributes('aria-pressed')).toBe('true')
+    expect(useToastStore().toasts.map((toast) => toast.message)).toEqual([
+      '보내기를 기다리는 메일은 목록에서 중요 표시를 바꿀 수 없습니다. 메일을 열어 바꿔 주세요.',
+    ])
+  })
+
+  it('임시보관함의 제목 없는 저장본 — 흐린 "(제목 없음)", 굵게 하지 않고 누르면 쓰기 화면에서 이어 쓴다 (리뷰 L5)', async () => {
+    rememberGrouped()
+    rows = [
+      conversation('d1', ['d1'], {
+        latest: summary('d1', { subject: '', mailboxIds: ['drafts'], isRead: false }),
+        participants: [ME],
+        isRead: false,
+      }),
+    ]
+    const { wrapper } = await mountMail('/mail/drafts')
+    const row = wrapper.get('.thread-row')
+
+    expect(row.get('.thread-row__subject').text()).toBe('(제목 없음)')
+    expect(row.get('.thread-row__subject').classes()).toContain('is-placeholder')
+    expect(row.classes()).not.toContain('is-unread')
+    expect(row.get('.thread-row__who').text()).toBe('받는 사람: 김아라')
+    expect(row.get('.thread-row__main').attributes('href')).toBe('/mail/compose?draft=d1')
+  })
+
+  it('검색 결과는 묶지 않는다 — 켜져 있어도 GET /messages 이고 [대화로 묶기]가 없다', async () => {
+    rememberGrouped()
+    const { wrapper } = await mountMail('/mail/search?q=%ED%9A%8C%EC%9D%98&in=inbox')
+
+    expect(threadRequests()).toHaveLength(0)
+    expect(messageListRequests()[0]?.params).toMatchObject({ q: '회의', mailboxId: 'inbox' })
+    expect(wrapper.find('[data-group-toggle]').exists()).toBe(false)
+  })
+})
diff --git a/frontend/src/pages/mail/MailboxPage.vue b/frontend/src/pages/mail/MailboxPage.vue
index f03d1c4..9d62474 100644
--- a/frontend/src/pages/mail/MailboxPage.vue
+++ b/frontend/src/pages/mail/MailboxPage.vue
@@ -7,6 +7,10 @@
 //   - 목록: 메일을 열지 않았으면 게시판형 표(MainList), 열었으면 표 자리에 본문을 넓게(MainListRead)
 // 검색 결과는 메일함 목록과 같은 목록 · 표 · 본문을 쓴다 — 목록의 출처만 다르다 (mail-list-source.ts)
 // 예약됨(9단계)은 고르기 · 여러 통 처리가 없는 목록(ScheduledMessageList — 받는 사람 · 제목 · 보낼 시각)을 쓰고, 연 메일은 같은 본문이다
+// 대화로 묶어 보기(14단계 — 설정 groupByConversation)를 켰으면 메일함 목록의 출처가 GET /conversations 다 — 주소는 같고 한 줄이 대화 하나다.
+//   설정을 받기 전 · 받지 못했으면 이 브라우저의 짐작(mail-settings.store — 처음이면 끔)으로 연다(기다리게 하지 않는다) — 받아 보니 다르면 그때 바꾼다.
+//   켜고 끄면(목록 머리의 [대화로 묶기] · 설정 화면) 앞 목록의 요청을 끊고 처음 쪽부터 받는다. 검색 결과 · 예약됨은 묶지 않는다.
+//   로그아웃 · 세션 만료 · 제한된 세션(canUseApp false)에는 목록을 부르지 않는다 — 떠나는 화면이 막 비운 목록을 다시 채우지 않게 (리뷰 M1)
 import { computed, watch } from 'vue'
 import { useRoute, useRouter } from 'vue-router'
 
@@ -18,13 +22,18 @@ import MessageReader from '@/components/mail/MessageReader.vue'
 import MessageTable from '@/components/mail/MessageTable.vue'
 import ScheduledMessageList from '@/components/mail/ScheduledMessageList.vue'
 import { useMailSearchNavigation } from '@/composables/useMailSearchNavigation'
-import { isScheduledRouteName } from '@/shared/utils/mail-list-source'
+import { isScheduledRouteName, isSearchTooLong, listKeyOf } from '@/shared/utils/mail-list-source'
+import { messageHighlightKey, messageHighlightQueryOf } from '@/shared/utils/mail-search'
+import { useAuthStore } from '@/stores/auth.store'
 import { useMailStore } from '@/stores/mail.store'
+import { useMailSettingsStore } from '@/stores/mail-settings.store'
 import { useMailViewStore } from '@/stores/mail-view.store'
 
 const route = useRoute()
 const router = useRouter()
+const authStore = useAuthStore()
 const mailStore = useMailStore()
+const settingsStore = useMailSettingsStore()
 const viewStore = useMailViewStore()
 const { isSearching, routeSearch, closeSearch } = useMailSearchNavigation()
 
@@ -40,10 +49,13 @@ const isListView = computed(() => viewStore.mode === 'list')
 /** 목록이 있는 화면 — 메일함 · 검색 결과 · 예약됨 */
 const hasList = computed(() => Boolean(mailboxId.value) || isSearching.value || isScheduled.value)
 
+// 메일함 · 묶어 보기가 바뀔 때 — 같은 목록으로 돌아오면(쓰기 화면에서 복귀 등) 스토어가 보이던 채로 새로 고친다.
+// 세션이 끝났으면 부르지 않는다 (머리말 — 로그아웃은 스토어를 비우고 로그인 화면으로 간다)
 watch(
-  mailboxId,
-  (id) => {
-    if (id) void mailStore.openMailbox(id)
+  [mailboxId, () => settingsStore.groupByConversation, () => authStore.canUseApp],
+  ([id, grouped, usable]) => {
+    if (!id || !usable) return
+    void (grouped ? mailStore.openConversations(id) : mailStore.openMailbox(id))
   },
   { immediate: true },
 )
@@ -57,25 +69,37 @@ watch(
   { immediate: true },
 )
 
-// 검색어 · 범위가 바뀔 때만 다시 찾는다 — 결과에서 메일을 열고 닫는 것으로는 다시 찾지 않는다.
-// 검색어가 없는 주소(/mail/search)는 검색을 닫은 것으로 본다
+// 검색어 · 범위 · 조건(14단계)이 바뀔 때만 다시 찾는다 — 결과에서 메일을 열고 닫는 것으로는 다시 찾지 않는다.
+// 검색어도 조건도 없는 주소(/mail/search)는 검색을 닫은 것으로 본다
 watch(
-  [isSearching, () => routeSearch.value?.q ?? null, () => routeSearch.value?.scope ?? null],
-  ([searching, q, scope]) => {
+  [isSearching, () => (routeSearch.value ? listKeyOf(routeSearch.value) : null)],
+  ([searching, key]) => {
     if (!searching) return
-    if (q === null || scope === null) {
+    const search = routeSearch.value
+    if (key === null || !search) {
       void closeSearch()
       return
     }
-    void mailStore.openSearch(q, scope)
+    void mailStore.openSearch(search.q, search.scope, { conditions: search.conditions })
   },
   { immediate: true },
 )
 
+/**
+ * 검색 결과에서 연 메일의 강조 쿼리 (14단계 — 검색어와 글 조건 넷만). 메일함에서 연 메일은 null —
+ * 쿼리가 바뀌면 같은 메일이어도 다시 받는다(검색 결과의 강조 본문이 메일함 화면에 남지 않게).
+ * 낱말이 한도를 넘는 주소(손으로 고친 주소)면 싣지 않는다 — 서버가 400 으로 거절해 메일을 열지 못한다
+ */
+const highlightQuery = computed(() =>
+  isSearching.value && routeSearch.value && !isSearchTooLong(routeSearch.value)
+    ? messageHighlightQueryOf(routeSearch.value.q, routeSearch.value.conditions)
+    : null,
+)
+
 watch(
-  messageId,
-  (id) => {
-    if (id) void mailStore.openMessage(id)
+  [messageId, () => messageHighlightKey(highlightQuery.value)],
+  ([id]) => {
+    if (id) void mailStore.openMessage(id, highlightQuery.value)
     else mailStore.closeMessage()
   },
   { immediate: true },
diff --git a/frontend/src/pages/settings/MailLargeFilesPage.spec.ts b/frontend/src/pages/settings/MailLargeFilesPage.spec.ts
index 92393c3..66a6ee2 100644
--- a/frontend/src/pages/settings/MailLargeFilesPage.spec.ts
+++ b/frontend/src/pages/settings/MailLargeFilesPage.spec.ts
@@ -276,7 +276,7 @@ describe('MailLargeFilesPage', () => {
 
     expect(view.get('[data-large-usage]').text()).toBe('0 / 10 GB')
     expect(view.get('[data-large-empty]').text()).toContain('링크로 보낸 파일이 없습니다')
-    expect(view.get('[data-large-empty]').text()).toContain('메일 쓰기에서 20MB 가 넘는 파일을 고르면 링크로 보냅니다.')
+    expect(view.get('[data-large-empty]').text()).toContain('메일 쓰기에서 20MB가 넘는 파일을 고르면 링크로 보냅니다.')
     expect(view.find('#large-unsent-title').exists()).toBe(false)
   })
 
diff --git a/frontend/src/pages/settings/MailSendReadPage.spec.ts b/frontend/src/pages/settings/MailSendReadPage.spec.ts
index 69006b8..85ecf3b 100644
--- a/frontend/src/pages/settings/MailSendReadPage.spec.ts
+++ b/frontend/src/pages/settings/MailSendReadPage.spec.ts
@@ -13,10 +13,10 @@ import MailSendReadPage from './MailSendReadPage.vue'
 // 설정 › 메일 › 보내기 · 읽기 (디자인 원본 SettingsSendRead · 계약 2절 "보내기 · 읽기 설정") — 고르는 대로 PATCH, "저장했습니다"
 
 const USER = { email: 'ara.kim@arasystem.it.kr', name: '김아라' }
-const DEFAULTS: MailSettings = { undoSendSeconds: 10, externalImages: 'ask' }
+const DEFAULTS: MailSettings = { undoSendSeconds: 10, externalImages: 'ask', groupByConversation: false }
 
 interface Server {
-  settings?: MailSettings
+  settings?: Partial<MailSettings>
   /** GET /mail-settings 의 응답을 바꾼다 (실패 등) */
   load?: MockResult
   patch?: (request: MockRequest) => MockResult | Promise<MockResult>
@@ -118,6 +118,37 @@ describe('MailSendReadPage', () => {
     expect(wrapper.get('[data-settings-status]').text()).toBe('저장했습니다')
   })
 
+  it('대화로 묶기(14단계 — 목록 위 단추와 같은 이름) — 끔 · 켬 전환과 설명, 고르면 그 칸만 PATCH 하고 "저장했습니다"', async () => {
+    const wrapper = await mountPage()
+    const grouping = () =>
+      wrapper.findAll('[data-group-by-conversation]').map((button) => [button.text(), button.attributes('aria-pressed')])
+
+    expect(wrapper.get('#send-read-group-title').text()).toBe('대화로 묶기')
+    expect(grouping()).toEqual([
+      ['끔', 'true'],
+      ['켬', 'false'],
+    ])
+    expect(wrapper.get('#send-read-group-hint').text()).toBe(
+      '답장과 전달로 이어진 메일을 메일함 목록에서 한 줄로 묶어 보여 줍니다. 메일함 목록 위의 말풍선 모양 [대화로 묶기] 단추로도 켜고 끌 수 있습니다.',
+    )
+
+    await wrapper.get('[data-group-by-conversation="true"]').trigger('click')
+    await flushPromises()
+
+    expect(patches()).toEqual([{ groupByConversation: true }])
+    expect(grouping()).toEqual([
+      ['끔', 'false'],
+      ['켬', 'true'],
+    ])
+    expect(wrapper.get('[data-settings-status]').text()).toBe('저장했습니다')
+  })
+
+  it('묶어 보기 필드가 없는 서버(14단계 앞)면 끔으로 그린다', async () => {
+    const wrapper = await mountPage({ load: ok({ undoSendSeconds: 10, externalImages: 'ask' }) })
+
+    expect(wrapper.get('[data-group-by-conversation="false"]').attributes('aria-pressed')).toBe('true')
+  })
+
   it('지금 값을 다시 누르면 보내지 않는다', async () => {
     const wrapper = await mountPage()
 
diff --git a/frontend/src/pages/settings/MailSendReadPage.vue b/frontend/src/pages/settings/MailSendReadPage.vue
index 7aadc1d..1dcef7a 100644
--- a/frontend/src/pages/settings/MailSendReadPage.vue
+++ b/frontend/src/pages/settings/MailSendReadPage.vue
@@ -3,14 +3,20 @@
 // — /settings/mail/send-read · 탭 제목 "보내기 · 읽기"
 // 머리 "보내기 · 읽기" + 설명 + 오른쪽에 "저장했습니다"(role=status — 저장 단추 없음) →
 // 「보내기 취소」 전환(36 — .segmented 밀도 예외: 끔 · 5초 · 10초 · 20초 · 30초) + 설명 → 가는 선 →
-// 「외부 이미지」 라디오 셋(늘 묻기 · 주소록 · 사내 직원의 메일은 늘 보기 · 늘 보기 — 줄마다 아래 설명) + 회색 안내 상자.
+// 「외부 이미지」 라디오 셋(늘 묻기 · 주소록 · 사내 직원의 메일은 늘 보기 · 늘 보기 — 줄마다 아래 설명) + 회색 안내 상자 → 가는 선 →
+// 「대화로 묶기」 전환(36 — 끔 · 켬, 14단계 — 목록 머리의 [대화로 묶기]와 같은 설정 · 같은 이름) + 설명.
 // - 들어올 때마다 새로 받는다(다른 PC 에서 바꿨을 수 있다 — 서버에 저장되어 어느 PC 에서나 같다). 받는 동안은 자리만, 못 받으면 사전 문구와 "다시 시도"
 // - 고르는 대로 그 칸만 PATCH 한다(mail-settings.store — 화면을 먼저 바꾸고 실패하면 고르기 전 값으로 되돌린다, 알림은 인터셉터).
 //   저장이 끝나면 "저장했습니다", 다시 고르면 내린다
 import AppIcon from '@/components/AppIcon.vue'
 import MailLoadError from '@/components/mail/MailLoadError.vue'
 import SettingsPageFrame from '@/components/settings/SettingsPageFrame.vue'
-import { EXTERNAL_IMAGES_OPTIONS, MAIL_SETTINGS_TEXT, UNDO_SEND_OPTIONS } from '@/shared/constants/mail-settings'
+import {
+  EXTERNAL_IMAGES_OPTIONS,
+  GROUP_BY_CONVERSATION_OPTIONS,
+  MAIL_SETTINGS_TEXT,
+  UNDO_SEND_OPTIONS,
+} from '@/shared/constants/mail-settings'
 import type { ExternalImagesSetting, UndoSendSeconds } from '@/shared/types/mail'
 import { useMailSettingsStore } from '@/stores/mail-settings.store'
 
@@ -28,6 +34,10 @@ function chooseImages(option: ExternalImagesSetting) {
   void settingsStore.update('externalImages', option)
 }
 
+function chooseGrouping(grouped: boolean) {
+  void settingsStore.update('groupByConversation', grouped)
+}
+
 // 처음 그리기 전에 — 지난번에 받아 둔 값을 잠깐 그렸다 바꾸지 않게
 void settingsStore.load()
 </script>
@@ -135,6 +145,44 @@ void settingsStore.load()
           {{ MAIL_SETTINGS_TEXT.imagesNote }}
         </p>
       </fieldset>
+
+      <hr class="send-read__rule">
+
+      <section
+        class="send-read__group"
+        aria-labelledby="send-read-group-title"
+      >
+        <h2
+          id="send-read-group-title"
+          class="send-read__title"
+        >
+          {{ MAIL_SETTINGS_TEXT.groupTitle }}
+        </h2>
+        <div
+          role="group"
+          class="segmented segmented--outline send-read__undo"
+          aria-labelledby="send-read-group-title"
+          aria-describedby="send-read-group-hint"
+        >
+          <button
+            v-for="grouped in GROUP_BY_CONVERSATION_OPTIONS"
+            :key="String(grouped)"
+            type="button"
+            class="segmented__item"
+            :aria-pressed="settingsStore.settings.groupByConversation === grouped"
+            :data-group-by-conversation="String(grouped)"
+            @click="chooseGrouping(grouped)"
+          >
+            {{ grouped ? MAIL_SETTINGS_TEXT.groupOn : MAIL_SETTINGS_TEXT.groupOff }}
+          </button>
+        </div>
+        <p
+          id="send-read-group-hint"
+          class="form-message"
+        >
+          {{ MAIL_SETTINGS_TEXT.groupHint }}
+        </p>
+      </section>
     </template>
 
     <div
diff --git a/frontend/src/pages/share/SharePage.spec.ts b/frontend/src/pages/share/SharePage.spec.ts
index 6a24a10..b8b9d6c 100644
--- a/frontend/src/pages/share/SharePage.spec.ts
+++ b/frontend/src/pages/share/SharePage.spec.ts
@@ -120,7 +120,7 @@ describe('SharePage', () => {
     expect(view.get('.share__safety').text()).toBe(
       '이 화면은 로그인이나 비밀번호를 묻지 않습니다. 묻는 화면이 나오면 닫고 보낸 사람에게 확인해 주세요.',
     )
-    expect(view.get('.share__report').text()).toBe('받을 이유가 없는 파일이면 security@arasystem.it.kr 로 알려 주세요.')
+    expect(view.get('.share__report').text()).toBe('받을 이유가 없는 파일이면 security@arasystem.it.kr(으)로 알려 주세요.')
     expect(view.get('.share__english').text()).toBe(
       'Files from 김아라 (ara.kim@arasystem.it.kr). Download by Nov 29, 2026 (KST). This page will never ask you to log in or enter a password.',
     )
diff --git a/frontend/src/pages/share/SharePage.vue b/frontend/src/pages/share/SharePage.vue
index 692cc60..378f9a3 100644
--- a/frontend/src/pages/share/SharePage.vue
+++ b/frontend/src/pages/share/SharePage.vue
@@ -22,6 +22,7 @@ import { APP_NAME } from '@/shared/constants/brand'
 import { SHARE_PAGE_TEXT, SHARE_SCAN_POLL_DELAYS_MS, SHARE_SCAN_POLL_LIMIT } from '@/shared/constants/large-file'
 import type { PublicLink, PublicLinkFile } from '@/shared/types/large-file'
 import { formatCount, formatFileSize } from '@/shared/utils/format'
+import { directionParticle } from '@/shared/utils/korean'
 import {
   formatKstEnglishDate,
   formatKstFullDate,
@@ -71,6 +72,10 @@ const view = computed(() => {
   return 'active'
 })
 
+/** 신고 주소 뒤의 글 — 조사는 주소에 붙이고 받침에 맞춘다 (영문으로 끝나면 "(으)로") */
+const reportAfter = computed(() =>
+  link.value ? SHARE_PAGE_TEXT.reportAfter(directionParticle(link.value.reportAddress)) : '',
+)
 const untilText = computed(() => (link.value ? SHARE_PAGE_TEXT.until(formatKstFullDate(link.value.expiresAt)) : ''))
 const untilTail = computed(() => {
   if (!link.value) return ''
@@ -395,7 +400,7 @@ watch(
           v-if="link && view !== 'loading'"
           class="share__report"
         >
-          {{ SHARE_PAGE_TEXT.reportBefore }}<a :href="`mailto:${link.reportAddress}`">{{ link.reportAddress }}</a>{{ SHARE_PAGE_TEXT.reportAfter }}
+          {{ SHARE_PAGE_TEXT.reportBefore }}<a :href="`mailto:${link.reportAddress}`">{{ link.reportAddress }}</a>{{ reportAfter }}
         </p>
         <p
           v-if="english"
diff --git a/frontend/src/shared/constants/icons.ts b/frontend/src/shared/constants/icons.ts
index c79d90f..4a56424 100644
--- a/frontend/src/shared/constants/icons.ts
+++ b/frontend/src/shared/constants/icons.ts
@@ -330,6 +330,23 @@ export const ICONS = {
     path('M7 19h5'),
     rect(16, 12, 6, 10, 2),
   ],
+
+  // ── 14단계: 검색 (디자인 원본 Search14) ──
+  /** 검색 칸의 [조건] (조절 막대 셋) */
+  sliders: [
+    line(4, 21, 4, 14),
+    line(4, 10, 4, 3),
+    line(12, 21, 12, 12),
+    line(12, 8, 12, 3),
+    line(20, 21, 20, 16),
+    line(20, 12, 20, 3),
+    line(1, 14, 7, 14),
+    line(9, 8, 15, 8),
+    line(17, 16, 23, 16),
+  ],
+  // ── 14단계: 대화로 묶어 보기 (디자인 원본 ListThreads14) ──
+  /** 목록 머리의 [대화로 묶기] (말풍선) */
+  'message-square': [path('M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z')],
 } as const satisfies Record<string, readonly IconShape[]>
 
 export type IconName = keyof typeof ICONS
diff --git a/frontend/src/shared/constants/large-file.ts b/frontend/src/shared/constants/large-file.ts
index 7c085f3..ac26e35 100644
--- a/frontend/src/shared/constants/large-file.ts
+++ b/frontend/src/shared/constants/large-file.ts
@@ -90,9 +90,12 @@ export const LARGE_FILE_TEXT = {
     `받는 사람은 보낸 날부터 ${days}일 동안 내려받을 수 있습니다. 오늘 보내면 ${until}까지입니다.`,
   /** 보관 사용량이 80%를 넘을 때 링크 묶음 머리 오른쪽 */
   quotaWarning: (usage: string) => `보관 ${usage}`,
-  /** 합계 때문에 저절로 링크로 바꿨을 때 — 칸 아래 ⓘ 한 줄 (role=status) */
+  /**
+   * 합계 때문에 저절로 링크로 바꿨을 때 — 칸 아래 ⓘ 한 줄 (role=status).
+   * total 은 늘 "25MB" 꼴(formatMegabytes — 메가바이트로 읽어 받침이 없다)이라 조사를 '를'로 붙여 쓴다
+   */
   switchedByTotal: (name: string, size: string, total: string) =>
-    `‘${name}’(${size})는 메일에 담으면 합계가 ${total} 를 넘어 링크로 보냅니다.`,
+    `‘${name}’(${size})는 메일에 담으면 합계가 ${total}를 넘어 링크로 보냅니다.`,
   sendAsLink: '링크로 보내기',
   pause: '멈춤',
   resume: '이어 올리기',
@@ -123,7 +126,7 @@ export const LARGE_FILE_TEXT = {
   missingExpired: '기간이 지나 지워진 파일입니다. 빼고 다시 올려 주세요.',
   missingDeleted: '[설정] → [대용량 첨부]에서 지운 파일입니다. 빼고 다시 올려 주세요.',
   missingUnknown: '파일을 찾을 수 없습니다. 빼고 다시 올려 주세요.',
-  tooLarge: (max: string) => `파일 하나는 ${max} 까지 보낼 수 있습니다.`,
+  tooLarge: (max: string) => `파일 하나는 ${max}까지 보낼 수 있습니다.`,
   tooMany: (count: string) => `링크로 보내는 파일은 메일 한 통에 ${count}개까지입니다.`,
   overQuota: (limit: string) =>
     `대용량 첨부는 ${limit}까지 보관할 수 있어 더 올릴 수 없습니다. 보내지 않은 파일을 지우거나 링크를 끊으면 바로 공간이 생깁니다.`,
@@ -271,8 +274,9 @@ export const LARGE_FILE_SETTINGS_TEXT = {
   more: '더 보기',
   moreHint: '최근에 보낸 순서로 20개씩 보입니다. 끝난 링크는 90일 뒤 목록에서 빠집니다.',
   emptyTitle: '링크로 보낸 파일이 없습니다',
+  /** max 는 늘 "20MB" 꼴(formatMegabytes — 받침이 없다)이라 조사를 '가'로 붙여 쓴다 */
   emptyHint: (max: string, days: string) =>
-    `메일 쓰기에서 ${max} 가 넘는 파일을 고르면 링크로 보냅니다. 받는 사람은 보낸 날부터 ${days}일 동안 내려받을 수 있습니다.`,
+    `메일 쓰기에서 ${max}가 넘는 파일을 고르면 링크로 보냅니다. 받는 사람은 보낸 날부터 ${days}일 동안 내려받을 수 있습니다.`,
   noSubject: '(제목 없음)',
 } as const
 
@@ -300,7 +304,11 @@ export const SHARE_PAGE_TEXT = {
   resumeHint: '내려받다 끊기면 브라우저의 다운로드 목록에서 다시 시도해 주세요. 받은 곳부터 이어서 받습니다.',
   noLogin: '이 화면은 로그인이나 비밀번호를 묻지 않습니다. 묻는 화면이 나오면 닫고 보낸 사람에게 확인해 주세요.',
   reportBefore: '받을 이유가 없는 파일이면 ',
-  reportAfter: ' 로 알려 주세요.',
+  /**
+   * 신고 주소 뒤 — 조사는 주소에 붙여 쓰고 받침에 맞춘다(korean.ts 의 directionParticle).
+   * 주소는 운영 설정이고 영문으로 끝나 보통 "(으)로" — "postmaster@arasystem.it.kr(으)로 알려 주세요."
+   */
+  reportAfter: (particle: string) => `${particle} 알려 주세요.`,
   englishActive: (sender: string, email: string, until: string) =>
     `Files from ${sender} (${email}). Download by ${until} (KST). This page will never ask you to log in or enter a password.`,
   scanningTitle: '보안 검사 중입니다',
diff --git a/frontend/src/shared/constants/mail-block.ts b/frontend/src/shared/constants/mail-block.ts
index 7806496..90f49f5 100644
--- a/frontend/src/shared/constants/mail-block.ts
+++ b/frontend/src/shared/constants/mail-block.ts
@@ -60,8 +60,8 @@ export const MAIL_BLOCK_TEXT = {
   scopeGroup: '차단할 범위',
   scopeAddress: '이 주소만',
   scopeDomain: '이 도메인 전체',
-  /** "@cloudbrief.example 에서 오는 메일 모두" */
-  scopeDomainHint: (domain: string) => `${domain} 에서 오는 메일 모두`,
+  /** "@cloudbrief.example에서 오는 메일 모두" — 조사는 붙여 쓴다 ('에서'는 받침과 상관없다) */
+  scopeDomainHint: (domain: string) => `${domain}에서 오는 메일 모두`,
   /** 「이 도메인 전체」를 끈 까닭 — 여러 사람이 쓰는 메일 서비스 (보드에 없다) */
   scopeDomainPublic: '여러 사람이 쓰는 메일 서비스라 도메인으로 막을 수 없습니다.',
   moveToJunk: '이 메일도 스팸메일함으로 옮기기',
diff --git a/frontend/src/shared/constants/mail-conversation.ts b/frontend/src/shared/constants/mail-conversation.ts
new file mode 100644
index 0000000..d922cf1
--- /dev/null
+++ b/frontend/src/shared/constants/mail-conversation.ts
@@ -0,0 +1,92 @@
+// 같은 대화 — 읽기 화면의 "같은 대화" 칸 (14단계 — 계약 2절 "대화 — 14단계" · 디자인 README 「14단계 — 검색 · 대화 묶기」 › "읽기 화면 — 같은 대화 (Thread14)")
+// 와 목록의 "대화로 묶어 보기" (같은 README › "목록 — 대화로 묶어 보기 (ListThreads14)" — 아래 MAIL_CONVERSATION_LIST_TEXT)
+// 화면 글은 디자인 README 「화면 문구 — 사용자에게 말하듯」을 따른다 — 이 파일이 원본이다.
+
+/** 한 번에 받는 수 — 계약의 처음 값이자 최대(100). 대화는 대개 한 쪽이다 */
+export const MAIL_CONVERSATION_PAGE_SIZE = 100
+
+/**
+ * 쪽이 모자라면 이어 묻는 횟수 — 칸을 열 때 · [더 보기] 한 번에 요청을 이만큼까지 보낸다(검색의 이어 찾기 MAIL_SEARCH_FILL_MAX_REQUESTS 와 같은 결).
+ * 엔진 방식(그 직원의 색인을 채우는 동안)은 한 요청이 스레드를 1,000통까지만 훑어 hasNext 인데 항목이 적거나 0개인 쪽이 온다 —
+ * 새로 한 쪽(100통)이 차거나 더 없으면 멈추고, 그래도 남으면 [더 보기]로 사용자가 잇는다
+ */
+export const MAIL_CONVERSATION_FILL_MAX_REQUESTS = 5
+
+/**
+ * 요청 하나의 시간 한도 — 서버는 엔진 방식의 한 요청을 15초 안에 끝내고(넘으면 503 MAIL_001) 그 전에 색인을 1.5초 맞춘다.
+ * 기본 10초(useApi)로는 서버가 답하기 전에 끊기므로 넉넉히 둔다
+ */
+export const MAIL_CONVERSATION_TIMEOUT_MS = 30_000
+
+/**
+ * 바뀜 소식으로 다시 받는 사이의 최소 간격 — 마지막으로 받기가 **끝난** 뒤 이만큼 안에 온 소식은 모았다가 간격이 끝날 때 한 번 받는다.
+ * 소식은 메일함들의 통 수가 바뀌었을 때만 온다(새 메일 · 지움 · 옮김 — 읽음 · 중요 표시만 바뀐 것은 아니다, mail.store.ts).
+ * 대화 경로도 요청 수 한도(경로마다 · IP 마다 1분 100회 — 사무실은 한 IP)를 함께 쓴다
+ */
+export const MAIL_CONVERSATION_REFRESH_GAP_MS = 10_000
+
+/**
+ * 접힌 줄의 받아 둔 본문 수 — 최근에 본 것부터 이만큼만 둔다(다시 펴면 다시 받는다). 펼친 줄의 본문은 세지 않고 늘 둔다
+ */
+export const MAIL_CONVERSATION_DETAIL_CACHE_MAX = 10
+
+/** 읽기 화면의 "같은 대화" 칸 (디자인 원본 Thread14) */
+export const MAIL_CONVERSATION_TEXT = {
+  /** 칸 제목 — 통 수를 모르면(total null — 쪽을 넘긴 뒤 · 엔진 방식의 큰 대화) 수 없이 */
+  title: '같은 대화',
+  titleCount: (count: string) => `같은 대화 ${count}통`,
+  /** 내가 보낸 메일의 이름 자리 (3차 "대화로 묶어 보기"의 참여자 줄도 같은 말) */
+  me: '나',
+  current: '지금 보고 있는 메일',
+  reply: '답장',
+  openOnly: '이 메일만 열기',
+  /**
+   * 펼친 줄의 본문 아래 · [답장] 위 — 첨부 목록은 읽기 화면에만 있다. 수는 읽기 화면의 "첨부 파일 N개"와 같다(본문 그림 빼고 · 대용량 첨부 더해)
+   * (2026-11-06 실사용 시험 — 펼친 줄에 첨부가 있다는 표시가 없었다)
+   */
+  attachmentsNote: (count: string) => `첨부 파일 ${count}개는 [이 메일만 열기]를 누르면 볼 수 있습니다.`,
+  /** 펼친 줄의 머리 — 읽기 화면 머리와 같은 이름 ("받는 사람  김아라 <…>" · "제목  …") */
+  recipients: '받는 사람',
+  subject: '제목',
+  /** 펼친 줄의 본문을 받는 동안 (화면 낭독) */
+  bodyLoading: '메일 불러오는 중',
+  /** 펼친 줄의 본문 틀 이름 (화면 낭독) — 같은 대화는 제목이 같아 보낸 사람 · 시각으로 가른다 */
+  bodyTitle: (who: string, time: string) => `메일 본문: ${who}, ${time}`,
+  more: '더 보기',
+  moreBusy: '불러오는 중…',
+  loadFailed: '같은 대화를 불러오지 못했습니다.',
+  retry: '다시 시도',
+  traceCode: (code: string) => `문의 코드 ${code}`,
+} as const
+
+// ── 목록 — 대화로 묶어 보기 (디자인 README 「14단계 — 검색 · 대화 묶기」 › "목록 — 대화로 묶어 보기 (ListThreads14)") ─────────
+
+/** 목록 머리 · 대화 줄 · 여러 통 처리의 글 (디자인 원본 ListThreads14 — 화면 문구는 README 「화면 문구 — 사용자에게 말하듯」) */
+export const MAIL_CONVERSATION_LIST_TEXT = {
+  /** 목록 머리 오른쪽의 눌림 단추 (aria-pressed) — 분할 보기에서는 아이콘만이라 title 도 이 글이다 */
+  toggle: '대화로 묶기',
+  /** 목록 머리 글 — 켰을 때 "대화 6개, 안 읽은 메일 2통", 껐을 때 "메일 9통, 안 읽은 메일 2통" (안 읽은 메일이 없으면 뒤를 뺀다) */
+  conversationCount: (count: string) => `대화 ${count}개`,
+  messageCount: (count: string) => `메일 ${count}통`,
+  unreadCount: (count: string) => `안 읽은 메일 ${count}통`,
+  /** 대화 줄의 통 수 — 회색 글 (한 통이면 없다) */
+  rowCount: (count: string) => `${count}통`,
+  /** 여러 통 처리 도구 줄의 머리 — 고른 것은 대화다 */
+  selected: (count: string) => `대화 ${count}개 선택됨`,
+  /**
+   * 분할 보기(목록 칸이 좁다)의 도구 줄 머리 — 보이는 글만 줄인다(단추 일곱이 한 줄에 들게). 화면 낭독은 selected 전체를 읽는다
+   * (2026-11-06 실사용 시험 — "대화 1개 선택됨"이면 단추가 두 줄로 넘쳤다)
+   */
+  selectedShort: (count: string) => `${count}개 선택됨`,
+  /** 표 머리의 고르기 상자 */
+  selectAll: '불러온 대화 모두 고르기',
+  /**
+   * 목록 보기 표의 사람 칸 머리 — 어느 메일함이든 같다(줄이 대화의 참여자라서. 묶지 않은 표는 "보낸 사람" · 보낸편지함 "받는 사람" 그대로)
+   * (2026-11-06 실사용 시험 — 보낸편지함에서 머리는 "보낸 사람"인데 줄은 "받는 사람: …"이었다)
+   */
+  participantsColumn: '참여자',
+  /** 목록 보기 표의 caption — 메일 목록은 "받은편지함 메일 목록" */
+  tableCaption: (mailbox: string) => `${mailbox} 대화 목록`,
+  /** 줄의 메일이 모두 보내기를 기다리는 메일일 때 별(중요 표시)의 까닭 — 고르기 칸은 메일 줄과 같은 글(SEND_LATER_TEXT.heldNotSelectable) */
+  heldFlagNote: '보내기를 기다리는 메일은 목록에서 중요 표시를 바꿀 수 없습니다. 메일을 열어 바꿔 주세요.',
+} as const
diff --git a/frontend/src/shared/constants/mail-search.ts b/frontend/src/shared/constants/mail-search.ts
new file mode 100644
index 0000000..b3fd8a5
--- /dev/null
+++ b/frontend/src/shared/constants/mail-search.ts
@@ -0,0 +1,137 @@
+// 메일 검색 14단계 — 조건 검색 · 이어 찾기 · 검색 준비 중 · 한 글자 안내 (계약 2절 "검색 — 14단계" · 디자인 README 「14단계 — 검색 · 대화 묶기」)
+// 3단계의 검색 칸 · 결과 머리 글(MAIL_SEARCH_TEXT)과 검색어 한도는 shared/constants/mail.ts 에 있다.
+// 화면 글은 디자인 README 「화면 문구 — 사용자에게 말하듯」을 따른다 — 이 파일이 원본이다.
+
+/**
+ * 화면 주소(/mail/search?…)에 싣는 조건의 이름 — 검색어처럼 앞단 nginx 의 접근 로그에 쿼리가 남지 않는다 (계약 2절 "검색 — 14단계").
+ * 글 칸 넷은 API 와 같은 이름이고, 기간은 브라우저 시간대의 날짜(YYYY-MM-DD — 시작 날짜 · 끝 날짜 모두 든다),
+ * 첨부는 켰을 때만 `attachment=1`. API 의 after · before 는 보낼 때 이 날짜로 만든다(mail-search.ts)
+ */
+export const SEARCH_ROUTE_PARAMS = {
+  from: 'from',
+  to: 'to',
+  subject: 'subject',
+  body: 'body',
+  since: 'since',
+  until: 'until',
+  attachment: 'attachment',
+} as const
+
+/**
+ * 고를 수 있는 날짜의 범위 (YYYY-MM-DD — 두 날짜 모두 든다). 끝은 9999-12-30 — 9999-12-31 은 UTC 의 다음 날 0시가 10000년이라
+ * 서버가 받지 않는다(어느 시간대에서도 보낼 수 있게). 주소의 날짜도 이 밖이면 버린다 (mail-search.ts 의 isSearchDay)
+ */
+export const SEARCH_DAY_MIN = '1970-01-01'
+export const SEARCH_DAY_MAX = '9999-12-30'
+
+/** 주소의 attachment 값 — 첨부 파일이 있는 메일만 */
+export const SEARCH_ATTACHMENT_ROUTE_VALUE = '1'
+/** API 의 hasAttachment 값 — 이것만 받는다 (다른 값은 400 VAL_001) */
+export const SEARCH_HAS_ATTACHMENT_VALUE = 'true'
+
+/**
+ * 결과가 모자라면 이어 묻는 횟수 — 한 번 찾을 때(검색을 열 때 · [메일 더 보기] · [더 찾기] · 목록 보기의 [다음]) 요청을 이만큼까지 보낸다.
+ * 서버(색인 방식)는 한 요청에 메일 3,000통까지만 확인해 hasNext 인데 항목이 적거나 0개일 수 있다 — 한 쪽(20통)을 채우거나 더 없으면 멈춘다.
+ * 5번이면 1만 5천 통을 훑는다(한 요청 1초 안 — 계약). 넘으면 [더 찾기]로 사용자가 잇는다
+ */
+export const MAIL_SEARCH_FILL_MAX_REQUESTS = 5
+
+/** 기간 고르기 — 최근 N주 · 달 · 해는 그만큼 앞의 같은 날부터 오늘까지(두 날짜 모두 든다) */
+export type SearchPeriod = 'all' | 'week' | 'month' | 'quarter' | 'year' | 'custom'
+
+/** 미리 정한 기간 — 오늘에서 뺄 날 · 달 수 */
+export interface SearchPeriodPreset {
+  id: Exclude<SearchPeriod, 'all' | 'custom'>
+  days?: number
+  months?: number
+}
+
+export const SEARCH_PERIOD_PRESETS: readonly SearchPeriodPreset[] = [
+  { id: 'week', days: 7 },
+  { id: 'month', months: 1 },
+  { id: 'quarter', months: 3 },
+  { id: 'year', months: 12 },
+]
+
+/** 기간 고르기의 차례 · 이름 (디자인 원본 Search14) */
+export const SEARCH_PERIOD_LABELS: Readonly<Record<SearchPeriod, string>> = {
+  all: '전체 기간',
+  week: '최근 1주',
+  month: '최근 1달',
+  quarter: '최근 3달',
+  year: '최근 1년',
+  custom: '날짜 고르기',
+}
+
+export const SEARCH_PERIOD_ORDER: readonly SearchPeriod[] = ['all', 'week', 'month', 'quarter', 'year', 'custom']
+
+/** 검색 칸의 [조건] 단추와 「조건으로 찾기」 패널 (디자인 원본 Search14) */
+export const SEARCH_CONDITIONS_TEXT = {
+  toggle: '조건',
+  toggleTitle: '조건으로 찾기',
+  /** 조건이 걸려 있을 때 [조건] 단추에 더해 읽어 주는 글 */
+  toggleApplied: '조건이 걸려 있음',
+  title: '조건으로 찾기',
+  from: '보낸 사람',
+  to: '받는 사람',
+  subject: '제목',
+  body: '내용',
+  period: '기간',
+  attachment: '첨부',
+  fromPlaceholder: '이름이나 메일 주소',
+  toPlaceholder: '이름이나 메일 주소',
+  subjectPlaceholder: '제목에 든 말',
+  /** 칸 이름("내용")과 같은 말로 — 조건 줄도 "내용에 ‘…’이 든 메일"이다 */
+  bodyPlaceholder: '내용에 든 말',
+  since: '시작 날짜',
+  until: '끝 날짜',
+  attachmentOnly: '첨부 파일이 있는 메일만',
+  hint: '검색 칸의 말과 이 조건에 모두 맞는 메일을 찾습니다. 받는 사람에는 참조로 받은 사람도 들어갑니다.',
+  periodOrder: '끝 날짜를 시작 날짜와 같거나 그 뒤로 골라 주세요.',
+  periodRange: '날짜는 1970년 1월 1일부터 9999년 12월 30일 사이에서 골라 주세요.',
+  clear: '조건 지우기',
+  apply: '찾기',
+} as const
+
+/** 결과 머리 아래 "조건: …" 줄 (디자인 원본 Search14 "조건으로 찾음") — 조건은 쉼표로 잇는다 */
+export const SEARCH_CONDITION_LINE_TEXT = {
+  prefix: '조건: ',
+  separator: ', ',
+  from: (who: string) => `${who} 님이 보낸 메일`,
+  to: (who: string) => `${who} 님이 받은 메일`,
+  /** 보낸 사람 · 받는 사람 칸의 값이 내 이름이나 내 주소일 때 (2026-11-06 실사용 시험 — "김아라 님이 보낸 메일"보다 바로 읽힌다) */
+  fromMe: '내가 보낸 메일',
+  toMe: '내가 받은 메일',
+  /** 조사(이 · 가)는 부르는 쪽이 붙인다 */
+  subject: (text: string, particle: string) => `제목에 ‘${text}’${particle} 든 메일`,
+  body: (text: string, particle: string) => `내용에 ‘${text}’${particle} 든 메일`,
+  since: (day: string) => `${day}부터`,
+  until: (day: string) => `${day}까지`,
+  range: (since: string, until: string) => `${since}부터 ${until}까지`,
+  /** 시작 날짜와 끝 날짜가 같은 날 — "2026. 11. 6.부터 11. 6.까지" 대신 */
+  oneDay: (day: string) => `${day} 하루`,
+  attachment: '첨부 있음',
+  clear: '조건 지우기',
+} as const
+
+/** 결과 머리 아래 안내 줄 · 결과가 모자랄 때 (디자인 원본 Search14 "검색 준비 중") */
+export const SEARCH_NOTICE_TEXT = {
+  /**
+   * 지난 메일의 색인을 만드는 동안 (GET /search-index 의 building). 색인은 밤에만 채우므로 그렇게 말한다 —
+   * 낮 내내 같은 글이면 멈춘 줄 안다 (2026-11-06 실사용 시험)
+   */
+  indexing:
+    '지난 메일을 검색할 수 있게 밤사이에 준비하고 있습니다. 메일이 많으면 며칠 걸릴 수 있고, 그동안은 낱말이 통째로 같은 메일만 찾습니다.',
+  /** 한 글자 낱말뿐이라 본문은 찾지 않았을 때 (서버와 같은 낱말 나누기 — search-match.ts) */
+  singleChar:
+    '한 글자로만 찾을 때는 본문은 빼고 제목, 보낸 사람과 받는 사람, 첨부 파일 이름에서 찾습니다. 본문까지 찾으려면 두 글자 이상으로 찾아 주세요.',
+  /** 이어 찾을 것이 남았는데 아직 하나도 찾지 못했을 때 */
+  partialTitle: '아직 맞는 메일을 찾지 못했습니다',
+  partialHint: '메일이 많아 한 번에 다 찾지 못했습니다. [더 찾기]를 누르면 이어서 찾습니다.',
+  more: '더 찾기',
+  moreBusy: '찾는 중…',
+  /** 검색어와 조건을 합친 낱말이 한도를 넘는 주소로 들어왔을 때 — 찾지 않고 이 안내만 (조건이 있으면 조건 줄의 [조건 지우기]) */
+  tooManyWordsTitle: '찾을 말이 너무 많습니다',
+  tooManyWordsHint: (max: number) =>
+    `검색어와 조건에 넣은 낱말은 모두 합쳐 ${max}개까지 찾을 수 있습니다. 검색 칸이나 [조건]에서 낱말을 줄여 주세요.`,
+} as const
diff --git a/frontend/src/shared/constants/mail-send-later.ts b/frontend/src/shared/constants/mail-send-later.ts
index 5a0e956..8a2e080 100644
--- a/frontend/src/shared/constants/mail-send-later.ts
+++ b/frontend/src/shared/constants/mail-send-later.ts
@@ -60,8 +60,8 @@ export const SEND_LATER_TEXT = {
   undone: '보내기를 취소했습니다. 쓰던 메일로 돌아왔습니다.',
   /** 쓰기 화면으로 가지 못했을 때(지금 화면의 나가기 확인에서 머묾 등 — 보드에 없다) — 단추는 [고치기](edit) */
   undoneStayed: '보내기를 취소하고 임시보관함으로 옮겼습니다.',
-  /** time 은 formatScheduleTime — "10월 30일 (금) 오전 9:00 에 보냅니다." (보드 그대로 띄어 쓴다) */
-  scheduled: (time: string) => `${time} 에 보냅니다.`,
+  /** time 은 formatScheduleTime — "10월 30일 (금) 오전 9:00에 보냅니다." (조사는 붙여 쓴다 — 2026-11-06 실사용 시험) */
+  scheduled: (time: string) => `${time}에 보냅니다.`,
   viewScheduled: '예약됨 보기',
 
   // ── 예약됨 (메일함 패널 · 목록 · 읽기 화면) ──
@@ -74,8 +74,8 @@ export const SEND_LATER_TEXT = {
   emptyHint: '메일을 쓸 때 [보내기 ▾] → [예약 발송…]으로 보낼 시각을 정할 수 있습니다.',
   /** 표 · 목록의 보낼 시각 칸 이름 */
   sendAtColumn: '보낼 시각',
-  /** 읽기 화면 머리 아래 청록 줄 — "10월 30일 (금) 오전 9:00 에 보낼 메일입니다." */
-  notice: (time: string) => `${time} 에 보낼 메일입니다.`,
+  /** 읽기 화면 머리 아래 청록 줄 — "10월 30일 (금) 오전 9:00에 보낼 메일입니다." */
+  notice: (time: string) => `${time}에 보낼 메일입니다.`,
   edit: '고치기',
   cancelSchedule: '예약 취소',
   canceled: '예약을 취소하고 임시보관함으로 옮겼습니다.',
diff --git a/frontend/src/shared/constants/mail-settings.ts b/frontend/src/shared/constants/mail-settings.ts
index 14942eb..658ee28 100644
--- a/frontend/src/shared/constants/mail-settings.ts
+++ b/frontend/src/shared/constants/mail-settings.ts
@@ -8,6 +8,15 @@ export const UNDO_SEND_OPTIONS: readonly UndoSendSeconds[] = [0, 5, 10, 20, 30]
 /** 외부 이미지 — 고르는 차례 그대로 */
 export const EXTERNAL_IMAGES_OPTIONS: readonly ExternalImagesSetting[] = ['ask', 'trusted', 'always']
 
+/** 대화로 묶어 보기 (14단계) — 고르는 차례 그대로 (끔 · 켬 — 보내기 취소처럼 끔이 앞) */
+export const GROUP_BY_CONVERSATION_OPTIONS: readonly boolean[] = [false, true]
+
+/**
+ * 메일 화면이 탭으로 돌아올 때 설정을 다시 받는 간격 — 마지막으로 받은 지 이만큼 지났을 때만 (useMailSettingsRefresh).
+ * 다른 탭 · PC 에서 바꾼 묶기 · 보내기 취소 초 · 외부 이미지가 열어 둔 탭에 남지 않게 하되, 탭을 오갈 때마다 묻지는 않는다
+ */
+export const MAIL_SETTINGS_REFRESH_AFTER_MS = 60_000
+
 export const MAIL_SETTINGS_TEXT = {
   title: '보내기 · 읽기',
   /** 보드에 없다 — 저장 단추가 없으니 고르는 대로 저장된다는 것을 머리에서 알린다 */
@@ -31,4 +40,15 @@ export const MAIL_SETTINGS_TEXT = {
   } satisfies Record<ExternalImagesSetting, { label: string; hint: string }>,
   imagesNote:
     '외부 이미지는 회사를 거쳐 불러오므로 보낸 사람은 이 PC의 주소를 알 수 없습니다. 다만 이미지를 불러오면 보낸 사람은 메일을 열어 본 것을 알 수 있습니다.',
+
+  /**
+   * 대화로 묶기 (14단계 — 디자인 README "목록 — 대화로 묶어 보기 (ListThreads14)" 의 켬/끔 한 줄. 보드가 없어 글은 정했다).
+   * 이름은 목록 위 단추와 같다. 분할 보기의 그 단추는 아이콘(말풍선)만이라 설명에서 모양을 말한다 — 이름까지 넣으면 목록 머리에 개수 글이 들 자리가 없다
+   * (2026-11-06 실사용 시험: 이름까지 99px · 아이콘만 36px)
+   */
+  groupTitle: '대화로 묶기',
+  groupOff: '끔',
+  groupOn: '켬',
+  groupHint:
+    '답장과 전달로 이어진 메일을 메일함 목록에서 한 줄로 묶어 보여 줍니다. 메일함 목록 위의 말풍선 모양 [대화로 묶기] 단추로도 켜고 끌 수 있습니다.',
 } as const
diff --git a/frontend/src/shared/constants/mail.ts b/frontend/src/shared/constants/mail.ts
index 4ff5264..8eeeeb6 100644
--- a/frontend/src/shared/constants/mail.ts
+++ b/frontend/src/shared/constants/mail.ts
@@ -241,6 +241,22 @@ export const DRAFT_RESTORED_MESSAGE = '임시보관함으로 되돌렸습니다.
 export const DRAFT_NO_RECIPIENTS = '(받는 사람 없음)'
 export const MAIL_NO_SUBJECT = '(제목 없음)'
 
+/**
+ * 목록 줄의 화면 낭독 · 아이콘 이름 — 대화 줄(14단계 — ConversationListItem · ConversationTableRow)과
+ * 같은 대화 칸의 줄(ConversationMessageRow — unreadPrefix, 2026-11-07)이 쓴다.
+ * 메일 줄(MessageListItem · MessageTableRow)도 같은 글이다 — 고칠 때는 함께
+ */
+export const MAIL_LIST_ROW_TEXT = {
+  /** 안 읽은 줄의 이름 자리 앞 (화면에는 보이지 않는다) */
+  unreadPrefix: '안 읽음, ',
+  /** 별 단추 */
+  flag: '중요 표시',
+  /** 첨부 클립 */
+  attachment: '첨부 있음',
+} as const
+/** 보낸 사람이 없는 메일 — 목록 · 읽기 화면 · 같은 대화 칸의 이름 자리 */
+export const MAIL_NO_SENDER = '(보낸 사람 없음)'
+
 // ── 새 메일 확인 (계약 2절 "새 메일 확인" · 디자인 README "3단계 › 새 메일") ─────────────
 /** 화면이 보이는 동안 이 간격으로 바뀐 것이 있는지 묻는다 — 실시간 연결이 살아 있으면 묻지 않는다 (5단계, mail-notify.ts) */
 export const MAIL_STATE_POLL_INTERVAL_MS = 60_000
@@ -268,15 +284,27 @@ export const MAIL_SEARCH_TEXT = {
   /** "검색 닫기 — 받은편지함으로" — 돌아갈 메일함 이름과 조사는 부르는 쪽이 붙인다 */
   closeTitle: (place: string) => `검색을 닫고 ${place} 돌아가기`,
   title: '검색 결과',
-  quoted: (query: string) => `‘${query}’`,
-  count: (query: string, count: string) => `‘${query}’ · ${count}통`,
-  searching: (query: string) => `‘${query}’ · 찾는 중`,
+  /** 결과 머리의 검색어 — 조건만으로 찾았으면(14단계) 검색어 없이 수만 · 전체 수를 모르면(total null) 수를 뺀다 */
+  quoted: (query: string) => (query ? `‘${query}’` : ''),
+  count: (query: string, count: string) => (query ? `‘${query}’ · ${count}통` : `${count}통`),
+  searching: (query: string) => (query ? `‘${query}’ · 찾는 중` : '찾는 중'),
   scopeLabel: '찾을 곳',
   scopeAll: '전체 메일함',
   scopeAllHint: '휴지통과 스팸메일함은 빼고 찾습니다',
-  emptyTitle: (query: string) => `‘${query}’에 맞는 메일이 없습니다`,
-  emptyHint:
-    '낱말 단위로 찾습니다. ‘서버이전’의 ‘서버’처럼 붙여 쓴 말의 일부나, 제목 맨 앞의 [공지]나 Re: 같은 말머리로는 찾지 못합니다.',
+  emptyTitle: (query: string) => (query ? `‘${query}’에 맞는 메일이 없습니다` : '조건에 맞는 메일이 없습니다'),
+  /**
+   * 결과 없음의 도움말 (14단계 디자인 원본 Search14) — 검색어와 조건으로 찾았으면 emptyHint, 조건만으로 찾았으면 emptyConditionsHint,
+   * 검색어만으로 찾았으면(걸린 조건이 없다) emptyWordsHint — 없는 조건을 줄이라고 하지 않는다 (2026-11-06 실사용 시험)
+   */
+  emptyHint: '다른 말로 찾거나 조건을 줄여 보세요.',
+  emptyConditionsHint: '조건을 바꾸거나 줄여 보세요.',
+  emptyWordsHint: '다른 말로 찾아 보세요.',
+  /**
+   * 지난 메일을 검색할 수 있게 준비하는 동안(엔진 방식 — 14단계 GET /search-index 의 building)에만 결과 없음에 더하는 한계 안내.
+   * 바로 위의 "검색 준비 중" 줄과 같은 말(낱말 단위)을 되풀이하지 않고 찾지 못하는 예만 든다 (2026-11-06 실사용 시험)
+   */
+  wordLimitHint:
+    '준비가 끝나기 전에는 ‘서버이전’의 ‘서버’처럼 붙여 쓴 말의 일부나, 제목 맨 앞의 [공지]나 Re: 같은 말머리로는 찾지 못합니다.',
   searchAll: '전체 메일함에서 찾기',
   /** 결과 목록의 보이지 않는 이름 (불러오는 동안) */
   loading: '찾는 중',
@@ -311,10 +339,21 @@ export const MAIL_BULK_TEXT = {
   selectOne: (subject: string) => `고르기: ${subject}`,
   /** place 에는 메일함 이름과 조사를 붙여 넘긴다 ("보낸편지함으로") */
   moved: (count: string, place: string) => `메일 ${count}통을 ${place} 옮겼습니다.`,
+  /**
+   * 대화로 묶은 목록에서 줄에 한 옮기기 · 삭제 · 스팸 신고 (14단계) — 줄의 "4통"은 대화 전체라 옮긴 것은 지금 메일함의 메일임을 밝힌다
+   * ("받은편지함에 있는 메일 2통을 휴지통으로 옮겼습니다." — 2026-11-06 실사용 시험)
+   */
+  movedFrom: (from: string, count: string, place: string) => `${from}에 있는 메일 ${count}통을 ${place} 옮겼습니다.`,
   purged: (count: string) => `메일 ${count}통을 영구 삭제했습니다.`,
+  /** 대화로 묶은 휴지통에서 줄에 한 영구 삭제 (14단계 — movedFrom 과 같은 꼴, 2026-11-07) — "휴지통에 있는 메일 2통을 영구 삭제했습니다." */
+  purgedFrom: (from: string, count: string) => `${from}에 있는 메일 ${count}통을 영구 삭제했습니다.`,
   restored: (count: string) => `메일 ${count}통을 되돌렸습니다.`,
+  /** 한 메일함으로 되돌렸을 때 — place 에는 메일함 이름과 조사를 붙여 넘긴다 ("받은편지함으로"). 여러 곳이면 restored */
+  restoredTo: (count: string, place: string) => `메일 ${count}통을 ${place} 되돌렸습니다.`,
   skipped: (count: string) => `${count}통은 그사이 옮겨졌거나 지워져 그대로 두었습니다.`,
   purgeTitle: (count: string) => `메일 ${count}통을 영구 삭제할까요?`,
+  /** 대화로 묶은 휴지통에서 줄을 골랐을 때의 확인 창 제목 (purgedFrom 과 같은 꼴) — "휴지통에 있는 메일 2통을 영구 삭제할까요?" */
+  purgeTitleFrom: (from: string, count: string) => `${from}에 있는 메일 ${count}통을 영구 삭제할까요?`,
   purgeMessage: '휴지통에서 지운 메일은 되돌릴 수 없습니다.',
   purgeConfirm: '영구 삭제',
   purgeCancel: '취소',
@@ -328,6 +367,9 @@ export const MAIL_SPAM_TEXT = {
   notSpam: '스팸 아님',
   /** place 에는 메일함 이름과 조사를 붙여 넘긴다 ("받은편지함으로") */
   notSpamMoved: (count: string, place: string) => `메일 ${count}통을 스팸이 아닌 메일로 표시해 ${place} 옮겼습니다.`,
+  /** 대화로 묶은 목록에서 줄에 한 스팸 아님 (14단계 — MAIL_BULK_TEXT.movedFrom 과 같은 꼴) */
+  notSpamMovedFrom: (from: string, count: string, place: string) =>
+    `${from}에 있는 메일 ${count}통을 스팸이 아닌 메일로 표시해 ${place} 옮겼습니다.`,
 } as const
 
 /** 읽기 화면 도구 줄의 ⋯ (더 보기 40×44) 메뉴 */
diff --git a/frontend/src/shared/types/mail.ts b/frontend/src/shared/types/mail.ts
index 8396921..c7f20e7 100644
--- a/frontend/src/shared/types/mail.ts
+++ b/frontend/src/shared/types/mail.ts
@@ -3,7 +3,7 @@
 
 import type { ContactEmailLabel } from '@/shared/types/contacts'
 import type { DraftLargeFile, MessageLargeFile } from '@/shared/types/large-file'
-import type { CursorPaginationQuery } from '@/shared/types/pagination'
+import type { CursorPaginationQuery, PaginatedResult } from '@/shared/types/pagination'
 
 export interface Address {
   name: string | null
@@ -57,6 +57,33 @@ export interface MessageSummary {
   pendingSend?: PendingSend | null
 }
 
+/** 검색에서 맞은 곳 — [시작, 끝) UTF-16 위치 (끝은 들지 않는다 — 계약 2절 "검색 — 14단계") */
+export type SearchRange = readonly [start: number, end: number]
+
+/**
+ * 목록 항목의 검색 강조 (14단계) — 색인으로 찾은 검색 결과에만 온다. 강조가 있으면 subject 는 NFC 로 맞춘 글이고 위치는 그 글 기준이다.
+ * preview.text 는 본문에서 맞았으면 맞은 말 둘레 한 줄(잘린 쪽에 "…"), 아니면 미리 보기다
+ */
+export interface MessageListHighlight {
+  subject: SearchRange[]
+  preview: { text: string; ranges: SearchRange[] }
+}
+
+/** GET /messages 의 항목 — 요약 + 검색 강조. 메일함 목록 · 엔진 방식 검색은 null, 필드가 없으면(14단계 앞 서버) 없는 것으로 본다 */
+export interface MessageListItem extends MessageSummary {
+  searchHighlight?: MessageListHighlight | null
+}
+
+/**
+ * 읽기 화면의 검색 강조 (14단계 — 검색 쿼리를 함께 보냈을 때만). 강조가 있으면 subject · 첨부 이름 · textBody 는 NFC 로 맞춘 글이고
+ * htmlBody 는 맞은 글 조각에 속성 없는 <mark> 가 들어 있다. attachments 는 맞은 첨부만 (첨부 id → 맞은 곳)
+ */
+export interface MessageDetailHighlight {
+  subject: SearchRange[]
+  attachments: Record<string, SearchRange[]>
+  textBody: SearchRange[]
+}
+
 export interface Attachment {
   id: string
   name: string
@@ -108,6 +135,11 @@ export interface MessageDetail extends MessageSummary {
    * 그때 htmlBody 의 덩이 바깥 요소에 data-ara-large-files 가 붙는다(읽기 화면이 접는다). 필드가 없으면(11단계 앞 서버) 없는 것으로 본다
    */
   largeFiles?: MessageLargeFile[]
+  /**
+   * 검색 강조 (14단계) — 검색 결과에서 연 메일을 검색 쿼리(q · from · to · subject · body)와 함께 받았을 때만, 없으면 null.
+   * ⚠️ 강조가 든 응답은 읽기 화면에 보이기만 한다 — 답장 · 전달의 원문 인용 · 인쇄는 검색 쿼리 없이 다시 받는다 (계약 2절 "검색 — 14단계")
+   */
+  searchHighlight?: MessageDetailHighlight | null
 }
 
 /** GET /mail-quota — 메일함 패널 하단 사용량 표시와 첨부 사전 검사에 쓴다 */
@@ -125,13 +157,101 @@ export interface MailQuota {
 }
 
 /**
- * GET /messages 쿼리 — mailboxId 와 q 중 하나는 있어야 한다 (계약 2절 "검색").
- * q 만 있으면 휴지통 · 스팸메일함을 뺀 모든 메일함에서 찾는다
+ * GET /messages 쿼리 — mailboxId 와 검색(q 나 조건 하나) 가운데 하나는 있어야 한다 (계약 2절 "검색" · "검색 — 14단계").
+ * mailboxId 가 없으면 휴지통 · 스팸메일함을 뺀 모든 메일함에서 찾는다. q 와 조건 넷(from · to · subject · body)을 합친 낱말은 8개까지
  */
 export interface MessageListQuery extends CursorPaginationQuery {
   mailboxId?: string
   /** 검색어 — 앞뒤 공백을 뺀 1~200자, 낱말 8개까지 */
   q?: string
+  /** 보낸 사람(이름 · 주소) — 검사는 q 와 같다 */
+  from?: string
+  /** 받는 사람과 참조 */
+  to?: string
+  subject?: string
+  /** 본문 */
+  body?: string
+  /** 받은 시각이 이 시각 이상 — ISO 8601 UTC (화면은 시작 날짜의 0시를 보낸다) */
+  after?: string
+  /** 받은 시각이 이 시각 미만 — ISO 8601 UTC (화면은 끝 날짜의 다음 날 0시를 보낸다) */
+  before?: string
+  /** 'true' 면 첨부 파일이 있는 메일만 (다른 값은 400 VAL_001) */
+  hasAttachment?: 'true'
+}
+
+/**
+ * GET /messages/{id} 의 강조 쿼리 (14단계) — 검색 주소의 조건 가운데 이 다섯만 보낸다(after · before · hasAttachment · cursor · limit 은 400 VAL_001).
+ * from · to 는 서버가 받기만 하고 강조하지 않는다
+ */
+export interface MessageHighlightQuery {
+  q?: string
+  from?: string
+  to?: string
+  subject?: string
+  body?: string
+}
+
+/** 지난 메일 색인의 상태 (GET /search-index — 14단계) — building 이면 그 직원의 검색은 엔진 방식(낱말 통째 일치)이다 */
+export type SearchIndexStatus = 'building' | 'ready'
+
+export interface SearchIndexState {
+  status: SearchIndexStatus
+  /** 채운 메일 수 */
+  done: number
+  /** 채우기를 시작할 때의 메일 수 — 시작 전이면 null */
+  total: number | null
+}
+
+// ── 대화 (계약 2절 "대화 — 14단계") ─────────────────────────
+
+/** 대화의 기준 — index 우리 색인(답장 관계 + 말머리를 뗀 제목이 같음) · engine 엔진의 스레드(그 직원의 색인을 채우는 동안) */
+export type ConversationBasis = 'index' | 'engine'
+
+/**
+ * GET /messages/{id}/conversation 응답 — 그 메일의 같은 대화, 오래된 차례(한 통뿐이면 그 메일 하나).
+ * hasNext 인데 항목이 limit 보다 적거나 0개일 수 있다(engine — 한 요청이 스레드를 1,000통까지만 훑는다).
+ * total 은 index 면 첫 쪽에서만, engine 이면 쪽마다(1,000통을 넘으면 null). 모양이 틀린 응답은 빈 대화 · basis null 로 맞춘다 (useMail().getConversation)
+ */
+export interface ConversationPage extends PaginatedResult<MessageSummary> {
+  basis: ConversationBasis | null
+}
+
+/**
+ * GET /conversations 의 한 줄 — 그 메일함 안의 대화 하나 (14단계 — 계약 2절 "대화로 묶어 보기").
+ * 고르기 · 읽음 · 중요 · 이동 · 삭제는 messageIds 에서 pendingSendIds 를 뺀 메일에 한다 (붙잡힌 메일은 취소로만 보낸편지함을 떠난다)
+ */
+export interface ConversationSummary {
+  /** 대화 id — 불투명(기준마다 다르다). 한 목록 안에서 줄을 가리는 데만 쓴다 */
+  id: string
+  /** 그 메일함 안의 마지막 메일 — 줄의 제목 · 시각 · 붙잡은 발송, 누르면 연다 */
+  latest: MessageSummary
+  /** 대화 전체의 보낸 사람 — 받은 차례, 주소마다 한 번, 10명까지 (화면은 내 주소를 "나"로) */
+  participants: Address[]
+  /** 대화 전체의 메일 수 — 보낸편지함 포함, 휴지통 · 스팸메일함에만 든 메일은 뺀다. 엔진 방식에서 상한에 걸린 줄은 어림이다 */
+  messageCount: number
+  /** 그 메일함 안의 그 대화 메일 — 최신부터 500통까지 (useMail 이 마지막 메일을 늘 넣어 둔다) */
+  messageIds: string[]
+  /** messageIds 가운데 붙잡힌 메일(보내기 취소 · 예약) — 없으면 빈 배열 */
+  pendingSendIds: string[]
+  /** 그 메일함 안의 메일을 모두 읽었다 */
+  isRead: boolean
+  /** 그 메일함 안에 중요 표시한 메일이 하나라도 있다 */
+  isFlagged: boolean
+  /** 그 메일함 안에 첨부가 있는 메일이 하나라도 있다 */
+  hasAttachment: boolean
+}
+
+/** GET /conversations 쿼리 — 검색 쿼리(q · 조건)는 받지 않는다 */
+export interface ConversationListQuery extends CursorPaginationQuery {
+  mailboxId: string
+}
+
+/**
+ * GET /conversations 응답 — 그 메일함 안 마지막 받은 시각 최신부터. total 은 index 면 첫 쪽에서만(그 메일함의 대화 수), engine 이면 쪽마다.
+ * 모양이 틀린 줄은 뺀다 (useMail().listConversations)
+ */
+export interface ConversationListPage extends PaginatedResult<ConversationSummary> {
+  basis: ConversationBasis | null
 }
 
 /** PATCH /messages/{id} 본문 — 하나 이상 지정한다 */
@@ -252,10 +372,15 @@ export type UndoSendSeconds = 0 | 5 | 10 | 20 | 30
 /** 외부 이미지 — 늘 묻기 · 주소록과 사내 직원은 늘 보기 · 늘 보기 */
 export type ExternalImagesSetting = 'ask' | 'trusted' | 'always'
 
-/** GET · PATCH /mail-settings — 직원마다 서버 DB 에 하나(어느 PC 에서나 같다). 처음 값은 10초 · 늘 묻기 */
+/** GET · PATCH /mail-settings — 직원마다 서버 DB 에 하나(어느 PC 에서나 같다). 처음 값은 10초 · 늘 묻기 · 묶지 않음 */
 export interface MailSettings {
   undoSendSeconds: UndoSendSeconds
   externalImages: ExternalImagesSetting
+  /**
+   * 메일함 목록을 대화로 묶어 보기 (14단계 — 계약 2절 "대화 — 14단계"). 서버는 저장해 돌려주기만 하고 묶은 목록을 부를지는 화면이 정한다.
+   * 필드가 없는 서버(14단계 앞)면 false 로 본다 (useMailSettings 가 맞춘다)
+   */
+  groupByConversation: boolean
 }
 
 // ── 보낸 사람 차단 (계약 2절 "보낸 사람 차단" — 9단계) ─────────────
diff --git a/frontend/src/shared/utils/format.spec.ts b/frontend/src/shared/utils/format.spec.ts
index 68ac616..491820a 100644
--- a/frontend/src/shared/utils/format.spec.ts
+++ b/frontend/src/shared/utils/format.spec.ts
@@ -2,6 +2,7 @@ import { describe, expect, it } from 'vitest'
 
 import {
   formatBlockedDay,
+  formatConversationTime,
   formatDraftSavedTime,
   formatPrintDateTime,
   formatScheduleShortTime,
@@ -215,3 +216,24 @@ describe('formatRelativeDayTime (11단계 — 설정 › 대용량 첨부의 날
     expect(formatRelativeDayTime('나중에', now, SEOUL)).toBe('')
   })
 })
+
+describe('formatConversationTime (14단계 — 같은 대화 칸의 시각, 디자인 원본 Thread14)', () => {
+  /** 2026-11-05(목) 오후 3시 (서울) */
+  const now = new Date('2026-11-05T06:00:00Z')
+
+  it('오늘 · 어제는 그 말과 시각 — "오늘 오전 10:42"', () => {
+    expect(formatConversationTime('2026-11-05T01:42:00Z', now, SEOUL)).toBe('오늘 오전 10:42')
+    expect(formatConversationTime('2026-11-04T04:05:00Z', now, SEOUL)).toBe('어제 오후 1:05')
+  })
+
+  it('그 밖의 올해는 요일까지 "10월 29일 (목) 오전 9:30", 다른 해는 연도까지 (읽기 화면 머리와 같다)', () => {
+    expect(formatConversationTime('2026-10-29T00:30:00Z', now, SEOUL)).toBe('10월 29일 (목) 오전 9:30')
+    expect(formatConversationTime('2025-10-29T00:30:00Z', now, SEOUL)).toBe('2025. 10. 29. (수) 오전 9:30')
+  })
+
+  it('날은 서울 날짜로 가른다 — UTC 로는 어제여도 서울로 오늘이면 "오늘"', () => {
+    // 2026-11-04T23:30Z = 서울 11월 5일 오전 8:30
+    expect(formatConversationTime('2026-11-04T23:30:00Z', now, SEOUL)).toBe('오늘 오전 8:30')
+    expect(formatConversationTime('나중에', now, SEOUL)).toBe('')
+  })
+})
diff --git a/frontend/src/shared/utils/format.ts b/frontend/src/shared/utils/format.ts
index 6855e8b..c3c4dd1 100644
--- a/frontend/src/shared/utils/format.ts
+++ b/frontend/src/shared/utils/format.ts
@@ -274,6 +274,23 @@ export function formatScheduleTime(value: string | number, timeZone?: string): s
   }).format(date)
 }
 
+/**
+ * 같은 대화 칸의 시각 (14단계 디자인 원본 Thread14: "오늘 오전 10:42" · "10월 29일 (목) 오전 9:30") — 줄마다 날과 시각을 함께 보인다
+ * - 오늘 · 어제: "오늘 오전 10:42" · "어제 오후 1:05"
+ * - 올해: "10월 29일 (목) 오전 9:30"
+ * - 그 이전: "2025. 10. 29. (수) 오전 9:30" (읽기 화면 머리와 같다)
+ */
+export function formatConversationTime(value: string, now: Date = new Date(), timeZone?: string): string {
+  const date = parseDate(value)
+  if (!date) return ''
+  const target = calendarDayOf(date, timeZone)
+  const today = calendarDayOf(now, timeZone)
+  const time = new Intl.DateTimeFormat('ko-KR', { timeZone, hour: 'numeric', minute: '2-digit' }).format(date)
+  if (isSameDay(target, today)) return `오늘 ${time}`
+  if (isSameDay(target, previousDay(today))) return `어제 ${time}`
+  return target.year === today.year ? formatScheduleTime(value, timeZone) : formatMailDateTime(value, timeZone)
+}
+
 /** 보낸편지함 날짜 칸의 예약 시각 — 요일 없이 (디자인 원본 MailSendLater: "예약 · 10월 30일 오전 9:00") */
 export function formatScheduleShortTime(value: string | number, timeZone?: string): string {
   const date = dateOf(value)
diff --git a/frontend/src/shared/utils/mail-bulk.spec.ts b/frontend/src/shared/utils/mail-bulk.spec.ts
index e54b769..f206f4e 100644
--- a/frontend/src/shared/utils/mail-bulk.spec.ts
+++ b/frontend/src/shared/utils/mail-bulk.spec.ts
@@ -6,6 +6,7 @@ import {
   movedMessageText,
   notSpamMovedText,
   purgedMessageText,
+  purgeTitleText,
   restoredMessageText,
   sendInChunks,
 } from './mail-bulk'
@@ -72,4 +73,41 @@ describe('mail-bulk (여러 통 처리 보조)', () => {
       '메일 2통을 스팸이 아닌 메일로 표시해 받은편지함으로 옮겼습니다. 1통은 그사이 옮겨졌거나 지워져 그대로 두었습니다.',
     )
   })
+
+  it('대화로 묶은 목록에서 줄에 한 일 — "{메일함}에 있는 메일 N통을 …" (줄의 통 수는 대화 전체라서 — 14단계), 휴지통 · 스팸도 같은 꼴', () => {
+    expect(movedMessageText(2, '휴지통', 0, { from: '받은편지함' })).toBe('받은편지함에 있는 메일 2통을 휴지통으로 옮겼습니다.')
+    expect(movedMessageText(3, '스팸메일함', 0, { from: '프로젝트' })).toBe('프로젝트에 있는 메일 3통을 스팸메일함으로 옮겼습니다.')
+    expect(movedMessageText(2, '보관함', 1, { from: '받은편지함' })).toBe(
+      '받은편지함에 있는 메일 2통을 보관함으로 옮겼습니다. 1통은 그사이 옮겨졌거나 지워져 그대로 두었습니다.',
+    )
+    expect(notSpamMovedText(1, '받은편지함', 0, { from: '스팸메일함' })).toBe(
+      '스팸메일함에 있는 메일 1통을 스팸이 아닌 메일로 표시해 받은편지함으로 옮겼습니다.',
+    )
+    // 묶지 않은 목록(from 없음)은 지금 글 그대로
+    expect(movedMessageText(2, '휴지통', 0, { from: null })).toBe('메일 2통을 휴지통으로 옮겼습니다.')
+  })
+
+  it('대화로 묶은 휴지통의 영구 삭제 — 확인 창 · 알림이 "휴지통에 있는 메일 N통을 …" (2026-11-07), 뒷말은 그대로', () => {
+    expect(purgeTitleText(2, { from: '휴지통' })).toBe('휴지통에 있는 메일 2통을 영구 삭제할까요?')
+    expect(purgeTitleText(1_234, { from: '휴지통' })).toBe('휴지통에 있는 메일 1,234통을 영구 삭제할까요?')
+    expect(purgedMessageText(2, 0, { from: '휴지통' })).toBe('휴지통에 있는 메일 2통을 영구 삭제했습니다.')
+    expect(purgedMessageText(2, 1, { from: '휴지통' })).toBe(
+      '휴지통에 있는 메일 2통을 영구 삭제했습니다. 1통은 그사이 옮겨졌거나 지워져 그대로 두었습니다.',
+    )
+    // 하나도 지우지 못했으면 뒷말만 (묶지 않은 목록과 같다)
+    expect(purgedMessageText(0, 2, { from: '휴지통' })).toBe('2통은 그사이 옮겨졌거나 지워져 그대로 두었습니다.')
+    // 묶지 않은 목록 · 읽기 화면(from 없음)은 지금 글 그대로
+    expect(purgeTitleText(2)).toBe('메일 2통을 영구 삭제할까요?')
+    expect(purgeTitleText(1, { from: null })).toBe('메일 1통을 영구 삭제할까요?')
+    expect(purgedMessageText(2, 0, { from: null })).toBe('메일 2통을 영구 삭제했습니다.')
+  })
+
+  it('되돌린 알림 — 한 메일함이면 "메일 N통을 {메일함}으로 되돌렸습니다.", 여러 곳 · 모르면 지금 글 그대로', () => {
+    expect(restoredMessageText(2, 0, '받은편지함')).toBe('메일 2통을 받은편지함으로 되돌렸습니다.')
+    expect(restoredMessageText(1, 0, '프로젝트')).toBe('메일 1통을 프로젝트로 되돌렸습니다.')
+    expect(restoredMessageText(2, 1, '받은편지함')).toBe(
+      '메일 2통을 받은편지함으로 되돌렸습니다. 1통은 그사이 옮겨졌거나 지워져 그대로 두었습니다.',
+    )
+    expect(restoredMessageText(3, 0, null)).toBe('메일 3통을 되돌렸습니다.')
+  })
 })
diff --git a/frontend/src/shared/utils/mail-bulk.ts b/frontend/src/shared/utils/mail-bulk.ts
index b4009e5..dc7b00e 100644
--- a/frontend/src/shared/utils/mail-bulk.ts
+++ b/frontend/src/shared/utils/mail-bulk.ts
@@ -75,22 +75,62 @@ function withSkipped(text: string, done: number, skipped: number): string {
   return done > 0 ? `${text} ${suffix}` : suffix
 }
 
-/** "메일 3통을 보낸편지함으로 옮겼습니다." — 메일함 이름의 받침에 맞춰 '으로/로' */
-export function movedMessageText(done: number, mailboxName: string, skipped = 0): string {
-  const place = `${mailboxName}${directionParticle(mailboxName)}`
-  return withSkipped(MAIL_BULK_TEXT.moved(formatCount(done), place), done, skipped)
+/** "받은편지함으로" — 메일함 이름의 받침에 맞춰 '으로/로' */
+function placeOf(mailboxName: string): string {
+  return `${mailboxName}${directionParticle(mailboxName)}`
 }
 
-/** 스팸 아님 — "메일 1통을 받은편지함으로 옮겼습니다 (스팸 아님)." (스팸 신고는 옮기기와 같은 문구 — movedMessageText) */
-export function notSpamMovedText(done: number, mailboxName: string, skipped = 0): string {
-  const place = `${mailboxName}${directionParticle(mailboxName)}`
-  return withSkipped(MAIL_SPAM_TEXT.notSpamMoved(formatCount(done), place), done, skipped)
+/**
+ * 옮기기 · 영구 삭제의 알림 · 확인 글의 꾸밈 — from 이 있으면 "{from}에 있는 메일 …"
+ * (대화로 묶은 목록에서 줄에 한 일 — 14단계. 줄의 통 수는 대화 전체라 그 메일함의 메일임을 밝힌다)
+ */
+export interface BulkTextOptions {
+  from?: string | null
 }
 
-export function purgedMessageText(done: number, skipped = 0): string {
-  return withSkipped(MAIL_BULK_TEXT.purged(formatCount(done)), done, skipped)
+/**
+ * "메일 3통을 보낸편지함으로 옮겼습니다." — 메일함 이름의 받침에 맞춰 '으로/로'.
+ * 대화로 묶은 목록에서 줄에 한 일이면 "받은편지함에 있는 메일 2통을 휴지통으로 옮겼습니다." (줄의 통 수는 대화 전체라서)
+ */
+export function movedMessageText(done: number, mailboxName: string, skipped = 0, options: BulkTextOptions = {}): string {
+  const count = formatCount(done)
+  const text = options.from
+    ? MAIL_BULK_TEXT.movedFrom(options.from, count, placeOf(mailboxName))
+    : MAIL_BULK_TEXT.moved(count, placeOf(mailboxName))
+  return withSkipped(text, done, skipped)
 }
 
-export function restoredMessageText(done: number, skipped = 0): string {
-  return withSkipped(MAIL_BULK_TEXT.restored(formatCount(done)), done, skipped)
+/** 스팸 아님 — "메일 1통을 스팸이 아닌 메일로 표시해 받은편지함으로 옮겼습니다." (스팸 신고는 옮기기와 같은 문구 — movedMessageText) */
+export function notSpamMovedText(done: number, mailboxName: string, skipped = 0, options: BulkTextOptions = {}): string {
+  const count = formatCount(done)
+  const text = options.from
+    ? MAIL_SPAM_TEXT.notSpamMovedFrom(options.from, count, placeOf(mailboxName))
+    : MAIL_SPAM_TEXT.notSpamMoved(count, placeOf(mailboxName))
+  return withSkipped(text, done, skipped)
+}
+
+/**
+ * 영구 삭제 확인 창의 제목 — "메일 2통을 영구 삭제할까요?".
+ * 대화로 묶은 휴지통에서 줄을 골랐으면 "휴지통에 있는 메일 2통을 영구 삭제할까요?" (줄의 통 수는 대화 전체이고 지우는 것은 휴지통의 메일뿐이라서)
+ */
+export function purgeTitleText(count: number, options: BulkTextOptions = {}): string {
+  const countText = formatCount(count)
+  return options.from ? MAIL_BULK_TEXT.purgeTitleFrom(options.from, countText) : MAIL_BULK_TEXT.purgeTitle(countText)
+}
+
+/** "메일 2통을 영구 삭제했습니다." — 대화로 묶은 휴지통에서 줄에 한 일이면 "휴지통에 있는 메일 2통을 영구 삭제했습니다." */
+export function purgedMessageText(done: number, skipped = 0, options: BulkTextOptions = {}): string {
+  const count = formatCount(done)
+  const text = options.from ? MAIL_BULK_TEXT.purgedFrom(options.from, count) : MAIL_BULK_TEXT.purged(count)
+  return withSkipped(text, done, skipped)
+}
+
+/**
+ * 되돌리기 — 한 메일함으로 되돌렸으면 "메일 2통을 받은편지함으로 되돌렸습니다.", 여러 곳(또는 메일함 이름을 모름)이면 "메일 N통을 되돌렸습니다."
+ * (2026-11-06 실사용 시험 — 되돌리기 알림 두 장이 같은 글로 쌓였다)
+ */
+export function restoredMessageText(done: number, skipped = 0, mailboxName: string | null = null): string {
+  const count = formatCount(done)
+  const text = mailboxName ? MAIL_BULK_TEXT.restoredTo(count, placeOf(mailboxName)) : MAIL_BULK_TEXT.restored(count)
+  return withSkipped(text, done, skipped)
 }
diff --git a/frontend/src/shared/utils/mail-conversation-list.spec.ts b/frontend/src/shared/utils/mail-conversation-list.spec.ts
new file mode 100644
index 0000000..6fb512b
--- /dev/null
+++ b/frontend/src/shared/utils/mail-conversation-list.spec.ts
@@ -0,0 +1,336 @@
+import { describe, expect, it } from 'vitest'
+
+import type { ConversationSummary, MessageSummary } from '@/shared/types/mail'
+import type { PageInfo } from '@/shared/types/pagination'
+import {
+  appendConversationPage,
+  conversationActionIds,
+  conversationActionIdsOf,
+  conversationCountText,
+  conversationListPageOf,
+  conversationNeighborAfterRemoval,
+  conversationParticipantNames,
+  conversationRowIndexOf,
+  conversationWho,
+  isConversationHeld,
+  listHeadCountText,
+  listHeadShortCountText,
+  mergeRefreshedConversations,
+  withConversationFlags,
+  withConversationFlagsOf,
+  withoutConversationMessages,
+} from './mail-conversation-list'
+
+// 대화로 묶어 보기 — 묶은 목록의 줄 (14단계 — 계약 2절 "대화로 묶어 보기" · 디자인 원본 ListThreads14)
+
+const ME = 'ara.kim@arasystem.test'
+const DOYUN = { name: '이도윤', email: 'doyun.lee@arasystem.test' }
+const HR = { name: '인사팀', email: 'hr@arasystem.test' }
+const MINSU = { name: '김민수', email: 'minsu.kim@arasystem.test' }
+
+function summary(id: string, partial: Partial<MessageSummary> = {}): MessageSummary {
+  return {
+    id,
+    threadId: `t-${id}`,
+    mailboxIds: ['inbox'],
+    from: DOYUN,
+    to: [{ name: '김아라', email: ME }],
+    subject: `제목 ${id}`,
+    preview: '',
+    receivedAt: '2026-11-05T01:00:00Z',
+    isRead: true,
+    isFlagged: false,
+    hasAttachment: false,
+    size: 100,
+    pendingSend: null,
+    ...partial,
+  }
+}
+
+function conversation(id: string, messageIds: string[], partial: Partial<ConversationSummary> = {}): ConversationSummary {
+  return {
+    id,
+    latest: summary(messageIds[0] ?? `${id}-latest`),
+    participants: [DOYUN],
+    messageCount: messageIds.length,
+    messageIds,
+    pendingSendIds: [],
+    isRead: true,
+    isFlagged: false,
+    hasAttachment: false,
+    ...partial,
+  }
+}
+
+const ids = (rows: readonly { id: string }[]) => rows.map((row) => row.id)
+const INFO = (partial: Partial<PageInfo> = {}): PageInfo => ({ hasNext: false, nextCursor: null, total: null, ...partial })
+
+describe('conversationListPageOf — 응답 맞추기', () => {
+  it('계약의 모양이면 그대로 — 기준(basis)도 싣는다', () => {
+    const row = conversation('c1', ['m2', 'm1'], { participants: [DOYUN, { name: null, email: ME }] })
+    const page = conversationListPageOf({
+      items: [row],
+      pageInfo: { hasNext: true, nextCursor: 'next', total: 6 },
+      basis: 'engine',
+    })
+
+    expect(page.items).toEqual([row])
+    expect(page.pageInfo).toEqual({ hasNext: true, nextCursor: 'next', total: 6 })
+    expect(page.basis).toBe('engine')
+  })
+
+  it('목록 모양이 틀리면 빈 목록, 줄 모양이 틀리면 그 줄만 뺀다 (id 없음 · 마지막 메일이 요약 모양이 아님)', () => {
+    expect(conversationListPageOf(null).items).toEqual([])
+    expect(conversationListPageOf({ items: 'x', pageInfo: {} }).items).toEqual([])
+
+    const page = conversationListPageOf({
+      items: [conversation('ok', ['m1']), { id: '', latest: summary('m2') }, { id: 'c3', latest: { id: 'm3' } }, 'c4'],
+      pageInfo: { hasNext: false, nextCursor: null, total: 4 },
+      basis: 'index',
+    })
+    expect(ids(page.items)).toEqual(['ok'])
+  })
+
+  it('마지막 메일은 늘 messageIds 에 들고, 틀린 칸은 맞춘다 — 통 수가 정수가 아니면 messageIds 의 수, 불리언이 아니면 마지막 메일의 값', () => {
+    const [row] = conversationListPageOf({
+      items: [
+        {
+          id: 'c1',
+          latest: summary('m3', { isRead: false, isFlagged: true, hasAttachment: true }),
+          participants: [DOYUN, { email: 3 }, { name: undefined, email: ME }],
+          messageCount: 2.5,
+          messageIds: ['m1', 7, ''],
+          pendingSendIds: 'x',
+        },
+      ],
+      pageInfo: { hasNext: true, nextCursor: '', total: -1 },
+      basis: 'thread',
+    }).items
+
+    expect(row?.messageIds).toEqual(['m3', 'm1'])
+    expect(row?.messageCount).toBe(2)
+    expect(row?.pendingSendIds).toEqual([])
+    expect(row?.participants).toEqual([DOYUN, { name: null, email: ME }])
+    expect([row?.isRead, row?.isFlagged, row?.hasAttachment]).toEqual([false, true, true])
+  })
+
+  it('커서 없는 hasNext 는 다음 쪽이 없는 것, 음수 total 은 모르는 것, 모르는 basis 는 null', () => {
+    const page = conversationListPageOf({ items: [], pageInfo: { hasNext: true, nextCursor: '', total: -1 }, basis: 'thread' })
+    expect(page.pageInfo).toEqual({ hasNext: false, nextCursor: null, total: null })
+    expect(page.basis).toBeNull()
+  })
+})
+
+describe('줄에 하는 일 — 붙잡힌 메일은 뺀다', () => {
+  it('pendingSendIds 와 마지막 메일의 pendingSend 를 뺀 메일이 할 일이다', () => {
+    const row = conversation('c1', ['m3', 'm2', 'm1'], {
+      latest: summary('m3', { pendingSend: { sendAt: '2026-11-06T01:00:00Z', kind: 'undo' } }),
+      pendingSendIds: ['m2'],
+    })
+    expect(conversationActionIds(row)).toEqual(['m1'])
+    expect(isConversationHeld(row)).toBe(false)
+  })
+
+  it('줄의 메일이 모두 붙잡힌 메일이면 고를 수 없다', () => {
+    const row = conversation('c1', ['m2', 'm1'], { pendingSendIds: ['m2', 'm1'] })
+    expect(conversationActionIds(row)).toEqual([])
+    expect(isConversationHeld(row)).toBe(true)
+  })
+
+  it('여러 줄의 할 일은 겹치지 않게 모은다 (같은 id 를 두 번 보내면 서버가 거절한다)', () => {
+    const rows = [conversation('c1', ['m3', 'm2']), conversation('c2', ['m2', 'm1'], { pendingSendIds: ['m1'] })]
+    expect(conversationActionIdsOf(rows)).toEqual(['m3', 'm2'])
+  })
+
+  it('메일의 줄 — 마지막 메일이거나 줄에 든 메일, 없으면 -1', () => {
+    const rows = [conversation('c1', ['m3', 'm2']), conversation('c2', ['m1'])]
+    expect(conversationRowIndexOf(rows, 'm2')).toBe(0)
+    expect(conversationRowIndexOf(rows, 'm1')).toBe(1)
+    expect(conversationRowIndexOf(rows, 'zz')).toBe(-1)
+  })
+})
+
+describe('줄의 글', () => {
+  it('참여자 — 다른 사람은 받은 차례, 내 주소는 "나"로 끝에, 같은 이름은 한 번 (디자인 원본 ListThreads14 "인사팀, 김민수, 나")', () => {
+    const row = conversation('c1', ['m1'], {
+      // 내 주소는 대소문자 · 앞뒤 공백을 가리지 않는다
+      participants: [HR, { name: '김아라', email: ' Ara.Kim@Arasystem.TEST ' }, MINSU, { ...MINSU, email: 'm2@x.test' }],
+    })
+    expect(conversationParticipantNames(row, ME)).toEqual(['인사팀', '김민수', '나'])
+  })
+
+  it('이름 자리 — 받은편지함은 참여자를 쉼표로, 이름이 없으면 주소', () => {
+    const row = conversation('c1', ['m1'], { participants: [{ name: ME, email: ME }, { name: null, email: 'x@ext.test' }] })
+    expect(conversationWho(row, { myEmail: ME, role: 'inbox', view: 'split' })).toEqual({ text: 'x@ext.test, 나', placeholder: false })
+  })
+
+  it('보낸편지함 · 임시보관함에서 참여자가 나뿐이면 마지막 메일의 받는 사람 ("받는 사람: …")', () => {
+    const sentRow = conversation('c1', ['m1'], {
+      participants: [{ name: '김아라', email: ME }],
+      latest: summary('m1', { mailboxIds: ['sent'], from: { name: '김아라', email: ME }, to: [DOYUN, MINSU] }),
+    })
+    expect(conversationWho(sentRow, { myEmail: ME, role: 'sent', view: 'table' }).text).toBe('받는 사람: 이도윤 외 1명')
+
+    const draftRow = conversation('c2', ['d1'], { participants: [], latest: summary('d1', { to: [] }) })
+    expect(conversationWho(draftRow, { myEmail: ME, role: 'drafts', view: 'split' })).toEqual({
+      text: '(받는 사람 없음)',
+      placeholder: true,
+    })
+
+    // 답장이 와서 다른 사람이 있으면 참여자 그대로
+    const replied = conversation('c3', ['m2', 'm1'], { participants: [{ name: '김아라', email: ME }, DOYUN] })
+    expect(conversationWho(replied, { myEmail: ME, role: 'sent', view: 'split' }).text).toBe('이도윤, 나')
+  })
+
+  it('받은편지함에서 참여자가 없으면 마지막 메일의 보낸 사람, 나뿐이면 "나"', () => {
+    expect(conversationWho(conversation('c1', ['m1'], { participants: [] }), { myEmail: ME, role: 'inbox', view: 'split' }).text).toBe(
+      '이도윤',
+    )
+    expect(
+      conversationWho(conversation('c2', ['m1'], { participants: [{ name: '김아라', email: ME }] }), {
+        myEmail: ME,
+        role: null,
+        view: 'split',
+      }).text,
+    ).toBe('나')
+  })
+
+  it('통 수 — 한 통이면 없고, 여러 통이면 "4통" (천 단위 쉼표)', () => {
+    expect(conversationCountText(conversation('c1', ['m1']))).toBeNull()
+    expect(conversationCountText(conversation('c2', ['m1'], { messageCount: 4 }))).toBe('4통')
+    expect(conversationCountText(conversation('c3', ['m1'], { messageCount: 1234 }))).toBe('1,234통')
+  })
+
+  it('목록 머리 글 — 켰을 때 "대화 6개, 안 읽은 메일 2통", 껐을 때 "메일 9통, 안 읽은 메일 2통" (모르는 수 · 0 은 뺀다)', () => {
+    expect(listHeadCountText({ grouped: true, total: 6, unread: 2 })).toBe('대화 6개, 안 읽은 메일 2통')
+    expect(listHeadCountText({ grouped: false, total: 9, unread: 2 })).toBe('메일 9통, 안 읽은 메일 2통')
+    expect(listHeadCountText({ grouped: true, total: null, unread: 2 })).toBe('안 읽은 메일 2통')
+    expect(listHeadCountText({ grouped: true, total: 1500, unread: 0 })).toBe('대화 1,500개')
+    expect(listHeadCountText({ grouped: true, total: null, unread: 0 })).toBe('')
+  })
+
+  it('좁은 목록 머리(분할 보기) — 안 읽은 메일이 있으면 "안 읽은 메일 2통"만, 없으면 "메일 9통" · "대화 6개" (2026-11-06 실사용 시험)', () => {
+    expect(listHeadShortCountText({ grouped: true, total: 6, unread: 2 })).toBe('안 읽은 메일 2통')
+    expect(listHeadShortCountText({ grouped: false, total: 9, unread: 1_234 })).toBe('안 읽은 메일 1,234통')
+    expect(listHeadShortCountText({ grouped: false, total: 9, unread: 0 })).toBe('메일 9통')
+    expect(listHeadShortCountText({ grouped: true, total: 15, unread: 0 })).toBe('대화 15개')
+    expect(listHeadShortCountText({ grouped: true, total: null, unread: 0 })).toBe('')
+  })
+})
+
+describe('이 탭이 바꾼 표시', () => {
+  it('줄의 메일을 모두 바꾸면 줄 전체가 읽음 · 중요 해제 — 마지막 메일의 표시도', () => {
+    const row = conversation('c1', ['m2', 'm1'], { isRead: false, isFlagged: true })
+    const read = withConversationFlags(row, new Set(['m2', 'm1']), { isRead: true, isFlagged: false })
+    expect([read.isRead, read.isFlagged]).toEqual([true, false])
+    expect([read.latest.isRead, read.latest.isFlagged]).toEqual([true, false])
+  })
+
+  it('일부만 바꾸면 읽음 · 중요 해제는 모른다(그대로) — 안 읽음 · 중요는 한 통만 바꿔도 줄이 그렇다', () => {
+    const row = conversation('c1', ['m2', 'm1'], { isRead: false, isFlagged: true })
+    const partial = withConversationFlags(row, new Set(['m2']), { isRead: true, isFlagged: false })
+    expect([partial.isRead, partial.isFlagged]).toEqual([false, true])
+    expect(partial.latest.isRead).toBe(true)
+
+    const readRow = conversation('c2', ['m4', 'm3'])
+    const unread = withConversationFlags(readRow, new Set(['m3']), { isRead: false, isFlagged: true })
+    expect([unread.isRead, unread.isFlagged]).toEqual([false, true])
+    // 마지막 메일이 아닌 메일은 마지막 메일의 표시를 바꾸지 않는다
+    expect(unread.latest).toBe(readRow.latest)
+  })
+
+  it('읽음은 붙잡힌 메일을 빼고 센다 — 나머지를 모두 바꿨으면 줄 전체다. 든 메일이 없으면 같은 줄', () => {
+    const row = conversation('c1', ['m2', 'm1'], { isRead: false, pendingSendIds: ['m2'] })
+    expect(withConversationFlags(row, new Set(['m1']), { isRead: true }).isRead).toBe(true)
+    expect(withConversationFlags(row, new Set(['zz']), { isRead: true })).toBe(row)
+  })
+
+  it('중요 해제는 붙잡힌 메일의 표시를 몰라 그 메일까지 바꿨을 때만 줄 전체다 — 줄의 중요 표시가 붙잡힌 메일에만 있을 수 있다 (리뷰 L1)', () => {
+    const row = conversation('c1', ['m2', 'm1'], { isFlagged: true, pendingSendIds: ['m2'] })
+    expect(withConversationFlags(row, new Set(['m1']), { isFlagged: false }).isFlagged).toBe(true)
+    expect(withConversationFlags(row, new Set(['m2', 'm1']), { isFlagged: false }).isFlagged).toBe(false)
+  })
+
+  it('되돌리기 — 줄과(마지막 메일이 그대로면) 마지막 메일의 표시를 앞 값으로', () => {
+    const original = conversation('c1', ['m2', 'm1'], { isRead: false, latest: summary('m2', { isRead: false }) })
+    const changed = withConversationFlags(original, new Set(['m2', 'm1']), { isRead: true })
+    expect([changed.isRead, changed.latest.isRead]).toEqual([true, true])
+    const restored = withConversationFlagsOf(changed, original)
+    expect([restored.isRead, restored.latest.isRead]).toEqual([false, false])
+
+    const newLatest = { ...changed, latest: summary('m9', { isRead: true }) }
+    expect(withConversationFlagsOf(newLatest, original).latest.isRead).toBe(true)
+  })
+})
+
+describe('뺀 메일 · 이어서 열 메일', () => {
+  it('메일이 모두 빠진 줄은 빼고 그 수를 센다 — 남은 줄은 메일만 줄인다', () => {
+    const rows = [conversation('c1', ['m3', 'm2'], { pendingSendIds: ['m2'] }), conversation('c2', ['m1']), conversation('c3', ['m0'])]
+    const result = withoutConversationMessages(rows, new Set(['m3', 'm1']))
+    expect(ids(result.rows)).toEqual(['c1', 'c3'])
+    expect(result.rows[0]?.messageIds).toEqual(['m2'])
+    expect(result.rows[0]?.pendingSendIds).toEqual(['m2'])
+    expect(result.removedRows).toBe(1)
+    expect(result.rows[1]).toBe(rows[2])
+  })
+
+  it('이어서 열 메일 — 메일 목록과 같은 결: 그 줄의 다음 칸(더 오래된 메일), 없으면 앞 칸, 줄이 비면 다음 줄 · 앞 줄의 마지막 메일 (리뷰 L3)', () => {
+    const rows = [conversation('c1', ['m6']), conversation('c2', ['m5', 'm4', 'm3']), conversation('c3', ['m2'])]
+    // 가운데 메일([이 메일만 열기]로 연 더 오래된 메일) — 다음 칸
+    expect(conversationNeighborAfterRemoval(rows, 'm4')).toBe('m3')
+    expect(conversationNeighborAfterRemoval(rows, 'm5')).toBe('m4')
+    // 줄의 끝 칸 — 앞 칸
+    expect(conversationNeighborAfterRemoval(rows, 'm3')).toBe('m4')
+    // 줄에 그 메일뿐 — 다음 줄, 마지막 줄이면 앞 줄의 마지막 메일
+    expect(conversationNeighborAfterRemoval(rows, 'm6')).toBe('m5')
+    expect(conversationNeighborAfterRemoval(rows, 'm2')).toBe('m5')
+    expect(conversationNeighborAfterRemoval([conversation('c1', ['m1'])], 'm1')).toBeNull()
+    expect(conversationNeighborAfterRemoval(rows, 'zz')).toBeNull()
+  })
+
+  it('이어서 열 메일 — 다음 맞추기 전의 옛 마지막 메일(이미 뺀 메일)이면 남은 메일의 첫 칸', () => {
+    const stale = conversation('c1', ['m3', 'm2'], { latest: summary('m9') })
+    expect(conversationNeighborAfterRemoval([stale, conversation('c2', ['m1'])], 'm9')).toBe('m3')
+  })
+})
+
+describe('쪽 붙이기 · 다시 받아 맞추기', () => {
+  it('붙일 때 이미 있는 줄은 건너뛰고, 다음 쪽의 total 이 없으면 아는 수를 남긴다', () => {
+    const merged = appendConversationPage([conversation('c1', ['m3'])], INFO({ total: 6 }), {
+      items: [conversation('c1', ['m3']), conversation('c2', ['m2'])],
+      pageInfo: INFO({ total: null }),
+      basis: 'index',
+    })
+    expect(ids(merged.rows)).toEqual(['c1', 'c2'])
+    expect(merged.pageInfo.total).toBe(6)
+  })
+
+  it('다시 받은 범위 밖의 옛 줄은 남기고 옛 커서를 쓴다 — 메일이 겹치는 옛 줄은 같은 대화로 본다(합쳐진 대화)', () => {
+    const current = [conversation('a', ['m9']), conversation('b', ['m8']), conversation('c', ['m7', 'm6']), conversation('d', ['m5'])]
+    const fetched = [conversation('x', ['m10']), conversation('a', ['m9']), conversation('b2', ['m8', 'm7'])]
+    const result = mergeRefreshedConversations({
+      current,
+      currentPageInfo: INFO({ hasNext: true, nextCursor: 'old', total: 10 }),
+      fetched,
+      fetchedPageInfo: INFO({ hasNext: true, nextCursor: 'new', total: 11 }),
+    })
+    // b 는 b2 와 메일이 겹치고(m8) c 는 m7 이 겹쳐 같은 대화로 본다 — 남는 옛 줄은 d
+    expect(ids(result.rows)).toEqual(['x', 'a', 'b2', 'd'])
+    expect(result.pageInfo).toEqual({ hasNext: true, nextCursor: 'old', total: 11 })
+  })
+
+  it('"새 메일 N통" — 맨 앞부터 새 줄은 한 통, 새 메일이 든 줄은 새 메일 수를 이어 세고, 바뀌지 않은 줄에서 멈춘다', () => {
+    const current = [conversation('a', ['m3', 'm2']), conversation('b', ['m1'])]
+    const fetched = [
+      conversation('new', ['m9', 'm0']),
+      conversation('b', ['m8', 'm7', 'm1']),
+      conversation('a', ['m3', 'm2']),
+      conversation('late', ['m6']),
+    ]
+    const result = mergeRefreshedConversations({ current, currentPageInfo: INFO(), fetched, fetchedPageInfo: INFO() })
+    expect(result.addedAbove).toBe(3)
+
+    const unchanged = mergeRefreshedConversations({ current, currentPageInfo: INFO(), fetched: current, fetchedPageInfo: INFO() })
+    expect(unchanged.addedAbove).toBe(0)
+  })
+})
diff --git a/frontend/src/shared/utils/mail-conversation-list.ts b/frontend/src/shared/utils/mail-conversation-list.ts
new file mode 100644
index 0000000..97fea06
--- /dev/null
+++ b/frontend/src/shared/utils/mail-conversation-list.ts
@@ -0,0 +1,347 @@
+// 대화로 묶어 보기 — 묶은 목록(GET /conversations)의 줄을 다루는 순수 함수만 둔다
+// (14단계 — 계약 2절 "대화로 묶어 보기" · 디자인 README 「14단계 — 검색 · 대화 묶기」 › "목록 — 대화로 묶어 보기 (ListThreads14)")
+// - 응답 맞추기: 모양이 틀린 줄은 뺀다. 마지막 메일(latest)은 늘 messageIds 에 넣어 둔다 — 줄에 든 메일인지 messageIds 만 보면 되게
+// - 줄에 하는 일(고르기 · 읽음 · 중요 · 이동 · 삭제)은 messageIds 에서 붙잡힌 메일(pendingSendIds · 마지막 메일의 pendingSend)을 뺀 메일에 한다 —
+//   붙잡힌 메일은 취소로만 보낸편지함을 떠난다. 남는 메일이 없으면 그 줄은 고를 수 없다
+// - 참여자: 다른 사람은 받은 차례로, 내 주소는 "나"로 끝에 (디자인 원본 ListThreads14 — "이도윤, 나" · "인사팀, 김민수, 나").
+//   보낸편지함 · 임시보관함에서 참여자가 나뿐이면 메일 목록처럼 "받는 사람: …" 이다 (나만 늘어선 줄이 되지 않게 — 보드에 없어 정했다)
+// - 이 탭이 바꾼 표시(읽음 · 중요): 줄의 메일을 모두 바꿨을 때만 줄 전체가 읽음 · 중요 해제가 된다 — 일부만이면 나머지를 몰라 그대로 두고
+//   다음 맞추기(새 메일 확인 · 실시간 소식)가 서버 값으로 고친다. 안 읽음 · 중요는 한 통만 바꿔도 줄이 그렇다.
+//   읽음은 붙잡힌 메일(내가 보내는 메일 — 읽은 메일)을 빼고 세지만, 중요 해제는 붙잡힌 메일의 표시를 몰라 그 메일까지 바꿨을 때만이다
+//   (줄의 중요 표시가 붙잡힌 메일에만 있을 수 있다 — 14단계 리뷰 L1)
+// - 뺀 메일: 줄의 메일이 모두 빠지면 줄도 뺀다. 남으면 줄은 그대로다(마지막 메일은 다음 맞추기까지 옛 것 — 부르는 쪽이 곧 다시 맞춘다).
+//   뺀 뒤 열 메일은 메일 목록과 같은 결 — 그 줄의 messageIds 에서 다음 칸(더 오래된 메일), 없으면 앞 칸, 줄이 비면 다음 줄 · 앞 줄
+// - 다시 받아 맞추기: 메일 목록(mail-list-merge.ts)과 같은 규칙 — 다시 받은 범위 밖의 옛 줄은 남긴다. 메일이 겹치는 옛 줄은 같은 대화로 본다
+//   (늦게 온 원본으로 두 대화가 합쳐지면 id 가 바뀐다 — 계약의 알려진 한계)
+
+import { OUTGOING_MAILBOX_ROLES } from '@/shared/constants/mail'
+import { MAIL_CONVERSATION_LIST_TEXT, MAIL_CONVERSATION_TEXT } from '@/shared/constants/mail-conversation'
+import type {
+  Address,
+  ConversationBasis,
+  ConversationListPage,
+  ConversationSummary,
+  MailboxRole,
+  MessageSummary,
+} from '@/shared/types/mail'
+import type { PageInfo } from '@/shared/types/pagination'
+import { formatCount } from '@/shared/utils/format'
+import { isMyAddress, isSummaryLike, participantName } from '@/shared/utils/mail-conversation'
+import { rowWho, type RowWho } from '@/shared/utils/mail-list-row'
+import { isHeldMessage } from '@/shared/utils/pending-send'
+
+const CONVERSATION_BASES: readonly string[] = ['index', 'engine']
+
+/** 이 탭이 줄의 메일에 바로 적는 표시 — 메일 목록(list.ts)의 LocalChanges 와 같은 칸 */
+export type ConversationFlagChanges = Partial<Pick<MessageSummary, 'isRead' | 'isFlagged' | 'mailboxIds'>>
+
+// ── 응답 맞추기 ─────────────────────────────────────────────
+
+function isAddressLike(value: unknown): value is Address {
+  if (typeof value !== 'object' || value === null) return false
+  const candidate = value as { name?: unknown; email?: unknown }
+  return (
+    typeof candidate.email === 'string' &&
+    (candidate.name === null || candidate.name === undefined || typeof candidate.name === 'string')
+  )
+}
+
+function idsOf(value: unknown): string[] {
+  if (!Array.isArray(value)) return []
+  return value.filter((id): id is string => typeof id === 'string' && id !== '')
+}
+
+function booleanOr(value: unknown, fallback: boolean): boolean {
+  return typeof value === 'boolean' ? value : fallback
+}
+
+/** 줄 하나 — 줄이 읽는 칸의 모양이 틀리면 null (그 줄만 뺀다) */
+function conversationOf(value: unknown): ConversationSummary | null {
+  if (typeof value !== 'object' || value === null) return null
+  const candidate = value as Partial<Record<keyof ConversationSummary, unknown>>
+  if (typeof candidate.id !== 'string' || candidate.id === '' || !isSummaryLike(candidate.latest)) return null
+  const latest = candidate.latest
+  const listed = idsOf(candidate.messageIds)
+  const messageIds = listed.includes(latest.id) ? listed : [latest.id, ...listed]
+  const count = candidate.messageCount
+  return {
+    id: candidate.id,
+    latest,
+    participants: Array.isArray(candidate.participants)
+      ? candidate.participants.filter(isAddressLike).map((address) => ({ name: address.name ?? null, email: address.email }))
+      : [],
+    messageCount: typeof count === 'number' && Number.isInteger(count) && count > 0 ? count : messageIds.length,
+    messageIds,
+    pendingSendIds: idsOf(candidate.pendingSendIds),
+    isRead: booleanOr(candidate.isRead, latest.isRead),
+    isFlagged: booleanOr(candidate.isFlagged, latest.isFlagged),
+    hasAttachment: booleanOr(candidate.hasAttachment, latest.hasAttachment),
+  }
+}
+
+/**
+ * GET /conversations 의 응답 → ConversationListPage. 목록 모양이 틀리면 빈 목록, 줄 모양이 틀리면 그 줄만 뺀다.
+ * 커서가 없는 hasNext 는 다음 쪽이 없는 것으로, 음수 · 정수가 아닌 total 은 모르는 것(null)으로 본다 (같은 대화의 conversationPageOf 와 같다)
+ */
+export function conversationListPageOf(value: unknown): ConversationListPage {
+  const empty: ConversationListPage = { items: [], pageInfo: { hasNext: false, nextCursor: null, total: 0 }, basis: null }
+  if (typeof value !== 'object' || value === null) return empty
+  const candidate = value as { items?: unknown; pageInfo?: unknown; basis?: unknown }
+  if (!Array.isArray(candidate.items) || typeof candidate.pageInfo !== 'object' || candidate.pageInfo === null) return empty
+  const info = candidate.pageInfo as { hasNext?: unknown; nextCursor?: unknown; total?: unknown }
+  const nextCursor = typeof info.nextCursor === 'string' && info.nextCursor !== '' ? info.nextCursor : null
+  const total = typeof info.total === 'number' && Number.isInteger(info.total) && info.total >= 0 ? info.total : null
+  const basis =
+    typeof candidate.basis === 'string' && CONVERSATION_BASES.includes(candidate.basis)
+      ? (candidate.basis as ConversationBasis)
+      : null
+  return {
+    items: candidate.items.map(conversationOf).filter((row): row is ConversationSummary => row !== null),
+    pageInfo: { hasNext: info.hasNext === true && nextCursor !== null, nextCursor, total },
+    basis,
+  }
+}
+
+// ── 줄에 하는 일 ─────────────────────────────────────────────
+
+/** 줄의 붙잡힌 메일 — pendingSendIds 와 마지막 메일의 pendingSend */
+function heldIdsOf(row: ConversationSummary): Set<string> {
+  const held = new Set(row.pendingSendIds)
+  if (isHeldMessage(row.latest)) held.add(row.latest.id)
+  return held
+}
+
+/** 줄에 하는 일(고르기 · 읽음 · 중요 · 이동 · 삭제)을 보낼 메일 — 붙잡힌 메일은 뺀다 (최신부터) */
+export function conversationActionIds(row: ConversationSummary): string[] {
+  const held = heldIdsOf(row)
+  return row.messageIds.filter((id) => !held.has(id))
+}
+
+/** 줄의 메일이 모두 붙잡힌 메일이다 — 고를 수 없고 별(중요 표시)도 바꿀 수 없다 */
+export function isConversationHeld(row: ConversationSummary): boolean {
+  return conversationActionIds(row).length === 0
+}
+
+/** 여러 줄의 할 일 메일 — 겹치지 않게 (같은 id 를 두 번 보내면 서버가 거절한다) */
+export function conversationActionIdsOf(rows: readonly ConversationSummary[]): string[] {
+  return [...new Set(rows.flatMap(conversationActionIds))]
+}
+
+/** 그 메일이 든 줄인가 — 마지막 메일은 늘 messageIds 에 있다(conversationListPageOf). 뺀 뒤 남은 옛 마지막 메일은 들지 않는다 */
+export function conversationHasMessage(row: ConversationSummary, messageId: string): boolean {
+  return row.messageIds.includes(messageId)
+}
+
+/** 그 메일의 줄 — 줄에 든 메일이거나 그 줄의 마지막 메일(다음 맞추기 전의 옛 것 포함). 없으면 -1 */
+export function conversationRowIndexOf(rows: readonly ConversationSummary[], messageId: string): number {
+  return rows.findIndex((row) => row.latest.id === messageId || conversationHasMessage(row, messageId))
+}
+
+// ── 줄의 글 ─────────────────────────────────────────────
+
+/** 참여자 이름 — 다른 사람은 받은 차례(같은 이름은 한 번), 나는 끝에 "나" */
+export function conversationParticipantNames(row: ConversationSummary, myEmail: string | null | undefined): string[] {
+  const others: string[] = []
+  let mine = false
+  for (const address of row.participants) {
+    if (isMyAddress(address, myEmail)) {
+      mine = true
+      continue
+    }
+    const name = participantName(address, myEmail)
+    if (name && !others.includes(name)) others.push(name)
+  }
+  return mine ? [...others, MAIL_CONVERSATION_TEXT.me] : others
+}
+
+export interface ConversationWhoContext {
+  myEmail: string | null | undefined
+  /** 목록의 메일함 역할 */
+  role: MailboxRole | null
+  view: 'split' | 'table'
+}
+
+/**
+ * 줄의 이름 자리 — 참여자를 쉼표로 ("이도윤, 나"). 보낸편지함 · 임시보관함에서 참여자가 나뿐(또는 없음)이면 마지막 메일의 받는 사람을
+ * "받는 사람: …" 으로(표 머리 "참여자" 아래에서 참여자가 아니라 받는 사람인 것을 가르려고 앞말을 붙인다), 그 밖에서 참여자가 없으면
+ * 마지막 메일의 보낸 사람 규칙(mail-list-row.ts)
+ */
+export function conversationWho(row: ConversationSummary, context: ConversationWhoContext): RowWho {
+  const names = conversationParticipantNames(row, context.myEmail)
+  const onlyMe = names.length === 0 || (names.length === 1 && names[0] === MAIL_CONVERSATION_TEXT.me)
+  if (onlyMe && context.role && OUTGOING_MAILBOX_ROLES.includes(context.role)) {
+    return rowWho(row.latest, { role: context.role, mixed: true, view: context.view })
+  }
+  if (names.length === 0) return rowWho(row.latest, { role: context.role, mixed: false, view: context.view })
+  return { text: names.join(', '), placeholder: false }
+}
+
+/** 줄의 통 수 — "4통"(대화 전체 · 보낸편지함 포함), 한 통이면 null (보이지 않는다) */
+export function conversationCountText(row: ConversationSummary): string | null {
+  return row.messageCount > 1 ? MAIL_CONVERSATION_LIST_TEXT.rowCount(formatCount(row.messageCount)) : null
+}
+
+/**
+ * 목록 머리 글 — 대화로 묶었으면 "대화 6개, 안 읽은 메일 2통", 아니면 "메일 9통, 안 읽은 메일 2통".
+ * 대화 수는 목록의 total — 모르면(null) 그 부분을 빼고, 안 읽은 메일이 없으면 뒤를 뺀다. 둘 다 없으면 빈 글
+ */
+export function listHeadCountText(input: { grouped: boolean; total: number | null; unread: number }): string {
+  const parts: string[] = []
+  if (input.total !== null) {
+    const count = formatCount(input.total)
+    parts.push(
+      input.grouped ? MAIL_CONVERSATION_LIST_TEXT.conversationCount(count) : MAIL_CONVERSATION_LIST_TEXT.messageCount(count),
+    )
+  }
+  if (input.unread > 0) parts.push(MAIL_CONVERSATION_LIST_TEXT.unreadCount(formatCount(input.unread)))
+  return parts.join(', ')
+}
+
+/**
+ * 좁은 목록 머리(분할 보기)의 글 — 안 읽은 메일이 있으면 "안 읽은 메일 2통"만, 없으면 "메일 9통"(묶었으면 "대화 6개", 모르면 빈 글).
+ * 전체 글(listHeadCountText)은 title · 화면 낭독에 둔다 (2026-11-06 실사용 시험 — 1440 분할 보기에서 안 읽은 수가 늘 잘렸다)
+ */
+export function listHeadShortCountText(input: { grouped: boolean; total: number | null; unread: number }): string {
+  if (input.unread > 0) return MAIL_CONVERSATION_LIST_TEXT.unreadCount(formatCount(input.unread))
+  return listHeadCountText({ ...input, unread: 0 })
+}
+
+// ── 이 탭이 바꾼 것 ─────────────────────────────────────────────
+
+/**
+ * 메일들의 표시를 바꾼 뒤의 줄 (머리말) — ids 에 든 메일이 없으면 그 줄 그대로.
+ * 줄의 메일(붙잡힌 메일은 빼고)을 모두 바꿨으면 읽음 · 중요 해제도 줄 전체에 적는다. 마지막 메일이면 그 메일의 표시 · 메일함도 바꾼다
+ */
+export function withConversationFlags(
+  row: ConversationSummary,
+  ids: ReadonlySet<string>,
+  changes: ConversationFlagChanges,
+): ConversationSummary {
+  const latestHit = ids.has(row.latest.id)
+  if (!latestHit && !row.messageIds.some((id) => ids.has(id))) return row
+  const held = heldIdsOf(row)
+  // 읽음 — 붙잡힌 메일(내가 보내는 메일 · 읽은 메일)은 빼고 센다. 중요 해제 — 붙잡힌 메일의 표시는 몰라 그 메일까지 바꿨을 때만
+  const coversRead = row.messageIds.every((id) => ids.has(id) || held.has(id))
+  const coversAll = row.messageIds.every((id) => ids.has(id))
+  const next: ConversationSummary = { ...row }
+  if (latestHit) next.latest = { ...row.latest, ...changes }
+  if (changes.isRead === false) next.isRead = false
+  else if (changes.isRead === true && coversRead) next.isRead = true
+  if (changes.isFlagged === true) next.isFlagged = true
+  else if (changes.isFlagged === false && coversAll) next.isFlagged = false
+  return next
+}
+
+/** 줄의 읽음 · 중요 표시를 앞 값으로 — 보내지 못한 메일이 든 줄을 되돌린다(여러 통 처리). 마지막 메일이 그대로일 때만 그 메일의 표시도 */
+export function withConversationFlagsOf(row: ConversationSummary, original: ConversationSummary): ConversationSummary {
+  const latest =
+    row.latest.id === original.latest.id
+      ? { ...row.latest, isRead: original.latest.isRead, isFlagged: original.latest.isFlagged }
+      : row.latest
+  return { ...row, isRead: original.isRead, isFlagged: original.isFlagged, latest }
+}
+
+/** 메일을 뺀 뒤의 줄 (머리말) — 메일이 모두 빠진 줄은 빼고 그 수를 센다 */
+export function withoutConversationMessages(
+  rows: readonly ConversationSummary[],
+  ids: ReadonlySet<string>,
+): { rows: ConversationSummary[]; removedRows: number } {
+  let removedRows = 0
+  const next: ConversationSummary[] = []
+  for (const row of rows) {
+    if (!row.messageIds.some((id) => ids.has(id))) {
+      next.push(row)
+      continue
+    }
+    const messageIds = row.messageIds.filter((id) => !ids.has(id))
+    if (messageIds.length === 0) {
+      removedRows += 1
+      continue
+    }
+    next.push({ ...row, messageIds, pendingSendIds: row.pendingSendIds.filter((id) => !ids.has(id)) })
+  }
+  return { rows: next, removedRows }
+}
+
+/**
+ * 그 메일을 뺀 뒤 이어서 열 메일 — 메일 목록의 neighborAfterRemoval 과 같은 결이다 (14단계 리뷰 L3).
+ * 그 줄의 messageIds(최신부터)에서 그 메일의 다음 칸(더 오래된 메일), 없으면 앞 칸. 줄에 그 메일뿐이면 다음 줄의 마지막 메일, 없으면 앞 줄의 마지막 메일.
+ * 줄의 옛 마지막 메일(다음 맞추기 전 — messageIds 에서 이미 뺐다)이면 남은 메일의 첫 칸. 목록에 없는 메일이면 null
+ */
+export function conversationNeighborAfterRemoval(rows: readonly ConversationSummary[], messageId: string): string | null {
+  const index = conversationRowIndexOf(rows, messageId)
+  if (index === -1) return null
+  const ids = rows[index]?.messageIds ?? []
+  const position = ids.indexOf(messageId)
+  const inRow = position === -1 ? ids[0] : (ids[position + 1] ?? ids[position - 1])
+  if (inRow !== undefined) return inRow
+  return rows[index + 1]?.latest.id ?? rows[index - 1]?.latest.id ?? null
+}
+
+// ── 쪽 붙이기 · 다시 받아 맞추기 ─────────────────────────────────────────────
+
+/** 받은 쪽을 뒤에 붙인다 — 이미 있는 줄은 건너뛴다. 다음 쪽의 total 이 없으면(색인 방식은 첫 쪽에서만 센다) 아는 수를 남긴다 */
+export function appendConversationPage(
+  rows: readonly ConversationSummary[],
+  pageInfo: PageInfo | null,
+  page: ConversationListPage,
+): { rows: ConversationSummary[]; pageInfo: PageInfo } {
+  const known = new Set(rows.map((row) => row.id))
+  const fresh = page.items.filter((row) => !known.has(row.id))
+  return {
+    rows: [...rows, ...fresh],
+    pageInfo: { ...page.pageInfo, total: page.pageInfo.total ?? pageInfo?.total ?? null },
+  }
+}
+
+export interface ConversationMergeInput {
+  current: readonly ConversationSummary[]
+  currentPageInfo: PageInfo | null
+  fetched: readonly ConversationSummary[]
+  fetchedPageInfo: PageInfo
+}
+
+export interface ConversationMergeResult {
+  rows: ConversationSummary[]
+  pageInfo: PageInfo
+  /** 목록 맨 위의 새 메일 수 — 맨 앞부터 새로 생긴 줄(한 통으로 센다)과 새 메일이 든 줄(새 메일 수)이 이어지는 만큼 ("새 메일 N통") */
+  addedAbove: number
+}
+
+/** 불러온 만큼(최대 100줄)을 다시 받아 맞춘다 (머리말) — 다시 받은 범위는 서버 기준, 그 밖의 옛 줄은 그대로 */
+export function mergeRefreshedConversations(input: ConversationMergeInput): ConversationMergeResult {
+  const { current, fetched } = input
+  const fetchedIds = new Set(fetched.map((row) => row.id))
+  const fetchedMessages = new Set(fetched.flatMap((row) => row.messageIds))
+  const overlaps = (row: ConversationSummary) =>
+    fetchedIds.has(row.id) || row.messageIds.some((id) => fetchedMessages.has(id))
+
+  // 다시 받은 범위와 겹치는 마지막 옛 줄 — 그 뒤의 옛 줄은 다시 받지 않았다
+  let lastOverlap = -1
+  current.forEach((row, index) => {
+    if (overlaps(row)) lastOverlap = index
+  })
+  const tail = lastOverlap === -1 ? [] : current.slice(lastOverlap + 1).filter((row) => !overlaps(row))
+
+  // 남겨 둔 옛 줄이 있으면 "더 보기"는 그 뒤부터 — 옛 커서를 쓴다. 전체 수는 새 값
+  const pageInfo =
+    tail.length > 0 && input.currentPageInfo
+      ? { ...input.currentPageInfo, total: input.fetchedPageInfo.total }
+      : input.fetchedPageInfo
+
+  const previous = new Map(current.map((row) => [row.id, row]))
+  let addedAbove = 0
+  for (const row of fetched) {
+    const before = previous.get(row.id)
+    if (!before) {
+      addedAbove += 1
+      continue
+    }
+    const known = new Set(before.messageIds)
+    const fresh = row.messageIds.filter((id) => !known.has(id)).length
+    if (fresh === 0) break
+    addedAbove += fresh
+  }
+
+  return { rows: [...fetched, ...tail], pageInfo, addedAbove }
+}
diff --git a/frontend/src/shared/utils/mail-conversation.spec.ts b/frontend/src/shared/utils/mail-conversation.spec.ts
new file mode 100644
index 0000000..3dad3e7
--- /dev/null
+++ b/frontend/src/shared/utils/mail-conversation.spec.ts
@@ -0,0 +1,364 @@
+import { describe, expect, it } from 'vitest'
+
+import type { Mailbox, MessageSummary } from '@/shared/types/mail'
+import {
+  appendConversationPage,
+  conversationCountOf,
+  conversationMessageLocation,
+  conversationPageOf,
+  conversationReplyLocation,
+  conversationRowsOf,
+  conversationSenderOf,
+  hasConversation,
+  nextConversationCursor,
+  participantName,
+  previewWithoutOwnQuote,
+  type ConversationLinkContext,
+} from './mail-conversation'
+
+// 같은 대화 (14단계 — 계약 2절 "대화 — 14단계" · 디자인 원본 Thread14) — 응답 맞추기 · 통 수 · 이름 자리 · 누르면 갈 곳
+
+const SEOUL = 'Asia/Seoul'
+const ME = { email: 'ara.kim@arasystem.test', name: '김아라' }
+
+function mailbox(id: string, role: Mailbox['role'], name: string): Mailbox {
+  return { id, name, role, parentId: null, sortOrder: 0, totalCount: 0, unreadCount: 0 }
+}
+
+const INBOX = mailbox('inbox', 'inbox', '받은편지함')
+const SENT = mailbox('sent', 'sent', '보낸편지함')
+const DRAFTS = mailbox('drafts', 'drafts', '임시보관함')
+const PROJECT = mailbox('project', null, '프로젝트')
+const MAILBOXES = [INBOX, SENT, DRAFTS, PROJECT]
+
+function summary(id: string, partial: Partial<MessageSummary> = {}): MessageSummary {
+  return {
+    id,
+    threadId: 't1',
+    mailboxIds: ['inbox'],
+    from: { name: '이도윤', email: 'doyun.lee@arasystem.test' },
+    to: [{ name: '김아라', email: ME.email }],
+    subject: '회신: 유지보수 계약 갱신 건',
+    preview: '네, 확인했습니다.',
+    receivedAt: '2026-10-29T00:30:00Z',
+    isRead: true,
+    isFlagged: false,
+    hasAttachment: false,
+    size: 100,
+    ...partial,
+  }
+}
+
+const EMPTY_LINKS: ConversationLinkContext = {
+  source: { kind: 'mailbox', mailboxId: 'inbox' },
+  listedIds: new Set(),
+  mailboxes: MAILBOXES,
+}
+
+describe('conversationPageOf — 응답 모양 맞추기', () => {
+  it('계약의 모양이면 그대로 — 기준(basis)도 싣는다', () => {
+    const page = conversationPageOf({
+      items: [summary('m1'), summary('m2')],
+      pageInfo: { hasNext: true, nextCursor: 'c2', total: 4 },
+      basis: 'index',
+    })
+
+    expect(page.items.map((item) => item.id)).toEqual(['m1', 'm2'])
+    expect(page.pageInfo).toEqual({ hasNext: true, nextCursor: 'c2', total: 4 })
+    expect(page.basis).toBe('index')
+  })
+
+  it('모양이 틀리면(항목 · 쪽 정보가 없음 · 응답을 바꾼 게이트웨이) 빈 대화 — 칸을 보이지 않는다', () => {
+    for (const value of [null, 'html', { items: 'x', pageInfo: {} }, { items: [] }, { usedBytes: 0 }]) {
+      const page = conversationPageOf(value)
+      expect(page.items).toEqual([])
+      expect(page.pageInfo).toEqual({ hasNext: false, nextCursor: null, total: 0 })
+      expect(page.basis).toBeNull()
+      expect(hasConversation(page.items, page.pageInfo)).toBe(false)
+    }
+  })
+
+  it('커서 없는 hasNext 는 다음 쪽이 없는 것, 음수 · 소수 total 은 모르는 것, 모르는 basis 는 null, 줄이 읽는 칸이 없는 항목은 뺀다', () => {
+    const page = conversationPageOf({
+      items: [summary('m1'), { id: 'broken' }, { ...summary('m3'), preview: undefined }, summary('m4')],
+      pageInfo: { hasNext: true, nextCursor: '', total: 2.5 },
+      basis: 'thread',
+    })
+
+    expect(page.items.map((item) => item.id)).toEqual(['m1', 'm4'])
+    expect(page.pageInfo).toEqual({ hasNext: false, nextCursor: null, total: null })
+    expect(page.basis).toBeNull()
+    expect(conversationPageOf({ items: [], pageInfo: { hasNext: false, nextCursor: null, total: -1 } }).pageInfo.total).toBeNull()
+  })
+})
+
+describe('appendConversationPage · 통 수 · 칸 보이기', () => {
+  it('다음 쪽을 붙인다 — 이미 있는 메일은 건너뛰고, total 이 없는 다음 쪽(색인 방식)은 첫 쪽의 수를 남긴다', () => {
+    const first = { hasNext: true, nextCursor: 'c2', total: 3 }
+    const merged = appendConversationPage([summary('m1'), summary('m2')], first, {
+      items: [summary('m2'), summary('m3')],
+      pageInfo: { hasNext: false, nextCursor: null, total: null },
+      basis: 'index',
+    })
+
+    expect(merged.items.map((item) => item.id)).toEqual(['m1', 'm2', 'm3'])
+    expect(merged.added).toBe(1)
+    expect(merged.pageInfo).toEqual({ hasNext: false, nextCursor: null, total: 3 })
+  })
+
+  it('N 은 total — 모르면 다 받았을 때의 받은 수, 그것도 모르면(남은 쪽이 있다) null', () => {
+    const items = [summary('m1'), summary('m2')]
+    expect(conversationCountOf(items, { hasNext: true, nextCursor: 'c2', total: 8 })).toBe(8)
+    expect(conversationCountOf(items, { hasNext: false, nextCursor: null, total: null })).toBe(2)
+    expect(conversationCountOf(items, { hasNext: true, nextCursor: 'c2', total: null })).toBeNull()
+    expect(conversationCountOf(items, null)).toBeNull()
+  })
+
+  it('한 통뿐이면 칸이 없다 — 수를 모르면 두 통 넘게 받았거나 받을 쪽이 남았을 때 보인다', () => {
+    expect(hasConversation([summary('m1')], { hasNext: false, nextCursor: null, total: 1 })).toBe(false)
+    expect(hasConversation([summary('m1')], { hasNext: false, nextCursor: null, total: null })).toBe(false)
+    expect(hasConversation([summary('m1'), summary('m2')], { hasNext: false, nextCursor: null, total: 2 })).toBe(true)
+    // 엔진 방식의 큰 대화 — 첫 쪽에는 지금 메일뿐이지만 다른 메일이 있다는 수가 왔다
+    expect(hasConversation([summary('m1')], { hasNext: true, nextCursor: 'c2', total: 5 })).toBe(true)
+    expect(hasConversation([summary('m1')], { hasNext: true, nextCursor: 'c2', total: null })).toBe(true)
+    expect(nextConversationCursor({ hasNext: true, nextCursor: null, total: null })).toBeNull()
+  })
+})
+
+describe('이름 자리 — 내가 보냈으면 "나" + 회색 메일함 이름 (디자인 원본 Thread14)', () => {
+  const context = { me: ME, mailboxes: MAILBOXES }
+
+  it('보낸편지함의 메일은 "나" · 보낸편지함 — 머리글자는 내 이름의 첫 글자, 회색', () => {
+    const sent = summary('m1', { mailboxIds: ['sent'], from: { name: '김아라', email: ME.email } })
+
+    expect(conversationSenderOf(sent, context)).toEqual({ name: '나', initial: '김', mine: true, mailboxName: '보낸편지함' })
+  })
+
+  it('임시 저장본은 "나" · 임시보관함, 보낸 사람이 나면(대소문자 무시) 받은편지함에 들어도 "나" — 메일함 이름 없이', () => {
+    const draft = summary('m1', { mailboxIds: ['drafts'], from: null })
+    expect(conversationSenderOf(draft, context)).toEqual({ name: '나', initial: '김', mine: true, mailboxName: '임시보관함' })
+
+    const toSelf = summary('m2', { from: { name: null, email: 'Ara.Kim@AraSystem.test' } })
+    expect(conversationSenderOf(toSelf, context)).toMatchObject({ name: '나', mine: true, mailboxName: null })
+  })
+
+  it('받은 메일은 보낸 사람 이름(없으면 주소, 보낸 사람도 없으면 "(보낸 사람 없음)") — 내 메일함이 아닌 곳의 이름은 붙이지 않는다', () => {
+    expect(conversationSenderOf(summary('m1', { mailboxIds: ['project'] }), context)).toEqual({
+      name: '이도윤',
+      initial: '이',
+      mine: false,
+      mailboxName: null,
+    })
+    expect(conversationSenderOf(summary('m2', { from: { name: null, email: 'seojun.park@arasystem.test' } }), context).name).toBe(
+      'seojun.park@arasystem.test',
+    )
+    expect(conversationSenderOf(summary('m3', { from: null }), context)).toMatchObject({ name: '(보낸 사람 없음)', mine: false })
+  })
+
+  it('메일함을 아직 모르면 보낸 사람 주소로만 가른다', () => {
+    const sent = summary('m1', { mailboxIds: ['sent'], from: { name: '김아라', email: ME.email } })
+    expect(conversationSenderOf(sent, { me: ME, mailboxes: [] })).toMatchObject({ name: '나', mailboxName: null })
+    expect(conversationSenderOf(sent, { me: null, mailboxes: [] })).toMatchObject({ name: '김아라', mine: false })
+  })
+
+  it('participantName — 나면 "나", 아니면 이름 (3차 묶은 목록의 참여자 줄도 쓴다)', () => {
+    expect(participantName({ name: '김아라', email: ME.email }, ME.email)).toBe('나')
+    expect(participantName({ name: '이도윤', email: 'doyun.lee@arasystem.test' }, ME.email)).toBe('이도윤')
+    expect(participantName({ name: null, email: 'x@example.com' }, null)).toBe('x@example.com')
+  })
+})
+
+describe('누르면 갈 곳 — [이 메일만 열기] · [답장]', () => {
+  it('지금 메일함에 든 메일은 그 메일함 안, 다른 메일함의 메일은 그 메일이 든 메일함 (보낸편지함의 내 메일)', () => {
+    expect(conversationMessageLocation(summary('m2'), EMPTY_LINKS)).toEqual({
+      name: 'mail-message',
+      params: { mailboxId: 'inbox', messageId: 'm2' },
+    })
+    expect(conversationMessageLocation(summary('m1', { mailboxIds: ['sent'] }), EMPTY_LINKS)).toEqual({
+      name: 'mail-message',
+      params: { mailboxId: 'sent', messageId: 'm1' },
+    })
+  })
+
+  it('임시 저장본은 쓰기 화면에서 이어 쓴다 (목록에서 누를 때와 같다)', () => {
+    expect(conversationMessageLocation(summary('d1', { mailboxIds: ['drafts'] }), EMPTY_LINKS)).toEqual({
+      name: 'mail-compose',
+      query: { draft: 'd1' },
+    })
+  })
+
+  it('검색 결과 · 예약됨은 받아 둔 줄에 있는 메일만 그 목록 안에서 연다 — 아니면 그 메일의 메일함', () => {
+    const search: ConversationLinkContext = {
+      source: { kind: 'search', q: '계약', scope: 'all' },
+      listedIds: new Set(['m2']),
+      mailboxes: MAILBOXES,
+    }
+    expect(conversationMessageLocation(summary('m2'), search)).toEqual({
+      name: 'mail-search-message',
+      params: { messageId: 'm2' },
+      query: { q: '계약', in: 'all' },
+    })
+    expect(conversationMessageLocation(summary('m3', { mailboxIds: ['project'] }), search)).toEqual({
+      name: 'mail-message',
+      params: { mailboxId: 'project', messageId: 'm3' },
+    })
+
+    const scheduled: ConversationLinkContext = { source: { kind: 'scheduled' }, listedIds: new Set(['s1']), mailboxes: MAILBOXES }
+    expect(conversationMessageLocation(summary('s1', { mailboxIds: ['sent'] }), scheduled)).toEqual({
+      name: 'mail-scheduled-message',
+      params: { messageId: 's1' },
+    })
+  })
+
+  it('메일함을 모르면 그 메일의 첫 메일함 id 로', () => {
+    expect(
+      conversationMessageLocation(summary('m1', { mailboxIds: ['x1'] }), { ...EMPTY_LINKS, mailboxes: [] }),
+    ).toEqual({ name: 'mail-message', params: { mailboxId: 'x1', messageId: 'm1' } })
+  })
+
+  it('[답장]은 읽기 화면과 같은 쓰기 화면 — 임시 저장본 · 예약한 메일은 없고, 보내기 취소를 기다리는 메일은 있다', () => {
+    expect(conversationReplyLocation(summary('m1'), MAILBOXES)).toEqual({ name: 'mail-compose', query: { replyTo: 'm1' } })
+    expect(conversationReplyLocation(summary('d1', { mailboxIds: ['drafts'] }), MAILBOXES)).toBeNull()
+    const sendAt = '2026-10-30T00:00:00Z'
+    expect(
+      conversationReplyLocation(summary('s1', { mailboxIds: ['sent'], pendingSend: { kind: 'scheduled', sendAt } }), MAILBOXES),
+    ).toBeNull()
+    expect(
+      conversationReplyLocation(summary('s2', { mailboxIds: ['sent'], pendingSend: { kind: 'undo', sendAt } }), MAILBOXES),
+    ).not.toBeNull()
+  })
+})
+
+describe('conversationRowsOf — 칸의 줄', () => {
+  /** 2026-10-29(목) 오후 3시 (서울) */
+  const now = new Date('2026-10-29T06:00:00Z')
+  const context = { ...EMPTY_LINKS, currentId: 'm3', me: ME, now, timeZone: SEOUL }
+
+  it('오래된 차례 그대로 — 지금 메일 표시 · 시각("오늘 …" · "10월 27일 (화) …") · 미리 보기가 비면 제목', () => {
+    const rows = conversationRowsOf(
+      [
+        summary('m1', { mailboxIds: ['sent'], from: { name: '김아라', email: ME.email }, receivedAt: '2026-10-27T05:10:00Z' }),
+        summary('m2', { preview: '   ' }),
+        summary('m3', { receivedAt: '2026-10-29T01:42:00Z' }),
+      ],
+      context,
+    )
+
+    expect(rows.map((row) => [row.message.id, row.current, row.sender.name, row.time])).toEqual([
+      ['m1', false, '나', '10월 27일 (화) 오후 2:10'],
+      ['m2', false, '이도윤', '오늘 오전 9:30'],
+      ['m3', true, '이도윤', '오늘 오전 10:42'],
+    ])
+    expect(rows[1]?.preview).toBe('회신: 유지보수 계약 갱신 건')
+    expect(rows[0]?.preview).toBe('네, 확인했습니다.')
+    expect(rows[0]?.location).toEqual({ name: 'mail-message', params: { mailboxId: 'sent', messageId: 'm1' } })
+  })
+
+  it('안 읽음은 목록 줄과 같은 규칙 — 안 읽은 메일이면 지금 메일 · 보낸편지함의 메일도, 임시 저장본은 읽음 여부를 보이지 않는다 (2026-11-07)', () => {
+    const rows = conversationRowsOf(
+      [
+        summary('read'),
+        summary('unread', { isRead: false }),
+        summary('sent', { mailboxIds: ['sent'], isRead: false }),
+        summary('draft', { mailboxIds: ['drafts'], isRead: false }),
+        summary('m3', { isRead: false }),
+      ],
+      context,
+    )
+
+    expect(rows.map((row) => [row.message.id, row.unread])).toEqual([
+      ['read', false],
+      ['unread', true],
+      ['sent', true],
+      ['draft', false],
+      ['m3', true],
+    ])
+  })
+
+  it('붙잡힌 메일은 시각 자리에 목록과 같은 "예약 · …" · "보내는 중" — <time> 은 보낼 시각, 받은 줄 뒤에 둔다', () => {
+    const sendAt = '2026-10-30T00:00:00Z'
+    const rows = conversationRowsOf(
+      [
+        summary('s1', { mailboxIds: ['sent'], pendingSend: { kind: 'scheduled', sendAt } }),
+        summary('s2', { mailboxIds: ['sent'], pendingSend: { kind: 'undo', sendAt } }),
+        summary('m3'),
+      ],
+      context,
+    )
+
+    expect(rows.map((row) => [row.message.id, row.time, row.pending, row.timeValue])).toEqual([
+      ['m3', '오늘 오전 9:30', false, '2026-10-29T00:30:00Z'],
+      ['s1', '예약 · 10월 30일 오전 9:00', true, sendAt],
+      ['s2', '보내는 중', true, sendAt],
+    ])
+    expect(rows[1]?.replyLocation).toBeNull()
+  })
+
+  it('보내기를 기다리는 메일(pendingSend)은 받은 줄의 맨 끝에 보낼 시각 차례로 — 서버 차례(저장한 시각)를 거스르지 않게', () => {
+    const rows = conversationRowsOf(
+      [
+        summary('m1', { receivedAt: '2026-10-29T00:10:00Z' }),
+        // 10시 38분에 저장한 예약 메일(11시 38분에 보낸다) — 서버는 저장한 시각 차례로 준다
+        summary('late', {
+          mailboxIds: ['sent'],
+          receivedAt: '2026-10-29T01:38:00Z',
+          pendingSend: { kind: 'scheduled', sendAt: '2026-10-29T02:38:00Z' },
+        }),
+        summary('early', {
+          mailboxIds: ['sent'],
+          receivedAt: '2026-10-29T01:39:00Z',
+          pendingSend: { kind: 'scheduled', sendAt: '2026-10-29T02:00:00Z' },
+        }),
+        summary('m2', { receivedAt: '2026-10-29T02:00:00Z' }),
+        summary('m3', { receivedAt: '2026-10-29T02:10:00Z' }),
+      ],
+      context,
+    )
+
+    expect(rows.map((row) => row.message.id)).toEqual(['m1', 'm2', 'm3', 'early', 'late'])
+  })
+
+  it('줄의 미리 보기 — 우리 웹 · 앱의 원문 인용("> 원본 메일")부터 뒤는 잘라 내고, 남는 글이 없으면 제목', () => {
+    const rows = conversationRowsOf(
+      [
+        summary('m1', { preview: '도윤님, 금요일까지 정하겠습니다. > 원본 메일 > 보낸 사람: 이도윤 <doyun.lee@arasystem.test>' }),
+        summary('m2', { preview: '> 원본 메일 > 보낸 사람: 이도윤 > 날짜: 2026. 10. 29.' }),
+        summary('m3', { preview: '첨부를 확인해 주세요. > 원본' }),
+      ],
+      context,
+    )
+
+    expect(rows.map((row) => row.preview)).toEqual([
+      '도윤님, 금요일까지 정하겠습니다.',
+      '회신: 유지보수 계약 갱신 건',
+      '첨부를 확인해 주세요.',
+    ])
+  })
+})
+
+describe('previewWithoutOwnQuote — 우리 원문 인용 머리부터 잘라 낸다', () => {
+  it.each([
+    ['네, 확인했습니다. > 원본 메일 > 보낸 사람: 김아라', '네, 확인했습니다.'],
+    ['> 원본 메일 > 보낸 사람: 김아라', ''],
+    // 답장의 답장 — 처음 나온 머리부터
+    ['좋습니다. > 원본 메일 > 보낸 사람: 이도윤 > > 원본 메일 > 보낸 사람: 김아라', '좋습니다.'],
+    // 미리 보기 끝에서 잘린 머리도 머리다 (적어도 "> 원")
+    ['내일 뵙겠습니다. > 원본 메', '내일 뵙겠습니다.'],
+    ['내일 뵙겠습니다. > 원', '내일 뵙겠습니다.'],
+  ])('%s → %s', (preview, expected) => {
+    expect(previewWithoutOwnQuote(preview)).toBe(expected)
+  })
+
+  it.each([
+    // 다른 메일 프로그램의 인용 꼴은 손대지 않는다
+    '네. -----Original Message----- From: 이도윤',
+    '네. 2026년 10월 29일 (목) 오전 9:30, 이도윤 <doyun.lee@arasystem.test>님이 작성: > 견적서 보내드립니다.',
+    // 줄의 처음이 아닌 곳의 같은 글은 인용 머리가 아니다
+    '제목이 "A> 원본 메일"인 메일입니다.',
+    // 끝의 ">" 하나는 머리로 보지 않는다
+    '값이 a > b >',
+    '보통 미리 보기',
+  ])('%s — 그대로', (preview) => {
+    expect(previewWithoutOwnQuote(preview)).toBe(preview)
+  })
+})
diff --git a/frontend/src/shared/utils/mail-conversation.ts b/frontend/src/shared/utils/mail-conversation.ts
new file mode 100644
index 0000000..12e7d02
--- /dev/null
+++ b/frontend/src/shared/utils/mail-conversation.ts
@@ -0,0 +1,309 @@
+// 같은 대화 (14단계 — 계약 2절 "대화 — 14단계" · 디자인 README "읽기 화면 — 같은 대화 (Thread14)") — 순수 함수만 둔다
+// 읽기 화면의 "같은 대화" 칸(MessageConversation)이 쓰고, 3차 "대화로 묶어 보기"도 참여자 이름("나") · 쪽 맞추기를 다시 쓸 수 있게 나눠 둔다.
+// - 응답 맞추기: 모양이 틀리면 빈 대화(칸이 없다), 쪽을 붙일 때 이미 있는 메일은 건너뛰고 total 이 없는 다음 쪽은 아는 수를 남긴다
+// - 통 수 · 칸 보이기: total → 다 받았으면 받은 수 → 모르면 수 없이. 한 통뿐이면 칸이 없다
+// - 이름 자리: 내가 보낸 메일(보낸편지함 · 임시보관함에 들었거나 보낸 사람이 나)은 "나" + 회색 메일함 이름
+// - 누르면 갈 곳: 임시 저장본은 쓰기 화면(목록과 같다), 지금 목록에 있는 메일은 그 목록 안, 아니면 그 메일이 든 메일함
+// - 줄의 미리 보기: 우리 웹 · 앱이 답장 · 전달에 붙인 원문 인용("> 원본 메일")부터 뒤는 잘라 낸다 — 같은 대화의 줄마다 앞 메일이 되풀이되지 않게.
+//   남는 글이 없으면 제목. 다른 메일 프로그램의 인용 꼴은 손대지 않는다 (2026-11-06 실사용 시험)
+// - 줄의 차례: 서버 차례(받은 시각 — 내 메일은 저장한 시각) 그대로, 보내기를 기다리는 메일(pendingSend)만 받은 줄 뒤에 보낼 시각 차례로 —
+//   예약한 메일이 그 뒤에 온 답장보다 앞에 서지 않게 (2026-11-06 실사용 시험)
+// - 안 읽음: 목록 줄과 같은 규칙(mail-list-row.ts 의 isRowUnread — 임시 저장본은 읽음 여부를 보이지 않는다). 지금 보는 메일의 줄도 같다
+//   (2026-11-07 사용자 관점 점검 — 가운데 메일을 안 읽었으면 어느 것인지 알 수 없었다)
+
+import type { RouteLocationRaw } from 'vue-router'
+
+import { MAIL_NO_SENDER, MAIL_NO_SUBJECT, MAIL_QUOTE_LINE_PREFIX, OUTGOING_MAILBOX_ROLES } from '@/shared/constants/mail'
+import { MAIL_CONVERSATION_TEXT } from '@/shared/constants/mail-conversation'
+import { MAIL_QUOTE_HEADING } from '@/shared/constants/mail-editor'
+import type { AuthUser } from '@/shared/types/auth'
+import type { Address, ConversationBasis, ConversationPage, Mailbox, MessageSummary } from '@/shared/types/mail'
+import type { PageInfo } from '@/shared/types/pagination'
+import { formatConversationTime, initialOf } from '@/shared/utils/format'
+import { displayName, normalizeEmail } from '@/shared/utils/mail-address'
+import { isRowUnread, mailboxOfMessage, pendingSendLabel } from '@/shared/utils/mail-list-row'
+import { mailboxListIdOf, messageLocationOf, type MailListSource } from '@/shared/utils/mail-list-source'
+import { isScheduledMessage, messagePendingSend } from '@/shared/utils/pending-send'
+
+const CONVERSATION_BASES: readonly string[] = ['index', 'engine']
+
+/** 빈 대화 — 모양이 틀린 응답 (칸을 보이지 않는다) */
+function emptyConversationPage(): ConversationPage {
+  return { items: [], pageInfo: { hasNext: false, nextCursor: null, total: 0 }, basis: null }
+}
+
+/**
+ * 줄로 쓸 수 있는 항목인가 — 줄이 읽는 칸(id · 메일함 · 받는 사람 · 제목 · 미리 보기 · 받은 시각)의 모양만 본다 (나머지는 서버의 요약을 믿는다).
+ * 대화로 묶은 목록의 마지막 메일(latest)도 이것으로 본다 (mail-conversation-list.ts)
+ */
+export function isSummaryLike(value: unknown): value is MessageSummary {
+  if (typeof value !== 'object' || value === null) return false
+  const candidate = value as Partial<Record<keyof MessageSummary, unknown>>
+  return (
+    typeof candidate.id === 'string' &&
+    candidate.id !== '' &&
+    Array.isArray(candidate.mailboxIds) &&
+    Array.isArray(candidate.to) &&
+    typeof candidate.subject === 'string' &&
+    typeof candidate.preview === 'string' &&
+    typeof candidate.receivedAt === 'string'
+  )
+}
+
+/**
+ * GET /messages/{id}/conversation 의 응답 → ConversationPage. 모양이 틀리면(응답을 바꾼 게이트웨이 등) 빈 대화다.
+ * 커서가 없는 hasNext 는 다음 쪽이 없는 것으로, 음수 · 정수가 아닌 total 은 모르는 것(null)으로 본다
+ */
+export function conversationPageOf(value: unknown): ConversationPage {
+  if (typeof value !== 'object' || value === null) return emptyConversationPage()
+  const candidate = value as { items?: unknown; pageInfo?: unknown; basis?: unknown }
+  if (!Array.isArray(candidate.items) || typeof candidate.pageInfo !== 'object' || candidate.pageInfo === null) {
+    return emptyConversationPage()
+  }
+  const info = candidate.pageInfo as { hasNext?: unknown; nextCursor?: unknown; total?: unknown }
+  const nextCursor = typeof info.nextCursor === 'string' && info.nextCursor !== '' ? info.nextCursor : null
+  const total = typeof info.total === 'number' && Number.isInteger(info.total) && info.total >= 0 ? info.total : null
+  const basis =
+    typeof candidate.basis === 'string' && CONVERSATION_BASES.includes(candidate.basis)
+      ? (candidate.basis as ConversationBasis)
+      : null
+  return {
+    items: candidate.items.filter(isSummaryLike),
+    pageInfo: { hasNext: info.hasNext === true && nextCursor !== null, nextCursor, total },
+    basis,
+  }
+}
+
+/** 다음 쪽 커서 — 더 없으면 null */
+export function nextConversationCursor(pageInfo: PageInfo | null): string | null {
+  return pageInfo?.hasNext === true && pageInfo.nextCursor ? pageInfo.nextCursor : null
+}
+
+/**
+ * 받은 쪽을 뒤에 붙인다 — 이미 있는 메일은 건너뛴다(늦게 온 원본으로 차례가 밀렸을 수 있다). added 는 새로 붙인 수.
+ * 다음 쪽의 total 이 없으면(색인 방식은 첫 쪽에서만 센다) 아는 수를 남긴다
+ */
+export function appendConversationPage(
+  items: readonly MessageSummary[],
+  pageInfo: PageInfo | null,
+  page: ConversationPage,
+): { items: MessageSummary[]; pageInfo: PageInfo; added: number } {
+  const known = new Set(items.map((item) => item.id))
+  const fresh = page.items.filter((item) => !known.has(item.id))
+  return {
+    items: [...items, ...fresh],
+    pageInfo: { ...page.pageInfo, total: page.pageInfo.total ?? pageInfo?.total ?? null },
+    added: fresh.length,
+  }
+}
+
+/** 칸 제목의 통 수 — total, 모르면 다 받았을 때(다음 쪽 없음)의 받은 수, 그것도 모르면 null("같은 대화" — 수를 뺀다) */
+export function conversationCountOf(items: readonly unknown[], pageInfo: PageInfo | null): number | null {
+  if (!pageInfo) return null
+  if (pageInfo.total !== null) return pageInfo.total
+  return pageInfo.hasNext ? null : items.length
+}
+
+/** 칸을 보일까 — 다른 메일이 있을 때만(한 통뿐이면 칸이 없다). 수를 모르면 두 통 넘게 받았거나 더 받을 쪽이 남았을 때 */
+export function hasConversation(items: readonly unknown[], pageInfo: PageInfo | null): boolean {
+  const count = conversationCountOf(items, pageInfo)
+  if (count !== null) return count > 1
+  return items.length > 1 || nextConversationCursor(pageInfo) !== null
+}
+
+// ── 이름 자리 ─────────────────────────────────────────────
+
+/** 내 주소인가 — 대소문자 · 앞뒤 공백을 가리지 않는다 */
+export function isMyAddress(address: Address | null | undefined, myEmail: string | null | undefined): boolean {
+  if (!address || !myEmail) return false
+  return normalizeEmail(address.email) === normalizeEmail(myEmail)
+}
+
+/** 참여자 이름 — 나면 "나", 아니면 이름(없으면 주소). 3차 "대화로 묶어 보기"의 참여자 줄("이도윤, 나")도 이것을 쓴다 */
+export function participantName(address: Address | null | undefined, myEmail: string | null | undefined): string {
+  return isMyAddress(address, myEmail) ? MAIL_CONVERSATION_TEXT.me : displayName(address)
+}
+
+/** 그 메일이 든 보낸편지함 · 임시보관함 — 없으면(받은 메일 · 메일함을 아직 모름) null */
+export function outgoingMailboxOf(
+  message: Pick<MessageSummary, 'mailboxIds'>,
+  mailboxes: readonly Mailbox[],
+): Mailbox | null {
+  for (const id of message.mailboxIds) {
+    const mailbox = mailboxes.find((entry) => entry.id === id)
+    if (mailbox?.role && OUTGOING_MAILBOX_ROLES.includes(mailbox.role)) return mailbox
+  }
+  return null
+}
+
+function isDraftMessage(message: Pick<MessageSummary, 'mailboxIds'>, mailboxes: readonly Mailbox[]): boolean {
+  return outgoingMailboxOf(message, mailboxes)?.role === 'drafts'
+}
+
+export interface ConversationSender {
+  /** 이름 자리 — 내가 보냈으면 "나" */
+  name: string
+  /** 머리글자 — 나도 내 이름의 첫 글자 (디자인 원본 Thread14 "김") */
+  initial: string
+  /** 내가 보낸 메일 — 머리글자를 회색으로 */
+  mine: boolean
+  /** 이름 뒤 회색 글 — 보낸편지함 · 임시보관함에 든 메일이면 그 메일함 이름 */
+  mailboxName: string | null
+}
+
+/**
+ * 줄의 이름 자리 — 보낸편지함 · 임시보관함에 들었거나 보낸 사람이 나면 "나"(+ 그 메일함 이름), 아니면 보낸 사람 이름.
+ * 메일함을 아직 모르면 보낸 사람 주소로만 가른다(메일함 이름 없이)
+ */
+export function conversationSenderOf(
+  message: Pick<MessageSummary, 'from' | 'mailboxIds'>,
+  context: { me: AuthUser | null; mailboxes: readonly Mailbox[] },
+): ConversationSender {
+  const outgoing = outgoingMailboxOf(message, context.mailboxes)
+  const mine = outgoing !== null || isMyAddress(message.from, context.me?.email)
+  const initial = initialOf(message.from?.name, message.from?.email ?? '')
+  return {
+    name: mine ? MAIL_CONVERSATION_TEXT.me : displayName(message.from) || MAIL_NO_SENDER,
+    initial: initial || (mine ? initialOf(context.me?.name, context.me?.email ?? '') : ''),
+    mine,
+    mailboxName: outgoing?.name ?? null,
+  }
+}
+
+// ── 누르면 갈 곳 ─────────────────────────────────────────────
+
+export interface ConversationLinkContext {
+  /** 지금 목록 — 그 목록에 드는 메일이면 그 목록 안에서 연다 */
+  source: MailListSource | null
+  /** 지금 목록에 받아 둔 메일 — 검색 결과 · 예약됨은 받아 둔 줄에 있을 때만 그 목록 안에서 연다 */
+  listedIds: ReadonlySet<string>
+  mailboxes: readonly Mailbox[]
+}
+
+/**
+ * [이 메일만 열기] — 임시 저장본은 쓰기 화면에서 이어 쓴다(목록에서 누를 때와 같다). 지금 목록에 드는 메일은 그 목록 안의 주소(목록 · 검색 결과가 그대로),
+ * 아니면 그 메일이 든 메일함의 주소(보낸편지함의 내 메일 등 — 목록이 그 메일함으로 바뀐다). 기록에 쌓는다(RouterLink — 목록에서 메일을 여는 것과 같다)
+ */
+export function conversationMessageLocation(
+  message: Pick<MessageSummary, 'id' | 'mailboxIds'>,
+  context: ConversationLinkContext,
+): RouteLocationRaw {
+  if (isDraftMessage(message, context.mailboxes)) return { name: 'mail-compose', query: { draft: message.id } }
+  const { source } = context
+  // 메일함 목록(대화로 묶은 목록 포함 — 14단계)은 그 메일함에 든 메일이면 그 목록 안에서 연다
+  const listMailboxId = mailboxListIdOf(source)
+  if (source && listMailboxId !== null && message.mailboxIds.includes(listMailboxId)) {
+    return messageLocationOf(source, message.id)
+  }
+  if (source && listMailboxId === null && context.listedIds.has(message.id)) return messageLocationOf(source, message.id)
+  const mailboxId = mailboxOfMessage(message, context.mailboxes)?.id ?? message.mailboxIds[0]
+  if (mailboxId) return messageLocationOf({ kind: 'mailbox', mailboxId }, message.id)
+  return source ? messageLocationOf(source, message.id) : { name: 'mail' }
+}
+
+/** [답장] — 읽기 화면의 [답장]과 같은 쓰기 화면. 임시 저장본 · 예약한 메일은 없다(읽기 화면도 예약한 메일에는 답장이 없다) */
+export function conversationReplyLocation(
+  message: Pick<MessageSummary, 'id' | 'mailboxIds' | 'pendingSend'>,
+  mailboxes: readonly Mailbox[],
+): RouteLocationRaw | null {
+  if (isDraftMessage(message, mailboxes) || isScheduledMessage(message)) return null
+  return { name: 'mail-compose', query: { replyTo: message.id } }
+}
+
+// ── 줄 ─────────────────────────────────────────────
+
+export interface ConversationRow {
+  message: MessageSummary
+  /** 지금 읽기 화면에 연 메일 — "지금 보고 있는 메일", 누를 수 없다 */
+  current: boolean
+  /** 안 읽은 메일 — 목록 줄처럼 굵게, 화면 낭독은 이름 앞에 "안 읽음, " (임시 저장본은 늘 false) */
+  unread: boolean
+  sender: ConversationSender
+  /** 미리 보기 한 줄 — 비었으면 제목 */
+  preview: string
+  /** 시각 자리 — 붙잡힌 메일(보내기 취소 · 예약)은 목록과 같은 "보내는 중" · "예약 · …" */
+  time: string
+  /** <time datetime> — 붙잡힌 메일은 보낼 시각 */
+  timeValue: string
+  /** 붙잡힌 메일 — 시각 자리를 청록 굵게 (목록과 같다) */
+  pending: boolean
+  /** 펼쳤을 때의 [이 메일만 열기] */
+  location: RouteLocationRaw
+  /** 펼쳤을 때의 [답장] — 없으면 null */
+  replyLocation: RouteLocationRaw | null
+}
+
+export interface ConversationRowContext extends ConversationLinkContext {
+  currentId: string
+  me: AuthUser | null
+  /** 시각 글의 "오늘 · 어제"를 가르는 지금 */
+  now: Date
+  /** 테스트가 시간대를 넘긴다 — 주지 않으면 브라우저 시간대 */
+  timeZone?: string
+}
+
+/**
+ * 우리 웹 · 앱이 답장 · 전달의 텍스트 본문에 붙이는 원문 인용의 머리 줄 — "> 원본 메일" (mail-serialize.ts 의 인용 줄 머리 + 인용 머리 글).
+ * 미리 보기는 줄바꿈이 띄어쓰기로 바뀐 글이라 "…정하겠습니다. > 원본 메일 > 보낸 사람: …" 꼴로 온다
+ */
+const OWN_QUOTE_MARKER = `${MAIL_QUOTE_LINE_PREFIX}${MAIL_QUOTE_HEADING}`
+/** 미리 보기 끝에서 잘린 머리("> 원본 메")도 머리로 본다 — 적어도 인용 줄 머리 다음 한 글자("> 원")는 있어야 한다 */
+const OWN_QUOTE_TAIL_MIN = MAIL_QUOTE_LINE_PREFIX.length + 1
+const WHITESPACE = /\s/
+
+/** 그 자리가 글의 처음이거나 바로 앞이 띄어쓰기(줄바꿈)인가 — 인용 머리는 줄의 처음에만 있다 */
+function startsLine(text: string, index: number): boolean {
+  return index === 0 || WHITESPACE.test(text.charAt(index - 1))
+}
+
+/**
+ * 미리 보기에서 우리 웹 · 앱의 원문 인용("> 원본 메일")부터 뒤를 잘라 낸다 (머리말). 미리 보기 끝에서 잘린 머리도 지운다.
+ * 다른 메일 프로그램의 인용(“… 작성:” · "-----Original Message-----" 등)은 그대로 둔다
+ */
+export function previewWithoutOwnQuote(preview: string): string {
+  let from = 0
+  for (;;) {
+    const index = preview.indexOf(OWN_QUOTE_MARKER, from)
+    if (index === -1) break
+    if (startsLine(preview, index)) return preview.slice(0, index).trimEnd()
+    from = index + 1
+  }
+  for (let length = OWN_QUOTE_MARKER.length - 1; length >= OWN_QUOTE_TAIL_MIN; length -= 1) {
+    const start = preview.length - length
+    if (start >= 0 && preview.endsWith(OWN_QUOTE_MARKER.slice(0, length)) && startsLine(preview, start)) {
+      return preview.slice(0, start).trimEnd()
+    }
+  }
+  return preview
+}
+
+/** 보내기를 기다리는 메일(보내기 취소 · 예약)은 받은 줄 뒤에 보낼 시각 차례로 (머리말) — 나머지는 받은 차례 그대로 */
+export function orderHeldLast(items: readonly MessageSummary[]): MessageSummary[] {
+  const sendAtOf = (message: MessageSummary) => Date.parse(messagePendingSend(message)?.sendAt ?? '')
+  const held = items.filter((message) => messagePendingSend(message) !== null)
+  if (held.length === 0) return [...items]
+  return [
+    ...items.filter((message) => messagePendingSend(message) === null),
+    // 같은 시각이면 받은 차례 그대로 (sort 는 안정 정렬)
+    ...held.sort((a, b) => sendAtOf(a) - sendAtOf(b)),
+  ]
+}
+
+/** 받은 대화 → 칸의 줄 (오래된 차례 — 보내기를 기다리는 메일은 끝에) */
+export function conversationRowsOf(items: readonly MessageSummary[], context: ConversationRowContext): ConversationRow[] {
+  return orderHeldLast(items).map((message) => {
+    const pendingLabel = pendingSendLabel(message, context.timeZone)
+    return {
+      message,
+      current: message.id === context.currentId,
+      unread: isRowUnread(message, outgoingMailboxOf(message, context.mailboxes)?.role ?? null),
+      sender: conversationSenderOf(message, context),
+      preview: previewWithoutOwnQuote(message.preview).trim() || message.subject || MAIL_NO_SUBJECT,
+      time: pendingLabel ?? formatConversationTime(message.receivedAt, context.now, context.timeZone),
+      timeValue: message.pendingSend?.sendAt ?? message.receivedAt,
+      pending: pendingLabel !== null,
+      location: conversationMessageLocation(message, context),
+      replyLocation: conversationReplyLocation(message, context.mailboxes),
+    }
+  })
+}
diff --git a/frontend/src/shared/utils/mail-html.spec.ts b/frontend/src/shared/utils/mail-html.spec.ts
index 3fc2982..674c776 100644
--- a/frontend/src/shared/utils/mail-html.spec.ts
+++ b/frontend/src/shared/utils/mail-html.spec.ts
@@ -278,3 +278,39 @@ describe('대용량 첨부 덩이 접기 (11단계 — 디자인 원본 MailRead
     expect(doc).toContain('details[open] .ara-large-files__hint,details[open] .ara-large-files__open,details:not([open]) .ara-large-files__close{display:none}')
   })
 })
+
+describe('검색 강조 (14단계 — 계약 2절 "검색 — 14단계" › 읽기 화면)', () => {
+  it('서버가 서식 본문의 글 조각에 넣은 <mark> 는 한 번 더 정화해도 남는다 (속성은 지운다)', () => {
+    const html = sanitizeMailHtml('<p>지난번 <mark>계약</mark>서 초안을 <mark onclick="x()" class="a">첨부</mark>했습니다</p>')
+
+    expect(html).toBe('<p>지난번 <mark>계약</mark>서 초안을 <mark class="a">첨부</mark>했습니다</p>')
+    expect(buildMailDocument({ htmlBody: '<p><mark>계약</mark></p>', textBody: null })).toContain('<mark>계약</mark>')
+  })
+
+  it('글 본문은 맞은 곳(textHighlights)을 <mark> 로 — 나머지는 지금처럼 이스케이프한다', () => {
+    const doc = buildMailDocument({
+      htmlBody: null,
+      textBody: '<b>계약</b>서를 보냅니다\n계약 갱신',
+      textHighlights: [
+        [3, 5],
+        [17, 19],
+      ],
+    })
+
+    expect(doc).toContain('<div class="mail-text">&lt;b&gt;<mark>계약</mark>&lt;/b&gt;서를 보냅니다\n<mark>계약</mark> 갱신</div>')
+  })
+
+  it('서식 본문이 있으면 글 본문의 맞은 곳은 쓰지 않는다 · 맞은 곳이 없으면 지금과 같다', () => {
+    const withHtml = buildMailDocument({ htmlBody: '<p>본문</p>', textBody: '계약', textHighlights: [[0, 2]] })
+    expect(withHtml).not.toContain('<mark>')
+    expect(buildMailDocument({ htmlBody: null, textBody: 'a < b', textHighlights: null })).toContain(
+      '<div class="mail-text">a &lt; b</div>',
+    )
+  })
+
+  it('맞은 말의 모양은 문서 안 style 이 정한다 — 노랑 · 글자색 그대로 (디자인 원본 Search14)', () => {
+    expect(buildMailDocument({ htmlBody: null, textBody: '' })).toContain(
+      'mark{background:#FCE7A4;color:inherit;border-radius:0.125rem;padding:0 0.0625rem}',
+    )
+  })
+})
diff --git a/frontend/src/shared/utils/mail-html.ts b/frontend/src/shared/utils/mail-html.ts
index c51d483..d1b896b 100644
--- a/frontend/src/shared/utils/mail-html.ts
+++ b/frontend/src/shared/utils/mail-html.ts
@@ -11,6 +11,8 @@ import DOMPurify, { type Config, type DOMPurify as Purifier } from 'dompurify'
 
 import { MESSAGE_LARGE_FILE_TEXT } from '@/shared/constants/large-file'
 import { MAIL_IMAGE_PROXY_PATH } from '@/shared/constants/mail'
+import type { SearchRange } from '@/shared/types/mail'
+import { highlightSegments } from '@/shared/utils/search-highlight'
 
 /**
  * iframe 문서 안에만 적용하는 CSP.
@@ -166,6 +168,9 @@ const MAIL_FRAME_STYLE = [
   'pre{white-space:pre-wrap}',
   'blockquote{margin:0 0 0 0.25rem;padding-left:0.75rem;border-left:0.125rem solid #98A2B3;color:#4A5363}',
   '.mail-text{white-space:pre-wrap}',
+  // 검색에서 맞은 말 (14단계 — 서버가 정화한 HTML 의 글 조각에 넣은 <mark> · 글 본문은 아래 textHighlights).
+  // 짝: styles/tokens.css 의 --color-search-mark — 본문 틀은 화면의 변수를 읽지 못해 같은 값을 적는다, 한쪽을 고치면 둘 다
+  'mark{background:#FCE7A4;color:inherit;border-radius:0.125rem;padding:0 0.0625rem}',
   // 대용량 첨부 덩이를 접는 줄 (11단계 — 디자인 원본 MailReadLargeFiles: 높이 40 · 12.5px · 바탕 #F6F7F9 · 펼치기 #0A5F67).
   // 스크립트 없이 details · summary 로 열고 닫는다 — 접힌 동안은 "(접어 둠) — …" 와 「펼치기」, 펼치면 「접기」
   'details.ara-large-files{margin:0.875rem 0}',
@@ -234,6 +239,18 @@ export interface MailBodySource {
    * 대용량 첨부 덩이를 접는다 (11단계 — 읽기 화면이 첨부 칸에 그 파일을 보일 때). 인쇄 화면은 접지 않는다(종이에는 주소가 있어야 한다)
    */
   foldLargeFiles?: boolean
+  /**
+   * 글 본문(textBody)의 검색에서 맞은 곳 (14단계 — 검색 결과에서 연 메일의 searchHighlight.textBody). 글 본문을 보일 때만 <mark> 로 그린다 —
+   * 서식 본문은 서버가 이미 맞은 글 조각에 <mark> 를 넣었다
+   */
+  textHighlights?: readonly SearchRange[] | null
+}
+
+/** 글 본문 → 이스케이프한 HTML — 맞은 곳은 <mark> 로 */
+function textBodyHtml(textBody: string, highlights: readonly SearchRange[] | null | undefined): string {
+  return highlightSegments(textBody, highlights)
+    .map((segment) => (segment.mark ? `<mark>${escapeHtml(segment.text)}</mark>` : escapeHtml(segment.text)))
+    .join('')
 }
 
 /** 이 화면의 출처 — 브라우저가 아니면 빈 글 (CSP 는 'self' 로 연다 — mailFrameCspImagesShown) */
@@ -265,7 +282,7 @@ export function buildMailDocument(source: MailBodySource): string {
   const content =
     html !== null
       ? sanitizeMailHtml(html.trim(), { imagesShown })
-      : `<div class="mail-text">${escapeHtml(source.textBody ?? '')}</div>`
+      : `<div class="mail-text">${textBodyHtml(source.textBody ?? '', source.textHighlights)}</div>`
   const csp = imagesShown ? mailFrameCspImagesShown(source.origin ?? currentOrigin()) : MAIL_FRAME_CSP
 
   return [
diff --git a/frontend/src/shared/utils/mail-list-row.ts b/frontend/src/shared/utils/mail-list-row.ts
index 736d361..f6b1d1a 100644
--- a/frontend/src/shared/utils/mail-list-row.ts
+++ b/frontend/src/shared/utils/mail-list-row.ts
@@ -6,6 +6,7 @@
 
 import {
   DRAFT_NO_RECIPIENTS,
+  MAIL_NO_SENDER,
   MAIL_SEARCH_TEXT,
   OUTGOING_MAILBOX_ROLES,
 } from '@/shared/constants/mail'
@@ -16,7 +17,6 @@ import { displayName, draftRecipientNames, summarizeRecipients } from '@/shared/
 import { messagePendingSend } from '@/shared/utils/pending-send'
 
 const NO_RECIPIENTS = '받는 사람 없음'
-const NO_SENDER = '(보낸 사람 없음)'
 
 export interface RowContext {
   /** 행의 메일함 역할 — 메일함 목록 · 한 메일함 안의 검색은 그 메일함, 전체 메일함 검색은 그 메일의 메일함 */
@@ -72,7 +72,7 @@ export function rowWho(message: Pick<MessageSummary, 'from' | 'to'>, context: Ro
     const prefixed = view === 'split' || mixed
     return { text: prefixed ? `${MAIL_SEARCH_TEXT.recipientPrefix}${recipients}` : recipients, placeholder: false }
   }
-  return { text: displayName(message.from) || NO_SENDER, placeholder: false }
+  return { text: displayName(message.from) || MAIL_NO_SENDER, placeholder: false }
 }
 
 /** 표 머리의 보낸 사람 칸 이름 — 보낸편지함 · 임시보관함(한 메일함일 때)은 받는 사람 */
diff --git a/frontend/src/shared/utils/mail-list-source.spec.ts b/frontend/src/shared/utils/mail-list-source.spec.ts
index 8b53b9c..51eaa81 100644
--- a/frontend/src/shared/utils/mail-list-source.spec.ts
+++ b/frontend/src/shared/utils/mail-list-source.spec.ts
@@ -4,10 +4,12 @@ import { SEARCH_SCOPE_ALL } from '@/shared/constants/mail'
 import {
   exceedsSearchWords,
   isAllMailboxSearch,
+  isConversationSource,
   isSearchRouteName,
   listKeyOf,
   listLocationOf,
   listQueryOf,
+  mailboxListIdOf,
   messageLocationOf,
   normalizeSearchText,
   sameListSource,
@@ -93,3 +95,99 @@ describe('mail-list-source (보이는 목록의 출처)', () => {
     expect(exceedsSearchWords('  "회의를   잡겠습니다"  ')).toBe(false)
   })
 })
+
+describe('mail-list-source — 조건 검색 (14단계)', () => {
+  const CONDITIONS = {
+    from: '이도윤',
+    to: '',
+    subject: '',
+    body: '',
+    since: '2026-10-06',
+    until: '2026-11-06',
+    hasAttachment: true,
+  }
+  const WITH_CONDITIONS: MailListSource = { kind: 'search', q: '계약', scope: 'inbox', conditions: CONDITIONS }
+  const CONDITIONS_ONLY: MailListSource = { kind: 'search', q: '', scope: SEARCH_SCOPE_ALL, conditions: CONDITIONS }
+
+  it('주소에 조건을 싣는다 — 검색어가 없으면 q 를 뺀다. 결과에서 연 메일의 주소도 같은 쿼리', () => {
+    expect(listLocationOf(WITH_CONDITIONS)).toEqual({
+      name: 'mail-search',
+      query: {
+        q: '계약',
+        in: 'inbox',
+        from: '이도윤',
+        since: '2026-10-06',
+        until: '2026-11-06',
+        attachment: '1',
+      },
+    })
+    expect(listLocationOf(CONDITIONS_ONLY)).toEqual({
+      name: 'mail-search',
+      query: { in: 'all', from: '이도윤', since: '2026-10-06', until: '2026-11-06', attachment: '1' },
+    })
+    expect(messageLocationOf(CONDITIONS_ONLY, 'm1')).toEqual({
+      name: 'mail-search-message',
+      params: { messageId: 'm1' },
+      query: { in: 'all', from: '이도윤', since: '2026-10-06', until: '2026-11-06', attachment: '1' },
+    })
+  })
+
+  it('주소 → 출처 — 검색어가 없어도 조건이 있으면 검색이다. 조건이 없으면 conditions 를 두지 않는다', () => {
+    expect(
+      searchSourceFromQuery({ in: 'all', from: '이도윤', since: '2026-10-06', until: '2026-11-06', attachment: '1' }),
+    ).toEqual(CONDITIONS_ONLY)
+    expect(searchSourceFromQuery({ q: '회의', in: 'inbox', since: 'oops' })).toEqual({
+      kind: 'search',
+      q: '회의',
+      scope: 'inbox',
+    })
+    expect(searchSourceFromQuery({ in: 'all', attachment: '0' })).toBeNull()
+  })
+
+  it('API 쿼리 — 검색어 · 메일함 · 조건(날짜는 지역 0시의 UTC · 끝 날짜는 다음 날 0시)', () => {
+    expect(listQueryOf(WITH_CONDITIONS)).toEqual({
+      q: '계약',
+      mailboxId: 'inbox',
+      from: '이도윤',
+      after: new Date(2026, 9, 6).toISOString(),
+      before: new Date(2026, 10, 7).toISOString(),
+      hasAttachment: 'true',
+    })
+    expect(listQueryOf(CONDITIONS_ONLY)).not.toHaveProperty('q')
+  })
+
+  it('같은 목록인지 · 목록 키 — 조건까지 같아야 같다', () => {
+    const plain: MailListSource = { kind: 'search', q: '계약', scope: 'inbox' }
+    expect(sameListSource(WITH_CONDITIONS, plain)).toBe(false)
+    expect(sameListSource(WITH_CONDITIONS, { ...WITH_CONDITIONS, conditions: { ...CONDITIONS } })).toBe(true)
+    expect(sameListSource(plain, { ...plain, conditions: { ...CONDITIONS, from: '', since: null, until: null, hasAttachment: false } })).toBe(true)
+    expect(listKeyOf(WITH_CONDITIONS)).not.toBe(listKeyOf(plain))
+    expect(listKeyOf(plain)).toBe('search:inbox:계약')
+  })
+})
+
+describe('mail-list-source — 대화로 묶은 메일함 (14단계)', () => {
+  const THREADS: MailListSource = { kind: 'conversations', mailboxId: 'inbox' }
+
+  it('주소는 메일함 목록과 같다 — 줄을 누르면 그 메일함 안의 메일 주소', () => {
+    expect(listLocationOf(THREADS)).toEqual(listLocationOf(INBOX))
+    expect(messageLocationOf(THREADS, 'm1')).toEqual(messageLocationOf(INBOX, 'm1'))
+  })
+
+  it('가리키는 메일함은 그 메일함 — 메일함 목록처럼 다룬다(같은 대화 칸의 링크 · 다시 받기)', () => {
+    expect(scopeMailboxIdOf(THREADS)).toBe('inbox')
+    expect(mailboxListIdOf(THREADS)).toBe('inbox')
+    expect(mailboxListIdOf(INBOX)).toBe('inbox')
+    expect(mailboxListIdOf(SEARCH_INBOX)).toBeNull()
+    expect(isConversationSource(THREADS)).toBe(true)
+    expect(isConversationSource(INBOX)).toBe(false)
+    expect(isAllMailboxSearch(THREADS)).toBe(false)
+  })
+
+  it('같은 메일함이어도 묶은 목록과 메일 목록은 다른 목록이다 — 켜고 끄면 고른 것을 풀고 처음 쪽부터 받는다', () => {
+    expect(sameListSource(THREADS, { kind: 'conversations', mailboxId: 'inbox' })).toBe(true)
+    expect(sameListSource(THREADS, { kind: 'conversations', mailboxId: 'sent' })).toBe(false)
+    expect(sameListSource(THREADS, INBOX)).toBe(false)
+    expect(listKeyOf(THREADS)).not.toBe(listKeyOf(INBOX))
+  })
+})
diff --git a/frontend/src/shared/utils/mail-list-source.ts b/frontend/src/shared/utils/mail-list-source.ts
index c56068e..582c91c 100644
--- a/frontend/src/shared/utils/mail-list-source.ts
+++ b/frontend/src/shared/utils/mail-list-source.ts
@@ -1,10 +1,26 @@
-// 보이는 메일 목록의 출처 — 메일함 하나 · 검색 결과 · 예약됨(9단계) (순수 함수만 둔다)
-// 목록 · 표 · 읽기 화면 · 여러 통 처리는 출처를 몰라도 되게 이 함수들로 쿼리 · 주소를 만든다 (계약 2절 "검색" · "보내기 취소 · 예약 발송").
+// 보이는 메일 목록의 출처 — 메일함 하나 · 대화로 묶은 메일함(14단계) · 검색 결과 · 예약됨(9단계) (순수 함수만 둔다)
+// 목록 · 표 · 읽기 화면 · 여러 통 처리는 출처를 몰라도 되게 이 함수들로 쿼리 · 주소를 만든다 (계약 2절 "검색" · "보내기 취소 · 예약 발송" · "대화 — 14단계").
+// 대화로 묶은 메일함은 주소가 메일함 목록과 같다 — 묶을지는 사용자 설정(groupByConversation)이 정하고, 줄을 누르면 그 메일함의 마지막 메일을 연다.
 
-import type { LocationQuery, LocationQueryValue, RouteLocationRaw } from 'vue-router'
+import type { LocationQuery, RouteLocationRaw } from 'vue-router'
 
-import { MAIL_SEARCH_MAX_LENGTH, MAIL_SEARCH_MAX_WORDS, SEARCH_SCOPE_ALL } from '@/shared/constants/mail'
+import { MAIL_SEARCH_MAX_WORDS, SEARCH_SCOPE_ALL } from '@/shared/constants/mail'
 import type { MessageListQuery } from '@/shared/types/mail'
+import {
+  countSearchWords,
+  exceedsCombinedSearchWords,
+  firstQueryValue,
+  hasSearchConditions,
+  normalizeSearchText,
+  sameSearchConditions,
+  searchConditionsFromRoute,
+  searchConditionsKey,
+  searchConditionsParams,
+  searchConditionsRouteQuery,
+  type SearchConditions,
+} from '@/shared/utils/mail-search'
+
+export { normalizeSearchText } from '@/shared/utils/mail-search'
 
 export interface MailboxListSource {
   kind: 'mailbox'
@@ -13,10 +29,12 @@ export interface MailboxListSource {
 
 export interface SearchListSource {
   kind: 'search'
-  /** 앞뒤 공백을 뺀 검색어 */
+  /** 앞뒤 공백을 뺀 검색어 — 조건만으로 찾으면 빈 글 (14단계) */
   q: string
   /** 찾을 곳 — 메일함 id 또는 전체(SEARCH_SCOPE_ALL) */
   scope: string
+  /** 조건 (14단계 — 보낸 사람 · 받는 사람 · 제목 · 내용 · 기간 · 첨부). 없으면 검색어로만 찾는다 (조건이 없으면 두지 않는다 — searchSourceOf) */
+  conditions?: SearchConditions
 }
 
 /** 예약한 메일 — GET /scheduled-messages (보낼 시각 차례). 고르기 · 여러 통 처리는 없다 (디자인 README "9단계") */
@@ -24,10 +42,16 @@ export interface ScheduledListSource {
   kind: 'scheduled'
 }
 
+/** 대화로 묶은 메일함 — GET /conversations?mailboxId= (14단계). 한 줄이 그 메일함의 대화 하나다 */
+export interface ConversationListSource {
+  kind: 'conversations'
+  mailboxId: string
+}
+
 /** GET /messages 로 받는 목록 — 메일함 · 검색 */
 export type MessageListSource = MailboxListSource | SearchListSource
 
-export type MailListSource = MessageListSource | ScheduledListSource
+export type MailListSource = MessageListSource | ScheduledListSource | ConversationListSource
 
 /** 검색 결과 · 검색 결과에서 연 메일의 라우트 이름 (router/index.ts) */
 export const MAIL_SEARCH_ROUTE = 'mail-search'
@@ -50,20 +74,40 @@ export function isScheduledRouteName(name: unknown): boolean {
 export function sameListSource(a: MailListSource | null, b: MailListSource | null): boolean {
   if (!a || !b) return a === b
   if (a.kind === 'mailbox' && b.kind === 'mailbox') return a.mailboxId === b.mailboxId
-  if (a.kind === 'search' && b.kind === 'search') return a.q === b.q && a.scope === b.scope
+  if (a.kind === 'conversations' && b.kind === 'conversations') return a.mailboxId === b.mailboxId
+  if (a.kind === 'search' && b.kind === 'search') {
+    return a.q === b.q && a.scope === b.scope && sameSearchConditions(a.conditions, b.conditions)
+  }
   return a.kind === 'scheduled' && b.kind === 'scheduled'
 }
 
-/** GET /messages 쿼리 — 메일함은 mailboxId, 검색은 q (+ 한 메일함에서 찾으면 mailboxId) */
-export function listQueryOf(source: MessageListSource): Pick<MessageListQuery, 'mailboxId' | 'q'> {
-  if (source.kind === 'mailbox') return { mailboxId: source.mailboxId }
-  return source.scope === SEARCH_SCOPE_ALL ? { q: source.q } : { q: source.q, mailboxId: source.scope }
+/** 대화로 묶은 메일함인가 (14단계) */
+export function isConversationSource(source: MailListSource | null | undefined): source is ConversationListSource {
+  return source?.kind === 'conversations'
 }
 
-/** 출처가 가리키는 메일함 하나 — 메일함 목록이거나 한 메일함 안의 검색. 전체 메일함 검색 · 예약됨이면 null */
+/**
+ * 메일함 하나의 목록(묶었든 아니든)이면 그 메일함 id — 검색 결과 · 예약됨이면 null.
+ * "그 메일함에 든 메일이면 이 목록 안에서 연다" · "그 메일함을 보고 있으면 다시 받는다"를 가르는 데 쓴다
+ */
+export function mailboxListIdOf(source: MailListSource | null | undefined): string | null {
+  return source?.kind === 'mailbox' || source?.kind === 'conversations' ? source.mailboxId : null
+}
+
+/** GET /messages 쿼리 — 메일함은 mailboxId, 검색은 q (+ 한 메일함에서 찾으면 mailboxId) + 조건(14단계 — 빈 칸은 넣지 않는다) */
+export function listQueryOf(source: MessageListSource): Omit<MessageListQuery, 'cursor' | 'limit'> {
+  if (source.kind === 'mailbox') return { mailboxId: source.mailboxId }
+  return {
+    ...(source.q ? { q: source.q } : {}),
+    ...(source.scope === SEARCH_SCOPE_ALL ? {} : { mailboxId: source.scope }),
+    ...searchConditionsParams(source.conditions),
+  }
+}
+
+/** 출처가 가리키는 메일함 하나 — 메일함 목록(묶었든 아니든)이거나 한 메일함 안의 검색. 전체 메일함 검색 · 예약됨이면 null */
 export function scopeMailboxIdOf(source: MailListSource | null): string | null {
   if (!source || source.kind === 'scheduled') return null
-  if (source.kind === 'mailbox') return source.mailboxId
+  if (source.kind === 'mailbox' || source.kind === 'conversations') return source.mailboxId
   return source.scope === SEARCH_SCOPE_ALL ? null : source.scope
 }
 
@@ -80,56 +124,67 @@ export function isScheduledSource(source: MailListSource | null): boolean {
 /** 목록마다 다른 키 — 표 위치 기억 등 */
 export function listKeyOf(source: MailListSource): string {
   if (source.kind === 'scheduled') return 'scheduled'
-  return source.kind === 'mailbox' ? `mailbox:${source.mailboxId}` : `search:${source.scope}:${source.q}`
+  if (source.kind === 'mailbox') return `mailbox:${source.mailboxId}`
+  if (source.kind === 'conversations') return `conversations:${source.mailboxId}`
+  const conditions = searchConditionsKey(source.conditions)
+  return conditions ? `search:${source.scope}:${source.q}:${conditions}` : `search:${source.scope}:${source.q}`
 }
 
-/** 검색 주소의 쿼리 — /mail/search?q=…&in=<메일함 id | all> */
+/**
+ * 검색 주소의 쿼리 — /mail/search?q=…&in=<메일함 id | all> + 조건(14단계 — mail-search.ts 의 searchConditionsRouteQuery).
+ * 검색어 없이 조건만으로 찾으면 q 를 뺀다
+ */
 export function searchRouteQuery(source: SearchListSource): Record<string, string> {
-  return { q: source.q, in: source.scope }
+  return {
+    ...(source.q ? { q: source.q } : {}),
+    in: source.scope,
+    ...searchConditionsRouteQuery(source.conditions),
+  }
 }
 
-/** 목록 화면 주소 */
+/** 검색 출처 — 조건이 없으면 conditions 를 두지 않는다 (같은 검색은 늘 같은 모양) */
+export function searchSourceOf(q: string, scope: string, conditions?: SearchConditions | null): SearchListSource {
+  return conditions && hasSearchConditions(conditions)
+    ? { kind: 'search', q, scope, conditions }
+    : { kind: 'search', q, scope }
+}
+
+/** 목록 화면 주소 — 대화로 묶은 메일함도 메일함 주소다 */
 export function listLocationOf(source: MailListSource): RouteLocationRaw {
-  if (source.kind === 'mailbox') return { name: 'mail-mailbox', params: { mailboxId: source.mailboxId } }
+  if (source.kind === 'mailbox' || source.kind === 'conversations') {
+    return { name: 'mail-mailbox', params: { mailboxId: source.mailboxId } }
+  }
   if (source.kind === 'scheduled') return { name: MAIL_SCHEDULED_ROUTE }
   return { name: MAIL_SEARCH_ROUTE, query: searchRouteQuery(source) }
 }
 
 /** 목록에서 연 메일의 주소 — 검색 결과에서 열면 /mail/search/<메일 id>?q=…&in=…, 예약됨은 /mail/scheduled/<메일 id> */
 export function messageLocationOf(source: MailListSource, messageId: string): RouteLocationRaw {
-  if (source.kind === 'mailbox') {
+  if (source.kind === 'mailbox' || source.kind === 'conversations') {
     return { name: 'mail-message', params: { mailboxId: source.mailboxId, messageId } }
   }
   if (source.kind === 'scheduled') return { name: MAIL_SCHEDULED_MESSAGE_ROUTE, params: { messageId } }
   return { name: MAIL_SEARCH_MESSAGE_ROUTE, params: { messageId }, query: searchRouteQuery(source) }
 }
 
-function firstValue(value: LocationQueryValue | LocationQueryValue[] | undefined): string {
-  const first = Array.isArray(value) ? value[0] : value
-  return typeof first === 'string' ? first : ''
-}
-
-/** 앞 반쪽만 남은 서로게이트(이모지를 가운데서 자름) — 주소에 넣을 수 없다 (encodeURIComponent 가 실패한다) */
-const TRAILING_HIGH_SURROGATE = /[\uD800-\uDBFF]$/
-
 /**
- * 검색어 다듬기 — 앞뒤 공백을 빼고 서버 한도(200자 — JS 문자열 길이, 입력칸 maxlength 와 같다)에서 자른다.
- * 이모지를 가운데서 자르게 되면 그 글자를 뺀다
+ * 검색어와 조건 넷을 합친 낱말이 서버 한도(8개)를 넘는 검색인가 (14단계) — 검색 칸 · [조건]은 보내기 전에 막지만 손으로 고친 주소로 들어올 수 있다.
+ * 목록 스토어는 묻지 않고(400 이 될 것이라), 목록 틀은 까닭을 보이고, 읽기 화면은 강조 쿼리를 싣지 않는다
  */
-export function normalizeSearchText(text: string): string {
-  const cut = text.trim().slice(0, MAIL_SEARCH_MAX_LENGTH)
-  return (TRAILING_HIGH_SURROGATE.test(cut) ? cut.slice(0, -1) : cut).trim()
+export function isSearchTooLong(source: MailListSource | null | undefined): boolean {
+  return source?.kind === 'search' && exceedsCombinedSearchWords(source.q, source.conditions)
 }
 
 /** 서버가 받는 낱말 수를 넘는가 — 띄어쓰기로 나눈 조각을 센다 (따옴표와 상관없이, 서버와 같다) */
 export function exceedsSearchWords(text: string): boolean {
-  return text.split(/\s+/u).filter((word) => word !== '').length > MAIL_SEARCH_MAX_WORDS
+  return countSearchWords(text) > MAIL_SEARCH_MAX_WORDS
 }
 
-/** 주소의 검색 쿼리 → 출처. 검색어가 없으면 null (범위가 비었으면 전체) */
+/** 주소의 검색 쿼리 → 출처. 검색어도 조건도 없으면 null (범위가 비었으면 전체) */
 export function searchSourceFromQuery(query: LocationQuery): SearchListSource | null {
-  const q = normalizeSearchText(firstValue(query.q))
-  if (!q) return null
-  const scope = firstValue(query.in).trim()
-  return { kind: 'search', q, scope: scope || SEARCH_SCOPE_ALL }
+  const q = normalizeSearchText(firstQueryValue(query.q))
+  const conditions = searchConditionsFromRoute(query)
+  if (!q && !hasSearchConditions(conditions)) return null
+  const scope = firstQueryValue(query.in).trim()
+  return searchSourceOf(q, scope || SEARCH_SCOPE_ALL, conditions)
 }
diff --git a/frontend/src/shared/utils/mail-search.spec.ts b/frontend/src/shared/utils/mail-search.spec.ts
new file mode 100644
index 0000000..4525653
--- /dev/null
+++ b/frontend/src/shared/utils/mail-search.spec.ts
@@ -0,0 +1,284 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  combinedSearchWords,
+  exceedsCombinedSearchWords,
+  hasSearchConditions,
+  isReversedPeriod,
+  isSearchDay,
+  messageHighlightKey,
+  messageHighlightQueryOf,
+  NO_SEARCH_CONDITIONS,
+  normalizeSearchConditions,
+  periodOf,
+  periodRange,
+  sameSearchConditions,
+  searchConditionsFromRoute,
+  searchConditionsKey,
+  searchConditionsParams,
+  searchConditionsRouteQuery,
+  searchConditionsSummary,
+  skipsBodySearch,
+  type SearchConditions,
+} from './mail-search'
+
+// 조건 검색 (14단계 — 계약 2절 "검색 — 14단계" · 디자인 README 「14단계 › 검색 · 조건 검색 · 강조」)
+// 날짜는 브라우저 시간대의 날짜다 — 기대값도 지역 시각(new Date(년, 월, 일))으로 만든다 (TZ=UTC · KST 모두 같은 답)
+
+function conditions(partial: Partial<SearchConditions> = {}): SearchConditions {
+  return { ...NO_SEARCH_CONDITIONS, ...partial }
+}
+
+/** 지역 날짜 0시의 UTC ISO — 화면이 보내는 after · before 와 같은 방법 */
+const localMidnightIso = (year: number, month: number, day: number) => new Date(year, month - 1, day).toISOString()
+
+describe('조건 다듬기 · 같은 조건', () => {
+  it('글 칸은 검색어처럼(앞뒤 공백 · 200자), 날짜는 있는 날짜만, 첨부는 true 만', () => {
+    expect(
+      normalizeSearchConditions({
+        from: '  이도윤 ',
+        subject: '가'.repeat(250),
+        since: '2026-02-30',
+        until: '2026-11-05',
+        hasAttachment: true,
+      }),
+    ).toEqual({
+      from: '이도윤',
+      to: '',
+      subject: '가'.repeat(200),
+      body: '',
+      since: null,
+      until: '2026-11-05',
+      hasAttachment: true,
+    })
+    expect(normalizeSearchConditions(null)).toEqual(NO_SEARCH_CONDITIONS)
+    expect(normalizeSearchConditions({ since: '2026-1-5' }).since).toBeNull()
+  })
+
+  it('날짜는 1970-01-01 ~ 9999-12-30 안의 있는 날짜만 — 밖의 날짜는 그 날짜만 버린다', () => {
+    expect(isSearchDay('1970-01-01')).toBe(true)
+    expect(isSearchDay('9999-12-30')).toBe(true)
+    expect(isSearchDay('1969-12-31')).toBe(false)
+    // 9999-12-31 의 다음 날 0시는 10000년 — 서버가 받지 않는다
+    expect(isSearchDay('9999-12-31')).toBe(false)
+    expect(isSearchDay('10000-01-01')).toBe(false)
+    expect(isSearchDay('2024-02-29')).toBe(true)
+    expect(isSearchDay('2026-02-29')).toBe(false)
+    expect(isSearchDay('')).toBe(false)
+    expect(normalizeSearchConditions({ since: '1969-12-31', until: '2026-11-01' })).toEqual(
+      conditions({ until: '2026-11-01' }),
+    )
+    expect(normalizeSearchConditions({ since: '2026-11-01', until: '9999-12-31' })).toEqual(
+      conditions({ since: '2026-11-01' }),
+    )
+  })
+
+  it('시작이 끝보다 늦은 기간은 통째로 버린다 — 같은 날은 그 하루', () => {
+    expect(normalizeSearchConditions({ since: '2026-11-06', until: '2026-10-01', hasAttachment: true })).toEqual(
+      conditions({ hasAttachment: true }),
+    )
+    expect(normalizeSearchConditions({ since: '2026-11-06', until: '2026-11-06' })).toEqual(
+      conditions({ since: '2026-11-06', until: '2026-11-06' }),
+    )
+  })
+
+  it('조건이 하나라도 있는가 · 같은 조건인가 — 없는 조건과 빈 조건은 같다', () => {
+    expect(hasSearchConditions(null)).toBe(false)
+    expect(hasSearchConditions(NO_SEARCH_CONDITIONS)).toBe(false)
+    expect(hasSearchConditions(conditions({ hasAttachment: true }))).toBe(true)
+    expect(hasSearchConditions(conditions({ until: '2026-11-05' }))).toBe(true)
+    expect(sameSearchConditions(undefined, NO_SEARCH_CONDITIONS)).toBe(true)
+    expect(sameSearchConditions(conditions({ from: '이도윤' }), conditions({ from: '이도윤' }))).toBe(true)
+    expect(sameSearchConditions(conditions({ from: '이도윤' }), conditions({ to: '이도윤' }))).toBe(false)
+    expect(searchConditionsKey(NO_SEARCH_CONDITIONS)).toBe('')
+  })
+})
+
+describe('화면 주소 ↔ 조건', () => {
+  it('주소에는 걸린 칸만 싣는다 — from · to · subject · body · since · until · attachment=1', () => {
+    const value = conditions({
+      from: '이도윤',
+      body: '계약 갱신',
+      since: '2026-10-06',
+      until: '2026-11-06',
+      hasAttachment: true,
+    })
+    expect(searchConditionsRouteQuery(value)).toEqual({
+      from: '이도윤',
+      body: '계약 갱신',
+      since: '2026-10-06',
+      until: '2026-11-06',
+      attachment: '1',
+    })
+    expect(searchConditionsRouteQuery(NO_SEARCH_CONDITIONS)).toEqual({})
+    expect(searchConditionsFromRoute(searchConditionsRouteQuery(value))).toEqual(value)
+  })
+
+  it('주소의 모르는 값 · 틀린 날짜는 없는 것으로 본다 — 같은 이름이 여럿이면 첫 것', () => {
+    expect(
+      searchConditionsFromRoute({
+        from: ['  이도윤 ', '무시'],
+        since: 'yesterday',
+        until: '2026-13-01',
+        attachment: 'yes',
+      }),
+    ).toEqual(conditions({ from: '이도윤' }))
+    expect(searchConditionsFromRoute({ attachment: '1' }).hasAttachment).toBe(true)
+  })
+
+  it('손으로 고친 주소도 패널과 같은 검사를 거친다 — 거꾸로 된 기간 · 고를 수 없는 날짜는 버리고, 글 칸은 200자에서 자른다', () => {
+    expect(searchConditionsFromRoute({ since: '2026-11-06', until: '2026-10-01', subject: '견적' })).toEqual(
+      conditions({ subject: '견적' }),
+    )
+    expect(searchConditionsFromRoute({ since: '0999-01-01', until: '2026-11-01' })).toEqual(
+      conditions({ until: '2026-11-01' }),
+    )
+    expect(searchConditionsFromRoute({ body: `  ${'가'.repeat(201)}` }).body).toBe('가'.repeat(200))
+    // 낱말 수는 자르지 않는다 — 넘으면 목록이 찾지 않고 까닭을 보인다(exceedsCombinedSearchWords)
+    const many = searchConditionsFromRoute({ body: '하나 둘 셋 넷 다섯 여섯 일곱 여덟 아홉' })
+    expect(many.body).toBe('하나 둘 셋 넷 다섯 여섯 일곱 여덟 아홉')
+    expect(exceedsCombinedSearchWords('', many)).toBe(true)
+  })
+})
+
+describe('API 쿼리 · 읽기 화면의 강조 쿼리', () => {
+  it('기간은 시작 날짜 0시 · 끝 날짜 다음 날 0시를 브라우저 시간대에서 UTC 로 — 첨부는 hasAttachment=true', () => {
+    expect(
+      searchConditionsParams(
+        conditions({ to: 'ara.kim', subject: '견적', since: '2026-10-06', until: '2026-11-06', hasAttachment: true }),
+      ),
+    ).toEqual({
+      to: 'ara.kim',
+      subject: '견적',
+      after: localMidnightIso(2026, 10, 6),
+      before: localMidnightIso(2026, 11, 7),
+      hasAttachment: 'true',
+    })
+    // 시작만 · 끝만도 된다
+    expect(searchConditionsParams(conditions({ until: '2026-12-31' }))).toEqual({
+      before: localMidnightIso(2027, 1, 1),
+    })
+    expect(searchConditionsParams(undefined)).toEqual({})
+  })
+
+  it('읽기 화면에는 검색어와 글 칸 넷만 넘긴다 — 기간 · 첨부는 서버가 받지 않는다', () => {
+    const value = conditions({ from: '이도윤', body: '계약', since: '2026-10-06', hasAttachment: true })
+    expect(messageHighlightQueryOf('갱신', value)).toEqual({ q: '갱신', from: '이도윤', body: '계약' })
+    expect(messageHighlightQueryOf('', conditions({ subject: '견적' }))).toEqual({ subject: '견적' })
+    expect(messageHighlightQueryOf('', conditions({ since: '2026-10-06', hasAttachment: true }))).toBeNull()
+    expect(messageHighlightKey(null)).toBe('')
+    expect(messageHighlightKey({ q: '계약' })).not.toBe(messageHighlightKey({ subject: '계약' }))
+  })
+})
+
+describe('합친 낱말 수 — 검색어와 조건 넷을 합쳐 8개까지 (서버와 같은 기준)', () => {
+  it('띄어쓰기로 나눈 조각을 칸마다 세어 더한다', () => {
+    const value = conditions({ from: '이도윤', to: '김아라 박지훈', subject: '"계약 갱신"', body: '단가' })
+    expect(combinedSearchWords('견적 회의', value)).toBe(8)
+    expect(exceedsCombinedSearchWords('견적 회의', value)).toBe(false)
+    expect(exceedsCombinedSearchWords('견적 회의 일정', value)).toBe(true)
+    // 날짜 · 첨부는 낱말이 아니다
+    expect(combinedSearchWords('', conditions({ since: '2026-10-06', hasAttachment: true }))).toBe(0)
+  })
+})
+
+describe('기간 고르기', () => {
+  const today = new Date(2026, 10, 6, 15, 30)
+
+  it('최근 1주 · 1달 · 3달 · 1년은 그만큼 앞의 같은 날부터 오늘까지', () => {
+    expect(periodRange('week', today)).toEqual({ since: '2026-10-30', until: '2026-11-06' })
+    expect(periodRange('month', today)).toEqual({ since: '2026-10-06', until: '2026-11-06' })
+    expect(periodRange('quarter', today)).toEqual({ since: '2026-08-06', until: '2026-11-06' })
+    expect(periodRange('year', today)).toEqual({ since: '2025-11-06', until: '2026-11-06' })
+    expect(periodRange('all', today)).toEqual({ since: null, until: null })
+    expect(periodRange('custom', today)).toEqual({ since: null, until: null })
+  })
+
+  it('달은 그 달의 마지막 날을 넘지 않는다 — 3월 31일의 1달 앞은 2월 28일(윤년이면 29일)', () => {
+    expect(periodRange('month', new Date(2026, 2, 31)).since).toBe('2026-02-28')
+    expect(periodRange('month', new Date(2028, 2, 31)).since).toBe('2028-02-29')
+    expect(periodRange('quarter', new Date(2026, 4, 31)).since).toBe('2026-02-28')
+    expect(periodRange('week', new Date(2026, 0, 3)).since).toBe('2025-12-27')
+  })
+
+  it('두 날짜가 오늘 기준의 미리 정한 기간과 같으면 그 고르기, 아니면 날짜 고르기', () => {
+    expect(periodOf(null, null, today)).toBe('all')
+    expect(periodOf('2026-10-06', '2026-11-06', today)).toBe('month')
+    expect(periodOf('2026-10-30', '2026-11-06', today)).toBe('week')
+    // 다음 날 보면 같은 날짜도 날짜 고르기다
+    expect(periodOf('2026-10-06', '2026-11-06', new Date(2026, 10, 7))).toBe('custom')
+    expect(periodOf('2026-10-01', null, today)).toBe('custom')
+  })
+
+  it('시작이 끝보다 늦으면 거꾸로다 — 한쪽만 있으면 아니다', () => {
+    expect(isReversedPeriod('2026-11-05', '2026-10-01')).toBe(true)
+    expect(isReversedPeriod('2026-10-01', '2026-10-01')).toBe(false)
+    expect(isReversedPeriod('2026-11-05', null)).toBe(false)
+  })
+})
+
+describe('조건 줄 글', () => {
+  const today = new Date(2026, 10, 6)
+
+  it('"조건: 이도윤 님이 보낸 메일, 최근 1달, 첨부 있음" — 쉼표로 잇는다', () => {
+    expect(
+      searchConditionsSummary(
+        conditions({ from: '이도윤', since: '2026-10-06', until: '2026-11-06', hasAttachment: true }),
+        today,
+      ),
+    ).toBe('조건: 이도윤 님이 보낸 메일, 최근 1달, 첨부 있음')
+  })
+
+  it('받는 사람 · 제목 · 내용은 조사를 붙인다 — 날짜 고르기는 날짜로(같은 해면 끝 날짜의 해를 뺀다)', () => {
+    expect(
+      searchConditionsSummary(
+        conditions({ to: '김아라', subject: '견적', body: '계약서', since: '2026-10-01', until: '2026-11-05' }),
+        today,
+      ),
+    ).toBe('조건: 김아라 님이 받은 메일, 제목에 ‘견적’이 든 메일, 내용에 ‘계약서’가 든 메일, 2026. 10. 1.부터 11. 5.까지')
+    expect(searchConditionsSummary(conditions({ since: '2025-12-01', until: '2026-01-05' }), today)).toBe(
+      '조건: 2025. 12. 1.부터 2026. 1. 5.까지',
+    )
+    expect(searchConditionsSummary(conditions({ since: '2026-10-01' }), today)).toBe('조건: 2026. 10. 1.부터')
+    expect(searchConditionsSummary(conditions({ until: '2026-10-31' }), today)).toBe('조건: 2026. 10. 31.까지')
+    expect(searchConditionsSummary(NO_SEARCH_CONDITIONS, today)).toBe('')
+  })
+
+  it('하루만 고른 기간은 "2026. 11. 6. 하루" — 같은 날을 부터 · 까지로 두 번 쓰지 않는다', () => {
+    expect(searchConditionsSummary(conditions({ since: '2026-11-06', until: '2026-11-06' }), today)).toBe(
+      '조건: 2026. 11. 6. 하루',
+    )
+    expect(searchConditionsSummary(conditions({ since: '2025-12-31', until: '2025-12-31' }), today)).toBe(
+      '조건: 2025. 12. 31. 하루',
+    )
+  })
+
+  it('보낸 사람 · 받는 사람이 내 이름이나 주소면 "내가 보낸 메일" · "내가 받은 메일" — 대소문자 · 앞뒤 공백은 가리지 않고, 일부만 같으면 아니다', () => {
+    const me = { name: '김아라', email: 'ara.kim@arasystem.test' }
+    expect(searchConditionsSummary(conditions({ from: '김아라', to: ' ARA.KIM@arasystem.test ' }), today, me)).toBe(
+      '조건: 내가 보낸 메일, 내가 받은 메일',
+    )
+    expect(searchConditionsSummary(conditions({ from: 'ara.kim@arasystem.test' }), today, me)).toBe('조건: 내가 보낸 메일')
+    expect(searchConditionsSummary(conditions({ from: '아라', to: 'ara.kim' }), today, me)).toBe(
+      '조건: 아라 님이 보낸 메일, ara.kim 님이 받은 메일',
+    )
+    // 누구인지 모르면 지금 글 그대로
+    expect(searchConditionsSummary(conditions({ from: '김아라' }), today)).toBe('조건: 김아라 님이 보낸 메일')
+  })
+})
+
+describe('한 글자 안내 — 본문을 찾을 말이 한 글자뿐일 때만', () => {
+  it('검색어나 내용 조건이 모두 한 글자면 그렇다', () => {
+    expect(skipsBodySearch('김', NO_SEARCH_CONDITIONS)).toBe(true)
+    expect(skipsBodySearch('', conditions({ body: '가' }))).toBe(true)
+    expect(skipsBodySearch('김', conditions({ from: '이' }))).toBe(true)
+  })
+
+  it('두 글자 이상 낱말이 어느 칸에든 있거나, 본문을 찾을 말이 없으면 아니다', () => {
+    expect(skipsBodySearch('김 계약', NO_SEARCH_CONDITIONS)).toBe(false)
+    expect(skipsBodySearch('김', conditions({ subject: '견적' }))).toBe(false)
+    // 보낸 사람 · 제목 조건만이면 본문은 원래 찾지 않는다
+    expect(skipsBodySearch('', conditions({ from: '김' }))).toBe(false)
+    expect(skipsBodySearch('', conditions({ subject: '가', since: '2026-10-01' }))).toBe(false)
+  })
+})
diff --git a/frontend/src/shared/utils/mail-search.ts b/frontend/src/shared/utils/mail-search.ts
new file mode 100644
index 0000000..cca2620
--- /dev/null
+++ b/frontend/src/shared/utils/mail-search.ts
@@ -0,0 +1,336 @@
+// 조건 검색 (14단계 — 계약 2절 "검색 — 14단계" · 디자인 README 「14단계 › 검색 · 조건 검색 · 강조」) — 순수 함수만 둔다.
+// 조건 다듬기 · 화면 주소 ↔ 조건 · API 쿼리 · 읽기 화면의 강조 쿼리 · 합친 낱말 수 · 기간 고르기 · 조건 줄 글.
+// 검색 결과의 출처(검색어 · 범위 · 조건)는 mail-list-source.ts 가 이것으로 만든다.
+
+import type { LocationQuery, LocationQueryValue } from 'vue-router'
+
+import { MAIL_SEARCH_MAX_LENGTH, MAIL_SEARCH_MAX_WORDS } from '@/shared/constants/mail'
+import {
+  SEARCH_ATTACHMENT_ROUTE_VALUE,
+  SEARCH_CONDITION_LINE_TEXT,
+  SEARCH_DAY_MAX,
+  SEARCH_DAY_MIN,
+  SEARCH_HAS_ATTACHMENT_VALUE,
+  SEARCH_PERIOD_LABELS,
+  SEARCH_PERIOD_PRESETS,
+  SEARCH_ROUTE_PARAMS,
+  type SearchPeriod,
+  type SearchPeriodPreset,
+} from '@/shared/constants/mail-search'
+import type { MessageHighlightQuery, MessageListQuery } from '@/shared/types/mail'
+import { formatDate } from '@/shared/utils/format'
+import { subjectParticle } from '@/shared/utils/korean'
+import { endOfDayIso, startOfDayIso } from '@/shared/utils/mail-vacation'
+import { isSingleCharSearch, parseSearchTerms, SEARCH_WORD_SEPARATOR } from '@/shared/utils/search-match'
+
+/** 검색 칸 밖의 조건 — 글 칸은 비면 없는 것, 기간은 브라우저 시간대의 날짜(YYYY-MM-DD — 두 날짜 모두 든다) */
+export interface SearchConditions {
+  /** 보낸 사람(이름 · 주소) */
+  from: string
+  /** 받는 사람과 참조 */
+  to: string
+  subject: string
+  /** 본문 */
+  body: string
+  /** 시작 날짜 — 그날 0시부터. 없으면 null */
+  since: string | null
+  /** 끝 날짜 — 그날이 끝날 때까지(다음 날 0시 앞). 없으면 null */
+  until: string | null
+  hasAttachment: boolean
+}
+
+/** 글을 넣는 조건 칸 — q 와 같은 검사(200자 · 낱말 수)를 받는다 */
+export const SEARCH_CONDITION_TEXT_FIELDS = ['from', 'to', 'subject', 'body'] as const
+export type SearchConditionTextField = (typeof SEARCH_CONDITION_TEXT_FIELDS)[number]
+
+export const NO_SEARCH_CONDITIONS: Readonly<SearchConditions> = Object.freeze({
+  from: '',
+  to: '',
+  subject: '',
+  body: '',
+  since: null,
+  until: null,
+  hasAttachment: false,
+})
+
+/** 앞 반쪽만 남은 서로게이트(이모지를 가운데서 자름) — 주소에 넣을 수 없다 (encodeURIComponent 가 실패한다) */
+const TRAILING_HIGH_SURROGATE = /[\uD800-\uDBFF]$/
+/** 날짜 칸의 값 — <input type="date"> 와 같은 모양 */
+const DAY_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/
+
+/**
+ * 검색 글 다듬기 — 앞뒤 공백을 빼고 서버 한도(200자 — JS 문자열 길이, 입력칸 maxlength 와 같다)에서 자른다.
+ * 이모지를 가운데서 자르게 되면 그 글자를 뺀다. 검색어 · 조건 칸이 함께 쓴다
+ */
+export function normalizeSearchText(text: string): string {
+  const cut = text.trim().slice(0, MAIL_SEARCH_MAX_LENGTH)
+  return (TRAILING_HIGH_SURROGATE.test(cut) ? cut.slice(0, -1) : cut).trim()
+}
+
+/** 낱말 수 — 띄어쓰기로 나눈 조각 (따옴표와 상관없이, 서버의 countSearchWords 와 같다) */
+export function countSearchWords(text: string): number {
+  return text.split(SEARCH_WORD_SEPARATOR).filter((word) => word !== '').length
+}
+
+/**
+ * 찾을 수 있는 날짜(YYYY-MM-DD)인가 — 2월 30일처럼 넘어간 날짜 · 다른 모양 · SEARCH_DAY_MIN ~ SEARCH_DAY_MAX 밖은 아니다
+ * (9999-12-31 은 UTC 의 다음 날 0시가 10000년이라 서버가 받지 않는다 — 어느 시간대에서도 보낼 수 있는 범위만)
+ */
+export function isSearchDay(value: string): boolean {
+  return DAY_PATTERN.test(value) && value >= SEARCH_DAY_MIN && value <= SEARCH_DAY_MAX && startOfDayIso(value) !== null
+}
+
+function dayOrNull(value: string | null | undefined): string | null {
+  return typeof value === 'string' && isSearchDay(value) ? value : null
+}
+
+/**
+ * 조건 다듬기 — 글 칸은 검색어처럼, 날짜는 찾을 수 있는 날짜만(isSearchDay), 첨부는 true 만.
+ * 시작이 끝보다 늦은 기간(손으로 고친 주소)은 버린다 — 아무것도 맞지 않는 검색이 되지 않게 (패널은 보내기 전에 칸 아래에 알린다)
+ */
+export function normalizeSearchConditions(input: Partial<SearchConditions> | null | undefined): SearchConditions {
+  const since = dayOrNull(input?.since)
+  const until = dayOrNull(input?.until)
+  const reversed = since !== null && until !== null && since > until
+  return {
+    from: normalizeSearchText(input?.from ?? ''),
+    to: normalizeSearchText(input?.to ?? ''),
+    subject: normalizeSearchText(input?.subject ?? ''),
+    body: normalizeSearchText(input?.body ?? ''),
+    since: reversed ? null : since,
+    until: reversed ? null : until,
+    hasAttachment: input?.hasAttachment === true,
+  }
+}
+
+/** 조건이 하나라도 있는가 */
+export function hasSearchConditions(conditions: SearchConditions | null | undefined): boolean {
+  if (!conditions) return false
+  return (
+    SEARCH_CONDITION_TEXT_FIELDS.some((field) => conditions[field] !== '') ||
+    conditions.since !== null ||
+    conditions.until !== null ||
+    conditions.hasAttachment
+  )
+}
+
+/** 조건의 열쇠 — 같은 조건이면 같다. 조건이 없으면 빈 글 (목록 키 · 같은 검색인지 · 읽기 화면을 다시 받을지) */
+export function searchConditionsKey(conditions: SearchConditions | null | undefined): string {
+  if (!hasSearchConditions(conditions) || !conditions) return ''
+  return JSON.stringify([
+    conditions.from,
+    conditions.to,
+    conditions.subject,
+    conditions.body,
+    conditions.since,
+    conditions.until,
+    conditions.hasAttachment,
+  ])
+}
+
+export function sameSearchConditions(
+  a: SearchConditions | null | undefined,
+  b: SearchConditions | null | undefined,
+): boolean {
+  return searchConditionsKey(a) === searchConditionsKey(b)
+}
+
+/** 화면 주소의 조건 쿼리 — 빈 칸은 넣지 않는다 (/mail/search?q=…&in=…&from=…&since=2026-10-06&attachment=1) */
+export function searchConditionsRouteQuery(conditions: SearchConditions | null | undefined): Record<string, string> {
+  const query: Record<string, string> = {}
+  if (!conditions) return query
+  for (const field of SEARCH_CONDITION_TEXT_FIELDS) {
+    if (conditions[field]) query[SEARCH_ROUTE_PARAMS[field]] = conditions[field]
+  }
+  if (conditions.since) query[SEARCH_ROUTE_PARAMS.since] = conditions.since
+  if (conditions.until) query[SEARCH_ROUTE_PARAMS.until] = conditions.until
+  if (conditions.hasAttachment) query[SEARCH_ROUTE_PARAMS.attachment] = SEARCH_ATTACHMENT_ROUTE_VALUE
+  return query
+}
+
+/** 주소 쿼리의 첫 값 — 같은 이름이 여럿이면 첫 것, 글이 아니면 빈 글 */
+export function firstQueryValue(value: LocationQueryValue | LocationQueryValue[] | undefined): string {
+  const first = Array.isArray(value) ? value[0] : value
+  return typeof first === 'string' ? first : ''
+}
+
+/** 주소 쿼리 → 조건 (모르는 값 · 틀린 날짜는 없는 것으로) */
+export function searchConditionsFromRoute(query: LocationQuery): SearchConditions {
+  return normalizeSearchConditions({
+    from: firstQueryValue(query[SEARCH_ROUTE_PARAMS.from]),
+    to: firstQueryValue(query[SEARCH_ROUTE_PARAMS.to]),
+    subject: firstQueryValue(query[SEARCH_ROUTE_PARAMS.subject]),
+    body: firstQueryValue(query[SEARCH_ROUTE_PARAMS.body]),
+    since: firstQueryValue(query[SEARCH_ROUTE_PARAMS.since]) || null,
+    until: firstQueryValue(query[SEARCH_ROUTE_PARAMS.until]) || null,
+    hasAttachment: firstQueryValue(query[SEARCH_ROUTE_PARAMS.attachment]) === SEARCH_ATTACHMENT_ROUTE_VALUE,
+  })
+}
+
+/** API 쿼리의 조건 — 날짜는 브라우저 시간대의 시작 날짜 0시 · 끝 날짜 다음 날 0시를 UTC 로 (부재중과 같은 방식 — mail-vacation.ts) */
+export type SearchConditionParams = Pick<
+  MessageListQuery,
+  'from' | 'to' | 'subject' | 'body' | 'after' | 'before' | 'hasAttachment'
+>
+
+export function searchConditionsParams(conditions: SearchConditions | null | undefined): SearchConditionParams {
+  const params: SearchConditionParams = {}
+  if (!conditions) return params
+  for (const field of SEARCH_CONDITION_TEXT_FIELDS) {
+    if (conditions[field]) params[field] = conditions[field]
+  }
+  const after = conditions.since ? startOfDayIso(conditions.since) : null
+  const before = conditions.until ? endOfDayIso(conditions.until) : null
+  if (after) params.after = after
+  if (before) params.before = before
+  if (conditions.hasAttachment) params.hasAttachment = SEARCH_HAS_ATTACHMENT_VALUE
+  return params
+}
+
+/**
+ * 읽기 화면에 넘기는 강조 쿼리 — 검색어와 글 조건 넷만(기간 · 첨부는 서버가 받지 않는다). 빈 칸은 빼고, 하나도 없으면 null
+ */
+export function messageHighlightQueryOf(
+  q: string,
+  conditions: SearchConditions | null | undefined,
+): MessageHighlightQuery | null {
+  const query: MessageHighlightQuery = {}
+  if (q) query.q = q
+  for (const field of SEARCH_CONDITION_TEXT_FIELDS) {
+    const value = conditions?.[field] ?? ''
+    if (value) query[field] = value
+  }
+  return Object.keys(query).length > 0 ? query : null
+}
+
+/** 강조 쿼리의 열쇠 — 같은 쿼리로 받은 본문인지 본다 (없으면 빈 글) */
+export function messageHighlightKey(query: MessageHighlightQuery | null | undefined): string {
+  if (!query) return ''
+  return JSON.stringify([query.q ?? '', query.from ?? '', query.to ?? '', query.subject ?? '', query.body ?? ''])
+}
+
+/** 검색어와 조건 넷을 합친 낱말 수 — 서버 한도(8개)와 같은 기준 */
+export function combinedSearchWords(q: string, conditions: SearchConditions | null | undefined): number {
+  let total = countSearchWords(q)
+  for (const field of SEARCH_CONDITION_TEXT_FIELDS) total += countSearchWords(conditions?.[field] ?? '')
+  return total
+}
+
+export function exceedsCombinedSearchWords(q: string, conditions: SearchConditions | null | undefined): boolean {
+  return combinedSearchWords(q, conditions) > MAIL_SEARCH_MAX_WORDS
+}
+
+/**
+ * 한 글자 낱말뿐이라 본문을 찾지 않은 검색인가 (색인 방식 — 서버와 같은 판정, search-match.ts 의 isSingleCharSearch).
+ * 본문을 찾을 말(검색어나 내용 조건)이 있을 때만 그렇다 — 보낸 사람 · 받는 사람 · 제목 조건만이면 본문은 원래 찾지 않는다
+ */
+export function skipsBodySearch(q: string, conditions: SearchConditions | null | undefined): boolean {
+  const body = conditions?.body ?? ''
+  if (parseSearchTerms(q).length === 0 && parseSearchTerms(body).length === 0) return false
+  return isSingleCharSearch([q, conditions?.from ?? '', conditions?.to ?? '', conditions?.subject ?? '', body])
+}
+
+// ── 기간 고르기 ─────────────────────────────────────────────
+
+/** 오늘에서 그만큼 앞의 같은 날 — 달은 그 달의 마지막 날을 넘지 않는다(3월 31일의 1달 앞은 2월 28 · 29일) */
+function shiftBack(today: Date, preset: SearchPeriodPreset): Date {
+  const year = today.getFullYear()
+  const month = today.getMonth() - (preset.months ?? 0)
+  const lastDay = new Date(year, month + 1, 0).getDate()
+  const day = Math.min(today.getDate(), lastDay) - (preset.days ?? 0)
+  return new Date(year, month, day)
+}
+
+/** 미리 정한 기간의 두 날짜 — 그만큼 앞의 같은 날부터 오늘까지. 전체 기간 · 날짜 고르기는 날짜가 없다 */
+export function periodRange(period: SearchPeriod, today: Date): { since: string | null; until: string | null } {
+  const preset = SEARCH_PERIOD_PRESETS.find((candidate) => candidate.id === period)
+  if (!preset) return { since: null, until: null }
+  return { since: formatDate(shiftBack(today, preset)), until: formatDate(today) }
+}
+
+/** 두 날짜가 어떤 기간 고르기인가 — 둘 다 없으면 전체 기간, 오늘 기준의 미리 정한 기간과 같으면 그것, 아니면 날짜 고르기 */
+export function periodOf(since: string | null, until: string | null, today: Date): SearchPeriod {
+  if (since === null && until === null) return 'all'
+  const preset = SEARCH_PERIOD_PRESETS.find((candidate) => {
+    const range = periodRange(candidate.id, today)
+    return range.since === since && range.until === until
+  })
+  return preset?.id ?? 'custom'
+}
+
+/** 시작 날짜가 끝 날짜보다 늦은가 — 그러면 아무것도 맞지 않는다 (찾기 전에 막는다) */
+export function isReversedPeriod(since: string | null, until: string | null): boolean {
+  return since !== null && until !== null && since > until
+}
+
+// ── 조건 줄 글 ───────────────────────────────────────────────
+
+/** "2026. 10. 1." — withYear 가 아니면 "10. 1." */
+function periodDayText(day: string, withYear: boolean): string {
+  const match = DAY_PATTERN.exec(day)
+  if (!match) return day
+  const [year, month, date] = [Number(match[1]), Number(match[2]), Number(match[3])]
+  return withYear ? `${year}. ${month}. ${date}.` : `${month}. ${date}.`
+}
+
+function periodText(conditions: SearchConditions, today: Date): string | null {
+  const { since, until } = conditions
+  const period = periodOf(since, until, today)
+  if (period === 'all') return null
+  if (period !== 'custom') return SEARCH_PERIOD_LABELS[period]
+  if (since !== null && until !== null) {
+    // 하루만 고른 기간 — "2026. 11. 6. 하루" (같은 날을 부터 · 까지로 두 번 쓰지 않는다)
+    if (since === until) return SEARCH_CONDITION_LINE_TEXT.oneDay(periodDayText(since, true))
+    const sameYear = since.slice(0, 4) === until.slice(0, 4)
+    return SEARCH_CONDITION_LINE_TEXT.range(periodDayText(since, true), periodDayText(until, !sameYear))
+  }
+  if (since !== null) return SEARCH_CONDITION_LINE_TEXT.since(periodDayText(since, true))
+  return until !== null ? SEARCH_CONDITION_LINE_TEXT.until(periodDayText(until, true)) : null
+}
+
+/** 조건 줄의 "나" — 보낸 사람 · 받는 사람 칸의 값이 이 이름이나 주소면 "내가 보낸 메일" · "내가 받은 메일" */
+export interface SearchConditionsMe {
+  name?: string | null
+  email?: string | null
+}
+
+/** 견줄 모양 — 앞뒤 공백을 빼고 NFC · 소문자 (영문 이름 · 주소는 대소문자를 가리지 않는다) */
+function comparableName(value: string | null | undefined): string {
+  return (value ?? '').trim().normalize('NFC').toLowerCase()
+}
+
+/** 칸의 값이 나인가 — 내 이름이나 내 주소와 같을 때만(일부만 같으면 아니다) */
+function isMeValue(value: string, me: SearchConditionsMe | null | undefined): boolean {
+  if (!me) return false
+  const text = comparableName(value)
+  if (text === '') return false
+  return text === comparableName(me.email) || text === comparableName(me.name)
+}
+
+/**
+ * 결과 머리 아래 조건 줄 — "조건: 이도윤 님이 보낸 메일, 최근 1달, 첨부 있음" (쉼표로 잇는다 — 꼬리표 · 알약을 쓰지 않는다).
+ * 기간은 오늘 기준의 미리 정한 기간과 같으면 그 이름, 아니면 날짜(하루면 "… 하루"). 보낸 사람 · 받는 사람이 나면 "내가 보낸 메일" · "내가 받은 메일".
+ * 조건이 없으면 빈 글
+ */
+export function searchConditionsSummary(
+  conditions: SearchConditions | null | undefined,
+  today: Date,
+  me: SearchConditionsMe | null = null,
+): string {
+  if (!conditions || !hasSearchConditions(conditions)) return ''
+  const parts: string[] = []
+  if (conditions.from) {
+    parts.push(isMeValue(conditions.from, me) ? SEARCH_CONDITION_LINE_TEXT.fromMe : SEARCH_CONDITION_LINE_TEXT.from(conditions.from))
+  }
+  if (conditions.to) {
+    parts.push(isMeValue(conditions.to, me) ? SEARCH_CONDITION_LINE_TEXT.toMe : SEARCH_CONDITION_LINE_TEXT.to(conditions.to))
+  }
+  if (conditions.subject) {
+    parts.push(SEARCH_CONDITION_LINE_TEXT.subject(conditions.subject, subjectParticle(conditions.subject)))
+  }
+  if (conditions.body) parts.push(SEARCH_CONDITION_LINE_TEXT.body(conditions.body, subjectParticle(conditions.body)))
+  const period = periodText(conditions, today)
+  if (period) parts.push(period)
+  if (conditions.hasAttachment) parts.push(SEARCH_CONDITION_LINE_TEXT.attachment)
+  return `${SEARCH_CONDITION_LINE_TEXT.prefix}${parts.join(SEARCH_CONDITION_LINE_TEXT.separator)}`
+}
diff --git a/frontend/src/shared/utils/search-highlight.spec.ts b/frontend/src/shared/utils/search-highlight.spec.ts
new file mode 100644
index 0000000..498fa1e
--- /dev/null
+++ b/frontend/src/shared/utils/search-highlight.spec.ts
@@ -0,0 +1,62 @@
+import { describe, expect, it } from 'vitest'
+
+import { highlightSegments } from './search-highlight'
+
+// 검색 강조 조각 (14단계 — 서버가 준 [시작, 끝) UTF-16 위치, NFC 글 기준)
+
+const marked = (text: string, ranges: readonly (readonly [number, number])[] | null) =>
+  highlightSegments(text, ranges)
+    .map((segment) => (segment.mark ? `[${segment.text}]` : segment.text))
+    .join('')
+
+describe('highlightSegments', () => {
+  it('맞은 곳이 없으면 글 한 조각 — 빈 글이면 조각이 없다', () => {
+    expect(highlightSegments('계약서 초안', null)).toEqual([{ text: '계약서 초안', mark: false }])
+    expect(highlightSegments('계약서 초안', [])).toEqual([{ text: '계약서 초안', mark: false }])
+    expect(highlightSegments('', null)).toEqual([])
+  })
+
+  it('여러 범위를 차례로 자른다 — 앞 · 끝 · 맞닿은 곳도', () => {
+    expect(marked('Re: 유지보수 계약 갱신 건', [[12, 14], [4, 8]])).toBe('Re: [유지보수] 계약 [갱신] 건')
+    expect(marked('계약서', [[0, 2]])).toBe('[계약]서')
+    expect(marked('견적서와 계약', [[5, 7]])).toBe('견적서와 [계약]')
+    expect(marked('계약서', [[0, 3]])).toBe('[계약서]')
+  })
+
+  it('겹치거나 맞닿은 범위는 합친다', () => {
+    expect(marked('aaaa', [[0, 2], [1, 3]])).toBe('[aaa]a')
+    expect(marked('계약서', [[0, 2], [2, 3]])).toBe('[계약서]')
+  })
+
+  it('글 밖 · 거꾸로 · 정수가 아닌 위치는 버리고, 끝이 글을 넘으면 글 끝에서 자른다', () => {
+    expect(marked('계약', [[5, 7]])).toBe('계약')
+    expect(marked('계약', [[1, 1], [2, 1], [-1, 1], [0.5, 1]])).toBe('계약')
+    expect(marked('계약', [[1, 10]])).toBe('계[약]')
+  })
+
+  it('맞은 곳이 있으면 NFC 로 맞춘 글을 자른다 — 다른 정규형(NFD)의 같은 글이어도 위치가 맞다', () => {
+    const nfd = '계약서'.normalize('NFD')
+    expect(nfd.length).toBeGreaterThan(3)
+    expect(marked(nfd, [[0, 2]])).toBe('[계약]서')
+    // 맞은 곳이 없으면 글 그대로
+    expect(highlightSegments(nfd, null)[0]?.text).toBe(nfd)
+  })
+
+  it('BMP 밖 글자 뒤의 위치도 UTF-16 그대로 쓴다', () => {
+    expect(marked('😀계약', [[2, 4]])).toBe('😀[계약]')
+  })
+
+  it('위치가 서로게이트 쌍(이모지)의 가운데를 가르면 그 글자를 통째로 넣는다 — 반쪽 글자를 만들지 않는다', () => {
+    // 😀 는 UTF-16 두 칸(0 · 1)
+    expect(marked('😀계약', [[1, 4]])).toBe('[😀계약]')
+    expect(marked('😀계약', [[0, 1]])).toBe('[😀]계약')
+    expect(marked('계😀약', [[2, 3]])).toBe('계[😀]약')
+    expect(marked('계😀약', [[0, 2]])).toBe('[계😀]약')
+    // 가른 자리를 넓힌 뒤 맞닿으면 합친다
+    expect(marked('😀😀', [[0, 1], [3, 4]])).toBe('[😀😀]')
+    // 반쪽 글자(짝 없는 서로게이트)가 있으면 encodeURIComponent 가 URIError 를 던진다
+    const segments = highlightSegments('a😀b😀c', [[2, 5]])
+    expect(segments.map((segment) => segment.text)).toEqual(['a', '😀b😀', 'c'])
+    for (const segment of segments) expect(() => encodeURIComponent(segment.text)).not.toThrow()
+  })
+})
diff --git a/frontend/src/shared/utils/search-highlight.ts b/frontend/src/shared/utils/search-highlight.ts
new file mode 100644
index 0000000..6d05100
--- /dev/null
+++ b/frontend/src/shared/utils/search-highlight.ts
@@ -0,0 +1,60 @@
+// 검색 강조 — 서버가 준 맞은 곳(위치)으로 글을 조각낸다 (순수 함수만 둔다 — 계약 2절 "검색 — 14단계").
+// 화면은 조각을 v-html 없이 <mark> 로 그린다(HighlightedText.vue). 본문 틀(iframe)의 글 본문도 같은 조각을 이스케이프해 넣는다(mail-html.ts).
+
+import type { SearchRange } from '@/shared/types/mail'
+
+/** 그릴 조각 — mark 면 맞은 말 */
+export interface HighlightSegment {
+  text: string
+  mark: boolean
+}
+
+/** 그 자리가 서로게이트 쌍(이모지 등 BMP 밖 글자)의 가운데다 */
+function splitsPair(text: string, at: number): boolean {
+  if (at <= 0 || at >= text.length) return false
+  const before = text.charCodeAt(at - 1)
+  const after = text.charCodeAt(at)
+  return before >= 0xd800 && before <= 0xdbff && after >= 0xdc00 && after <= 0xdfff
+}
+
+/**
+ * 쓸 수 있는 위치만 — 정수 · 0 이상 · 시작 < 끝, 끝은 글 길이에서 자른다. 시작 차례로 놓고 겹치거나 맞닿은 것은 합친다.
+ * 위치가 서로게이트 쌍을 가르면 그 글자를 통째로 넣는다 — 반쪽 글자가 깨져 보이지 않게
+ */
+function usableRanges(ranges: readonly SearchRange[], text: string): [number, number][] {
+  const length = text.length
+  const valid: [number, number][] = []
+  for (const [start, end] of ranges) {
+    if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || start >= length || end <= start) continue
+    const from = splitsPair(text, start) ? start - 1 : start
+    const to = Math.min(end, length)
+    valid.push([from, splitsPair(text, to) ? to + 1 : to])
+  }
+  valid.sort((a, b) => a[0] - b[0] || a[1] - b[1])
+  const merged: [number, number][] = []
+  for (const range of valid) {
+    const last = merged[merged.length - 1]
+    if (last && range[0] <= last[1]) last[1] = Math.max(last[1], range[1])
+    else merged.push(range)
+  }
+  return merged
+}
+
+/**
+ * 글 → 조각 — 맞은 곳이 없으면 글 한 조각(빈 글이면 조각 없음).
+ * 서버는 NFC 로 맞춘 글의 위치를 준다 — 맞은 곳이 있으면 글을 NFC 로 맞춘 뒤 자른다(목록 맞추기가 다른 정규형의 같은 글로 덮어도 어긋나지 않게).
+ * 글 밖 · 거꾸로 된 위치는 버린다
+ */
+export function highlightSegments(text: string, ranges: readonly SearchRange[] | null | undefined): HighlightSegment[] {
+  if (!ranges || ranges.length === 0) return text ? [{ text, mark: false }] : []
+  const source = text.normalize('NFC')
+  const segments: HighlightSegment[] = []
+  let cursor = 0
+  for (const [start, end] of usableRanges(ranges, source)) {
+    if (start > cursor) segments.push({ text: source.slice(cursor, start), mark: false })
+    segments.push({ text: source.slice(start, end), mark: true })
+    cursor = end
+  }
+  if (cursor < source.length) segments.push({ text: source.slice(cursor), mark: false })
+  return segments
+}
diff --git a/frontend/src/shared/utils/search-match.spec.ts b/frontend/src/shared/utils/search-match.spec.ts
new file mode 100644
index 0000000..b8fde61
--- /dev/null
+++ b/frontend/src/shared/utils/search-match.spec.ts
@@ -0,0 +1,149 @@
+import { describe, expect, it } from 'vitest'
+
+import { FOLD_SAMPLES, GRAM_SAMPLES, MATCH_SAMPLES, SUBJECT_BASE_SAMPLES } from '@/test-utils/search-text-samples'
+import {
+  MAX_MATCH_RANGES,
+  foldText,
+  gramsOf,
+  isSingleCharSearch,
+  isSpaceCode,
+  matchRanges,
+  parseSearchTerms,
+  subjectBase,
+} from './search-match'
+
+// 서버와 같은 표본 표(backend test/search-text-samples.ts — 행과 순서까지 그대로)로 본다 — 계약 2절 "검색 — 14단계"
+
+describe('foldText (검색의 접기 — 짝: backend search-text.ts)', () => {
+  it.each(FOLD_SAMPLES)('%j → %j', (input, folded) => {
+    expect(foldText(input)).toBe(folded)
+  })
+
+  it('접은 글은 NFC 원문과 UTF-16 길이가 늘 같다 — 서버가 준 위치를 원문에 그대로 쓴다', () => {
+    for (const [input] of FOLD_SAMPLES) {
+      expect(foldText(input).length).toBe(input.normalize('NFC').length)
+    }
+    const changedLength: number[] = []
+    for (let code = 0; code <= 0xffff; code += 1) {
+      if (code >= 0xd800 && code <= 0xdfff) continue
+      const char = String.fromCharCode(code).normalize('NFC')
+      if (foldText(char).length !== char.length) changedLength.push(code)
+    }
+    expect(changedLength).toEqual([])
+  })
+
+  it('두 번 접어도 같다 · 짝이 없는 서로게이트는 그대로 둔다', () => {
+    for (const [input, folded] of FOLD_SAMPLES) {
+      expect(foldText(folded)).toBe(folded)
+      expect(foldText(foldText(input))).toBe(folded)
+    }
+    expect(foldText('a\ud800B')).toBe('a\ud800b')
+    expect(foldText('\udc00A')).toBe('\udc00a')
+  })
+})
+
+describe('gramsOf (글자 두 개 묶음)', () => {
+  it.each(GRAM_SAMPLES)('%j → %j', (fold, grams) => {
+    expect([...gramsOf(fold)]).toEqual(grams)
+  })
+
+  it('공백은 정규식 \\s 와 같은 글자다 (낱말 나누기와 같다)', () => {
+    const differ: number[] = []
+    for (let code = 0; code <= 0xffff; code += 1) {
+      if (isSpaceCode(code) !== /\s/u.test(String.fromCharCode(code))) differ.push(code)
+    }
+    expect(differ).toEqual([])
+  })
+})
+
+describe('matchRanges (맞은 곳)', () => {
+  it.each(MATCH_SAMPLES)('%j 에서 %j → %j', (original, terms, ranges) => {
+    expect(matchRanges(original, terms)).toEqual(ranges)
+  })
+
+  it('맞은 곳은 limit 개까지만 모은다', () => {
+    expect(matchRanges('가'.repeat(5_000), ['가'])).toEqual([[0, MAX_MATCH_RANGES]])
+    expect(matchRanges('가 '.repeat(10), ['가'], 3)).toEqual([
+      [0, 1],
+      [2, 3],
+      [4, 5],
+    ])
+  })
+})
+
+describe('subjectBase (말머리를 뗀 제목 — 짝: backend subject-base.ts)', () => {
+  it.each(SUBJECT_BASE_SAMPLES)('%j → %j', (subject, base) => {
+    expect(subjectBase(subject)).toBe(base)
+  })
+})
+
+describe('parseSearchTerms (검색어 나누기 — 짝: backend search-query.ts)', () => {
+  it('띄어쓰기로 낱말을 나눈다 — 여러 칸 · 전각 공백 · 줄바꿈도 한 번의 띄어쓰기', () => {
+    expect(parseSearchTerms(` 서버  이전\u3000일정\n공유 `)).toEqual([
+      { kind: 'word', text: '서버' },
+      { kind: 'word', text: '이전' },
+      { kind: 'word', text: '일정' },
+      { kind: 'word', text: '공유' },
+    ])
+  })
+
+  it('큰따옴표 안은 구절 하나다 — 짝이 없는 마지막 따옴표는 없는 것으로 본다', () => {
+    expect(parseSearchTerms('회의 "일정   공유" 서버')).toEqual([
+      { kind: 'word', text: '회의' },
+      { kind: 'phrase', text: '일정 공유' },
+      { kind: 'word', text: '서버' },
+    ])
+    expect(parseSearchTerms('회의 "일정 공유').map((term) => term.text)).toEqual(['회의', '일정', '공유'])
+    expect(parseSearchTerms('"a b" "c')).toEqual([
+      { kind: 'phrase', text: 'a b' },
+      { kind: 'word', text: 'c' },
+    ])
+  })
+
+  it('문자 · 숫자가 없는 낱말 · 구절은 버리고, 낱말 앞뒤의 문장부호는 뗀다 — 같은 낱말은 한 번', () => {
+    for (const query of ['-', '…', '- … !!', '"- …"', '😀', '" "', '""']) {
+      expect(parseSearchTerms(query)).toEqual([])
+    }
+    expect(parseSearchTerms('회의, (회의) 회의. “회의” [공지] 2026. 회의!').map((term) => term.text)).toEqual([
+      '회의',
+      '공지',
+      '2026',
+    ])
+    expect(parseSearchTerms('"회의, 일정."')).toEqual([{ kind: 'phrase', text: '회의, 일정.' }])
+    expect(parseSearchTerms('회의 회의 "일정" "일정" 일정')).toEqual([
+      { kind: 'word', text: '회의' },
+      { kind: 'phrase', text: '일정' },
+      { kind: 'word', text: '일정' },
+    ])
+  })
+
+  it('NFC 로 모으고 NUL 은 U+FFFD 로 바꾼다 (서버의 색인과 같다)', () => {
+    expect(parseSearchTerms('\u1112\u1161\u11ab\u1100\u1173\u11af')).toEqual([{ kind: 'word', text: '한글' }])
+    expect(parseSearchTerms(`계\u0000약`)).toEqual([{ kind: 'word', text: '계\ufffd약' }])
+  })
+})
+
+describe('isSingleCharSearch (한 글자 낱말뿐인 검색 — 서버가 본문을 찾지 않는다)', () => {
+  it('낱말이 모두 한 글자면 그렇다 — 검색어 · 조건 칸을 모두 합쳐 본다', () => {
+    expect(isSingleCharSearch(['김'])).toBe(true)
+    expect(isSingleCharSearch(['김 a 3'])).toBe(true)
+    expect(isSingleCharSearch(['김', '', '', '', '박'])).toBe(true)
+    // 한 글자 낱말로만 된 구절도 묶음이 없다
+    expect(isSingleCharSearch(['"가 나"'])).toBe(true)
+  })
+
+  it('두 글자 이상 낱말이 하나라도 있으면 아니다 — 다른 칸에 있어도', () => {
+    expect(isSingleCharSearch(['계약'])).toBe(false)
+    expect(isSingleCharSearch(['김 계약'])).toBe(false)
+    expect(isSingleCharSearch(['김', '', '', '견적', ''])).toBe(false)
+    expect(isSingleCharSearch(['"가나"'])).toBe(false)
+  })
+
+  it('찾을 낱말이 없으면(빈 글 · 문장부호뿐) 아니다', () => {
+    expect(isSingleCharSearch([])).toBe(false)
+    expect(isSingleCharSearch(['', '   '])).toBe(false)
+    expect(isSingleCharSearch(['- …'])).toBe(false)
+    // 앞뒤 문장부호를 떼면 한 글자다 — 서버와 같게 뗀 뒤 센다
+    expect(isSingleCharSearch(['(김)'])).toBe(true)
+  })
+})
diff --git a/frontend/src/shared/utils/search-match.ts b/frontend/src/shared/utils/search-match.ts
new file mode 100644
index 0000000..804f8a7
--- /dev/null
+++ b/frontend/src/shared/utils/search-match.ts
@@ -0,0 +1,328 @@
+// 메일 검색의 낱말 나누기 · 접기(정규화) · 글자 두 개 묶음 · 맞은 곳 · 말머리 떼기 (순수 함수만 둔다 — 계약 2절 "검색 — 14단계")
+//
+// ⚠️ backend 와 **짝**이다 — `src/shared/utils/search-query.ts`(낱말 나누기) · `search-text.ts`(접기 · 묶음 · 맞은 곳) ·
+//    `subject-base.ts`(말머리 떼기). 같은 표본 표(frontend `src/test-utils/search-text-samples.ts` · backend `test/search-text-samples.ts` —
+//    행과 순서까지 그대로)를 두 쪽 테스트에 둔다. 한쪽을 고치면 둘 다 고친다.
+// 화면은 이것으로 "한 글자 낱말뿐이라 본문을 찾지 않은 검색"을 알아본다(isSingleCharSearch — 결과 머리의 한 줄).
+// 서버는 그 사실을 응답에 싣지 않는다 — 서버와 같은 낱말 나누기 · 묶음으로 같은 답을 낸다. 강조할 곳은 서버가 준다(searchHighlight).
+//
+// 접기(foldText)는 먼저 NFC 로 맞춘 뒤 **코드 포인트 하나씩** 바꾼다 — 전각 ASCII(！ ~ ～) → 반각, 소문자(결과가 코드 포인트 하나이고
+// UTF-16 길이가 같을 때만 — 'İ' 처럼 늘어나면 그대로), 공백류(줄바꿈 · 탭 · NBSP · U+3000 등 정규식 `\s` 의 글자) → 띄어쓰기(U+0020) 하나.
+// 그래서 NFC 원문과 접은 글은 코드 포인트 · UTF-16 위치가 같다. NFKC 는 쓰지 않는다(㈜ → (주) 처럼 길이를 바꿔 위치를 잃는다).
+// 모든 함수는 입력을 한 번(맞은 곳은 낱말마다 한 번) 훑는다 — 길이에 비례한다.
+
+// ── 낱말 나누기 (짝: backend search-query.ts) ─────────────────────────────
+
+/** 검색어의 낱말을 나누는 기준 — 공백 문자(전각 공백 · 줄바꿈 포함). 낱말 수 · 서버의 엔진 조건 · 색인 찾기가 같은 기준이다 */
+export const SEARCH_WORD_SEPARATOR = /\s+/u
+
+/** 큰따옴표 — 감싼 부분은 구절로 찾는다 */
+const QUOTE = '"'
+
+/** NUL(U+0000) — 서버는 색인과 같게 U+FFFD 로 1:1 바꿔 찾는다 */
+const NUL = String.fromCharCode(0)
+const REPLACEMENT_CHARACTER = String.fromCharCode(0xfffd)
+
+/** 찾을 수 있는 글자 — 문자(\p{L})나 숫자(\p{N}). 하나도 없는 낱말 · 구절(`-` · `…` · 그림 문자뿐)은 버린다 */
+const SEARCHABLE_CHARACTER = /[\p{L}\p{N}]/u
+
+/**
+ * 낱말 앞뒤에 붙은, 문자 · 숫자가 아닌 글자 — 떼고 가운데 낱말로 찾는다('회의,' · '(회의)' → '회의').
+ * 뒤쪽은 "문자 · 숫자 · 결합 문자가 아닌 글자 + 그 뒤의 결합 문자"를 뗀다 — 글자에 붙은 결합 문자는 남기고, 그림 문자와 그 이체 선택자는 함께 뗀다
+ */
+const WORD_EDGE_PUNCTUATION = /^[^\p{L}\p{N}]+|(?:[^\p{L}\p{N}\p{M}]\p{M}*)+$/gu
+
+/** 검색어를 나눈 조각 — 낱말 · 구절(큰따옴표 안) */
+export interface SearchTerm {
+  readonly kind: 'word' | 'phrase'
+  readonly text: string
+}
+
+function coreWord(word: string): string {
+  return word.replace(WORD_EDGE_PUNCTUATION, '')
+}
+
+function splitWords(text: string): string[] {
+  return text.split(SEARCH_WORD_SEPARATOR).filter((word) => word !== '')
+}
+
+/**
+ * 검색어를 낱말 · 구절로 나눈다 — 나온 순서대로, 같은 낱말 · 같은 구절은 한 번만 (서버와 같다).
+ * 큰따옴표 한 쌍 안은 구절(안의 여러 칸 공백은 한 칸으로), 짝이 없는 마지막 큰따옴표는 없는 것으로 본다.
+ * 낱말 앞뒤의 문장부호는 떼고, 문자 · 숫자가 하나도 없는 낱말 · 구절은 버린다. NFC 로 맞추고 NUL 은 U+FFFD 로 바꾼다
+ */
+export function parseSearchTerms(query: string): SearchTerm[] {
+  const segments = query.normalize('NFC').replaceAll(NUL, REPLACEMENT_CHARACTER).split(QUOTE)
+  const terms: SearchTerm[] = []
+  const seen = new Set<string>()
+  const add = (kind: SearchTerm['kind'], text: string) => {
+    const key = `${kind}\n${text}`
+    if (!SEARCHABLE_CHARACTER.test(text) || seen.has(key)) return
+    seen.add(key)
+    terms.push({ kind, text })
+  }
+
+  segments.forEach((segment, index) => {
+    // 홀수 번째 조각은 따옴표 안이다 — 뒤에 닫는 따옴표가 있을 때만 (마지막 조각이면 짝이 없다)
+    const isPhrase = index % 2 === 1 && index < segments.length - 1
+    if (isPhrase) {
+      add('phrase', splitWords(segment).join(' '))
+      return
+    }
+    for (const word of splitWords(segment)) add('word', coreWord(word))
+  })
+  return terms
+}
+
+// ── 접기 · 묶음 · 맞은 곳 (짝: backend search-text.ts) ────────────────────
+
+/** 전각 ASCII 의 범위와 반각과의 차이 (U+FF01 ！ ~ U+FF5E ～ → U+0021 ~ U+007E) */
+const FULLWIDTH_FIRST = 0xff01
+const FULLWIDTH_LAST = 0xff5e
+const FULLWIDTH_OFFSET = 0xfee0
+
+const ASCII_UPPER_A = 0x41
+const ASCII_UPPER_Z = 0x5a
+const ASCII_CASE_OFFSET = 0x20
+const ASCII_LIMIT = 0x80
+
+/** 소문자가 따로 없는 큰 묶음 — 한글 음절 · 자모, CJK 한자 · 기호 (toLowerCase 를 부르지 않고 건너뛴다) */
+const HANGUL_JAMO_FIRST = 0x1100
+const HANGUL_JAMO_LAST = 0x11ff
+const CJK_FIRST = 0x2e80
+const CJK_LAST = 0x9fff
+const HANGUL_SYLLABLE_FIRST = 0xac00
+const HANGUL_SYLLABLE_LAST = 0xd7a3
+
+const HIGH_SURROGATE_FIRST = 0xd800
+const HIGH_SURROGATE_LAST = 0xdbff
+const LOW_SURROGATE_FIRST = 0xdc00
+const LOW_SURROGATE_LAST = 0xdfff
+const BMP_LAST = 0xffff
+
+/** 맞은 곳을 이만큼까지만 모은다 — 글이 길고 낱말이 흔하면(한 글자) 끝없이 늘지 않게 */
+export const MAX_MATCH_RANGES = 500
+
+/** 맞은 곳 — [시작, 끝) UTF-16 위치 */
+export type MatchRange = readonly [start: number, end: number]
+
+/** 공백류를 바꾼 글자 — 띄어쓰기 하나 */
+const SPACE = ' '
+const SPACE_CODE = 0x20
+
+function isHighSurrogate(code: number): boolean {
+  return code >= HIGH_SURROGATE_FIRST && code <= HIGH_SURROGATE_LAST
+}
+
+function isLowSurrogate(code: number): boolean {
+  return code >= LOW_SURROGATE_FIRST && code <= LOW_SURROGATE_LAST
+}
+
+/** 소문자가 따로 없는 글자인가 (빠른 길 — 한글 · 한자) */
+function hasNoCase(code: number): boolean {
+  return (
+    (code >= HANGUL_SYLLABLE_FIRST && code <= HANGUL_SYLLABLE_LAST) ||
+    (code >= CJK_FIRST && code <= CJK_LAST) ||
+    (code >= HANGUL_JAMO_FIRST && code <= HANGUL_JAMO_LAST)
+  )
+}
+
+/** ASCII 한 글자(코드)의 접기 — 대문자만 소문자로 */
+function foldAsciiCode(code: number): number {
+  return code >= ASCII_UPPER_A && code <= ASCII_UPPER_Z ? code + ASCII_CASE_OFFSET : code
+}
+
+/** ASCII 밖 한 코드 포인트의 접기 — 바뀌지 않으면 null. `char` 는 그 코드 포인트의 글(UTF-16 한두 단위) */
+function foldCodePoint(code: number, char: string): string | null {
+  if (code >= FULLWIDTH_FIRST && code <= FULLWIDTH_LAST) {
+    return String.fromCharCode(foldAsciiCode(code - FULLWIDTH_OFFSET))
+  }
+  if (hasNoCase(code)) return null
+  const lower = char.toLowerCase()
+  if (lower === char || lower.length !== char.length) return null
+  // 같은 UTF-16 길이여도 코드 포인트가 둘이 될 수 있다(BMP 두 글자) — 하나일 때만
+  const first = lower.codePointAt(0) ?? 0
+  const firstWidth = first > BMP_LAST ? 2 : 1
+  return firstWidth === lower.length ? lower : null
+}
+
+/**
+ * 공백 글자인가 — 낱말 나누기 · 묶음의 경계 (JS 정규식 `\s` 와 같은 글자들: 띄어쓰기 · 탭 · 줄바꿈 · NBSP · 전각 공백 · U+2000~U+200A 등)
+ */
+export function isSpaceCode(code: number): boolean {
+  if (code <= 0x20) {
+    return code === 0x20 || (code >= 0x09 && code <= 0x0d)
+  }
+  if (code < 0xa0) return false
+  return (
+    code === 0xa0 ||
+    code === 0x1680 ||
+    (code >= 0x2000 && code <= 0x200a) ||
+    code === 0x2028 ||
+    code === 0x2029 ||
+    code === 0x202f ||
+    code === 0x205f ||
+    code === 0x3000 ||
+    code === 0xfeff
+  )
+}
+
+/**
+ * 찾기 · 색인의 접기 글 — NFC 뒤 코드 포인트 하나씩: 전각 ASCII → 반각, 소문자, 공백류 → 띄어쓰기.
+ * 결과는 `text.normalize('NFC')` 와 UTF-16 길이 · 위치가 같다
+ */
+export function foldText(text: string): string {
+  const source = text.normalize('NFC')
+  let folded = ''
+  let runStart = 0
+  for (let index = 0; index < source.length; ) {
+    const code = source.charCodeAt(index)
+    let width = 1
+    let point = code
+    if (isHighSurrogate(code) && index + 1 < source.length && isLowSurrogate(source.charCodeAt(index + 1))) {
+      width = 2
+      point = source.codePointAt(index) ?? code
+    }
+    let replacement: string | null
+    if (isSpaceCode(code)) {
+      // 공백류는 모두 BMP 의 한 단위다 — 띄어쓰기 하나로 1:1
+      replacement = code === SPACE_CODE ? null : SPACE
+    } else if (code < ASCII_LIMIT) {
+      const lowered = foldAsciiCode(code)
+      replacement = lowered === code ? null : String.fromCharCode(lowered)
+    } else {
+      replacement = foldCodePoint(point, source.slice(index, index + width))
+    }
+    if (replacement !== null) {
+      folded += source.slice(runStart, index) + replacement
+      runStart = index + width
+    }
+    index += width
+  }
+  return runStart === 0 ? source : folded + source.slice(runStart)
+}
+
+/**
+ * 글자 두 개 묶음 — 공백이 아닌 이웃한 코드 포인트 둘을 한 묶음으로, 나온 차례대로 겹치지 않게(같은 묶음은 한 번).
+ * 접은 글(foldText)에 쓴다. 공백을 넘지 않는다 — "회의 일정" → 회의 · 일정. 한 글자 낱말은 묶음이 없다
+ */
+export function gramsOf(fold: string, into: Set<string> = new Set()): Set<string> {
+  let previous: string | null = null
+  for (let index = 0; index < fold.length; ) {
+    const code = fold.charCodeAt(index)
+    const width = isHighSurrogate(code) && index + 1 < fold.length && isLowSurrogate(fold.charCodeAt(index + 1)) ? 2 : 1
+    if (isSpaceCode(code)) {
+      previous = null
+    } else {
+      const char = width === 1 ? fold.charAt(index) : fold.slice(index, index + 2)
+      if (previous !== null) into.add(previous + char)
+      previous = char
+    }
+    index += width
+  }
+  return into
+}
+
+/** 맞은 곳들을 시작 차례로 놓고 겹치거나 맞닿은 것을 합친다 */
+function mergeRanges(ranges: MatchRange[]): MatchRange[] {
+  ranges.sort((a, b) => a[0] - b[0] || a[1] - b[1])
+  const merged: [number, number][] = []
+  for (const [start, end] of ranges) {
+    const last = merged[merged.length - 1]
+    if (last && start <= last[1]) {
+      if (end > last[1]) last[1] = end
+    } else {
+      merged.push([start, end])
+    }
+  }
+  return merged
+}
+
+/** 찾는 말들을 접는다 — 같은 말은 한 번, 빈 말은 뺀다 */
+export function foldTerms(terms: readonly string[]): string[] {
+  return [...new Set(terms.map(foldText))].filter((term) => term !== '')
+}
+
+/** matchRanges 의 접은 글 판 — `haystack` 은 foldText 한 글, `terms` 는 foldTerms 한 말 */
+export function matchFoldedRanges(
+  haystack: string,
+  terms: readonly string[],
+  limit: number = MAX_MATCH_RANGES,
+): MatchRange[] {
+  const found: MatchRange[] = []
+  for (const term of terms) {
+    if (term === '') continue
+    let count = 0
+    for (let at = haystack.indexOf(term); at >= 0 && count < limit; at = haystack.indexOf(term, at + 1)) {
+      found.push([at, at + term.length])
+      count += 1
+    }
+  }
+  return mergeRanges(found).slice(0, limit)
+}
+
+/**
+ * 맞은 곳 — 원문(`original` — NFC 여야 위치가 맞는다)에서 찾는 말들(`terms` — 접기 전 글)이 나오는 자리를 모두 찾아
+ * 겹치거나 맞닿은 것을 합친 [시작, 끝) 목록(UTF-16, 시작 차례). 같은 접기 · 부분 일치다('aa' 는 'aaa' 의 [0, 3))
+ */
+export function matchRanges(original: string, terms: readonly string[], limit: number = MAX_MATCH_RANGES): MatchRange[] {
+  return matchFoldedRanges(foldText(original), foldTerms(terms), limit)
+}
+
+// ── 말머리 떼기 (짝: backend subject-base.ts) ────────────────────────────
+
+/** 앞의 말머리 하나 — 답장 · 전달 말머리 또는 대괄호 꼬리표, 뒤의 공백까지 (접은 글 — 소문자 · 반각) */
+const LEADING_PREFIX = /(?:(?:re|fwd|fw|aw|wg|회신|답장|전달) ?(?:\[\d{1,4}\]|\(\d{1,4}\))? ?:|\[[^\]]*\]) ?/uy
+
+/** 공백 글자의 이어짐을 띄어쓰기 하나로 · 앞뒤 공백 빼기 */
+function collapseSpaces(text: string): string {
+  let collapsed = ''
+  let pendingSpace = false
+  for (let index = 0; index < text.length; index += 1) {
+    if (isSpaceCode(text.charCodeAt(index))) {
+      pendingSpace = collapsed !== ''
+      continue
+    }
+    if (pendingSpace) collapsed += ' '
+    pendingSpace = false
+    collapsed += text.charAt(index)
+  }
+  return collapsed
+}
+
+/**
+ * 말머리를 뗀 제목의 접기 글 — 같은 대화인지 볼 때 제목을 견주는 글이다(대화 묶기 — 서버가 묶는다).
+ * 접기 → 공백을 하나로 · 앞뒤 공백 빼기 → 앞의 말머리(Re · Fw · Fwd · AW · WG · 회신 · 답장 · 전달 · 대괄호 꼬리표)를 여러 겹 뗀다
+ */
+export function subjectBase(subject: string): string {
+  const text = collapseSpaces(foldText(subject))
+  // 붙은 자리(sticky)에서만 맞춘다 — 뗄 때마다 글을 자르지 않고 자리만 옮긴다
+  let position = 0
+  for (;;) {
+    LEADING_PREFIX.lastIndex = position
+    const prefix = LEADING_PREFIX.exec(text)
+    if (!prefix || prefix[0] === '') break
+    position += prefix[0].length
+  }
+  return text.slice(position).trim()
+}
+
+// ── 화면이 쓰는 판정 ───────────────────────────────────────────────────
+
+/**
+ * 한 글자 낱말뿐인 검색인가 — 검색어 · 조건 칸의 낱말 · 구절을 모두 접어도 글자 두 개 묶음이 하나도 없으면 그렇다(서버의 search-plan 과 같은 판정).
+ * 그때 서버(색인 방식)는 본문을 찾지 않고 제목 · 사람 · 첨부 이름에서만 찾는다 (계약 2절 "검색 — 14단계" › 한 글자 낱말).
+ * `texts` 는 검색어 q 와 조건 넷(보낸 사람 · 받는 사람 · 제목 · 내용)의 글 — 빈 글은 없는 것이다
+ */
+export function isSingleCharSearch(texts: readonly string[]): boolean {
+  let terms = 0
+  const grams = new Set<string>()
+  for (const text of texts) {
+    for (const term of parseSearchTerms(text)) {
+      terms += 1
+      gramsOf(foldText(term.text), grams)
+      if (grams.size > 0) return false
+    }
+  }
+  return terms > 0
+}
diff --git a/frontend/src/stores/mail-settings.store.spec.ts b/frontend/src/stores/mail-settings.store.spec.ts
new file mode 100644
index 0000000..daf1108
--- /dev/null
+++ b/frontend/src/stores/mail-settings.store.spec.ts
@@ -0,0 +1,235 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { createPinia, setActivePinia } from 'pinia'
+
+import { ERROR_CODE_MESSAGES } from '@/shared/constants/error-codes.generated'
+import type { MailSettings } from '@/shared/types/mail'
+import { useAuthStore } from '@/stores/auth.store'
+import { useToastStore } from '@/stores/toast.store'
+import { fail, flushPromises, installMockApi, ok, restoreApiAdapter, type MockRequest, type MockResult } from '@/test-utils/mock-api'
+import { groupByConversationHintKey, useMailSettingsStore } from './mail-settings.store'
+
+// 보내기 · 읽기 설정의 묶어 보기 (14단계) — 설정을 받기 전의 짐작(사용자마다 · localStorage), 로그아웃이 보이는 값을 바꾸지 않음(리뷰 M1),
+// 받지 못했을 때도 고르기(리뷰 L4)
+
+const ARA = { email: 'ara.kim@arasystem.test', name: '김아라' }
+const DOYUN = { email: 'doyun.lee@arasystem.test', name: '이도윤' }
+const SETTINGS: MailSettings = { undoSendSeconds: 10, externalImages: 'ask', groupByConversation: true }
+
+describe('mail-settings.store — 묶어 보기 짐작 · 받지 못했을 때', () => {
+  let requests: MockRequest[]
+  let load: () => MockResult | Promise<MockResult>
+  let patch: (request: MockRequest) => MockResult | Promise<MockResult>
+
+  beforeEach(() => {
+    window.localStorage.clear()
+    setActivePinia(createPinia())
+    load = () => ok(SETTINGS)
+    patch = (request) => ok({ ...SETTINGS, ...(request.data as Partial<MailSettings>) })
+    requests = installMockApi((request) => (request.method === 'GET' ? load() : patch(request)))
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+    useToastStore().clear()
+    restoreApiAdapter()
+  })
+
+  const patches = () => requests.filter((request) => request.method === 'PATCH').map((request) => request.data)
+
+  it('짐작은 사용자마다다 — 김아라가 켰어도 이도윤은 묶지 않는다(처음 값)', async () => {
+    window.localStorage.setItem(groupByConversationHintKey(ARA.email), 'true')
+    const auth = useAuthStore()
+    const store = useMailSettingsStore()
+
+    auth.markAuthenticated(ARA)
+    await flushPromises()
+    expect(store.groupByConversation).toBe(true)
+
+    auth.clearAuth()
+    await flushPromises()
+    auth.markAuthenticated(DOYUN)
+    await flushPromises()
+    expect(store.groupByConversation).toBe(false)
+  })
+
+  it('받으면 서버의 값이 이기고 그 사용자의 짐작으로 기억한다', async () => {
+    useAuthStore().markAuthenticated(DOYUN)
+    const store = useMailSettingsStore()
+    expect(store.groupByConversation).toBe(false)
+
+    await store.load()
+
+    expect(store.groupByConversation).toBe(true)
+    expect(window.localStorage.getItem(groupByConversationHintKey(DOYUN.email))).toBe('true')
+  })
+
+  it('로그아웃 · 세션 만료는 보이는 값을 바꾸지 않는다 — 떠나는 메일 화면이 목록을 다시 부르지 않게 (리뷰 M1)', async () => {
+    const auth = useAuthStore()
+    auth.markAuthenticated(ARA)
+    const store = useMailSettingsStore()
+    await store.load()
+    expect(store.groupByConversation).toBe(true)
+
+    auth.clearAuth()
+    await flushPromises()
+    expect(store.settings).toBeNull()
+    expect(store.groupByConversation).toBe(true)
+
+    auth.markAuthenticated(ARA)
+    await store.load()
+    auth.expireSession()
+    await flushPromises()
+    expect(store.groupByConversation).toBe(true)
+  })
+
+  it('localStorage 를 읽지 · 쓰지 못해도 던지지 않는다 — 짐작은 처음 값(묶지 않음), 받은 값은 그대로 쓴다', async () => {
+    window.localStorage.setItem(groupByConversationHintKey(ARA.email), 'true')
+    vi.spyOn(Storage.prototype, 'getItem').mockImplementation(() => {
+      throw new Error('blocked')
+    })
+    vi.spyOn(Storage.prototype, 'setItem').mockImplementation(() => {
+      throw new Error('blocked')
+    })
+    useAuthStore().markAuthenticated(ARA)
+    const store = useMailSettingsStore()
+    expect(store.groupByConversation).toBe(false)
+
+    await store.load()
+    expect(store.groupByConversation).toBe(true)
+  })
+
+  describe('받지 못했으면 짐작대로 두고 [대화로 묶기]는 고를 수 있다 (리뷰 L4)', () => {
+    beforeEach(() => {
+      window.localStorage.setItem(groupByConversationHintKey(ARA.email), 'true')
+      useAuthStore().markAuthenticated(ARA)
+      load = () => fail(503, 'SYS_001')
+    })
+
+    it('그 칸만 PATCH 하고, 응답(설정 전체)을 받은 설정으로 삼는다', async () => {
+      const store = useMailSettingsStore()
+      await store.load()
+      expect([store.status, store.settings, store.groupByConversation]).toEqual(['error', null, true])
+
+      const saving = store.update('groupByConversation', false)
+      expect(store.groupByConversation).toBe(false)
+      expect(await saving).toBe(true)
+
+      expect(patches()).toEqual([{ groupByConversation: false }])
+      expect(store.status).toBe('ready')
+      expect(store.settings).toEqual({ ...SETTINGS, groupByConversation: false })
+      expect(store.groupByConversation).toBe(false)
+      expect(window.localStorage.getItem(groupByConversationHintKey(ARA.email))).toBe('false')
+      expect(store.saved).toBe(true)
+    })
+
+    it('저장도 실패하면 고르기 전의 짐작으로 되돌린다 — 알림은 인터셉터', async () => {
+      patch = () => fail(400, 'VAL_001')
+      const store = useMailSettingsStore()
+      await store.load()
+
+      expect(await store.update('groupByConversation', false)).toBe(false)
+
+      expect(store.groupByConversation).toBe(true)
+      expect(store.status).toBe('error')
+      expect(useToastStore().toasts.map((toast) => toast.message)).toEqual([ERROR_CODE_MESSAGES.VAL_001])
+    })
+
+    it('받은 값이 없으면 다른 칸(보내기 취소)은 고르지 않는다 — 받는 중에도 고르지 않는다', async () => {
+      const store = useMailSettingsStore()
+      await store.load()
+      expect(await store.update('undoSendSeconds', 5)).toBe(false)
+
+      load = () => ok(SETTINGS)
+      const loading = store.load()
+      expect(await store.update('groupByConversation', false)).toBe(false)
+      await loading
+      expect(patches()).toEqual([])
+    })
+  })
+
+  describe('조용히 다시 받기 refresh — 다른 탭 · PC 에서 바꾼 값 (2026-11-06 실사용 시험)', () => {
+    beforeEach(() => {
+      useAuthStore().markAuthenticated(ARA)
+    })
+
+    it('받은 값으로 바꾼다 — 받는 동안에도 상태는 ready 그대로(목록 머리의 [대화로 묶기]가 숨지 않게), 알리지 않는다', async () => {
+      const store = useMailSettingsStore()
+      await store.load()
+      const fetched = store.fetchSeq
+      load = () => ok({ undoSendSeconds: 30, externalImages: 'always', groupByConversation: false })
+
+      const refreshing = store.refresh()
+      expect(store.status).toBe('ready')
+      await refreshing
+
+      expect(store.settings).toEqual({ undoSendSeconds: 30, externalImages: 'always', groupByConversation: false })
+      expect(store.groupByConversation).toBe(false)
+      expect(store.knownUndoSendSeconds).toBe(30)
+      expect(store.fetchSeq).toBe(fetched + 1)
+      expect(window.localStorage.getItem(groupByConversationHintKey(ARA.email))).toBe('false')
+      expect(requests.filter((request) => request.method === 'GET').at(-1)?.config.silent).toBe(true)
+    })
+
+    it('받기 전 · 받는 중 · 저장하는 중에는 하지 않는다', async () => {
+      const store = useMailSettingsStore()
+      await store.refresh()
+      expect(requests).toHaveLength(0)
+
+      const loading = store.load()
+      await store.refresh()
+      await loading
+      expect(requests.filter((request) => request.method === 'GET')).toHaveLength(1)
+
+      let release: (result: MockResult) => void = () => undefined
+      patch = () => new Promise<MockResult>((resolve) => (release = resolve))
+      const saving = store.update('undoSendSeconds', 5)
+      await store.refresh()
+      expect(requests.filter((request) => request.method === 'GET')).toHaveLength(1)
+      release(ok({ ...SETTINGS, undoSendSeconds: 5 }))
+      await saving
+    })
+
+    it('받는 사이 고른 값이 있으면 받은 값을 버린다 — 늦게 온 옛 값이 방금 고른 것을 덮지 않게', async () => {
+      const store = useMailSettingsStore()
+      await store.load()
+      let release: (result: MockResult) => void = () => undefined
+      load = () => new Promise<MockResult>((resolve) => (release = resolve))
+
+      const refreshing = store.refresh()
+      await store.update('groupByConversation', false)
+      release(ok(SETTINGS))
+      await refreshing
+
+      expect(store.groupByConversation).toBe(false)
+      expect(store.settings?.groupByConversation).toBe(false)
+    })
+
+    it('받지 못하면 지금 값을 둔다 — 알리지 않는다', async () => {
+      const store = useMailSettingsStore()
+      await store.load()
+      load = () => fail(503, 'SYS_001')
+
+      await store.refresh()
+
+      expect(store.status).toBe('ready')
+      expect(store.settings).toEqual(SETTINGS)
+      expect(useToastStore().toasts).toEqual([])
+    })
+
+    it('세션이 바뀌면 받은 값을 버린다', async () => {
+      const store = useMailSettingsStore()
+      await store.load()
+      let release: (result: MockResult) => void = () => undefined
+      load = () => new Promise<MockResult>((resolve) => (release = resolve))
+
+      const refreshing = store.refresh()
+      useAuthStore().clearAuth()
+      await flushPromises()
+      release(ok({ ...SETTINGS, groupByConversation: false }))
+      await refreshing
+
+      expect(store.settings).toBeNull()
+      expect(store.groupByConversation).toBe(true)
+    })
+  })
+})
diff --git a/frontend/src/stores/mail-settings.store.ts b/frontend/src/stores/mail-settings.store.ts
index b0335b0..c883f77 100644
--- a/frontend/src/stores/mail-settings.store.ts
+++ b/frontend/src/stores/mail-settings.store.ts
@@ -9,9 +9,40 @@ import type { LoadStatus } from '@/stores/mail.store'
 
 type SettingKey = keyof MailSettings
 
+const GROUP_HINT_KEY_PREFIX = 'arasystem.mail.groupByConversation:'
+
+/** 묶어 보기의 짐작을 기억하는 localStorage 키 — 사용자 주소마다 따로 (보기 방식 mail-view.store 와 같은 결) */
+export function groupByConversationHintKey(email: string): string {
+  return `${GROUP_HINT_KEY_PREFIX}${email.trim().toLowerCase()}`
+}
+
+// 사생활 보호 모드 · 저장소 차단 등으로 localStorage 가 실패해도 짐작 없이(묶지 않음) 동작한다
+function readGroupHint(email: string | null): boolean {
+  if (!email) return false
+  try {
+    return window.localStorage.getItem(groupByConversationHintKey(email)) === 'true'
+  } catch {
+    return false
+  }
+}
+
+function writeGroupHint(email: string, grouped: boolean) {
+  try {
+    window.localStorage.setItem(groupByConversationHintKey(email), String(grouped))
+  } catch {
+    // 기억하지 못해도 이번 화면은 서버의 값으로 동작한다
+  }
+}
+
 // 보내기 · 읽기 설정 스토어 — 계약 2절 "보내기 · 읽기 설정" (9단계 — 직원마다 서버 DB 에 하나, 어느 PC 에서나 같다)
 // - 설정 › 메일 › 보내기 · 읽기는 들어올 때마다 새로 받는다(load) — 다른 PC 에서 바꿨을 수 있다. 오류는 화면이 직접 그린다.
-//   메일 화면은 들어올 때 한 번 받아 둔다(ensureLoaded — 알리지 않는다): 쓰기 화면의 [보내기 취소] 알림이 설정한 초로 마감을 센다
+//   메일 화면은 들어올 때 한 번 받아 둔다(ensureLoaded — 알리지 않는다): 쓰기 화면의 [보내기 취소] 알림이 설정한 초로 마감을 세고,
+//   메일함 화면이 대화로 묶어 볼지(groupByConversation — 14단계) 정한다. 목록 머리의 [대화로 묶기]도 이 스토어의 update 로 저장한다.
+//   받기 전에는 이 브라우저가 마지막으로 안 값(localStorage — 사용자 주소마다)으로 짐작한다: 새로고침마다 메일 목록을 받았다가 버리고
+//   묶은 목록을 다시 받지 않게(엔진 조회 한 번을 아낀다). 받으면 서버의 값이 이기고 짐작을 고친다.
+//   받지 못했으면(error) 짐작대로 두고, 그때도 [대화로 묶기]는 고를 수 있다 — 그 칸만 PATCH 하고, 응답(설정 전체)을 받은 설정으로 삼는다.
+//   실패하면 고르기 전의 짐작으로 되돌린다. 로그아웃 · 세션 만료(reset)는 화면이 보는 값을 바꾸지 않는다 — 떠나는 메일 화면이 목록을 다시 부르지 않게
+//   (2026-11-06 리뷰 M1). 다른 사람이 로그인하면 그 사람의 짐작으로 바뀐다
 // - 고르는 대로 그 칸만 PATCH 한다(저장 단추 없음). 화면은 늘 마지막으로 고른 값을 보인다.
 //   **칸마다 저장은 한 번에 하나**(6단계 필터의 saving 과 같은 결) — 보내는 동안 다시 고르면 마지막으로 고른 것만 기억해 두고,
 //   앞 저장이 끝난 뒤 그것이 서버의 답과 다르면 보낸다. 두 저장을 함께 보내면 서버가 나중에 처리한 쪽이 남는데, 응답 차례로는 그것을 알 수 없어
@@ -19,6 +50,11 @@ type SettingKey = keyof MailSettings
 //   마지막으로 고른 것의 저장이 실패하면 그 칸을 서버가 마지막으로 확인해 준 값으로 되돌린다(오류 알림은 인터셉터)
 // - 기다리는 저장이 모두 끝났고 마지막으로 끝난 저장이 성공이면 saved — 화면이 "저장했습니다"를 보인다. 다시 고르면 내린다
 // - 세션이 바뀐 뒤(로그아웃 · 다른 계정 — reset) · 다시 받은 뒤(load) 늦게 온 응답은 쓰지 않는다 (authStore.generation · 순번)
+// - 조용히 다시 받기(refresh — 메일 화면이 탭으로 돌아올 때, 마지막으로 받은 지 60초가 지났으면 useMailSettingsRefresh 가 부른다):
+//   다른 탭 · PC 에서 바꾼 값(묶기 · 보내기 취소 초 · 외부 이미지)이 열어 둔 탭에 남지 않게. 받는 동안에도 화면은 지금 값 그대로다(loading 으로 바꾸지 않는다).
+//   저장하는 중이면 하지 않고, 받는 사이 고르거나 다시 받거나 세션이 바뀌었으면 받은 값을 버린다 — 늦게 온 옛 값이 방금 고른 것을 덮지 않게.
+//   받은 묶기 값이 다르면 메일함 화면이 그 값으로 목록을 다시 연다(MailboxPage 의 watcher). 받지 못하면 알리지 않는다
+//   (2026-11-06 실사용 시험 — 다른 탭에서 끈 묶기가 열어 둔 탭에 남았다). 받을 때마다 fetchSeq 가 오른다(마지막으로 받은 때를 세는 쪽이 본다)
 export const useMailSettingsStore = defineStore('mail-settings', () => {
   const settingsApi = useMailSettings()
   const authStore = useAuthStore()
@@ -31,6 +67,16 @@ export const useMailSettingsStore = defineStore('mail-settings', () => {
   const saved = ref<boolean>(false)
   /** 저장하는 중인 칸 수 */
   const pending = ref<number>(0)
+  /** 설정을 받기 전의 묶어 보기 짐작 — 이 브라우저에서 이 사용자가 마지막으로 쓴 값 (위 머리말) */
+  const groupHint = ref<boolean>(false)
+  /** 받지 못한 채(error) 고른 묶어 보기의 고르기 전 짐작 — 저장이 실패하면 이 값으로 되돌린다. 고른 저장이 없으면 null */
+  let hintBeforeChoice: boolean | null = null
+  /** 설정을 받은 차례 — load · refresh 가 받을 때마다 오른다 (마지막으로 받은 때를 세는 useMailSettingsRefresh 가 본다) */
+  const fetchSeq = ref<number>(0)
+  /** 고른 차례 — 고를 때마다 오른다. 조용히 다시 받는 사이 고른 것이 있으면 받은 값을 버린다 */
+  let choiceSeq = 0
+  /** 조용히 다시 받는 중 — 한 번에 하나 */
+  let refreshing = false
 
   /**
    * 알고 있는 보내기 취소 시간(초) — 받아 둔 설정이 있을 때만, 모르면 null.
@@ -40,6 +86,14 @@ export const useMailSettingsStore = defineStore('mail-settings', () => {
     status.value === 'ready' && settings.value ? settings.value.undoSendSeconds : null,
   )
 
+  /**
+   * 메일함 목록을 대화로 묶어 보기 (14단계) — 받아 둔 설정의 값, 받기 전 · 받지 못했으면 짐작(이 브라우저가 이 사용자에게서 마지막으로 안 값,
+   * 처음이면 묶지 않음). 고르면 저장이 끝나기 전에 먼저 바뀐다(위 settings 와 같다) — 메일함 화면이 이 값으로 목록 출처를 정한다 (MailboxPage)
+   */
+  const groupByConversation = computed<boolean>(() =>
+    settings.value ? settings.value.groupByConversation === true : groupHint.value,
+  )
+
   /** 서버가 마지막으로 확인해 준 값 — 마지막으로 고른 것의 저장이 실패하면 그 칸을 이 값으로 되돌린다 */
   let confirmed: MailSettings | null = null
   /** 칸마다 마지막으로 고른 값 — 보내는 저장이 끝나면 이것을 본다 (보낼 것이 남았는지) */
@@ -67,12 +121,16 @@ export const useMailSettingsStore = defineStore('mail-settings', () => {
     saved.value = false
     // 저장하던 중에 떠났다 돌아왔으면 그 저장은 이 화면의 것이 아니다 — 세던 수가 남으면 "저장했습니다"가 다시 뜨지 않는다 (리뷰 #7)
     forgetSaves()
+    // 받지 못한 채 고른 묶어 보기는 저장됐는지 모른다 — 짐작을 고르기 전으로 (받으면 서버의 값이 이긴다)
+    if (hintBeforeChoice !== null) groupHint.value = hintBeforeChoice
+    hintBeforeChoice = null
     try {
       const result = await settingsApi.getSettings({ silent: true })
       if (current !== loadSeq) return settings.value
       settings.value = { ...result }
       confirmed = { ...result }
       status.value = 'ready'
+      fetchSeq.value += 1
       return result
     } catch (caught) {
       if (current !== loadSeq) return settings.value
@@ -87,8 +145,57 @@ export const useMailSettingsStore = defineStore('mail-settings', () => {
     if (status.value === 'idle' || status.value === 'error') void load()
   }
 
+  /**
+   * 조용히 다시 받는다 (머리말) — 받아 둔 값이 있거나 받지 못했을 때만(받기 전 · 받는 중이면 하지 않는다), 저장하는 중이 아닐 때만.
+   * 받는 사이 고르거나(choiceSeq) 다시 받거나(loadSeq) 세션이 바뀌었으면 받은 값을 버리고, 받지 못하면 지금 값을 둔다 (알리지 않는다)
+   */
+  async function refresh(): Promise<void> {
+    if (status.value !== 'ready' && status.value !== 'error') return
+    if (pending.value > 0 || refreshing) return
+    const session = authStore.generation
+    const sessionLoad = loadSeq
+    const choice = choiceSeq
+    refreshing = true
+    try {
+      const result = await settingsApi.getSettings({ silent: true })
+      const stale =
+        authStore.generation !== session || loadSeq !== sessionLoad || choiceSeq !== choice || pending.value > 0
+      if (stale) return
+      settings.value = { ...result }
+      confirmed = { ...result }
+      hintBeforeChoice = null
+      status.value = 'ready'
+      error.value = null
+      fetchSeq.value += 1
+    } catch {
+      // 알리지 않는다 — 지금 값을 두고 다음에 다시 받는다
+    } finally {
+      refreshing = false
+    }
+  }
+
+  /** 고를 수 있는가 — 받는 중 · 받기 전에는 못 한다. 받지 못했으면(error) 받아 둔 값이 있을 때, 없으면 짐작으로 보이는 묶어 보기만 */
+  function canChoose(key: SettingKey): boolean {
+    if (status.value === 'ready') return settings.value !== null
+    if (status.value !== 'error') return false
+    return settings.value !== null || key === 'groupByConversation'
+  }
+
+  /** 화면이 보이는 값 — 받아 둔 설정, 없으면(받지 못함) 묶어 보기는 짐작 */
+  function shownOf<K extends SettingKey>(key: K): MailSettings[K] | undefined {
+    if (settings.value) return settings.value[key]
+    return key === 'groupByConversation' ? (groupHint.value as MailSettings[K]) : undefined
+  }
+
   function setKey<K extends SettingKey>(key: K, value: MailSettings[K]) {
     if (settings.value) settings.value = { ...settings.value, [key]: value }
+    else if (key === 'groupByConversation') groupHint.value = value as boolean
+  }
+
+  /** 저장이 실패하면 되돌릴 값 — 서버가 마지막으로 확인해 준 값, 받지 못한 채 고른 묶어 보기는 고르기 전의 짐작 */
+  function fallbackOf<K extends SettingKey>(key: K): MailSettings[K] | undefined {
+    if (confirmed) return confirmed[key]
+    return key === 'groupByConversation' && hintBeforeChoice !== null ? (hintBeforeChoice as MailSettings[K]) : undefined
   }
 
   /** 그 칸의 저장을 보낸다 — 끝나면 마지막으로 고른 값이 서버의 답과 다를 때만 그것을 이어 보낸다. 마지막 요청이 성공했으면 true */
@@ -106,8 +213,15 @@ export const useMailSettingsStore = defineStore('mail-settings', () => {
           const result = await settingsApi.updateSettings({ [key]: value } as Partial<MailSettings>)
           if (!stillCurrent()) return false
           succeeded = true
-          confirmed = { ...(confirmed ?? result), [key]: result[key] }
           const latest = wanted.get(key) as MailSettings[K]
+          // 받지 못한 채 고른 것이었으면 응답(저장한 뒤의 설정 전체)을 받은 설정으로 삼는다 — 고른 값은 그대로 보인다
+          if (!settings.value) {
+            settings.value = { ...result, [key]: latest }
+            status.value = 'ready'
+            error.value = null
+          }
+          hintBeforeChoice = null
+          confirmed = { ...(confirmed ?? result), [key]: result[key] }
           // 그사이 다른 값을 골랐고 그것이 서버의 답과 다르면 이어 보낸다 — 아니면 서버의 답으로 맞추고 끝낸다
           if (latest !== value && latest !== result[key]) next = latest
           else setKey(key, result[key])
@@ -115,9 +229,10 @@ export const useMailSettingsStore = defineStore('mail-settings', () => {
           if (!stillCurrent()) return false
           succeeded = false
           const latest = wanted.get(key) as MailSettings[K]
-          // 그사이 다른 값을 골랐으면(서버가 확인한 값이 아니면) 그것을 보내 본다 — 아니면 서버가 확인한 값으로 되돌린다
-          if (latest !== value && latest !== confirmed?.[key]) next = latest
-          else if (confirmed) setKey(key, confirmed[key])
+          const fallback = fallbackOf(key)
+          // 그사이 다른 값을 골랐으면(서버가 확인한 값이 아니면) 그것을 보내 본다 — 아니면 서버가 확인한 값(받지 못했으면 고르기 전 짐작)으로 되돌린다
+          if (latest !== value && latest !== fallback) next = latest
+          else if (fallback !== undefined) setKey(key, fallback)
         }
         if (next === undefined) break
         value = next
@@ -127,6 +242,7 @@ export const useMailSettingsStore = defineStore('mail-settings', () => {
       if (stillCurrent()) {
         wanted.delete(key)
         chains.delete(key)
+        if (key === 'groupByConversation') hintBeforeChoice = null
         lastSucceeded = succeeded
         pending.value = Math.max(0, pending.value - 1)
         if (pending.value === 0) saved.value = lastSucceeded
@@ -136,14 +252,16 @@ export const useMailSettingsStore = defineStore('mail-settings', () => {
 
   /**
    * 한 칸을 고른다 — 화면을 먼저 바꾸고 PATCH { key: value }. 그 칸의 저장이 이미 돌고 있으면 보내지 않고 고른 값만 기억한다
-   * (앞 저장이 끝나면 이어 보낸다 — 위 머리말). 받은 설정이 없으면 보내지 않는다(false).
-   * 돌려주는 약속은 그 칸의 저장이 다 끝났을 때 — 마지막 요청이 성공했으면 true
+   * (앞 저장이 끝나면 이어 보낸다 — 위 머리말). 받는 중 · 받기 전이면 보내지 않는다(false). 받지 못했으면(error) 받아 둔 값이 없어도
+   * 묶어 보기는 짐작 위에서 고른다(canChoose). 돌려주는 약속은 그 칸의 저장이 다 끝났을 때 — 마지막 요청이 성공했으면 true
    */
   function update<K extends SettingKey>(key: K, value: MailSettings[K]): Promise<boolean> {
-    if (!settings.value || status.value !== 'ready') return Promise.resolve(false)
+    if (!canChoose(key)) return Promise.resolve(false)
     const running = chains.get(key)
     // 지금 값을 다시 눌렀다 — 보낼 것이 없다
-    if (!running && settings.value[key] === value) return Promise.resolve(true)
+    if (!running && shownOf(key) === value) return Promise.resolve(true)
+    if (!running && !settings.value && key === 'groupByConversation') hintBeforeChoice = groupHint.value
+    choiceSeq += 1
     setKey(key, value)
     wanted.set(key, value)
     saved.value = false
@@ -155,6 +273,9 @@ export const useMailSettingsStore = defineStore('mail-settings', () => {
 
   function reset() {
     loadSeq += 1
+    // 화면이 보는 묶어 보기는 그대로 둔다 — 로그아웃 · 세션 만료 직후 떠나는 메일 화면이 다른 목록을 부르지 않게 (리뷰 M1)
+    groupHint.value = groupByConversation.value
+    hintBeforeChoice = null
     settings.value = null
     confirmed = null
     forgetSaves()
@@ -169,5 +290,38 @@ export const useMailSettingsStore = defineStore('mail-settings', () => {
     () => reset(),
   )
 
-  return { settings, status, error, saved, pending, knownUndoSendSeconds, load, ensureLoaded, update, reset }
+  // 묶어 보기의 짐작 — 로그인한 사용자의 것을 읽고(로그아웃은 그대로 둔다 — reset), 받거나 고른 값이 생기면 기억해 둔다
+  watch(
+    () => authStore.user?.email ?? null,
+    (email) => {
+      if (email) groupHint.value = readGroupHint(email)
+    },
+    { immediate: true },
+  )
+  watch(
+    () => settings.value?.groupByConversation,
+    (grouped) => {
+      const email = authStore.user?.email
+      if (email && grouped !== undefined) {
+        groupHint.value = grouped
+        writeGroupHint(email, grouped)
+      }
+    },
+  )
+
+  return {
+    settings,
+    status,
+    error,
+    saved,
+    pending,
+    fetchSeq,
+    knownUndoSendSeconds,
+    groupByConversation,
+    load,
+    ensureLoaded,
+    refresh,
+    update,
+    reset,
+  }
 })
diff --git a/frontend/src/stores/mail.store.conversation.spec.ts b/frontend/src/stores/mail.store.conversation.spec.ts
new file mode 100644
index 0000000..46147c8
--- /dev/null
+++ b/frontend/src/stores/mail.store.conversation.spec.ts
@@ -0,0 +1,879 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { createPinia, setActivePinia } from 'pinia'
+
+import {
+  MAIL_CONVERSATION_DETAIL_CACHE_MAX,
+  MAIL_CONVERSATION_FILL_MAX_REQUESTS,
+  MAIL_CONVERSATION_PAGE_SIZE,
+} from '@/shared/constants/mail-conversation'
+import type { ConversationSummary, Mailbox, MessageDetail, MessageSummary } from '@/shared/types/mail'
+import { useAuthStore } from '@/stores/auth.store'
+import { useToastStore } from '@/stores/toast.store'
+import {
+  fail,
+  flushPromises,
+  installMockApi,
+  ok,
+  restoreApiAdapter,
+  type MockHandler,
+  type MockRequest,
+  type MockResult,
+} from '@/test-utils/mock-api'
+import { useMailStore } from './mail.store'
+
+// 14단계 같은 대화 — 받기 · 이어 받기 · 늦은 응답 · 다시 받기 · [더 보기] · 펼친 줄의 읽음 (계약 2절 "대화 — 14단계")
+
+const USER = { email: 'ara.kim@arasystem.test', name: '김아라' }
+
+function summary(id: string, partial: Partial<MessageSummary> = {}): MessageSummary {
+  return {
+    id,
+    threadId: 't1',
+    mailboxIds: ['inbox'],
+    from: { name: '이도윤', email: 'doyun.lee@arasystem.test' },
+    to: [{ name: '김아라', email: USER.email }],
+    subject: '회신: 유지보수 계약 갱신 건',
+    preview: `미리 보기 ${id}`,
+    receivedAt: '2026-10-29T00:30:00Z',
+    isRead: true,
+    isFlagged: false,
+    hasAttachment: false,
+    size: 100,
+    ...partial,
+  }
+}
+
+function detail(id: string, partial: Partial<MessageDetail> = {}): MessageDetail {
+  return {
+    ...summary(id),
+    cc: [],
+    bcc: [],
+    replyTo: [],
+    sentAt: null,
+    messageId: null,
+    references: [],
+    htmlBody: '<p>본문</p>',
+    textBody: '본문',
+    hasBlockedImages: false,
+    attachments: [],
+    ...partial,
+  }
+}
+
+function conversation(items: MessageSummary[], nextCursor: string | null = null, total: number | null = items.length): MockResult {
+  return ok({ items, pageInfo: { hasNext: nextCursor !== null, nextCursor, total }, basis: 'index' })
+}
+
+function deferred() {
+  let resolve: (value: MockResult) => void = () => undefined
+  const promise = new Promise<MockResult>((done) => {
+    resolve = done
+  })
+  return { promise, resolve }
+}
+
+const THREAD = [summary('m1', { mailboxIds: ['sent'] }), summary('m2'), summary('m3')]
+const ids = (list: readonly { id: string }[]) => list.map((entry) => entry.id)
+
+/** 한 쪽(100통)이 찬 첫 쪽 — 처음 받을 때 이어 묻지 않고 [더 보기]가 남는다 (색인 방식의 큰 대화) */
+function fullPage(...head: MessageSummary[]): MessageSummary[] {
+  const rest = Array.from({ length: MAIL_CONVERSATION_PAGE_SIZE - head.length }, (_, index) => summary(`p${index + 1}`))
+  return [...head, ...rest]
+}
+const conversationRequests = (requests: MockRequest[]) => requests.filter((request) => request.url.endsWith('/conversation'))
+
+describe('mail.store — 14단계 같은 대화', () => {
+  let requests: MockRequest[]
+
+  beforeEach(() => {
+    setActivePinia(createPinia())
+    useAuthStore().markAuthenticated(USER)
+  })
+
+  afterEach(() => {
+    useToastStore().clear()
+    restoreApiAdapter()
+  })
+
+  function serve(handler: MockHandler) {
+    requests = installMockApi(handler)
+  }
+
+  describe('받기', () => {
+    it('그 메일의 대화를 알리지 않고 받는다 — 오래된 차례 그대로, N 은 total', async () => {
+      serve(() => conversation(THREAD))
+      const store = useMailStore()
+
+      await store.loadConversation('m3')
+
+      const [request] = conversationRequests(requests)
+      expect(request?.url).toBe('/messages/m3/conversation')
+      expect(request?.params).toEqual({ limit: MAIL_CONVERSATION_PAGE_SIZE })
+      expect(request?.config.silent).toBe(true)
+      expect(ids(store.conversationItems)).toEqual(['m1', 'm2', 'm3'])
+      expect(store.conversationCount).toBe(3)
+      expect(store.conversationVisible).toBe(true)
+      expect(store.hasMoreConversation).toBe(false)
+    })
+
+    it('한 통뿐이면 칸이 없다', async () => {
+      serve(() => conversation([summary('m3')]))
+      const store = useMailStore()
+
+      await store.loadConversation('m3')
+
+      expect(store.conversationStatus).toBe('ready')
+      expect(store.conversationVisible).toBe(false)
+    })
+
+    it('못 받으면 알리지 않고 칸이 안내를 그린다 — 없는 메일(404 RES_001 · 이 경로가 없는 옛 서버)은 칸 없이', async () => {
+      serve(() => fail(503, 'MAIL_001'))
+      const store = useMailStore()
+
+      await store.loadConversation('m3')
+      expect(store.conversationStatus).toBe('error')
+      expect(store.conversationFailed).toBe(true)
+      expect(store.conversationError?.code).toBe('MAIL_001')
+
+      serve(() => fail(404, 'RES_001'))
+      await store.retryConversation()
+      expect(store.conversationStatus).toBe('error')
+      expect(store.conversationFailed).toBe(false)
+      expect(store.conversationVisible).toBe(false)
+      expect(useToastStore().toasts).toEqual([])
+    })
+
+    it('[다시 시도]는 처음부터 다시 받는다 — 받으면 칸이 보인다', async () => {
+      let healthy = false
+      serve(() => (healthy ? conversation(THREAD) : fail(503, 'MAIL_001')))
+      const store = useMailStore()
+      await store.loadConversation('m3')
+
+      healthy = true
+      await store.retryConversation()
+
+      expect(store.conversationFailed).toBe(false)
+      expect(store.conversationVisible).toBe(true)
+      expect(conversationRequests(requests)).toHaveLength(2)
+    })
+
+    it('같은 메일을 이미 받았거나 받는 중이면 다시 묻지 않는다 (다시 받기는 refreshConversation)', async () => {
+      const first = deferred()
+      serve(() => first.promise)
+      const store = useMailStore()
+
+      const loading = store.loadConversation('m3')
+      void store.loadConversation('m3')
+      first.resolve(conversation(THREAD))
+      await loading
+      await store.loadConversation('m3')
+
+      expect(conversationRequests(requests)).toHaveLength(1)
+    })
+  })
+
+  describe('이어 받기 — hasNext 인데 항목이 적거나 0개인 쪽 (엔진 방식)', () => {
+    it('지금 메일 한 통만 받고 이어 묻는 동안은 칸을 그리지 않고, 두 통 넘게 모이면 보이며 뒤에서 잇는다', async () => {
+      const third = deferred()
+      serve(({ params }) => {
+        if (!params.cursor) return conversation([summary('m3')], 'c2', null)
+        if (params.cursor === 'c2') return conversation([summary('m1'), summary('m2')], 'c3', null)
+        return third.promise
+      })
+      const store = useMailStore()
+
+      const loading = store.loadConversation('m3')
+      await flushPromises()
+
+      expect(conversationRequests(requests).map((request) => request.params.cursor)).toEqual([undefined, 'c2', 'c3'])
+      expect(store.conversationVisible).toBe(true)
+      expect(store.conversationLoadingMore).toBe(true)
+      // 서버의 차례대로 붙인다 — 다시 줄 세우지 않는다
+      expect(ids(store.conversationItems)).toEqual(['m3', 'm1', 'm2'])
+      // 수를 모르고 남은 쪽이 있다 — "같은 대화" (수 없이)
+      expect(store.conversationCount).toBeNull()
+
+      third.resolve(conversation([summary('m4')], null, null))
+      await loading
+      expect(store.conversationLoadingMore).toBe(false)
+      expect(store.conversationCount).toBe(4)
+    })
+
+    it(`빈 쪽이 이어지면 ${MAIL_CONVERSATION_FILL_MAX_REQUESTS}번까지만 묻고 멈춘다 — 남은 쪽은 [더 보기]`, async () => {
+      let next = 0
+      serve(({ params }) => {
+        next += 1
+        return params.cursor ? conversation([], `c${next + 1}`, null) : conversation([summary('m3'), summary('m2')], 'c2', null)
+      })
+      const store = useMailStore()
+
+      await store.loadConversation('m3')
+
+      expect(conversationRequests(requests)).toHaveLength(MAIL_CONVERSATION_FILL_MAX_REQUESTS)
+      expect(store.hasMoreConversation).toBe(true)
+      expect(store.conversationVisible).toBe(true)
+      expect(store.conversationLoadingMore).toBe(false)
+    })
+
+    it('한 쪽이 찼으면 더 묻지 않는다 — [더 보기]는 다음 쪽부터 같은 결로 잇고, 사용자가 누른 일이라 실패는 알린다(받은 데까지 남는다)', async () => {
+      let failing = false
+      serve(({ params }) => {
+        if (!params.cursor) return conversation(fullPage(summary('m1')), 'c2', 102)
+        if (failing) return fail(503, 'MAIL_001')
+        return conversation([summary('m2'), summary('m3')], null, null)
+      })
+      const store = useMailStore()
+      await store.loadConversation('m3')
+      expect(conversationRequests(requests)).toHaveLength(1)
+      expect(store.hasMoreConversation).toBe(true)
+
+      failing = true
+      await store.loadMoreConversation()
+      expect(conversationRequests(requests).at(-1)?.params).toEqual({ limit: MAIL_CONVERSATION_PAGE_SIZE, cursor: 'c2' })
+      expect(conversationRequests(requests).at(-1)?.config.silent).toBeUndefined()
+      expect(useToastStore().toasts.map((toast) => toast.kind)).toEqual(['error'])
+      expect(store.conversationItems).toHaveLength(MAIL_CONVERSATION_PAGE_SIZE)
+      expect(store.hasMoreConversation).toBe(true)
+
+      failing = false
+      await store.loadMoreConversation()
+      expect(ids(store.conversationItems).slice(-2)).toEqual(['m2', 'm3'])
+      expect(store.hasMoreConversation).toBe(false)
+      // 다음 쪽의 total 은 null — 첫 쪽의 수를 남긴다
+      expect(store.conversationCount).toBe(102)
+    })
+  })
+
+  describe('늦게 온 응답 · 같은 대화의 다른 메일', () => {
+    it('메일을 바꾸면 앞 메일의 늦은 응답은 버린다', async () => {
+      const late = deferred()
+      serve(({ url }) => (url === '/messages/m3/conversation' ? late.promise : conversation([summary('x1'), summary('x2')])))
+      const store = useMailStore()
+
+      const first = store.loadConversation('m3')
+      await store.loadConversation('x2')
+      late.resolve(conversation(THREAD))
+      await first
+
+      expect(store.conversationMessageId).toBe('x2')
+      expect(ids(store.conversationItems)).toEqual(['x1', 'x2'])
+    })
+
+    it('같은 대화의 다른 메일로 옮기면 줄을 둔 채 그 메일로 새로 받는다 — 옛 커서는 쓰지 않는다([더 보기]를 내린다)', async () => {
+      const second = deferred()
+      const first = fullPage(...THREAD)
+      serve(({ url }) => (url === '/messages/m3/conversation' ? conversation(first, 'old', null) : second.promise))
+      const store = useMailStore()
+      await store.loadConversation('m3')
+      expect(store.hasMoreConversation).toBe(true)
+
+      const moving = store.loadConversation('m2')
+      expect(store.conversationMessageId).toBe('m2')
+      expect(store.conversationVisible).toBe(true)
+      expect(ids(store.conversationItems)).toEqual(ids(first))
+      expect(store.hasMoreConversation).toBe(false)
+      // 남은 쪽이 있다는 것은 그대로 — 받은 수(100)를 통 수로 짐작하지 않는다
+      expect(store.conversationCount).toBeNull()
+
+      second.resolve(conversation([...THREAD, summary('m4')], null, 4))
+      await moving
+      expect(conversationRequests(requests).at(-1)?.url).toBe('/messages/m2/conversation')
+      expect(conversationRequests(requests).at(-1)?.params).toEqual({ limit: MAIL_CONVERSATION_PAGE_SIZE })
+      expect(ids(store.conversationItems)).toEqual(['m1', 'm2', 'm3', 'm4'])
+    })
+
+    it('열린 메일을 닫으면(주소에 메일이 없다) 칸을 비운다 — 늦은 응답도 버린다', async () => {
+      const late = deferred()
+      serve(() => late.promise)
+      const store = useMailStore()
+      const loading = store.loadConversation('m3')
+
+      store.closeMessage()
+      late.resolve(conversation(THREAD))
+      await loading
+
+      expect(store.conversationMessageId).toBeNull()
+      expect(store.conversationItems).toEqual([])
+      expect(store.conversationStatus).toBe('idle')
+    })
+
+    it('세션이 바뀌면(로그아웃 · 다른 계정) 비우고 늦은 응답을 버린다', async () => {
+      const late = deferred()
+      serve(() => late.promise)
+      const store = useMailStore()
+      const loading = store.loadConversation('m3')
+
+      useAuthStore().clearAuth()
+      useAuthStore().startSession({ email: 'seojun.park@arasystem.test', name: '박서준' })
+      await flushPromises()
+      late.resolve(conversation(THREAD))
+      await loading
+
+      expect(store.conversationMessageId).toBeNull()
+      expect(store.conversationItems).toEqual([])
+      expect(store.conversationStatus).toBe('idle')
+    })
+  })
+
+  describe('다시 받기 (바뀜 소식 · 쓰기 화면에서 돌아옴)', () => {
+    it('보이는 채로 처음 쪽부터 다시 받아 한 번에 바꾼다 — 실패는 알리지 않고 그대로 둔다', async () => {
+      let thread = THREAD
+      let failing = false
+      serve(() => (failing ? fail(503, 'MAIL_001') : conversation(thread)))
+      const store = useMailStore()
+      await store.loadConversation('m3')
+
+      thread = [...THREAD, summary('m4', { mailboxIds: ['sent'] })]
+      await store.refreshConversation()
+      expect(ids(store.conversationItems)).toEqual(['m1', 'm2', 'm3', 'm4'])
+      expect(conversationRequests(requests).at(-1)?.config.silent).toBe(true)
+
+      failing = true
+      await store.refreshConversation()
+      expect(ids(store.conversationItems)).toEqual(['m1', 'm2', 'm3', 'm4'])
+      expect(useToastStore().toasts).toEqual([])
+    })
+
+    it('한 번에 하나 — 받는 사이 온 요청은 여럿이어도 끝난 뒤 한 번만 더 받는다', async () => {
+      const replies: ReturnType<typeof deferred>[] = []
+      serve(() => {
+        if (replies.length === 0) return conversation(THREAD)
+        const reply = deferred()
+        replies.push(reply)
+        return reply.promise
+      })
+      const store = useMailStore()
+      await store.loadConversation('m3')
+      replies.push(deferred())
+
+      const refreshing = store.refreshConversation()
+      void store.refreshConversation()
+      void store.refreshConversation()
+      await flushPromises()
+      expect(conversationRequests(requests)).toHaveLength(2)
+
+      replies[1]?.resolve(conversation(THREAD))
+      await flushPromises()
+      expect(conversationRequests(requests)).toHaveLength(3)
+      replies[2]?.resolve(conversation(THREAD))
+      await refreshing
+      expect(conversationRequests(requests)).toHaveLength(3)
+    })
+
+    it('[더 보기]로 더 받은 대화는 저절로 다시 받지 않는다 — 받아 둔 줄이 처음 쪽으로 줄지 않게', async () => {
+      serve(({ params }) =>
+        params.cursor ? conversation([summary('m3')], null, null) : conversation(fullPage(summary('m1')), 'c2', 101),
+      )
+      const store = useMailStore()
+      await store.loadConversation('m3')
+      await store.loadMoreConversation()
+      const sent = conversationRequests(requests).length
+      expect(sent).toBe(2)
+
+      await store.refreshConversation()
+
+      expect(conversationRequests(requests)).toHaveLength(sent)
+      expect(store.conversationItems).toHaveLength(MAIL_CONVERSATION_PAGE_SIZE + 1)
+    })
+
+    it('붙잡힌 메일(보내기 취소 · 예약)이 든 대화만 엔진이 풀 때 다시 받는다 (refreshPendingSends)', async () => {
+      const held = summary('m4', {
+        mailboxIds: ['sent'],
+        pendingSend: { kind: 'undo', sendAt: '2026-10-29T01:00:10Z' },
+      })
+      let thread = THREAD
+      serve(({ url }) => {
+        if (url.endsWith('/conversation')) return conversation(thread)
+        return ok({ items: [], pageInfo: { hasNext: false, nextCursor: null, total: 0 } })
+      })
+      const store = useMailStore()
+      await store.loadConversation('m3')
+      await store.refreshPendingSends()
+      expect(conversationRequests(requests)).toHaveLength(1)
+
+      thread = [...THREAD, held]
+      await store.refreshConversation()
+      thread = [...THREAD, { ...held, pendingSend: null }]
+      await store.refreshPendingSends()
+
+      expect(conversationRequests(requests)).toHaveLength(3)
+      expect(store.conversationItems.at(-1)?.pendingSend).toBeNull()
+    })
+  })
+
+  describe('펼친 줄 — 검색 쿼리 없이 받고, 안 읽은 메일이면 읽음으로', () => {
+    function serveThread(items: MessageSummary[], options: { detailReply?: () => MockResult | Promise<MockResult>; patch?: () => MockResult } = {}) {
+      serve(({ url, method }) => {
+        if (url.endsWith('/conversation')) return conversation(items)
+        if (method === 'PATCH') return options.patch?.() ?? ok({ ...summary('m2'), isRead: true })
+        return options.detailReply?.() ?? ok(detail(url.split('/').pop() ?? 'm2', { isRead: false }))
+      })
+    }
+    const patches = () => requests.filter((request) => request.method === 'PATCH')
+    const details = () =>
+      requests.filter(
+        (request) => request.method === 'GET' && request.url.startsWith('/messages/') && !request.url.endsWith('/conversation'),
+      )
+
+    it('펴면 그 메일을 쿼리 없이(강조 없이) 알리지 않고 받고, 안 읽은 메일이면 한 번만 읽음으로 — 접었다 다시 펴도 다시 받지 않는다', async () => {
+      serveThread([summary('m1'), summary('m2', { isRead: false }), summary('m3')])
+      const store = useMailStore()
+      await store.loadConversation('m3')
+
+      store.toggleConversationMessage('m2')
+      expect(store.conversationExpandedIds.has('m2')).toBe(true)
+      expect(store.conversationDetails.get('m2')?.status).toBe('loading')
+      await flushPromises()
+
+      expect(details().map((request) => [request.url, request.params, request.config.silent])).toEqual([
+        ['/messages/m2', {}, true],
+      ])
+      expect(store.conversationDetails.get('m2')?.status).toBe('ready')
+      expect(patches().map((request) => [request.url, request.data])).toEqual([['/messages/m2', { isRead: true }]])
+      expect(store.conversationItems.find((item) => item.id === 'm2')?.isRead).toBe(true)
+
+      store.toggleConversationMessage('m2')
+      expect(store.conversationExpandedIds.has('m2')).toBe(false)
+      store.toggleConversationMessage('m2')
+      await flushPromises()
+      expect(details()).toHaveLength(1)
+      expect(patches()).toHaveLength(1)
+    })
+
+    it('지금 메일의 줄은 펴지 않는다', async () => {
+      serveThread(THREAD)
+      const store = useMailStore()
+      await store.loadConversation('m3')
+
+      store.toggleConversationMessage('m3')
+
+      expect(store.conversationExpandedIds.size).toBe(0)
+      expect(details()).toEqual([])
+    })
+
+    it('본문이 오기 전에 접었으면 읽음으로 바꾸지 않는다 (읽지 않았다)', async () => {
+      const reply = deferred()
+      serveThread([summary('m2', { isRead: false }), summary('m3')], { detailReply: () => reply.promise })
+      const store = useMailStore()
+      await store.loadConversation('m3')
+
+      store.toggleConversationMessage('m2')
+      store.toggleConversationMessage('m2')
+      reply.resolve(ok(detail('m2', { isRead: false })))
+      await flushPromises()
+
+      expect(store.conversationDetails.get('m2')?.status).toBe('ready')
+      expect(patches()).toEqual([])
+    })
+
+    it('받아 둔 대화가 옛 값이어도 이 탭이 읽음으로 아는 메일(보이는 목록 · 열린 메일)은 다시 읽음으로 바꾸지 않는다', async () => {
+      serveThread([summary('m1', { isRead: false }), summary('m2', { isRead: false }), summary('m3')])
+      const store = useMailStore()
+      store.messages = [summary('m1', { isRead: true })]
+      store.selected = detail('m2', { isRead: true })
+      await store.loadConversation('m3')
+
+      store.toggleConversationMessage('m1')
+      store.toggleConversationMessage('m2')
+      await flushPromises()
+
+      expect(patches()).toEqual([])
+      expect(store.conversationItems.filter((item) => !item.isRead)).toEqual([])
+    })
+
+    it('읽음으로 바꾸지 못하면 이 칸의 표시도 되돌린다 — 다시 펴면 다시 해 본다', async () => {
+      let rejecting = true
+      serveThread([summary('m2', { isRead: false }), summary('m3')], {
+        patch: () => (rejecting ? fail(503, 'MAIL_001') : ok({ ...summary('m2'), isRead: true })),
+      })
+      const store = useMailStore()
+      await store.loadConversation('m3')
+
+      store.toggleConversationMessage('m2')
+      await flushPromises()
+      expect(store.conversationItems.find((item) => item.id === 'm2')?.isRead).toBe(false)
+
+      rejecting = false
+      store.toggleConversationMessage('m2')
+      store.toggleConversationMessage('m2')
+      await flushPromises()
+      expect(patches()).toHaveLength(2)
+      expect(store.conversationItems.find((item) => item.id === 'm2')?.isRead).toBe(true)
+    })
+
+    it('본문을 못 받으면 줄 안에 오류 — [다시 시도]로 다시 받는다', async () => {
+      let failing = true
+      serveThread([summary('m2'), summary('m3')], {
+        detailReply: () => (failing ? fail(503, 'MAIL_001') : ok(detail('m2'))),
+      })
+      const store = useMailStore()
+      await store.loadConversation('m3')
+
+      store.toggleConversationMessage('m2')
+      await flushPromises()
+      const state = store.conversationDetails.get('m2')
+      expect(state?.status === 'error' ? state.error.code : null).toBe('MAIL_001')
+      expect(useToastStore().toasts).toEqual([])
+
+      failing = false
+      await store.retryConversationDetail('m2')
+      expect(store.conversationDetails.get('m2')?.status).toBe('ready')
+    })
+
+    it('같은 대화의 다른 메일로 옮기면 그 줄(이제 지금 메일)의 펼침을 접고, 읽기 화면이 본 앞 메일은 읽음으로 본다', async () => {
+      serveThread([summary('m2'), summary('m3', { isRead: false })])
+      const store = useMailStore()
+      await store.loadConversation('m3')
+      store.toggleConversationMessage('m2')
+      await flushPromises()
+
+      await store.loadConversation('m2')
+      expect(store.conversationExpandedIds.has('m2')).toBe(false)
+
+      store.toggleConversationMessage('m3')
+      await flushPromises()
+      expect(patches()).toEqual([])
+    })
+
+    it('본문을 받는 사이 세션이 바뀌면(로그아웃 뒤 다시 로그인) 버리고 읽음으로 바꾸지 않는다', async () => {
+      const reply = deferred()
+      serveThread([summary('m2', { isRead: false }), summary('m3')], { detailReply: () => reply.promise })
+      const store = useMailStore()
+      await store.loadConversation('m3')
+
+      store.toggleConversationMessage('m2')
+      useAuthStore().clearAuth()
+      useAuthStore().startSession(USER)
+      reply.resolve(ok(detail('m2', { isRead: false })))
+      await flushPromises()
+
+      expect(patches()).toEqual([])
+      expect(store.conversationDetails.get('m2')?.status).not.toBe('ready')
+    })
+
+    it(`접힌 줄의 받아 둔 본문은 최근 ${MAIL_CONVERSATION_DETAIL_CACHE_MAX}개만 둔다 — 펼친 줄의 본문은 세지 않고 늘 두며, 버린 본문은 다시 펴면 다시 받는다`, async () => {
+      const others = Array.from({ length: MAIL_CONVERSATION_DETAIL_CACHE_MAX + 3 }, (_, index) => summary(`r${index}`))
+      serveThread([...others, summary('m3')])
+      const store = useMailStore()
+      await store.loadConversation('m3')
+
+      store.toggleConversationMessage('r0')
+      await flushPromises()
+      for (let index = 1; index < others.length; index += 1) {
+        store.toggleConversationMessage(`r${index}`)
+        await flushPromises()
+        store.toggleConversationMessage(`r${index}`)
+      }
+
+      const cached = [...store.conversationDetails.keys()]
+      expect(cached[0]).toBe('r0')
+      expect(cached.slice(1)).toEqual(
+        Array.from({ length: MAIL_CONVERSATION_DETAIL_CACHE_MAX }, (_, index) => `r${index + 3}`),
+      )
+      expect(store.conversationExpandedIds.has('r0')).toBe(true)
+
+      const fetched = details().length
+      store.toggleConversationMessage(`r${others.length - 1}`)
+      await flushPromises()
+      expect(details()).toHaveLength(fetched)
+      store.toggleConversationMessage('r1')
+      await flushPromises()
+      expect(details()).toHaveLength(fetched + 1)
+    })
+  })
+
+  describe('다시 받아 달라는 소식 — 메일함들의 통 수가 바뀔 때만', () => {
+    const box = (id: string, totalCount: number, unreadCount: number) => ({
+      id,
+      name: id,
+      role: null,
+      parentId: null,
+      sortOrder: 0,
+      totalCount,
+      unreadCount,
+    })
+
+    it('처음 받은 메일함 목록 · 안 읽은 수만 바뀜 · 차례만 바뀜에는 오르지 않고, 새 메일 · 옮김으로 통 수가 바뀌면 오른다 — 비울 때도 오르지 않는다', async () => {
+      serve(() => ok(null))
+      const store = useMailStore()
+      const seq = () => store.conversationRefreshSeq
+
+      store.mailboxes = [box('inbox', 3, 1), box('sent', 1, 0)]
+      await flushPromises()
+      expect(seq()).toBe(0)
+
+      store.mailboxes = [box('inbox', 3, 0), box('sent', 1, 0)]
+      await flushPromises()
+      expect(seq()).toBe(0)
+
+      store.mailboxes = [box('inbox', 4, 0), box('sent', 1, 0)]
+      await flushPromises()
+      expect(seq()).toBe(1)
+
+      store.mailboxes = [box('inbox', 3, 0), box('sent', 2, 0)]
+      await flushPromises()
+      expect(seq()).toBe(2)
+
+      store.mailboxes = [box('sent', 2, 0), box('inbox', 3, 0)]
+      await flushPromises()
+      expect(seq()).toBe(2)
+
+      store.reset()
+      await flushPromises()
+      expect(seq()).toBe(2)
+    })
+  })
+
+  describe('묻는 중 · 붙잡힌 메일 · 그사이 지워진 메일', () => {
+    it('묻는 동안 conversationBusy — 끝나면 꺼진다 (칸이 그때부터 다시 받기의 간격을 센다)', async () => {
+      const reply = deferred()
+      serve(() => reply.promise)
+      const store = useMailStore()
+
+      const loading = store.loadConversation('m3')
+      expect(store.conversationBusy).toBe(true)
+      reply.resolve(conversation(THREAD))
+      await loading
+      expect(store.conversationBusy).toBe(false)
+
+      // 받을 것이 없으면(받은 대화가 없음) 묻지 않는다 — 켜지지 않는다
+      store.reset()
+      await store.refreshConversation()
+      expect(store.conversationBusy).toBe(false)
+    })
+
+    it('[더 보기]로 더 받은 대화는 붙잡힌 메일만 그 메일로 고친다 — 다 보냈으면 표시가 내려가고, 지워졌으면(404) 그 줄을 뺀다', async () => {
+      const sendAt = '2026-10-29T01:00:10Z'
+      const sent = summary('h1', { mailboxIds: ['sent'], pendingSend: { kind: 'undo', sendAt } })
+      const gone = summary('h2', { mailboxIds: ['sent'], pendingSend: { kind: 'scheduled', sendAt } })
+      serve(({ url, params }) => {
+        if (url.endsWith('/conversation')) {
+          return params.cursor ? conversation([sent, gone, summary('m3')], null, null) : conversation(fullPage(summary('m1')), 'c2', 103)
+        }
+        if (url === '/messages/h1') return ok(detail('h1', { mailboxIds: ['sent'], pendingSend: null, htmlBody: '<p>긴 본문</p>' }))
+        if (url === '/messages/h2') return fail(404, 'RES_001')
+        return ok({ items: [], pageInfo: { hasNext: false, nextCursor: null, total: 0 } })
+      })
+      const store = useMailStore()
+      await store.loadConversation('m3')
+      await store.loadMoreConversation()
+      const sentConversations = conversationRequests(requests).length
+
+      await store.refreshPendingSends()
+
+      expect(conversationRequests(requests)).toHaveLength(sentConversations)
+      expect(
+        requests.filter((request) => request.url === '/messages/h1' || request.url === '/messages/h2').map((request) => [request.url, request.config.silent]),
+      ).toEqual([
+        ['/messages/h1', true],
+        ['/messages/h2', true],
+      ])
+      const fixed = store.conversationItems.find((item) => item.id === 'h1')
+      expect(fixed?.pendingSend).toBeNull()
+      // 줄에는 요약만 — 본문을 싣지 않는다
+      expect(fixed && 'htmlBody' in fixed).toBe(false)
+      expect(store.conversationItems.some((item) => item.id === 'h2')).toBe(false)
+      expect(store.conversationCount).toBe(102)
+      expect(useToastStore().toasts).toEqual([])
+    })
+
+    it('[더 보기]로 더 받은 대화에서 펼친 본문이 404(그사이 지워짐)면 다시 받지 않고 그 줄만 뺀다', async () => {
+      serve(({ url, params }) => {
+        if (url.endsWith('/conversation')) {
+          return params.cursor ? conversation([summary('x1'), summary('m3')], null, null) : conversation(fullPage(summary('m1')), 'c2', 102)
+        }
+        return fail(404, 'RES_001')
+      })
+      const store = useMailStore()
+      await store.loadConversation('m3')
+      await store.loadMoreConversation()
+      const sentConversations = conversationRequests(requests).length
+
+      store.toggleConversationMessage('x1')
+      await flushPromises()
+
+      expect(conversationRequests(requests)).toHaveLength(sentConversations)
+      expect(store.conversationItems.some((item) => item.id === 'x1')).toBe(false)
+      expect(store.conversationExpandedIds.has('x1')).toBe(false)
+      expect(store.conversationCount).toBe(101)
+    })
+
+    it('같은 메일을 읽음으로 보내는 중이면 다시 보내지 않는다 — 안 읽은 수를 두 번 빼지 않게', async () => {
+      const patch = deferred()
+      serve(({ method }) => (method === 'PATCH' ? patch.promise : ok(null)))
+      const store = useMailStore()
+      store.mailboxes = [{ id: 'inbox', name: '받은편지함', role: 'inbox', parentId: null, sortOrder: 0, totalCount: 2, unreadCount: 2 }]
+      store.mailboxesStatus = 'ready'
+      const message = { id: 'm2', isRead: false, mailboxIds: ['inbox'] }
+
+      const first = store.markRead(message)
+      expect(await store.markRead(message)).toBe(true)
+      patch.resolve(ok({ ...summary('m2'), isRead: true }))
+      expect(await first).toBe(true)
+
+      expect(requests.filter((request) => request.method === 'PATCH')).toHaveLength(1)
+      expect(store.mailboxes[0]?.unreadCount).toBe(1)
+    })
+  })
+
+  describe('이 탭이 바꾼 읽음 — 칸의 줄에 바로 (2026-11-07 사용자 관점 점검)', () => {
+    const INBOX: Mailbox = { id: 'inbox', name: '받은편지함', role: 'inbox', parentId: null, sortOrder: 0, totalCount: 3, unreadCount: 1 }
+    const SENT: Mailbox = { ...INBOX, id: 'sent', name: '보낸편지함', role: 'sent', unreadCount: 0 }
+    const readOf = (store: ReturnType<typeof useMailStore>) => store.conversationItems.map((item) => [item.id, item.isRead])
+
+    function row(id: string, messageIds: string[], partial: Partial<ConversationSummary> = {}): ConversationSummary {
+      return {
+        id,
+        latest: summary(messageIds[0] ?? id),
+        participants: [{ name: '이도윤', email: 'doyun.lee@arasystem.test' }],
+        messageCount: messageIds.length,
+        messageIds,
+        pendingSendIds: [],
+        isRead: true,
+        isFlagged: false,
+        hasAttachment: false,
+        ...partial,
+      }
+    }
+
+    it('받는 동안 이 탭이 바꾼 읽음은 받은 값보다 앞선다(받은 쪽은 바꾸기 전의 서버 값일 수 있다) — 그 뒤에 시작한 받기는 받은 값을 믿는다', async () => {
+      const unreadThread = () => [summary('m1'), summary('m2', { isRead: false }), summary('m3')]
+      let reply: MockResult | Promise<MockResult> = conversation(unreadThread())
+      serve(({ url, method }) => {
+        if (url.endsWith('/conversation')) return reply
+        if (method === 'PATCH') return ok({ ...summary('m2'), isRead: true })
+        return ok(null)
+      })
+      const store = useMailStore()
+      await store.loadConversation('m3')
+
+      const stale = deferred()
+      reply = stale.promise
+      const refreshing = store.refreshConversation()
+      await store.markRead({ id: 'm2', isRead: false, mailboxIds: ['inbox'] })
+      expect(readOf(store)).toEqual([['m1', true], ['m2', true], ['m3', true]])
+      stale.resolve(conversation(unreadThread()))
+      await refreshing
+      expect(readOf(store)).toEqual([['m1', true], ['m2', true], ['m3', true]])
+
+      // 바꾼 뒤에 시작한 받기 — 그사이 다른 탭에서 안 읽음으로 했다
+      reply = conversation(unreadThread())
+      await store.refreshConversation()
+      expect(readOf(store)).toEqual([['m1', true], ['m2', false], ['m3', true]])
+    })
+
+    it('받기를 시작할 때 보내던 여러 통 처리의 읽음도 받은 값보다 앞선다 — 받는 사이에 끝나도', async () => {
+      let reply: MockResult | Promise<MockResult> = conversation([summary('m2', { isRead: false }), summary('m3')])
+      const bulk = deferred()
+      serve(({ url, method }) => {
+        if (url.endsWith('/conversation')) return reply
+        if (method === 'PATCH' && url === '/messages') return bulk.promise
+        return ok(null)
+      })
+      const store = useMailStore()
+      store.listSource = { kind: 'mailbox', mailboxId: 'inbox' }
+      store.messages = [summary('m2', { isRead: false }), summary('m3')]
+      await store.loadConversation('m3')
+
+      store.toggleCheck('m2')
+      const marking = store.patchChecked({ isRead: true })
+      const stale = deferred()
+      reply = stale.promise
+      const refreshing = store.refreshConversation()
+      bulk.resolve(ok({ updatedIds: ['m2'], failedIds: [] }))
+      await marking
+      stale.resolve(conversation([summary('m2', { isRead: false }), summary('m3')]))
+      await refreshing
+
+      expect(readOf(store)).toEqual([['m2', true], ['m3', true]])
+    })
+
+    it('대화 목록의 여러 통 처리가 바꾸지 못한 메일은 칸도 바꾸기 전 값으로 — 줄은 메일마다의 앞 값을 몰라 칸이 아는 값으로', async () => {
+      const bulk = deferred()
+      serve(({ url, method }) => {
+        if (url.endsWith('/conversation')) {
+          return conversation([summary('m1', { mailboxIds: ['sent'] }), summary('m2', { isRead: false }), summary('m3', { isRead: false })])
+        }
+        if (method === 'PATCH' && url === '/messages') return bulk.promise
+        return ok(null)
+      })
+      const store = useMailStore()
+      store.listSource = { kind: 'conversations', mailboxId: 'inbox' }
+      store.conversations = [row('c1', ['m3', 'm2'], { isRead: false })]
+      await store.loadConversation('m3')
+
+      store.toggleCheck('c1')
+      const marking = store.patchChecked({ isRead: true })
+      await flushPromises()
+      // 보내는 동안 — 줄의 메일은 읽은 모양, 보낸편지함의 m1 은 줄에 들지 않아 그대로
+      expect(readOf(store)).toEqual([['m1', true], ['m2', true], ['m3', true]])
+
+      bulk.resolve(ok({ updatedIds: ['m3'], failedIds: ['m2'] }))
+      await marking
+      expect(readOf(store)).toEqual([['m1', true], ['m2', false], ['m3', true]])
+    })
+
+    it('여러 통 처리의 중요 표시가 실패하면 중요 표시만 되돌린다 — 고른 때의 읽음으로 목록 · 칸을 덮지 않는다', async () => {
+      serve(({ url, method }) => {
+        if (url.endsWith('/conversation')) return conversation([summary('m2'), summary('m3')])
+        if (method === 'PATCH' && url === '/messages') return ok({ updatedIds: [], failedIds: ['m2'] })
+        return ok(null)
+      })
+      const store = useMailStore()
+      store.listSource = { kind: 'mailbox', mailboxId: 'inbox' }
+      // 목록은 옛 값(안 읽음)이고 칸은 받은 값(읽음)이다 — 검색 결과처럼 저절로 맞추지 않는 목록
+      store.messages = [summary('m2', { isRead: false }), summary('m3')]
+      await store.loadConversation('m3')
+
+      store.toggleCheck('m2')
+      await store.patchChecked({ isFlagged: true })
+
+      expect(store.messages.find((message) => message.id === 'm2')).toMatchObject({ isRead: false, isFlagged: false })
+      expect(readOf(store)).toEqual([['m2', true], ['m3', true]])
+    })
+
+    it('메일함 ⋯ › 모두 읽음이 끝나면 칸에 든 그 메일함의 메일도 읽음 — 다른 메일함의 메일은 그대로', async () => {
+      serve(({ url, method }) => {
+        if (url.endsWith('/conversation')) {
+          return conversation([summary('m1', { mailboxIds: ['sent'], isRead: false }), summary('m2', { isRead: false }), summary('m3')])
+        }
+        if (method === 'PATCH' && url === '/mailboxes/inbox/messages') return ok({ processed: 1, remaining: 0 })
+        if (url === '/mailboxes') return ok({ items: [INBOX, SENT], pageInfo: { hasNext: false, nextCursor: null, total: 2 } })
+        return ok(null)
+      })
+      const store = useMailStore()
+      store.mailboxes = [INBOX, SENT]
+      await store.loadConversation('m3')
+
+      const outcome = await store.runMailboxOperation('read', INBOX, () => undefined)
+
+      expect(outcome.status).toBe('done')
+      expect(readOf(store)).toEqual([['m1', false], ['m2', true], ['m3', true]])
+    })
+
+    it('다른 탭 · 기기에서 바꾼 읽음(목록 맞추기로 받은 값)은 칸에 옮기지 않는다 — 다음에 칸을 받을 때 보인다', async () => {
+      let thread = [summary('m2', { isRead: false }), summary('m3')]
+      serve(({ url, method }) => {
+        if (url.endsWith('/conversation')) return conversation(thread)
+        if (url === '/messages' && method === 'GET') {
+          return ok({ items: [summary('m2'), summary('m3')], pageInfo: { hasNext: false, nextCursor: null, total: 2 } })
+        }
+        return ok(null)
+      })
+      const store = useMailStore()
+      store.listSource = { kind: 'mailbox', mailboxId: 'inbox' }
+      store.messages = [summary('m2', { isRead: false }), summary('m3')]
+      store.pageInfo = { hasNext: false, nextCursor: null, total: 2 }
+      store.listStatus = 'ready'
+      await store.loadConversation('m3')
+
+      await store.syncVisibleList()
+      expect(store.messages.find((message) => message.id === 'm2')?.isRead).toBe(true)
+      expect(readOf(store)).toEqual([['m2', false], ['m3', true]])
+
+      thread = [summary('m2'), summary('m3')]
+      await store.refreshConversation()
+      expect(readOf(store)).toEqual([['m2', true], ['m3', true]])
+    })
+  })
+})
diff --git a/frontend/src/stores/mail.store.list.spec.ts b/frontend/src/stores/mail.store.list.spec.ts
index 123372f..38da811 100644
--- a/frontend/src/stores/mail.store.list.spec.ts
+++ b/frontend/src/stores/mail.store.list.spec.ts
@@ -55,6 +55,8 @@ function page(items: MessageSummary[], nextCursor: string | null = null, total:
 }
 
 const ids = (list: readonly { id: string }[]) => list.map((item) => item.id)
+/** 목록 요청만 — 검색을 시작할 때 묻는 색인 상태(GET /search-index — 14단계)는 뺀다 */
+const listRequests = (requests: MockRequest[]) => requests.filter((request) => request.url === '/messages')
 const patches = (requests: MockRequest[]) =>
   requests.filter((request) => request.method === 'PATCH' && request.url === '/messages').map((request) => request.data as MessagesPatch)
 
@@ -94,12 +96,12 @@ describe('mail.store — 3단계 목록', () => {
       const store = useMailStore()
 
       await store.openSearch('회의', 'inbox')
-      expect(requests[0]?.params).toEqual({ q: '회의', mailboxId: 'inbox', limit: 20 })
+      expect(listRequests(requests)[0]?.params).toEqual({ q: '회의', mailboxId: 'inbox', limit: 20 })
       expect(store.search).toEqual({ kind: 'search', q: '회의', scope: 'inbox' })
       expect(store.currentMailboxId).toBe('inbox')
 
       await store.openSearch('회의', SEARCH_SCOPE_ALL)
-      expect(requests[1]?.params).toEqual({ q: '회의', limit: 20 })
+      expect(listRequests(requests)[1]?.params).toEqual({ q: '회의', limit: 20 })
       expect(store.currentMailboxId).toBeNull()
       expect(ids(store.messages)).toEqual(['r1'])
     })
@@ -110,24 +112,28 @@ describe('mail.store — 3단계 목록', () => {
 
       await store.openSearch('회의', SEARCH_SCOPE_ALL)
       await store.openSearch('회의', SEARCH_SCOPE_ALL)
-      expect(requests).toHaveLength(1)
+      expect(listRequests(requests)).toHaveLength(1)
 
       await store.openSearch('회의', SEARCH_SCOPE_ALL, { force: true })
-      expect(requests).toHaveLength(2)
+      expect(listRequests(requests)).toHaveLength(2)
       expect(store.listStatus).toBe('ready')
     })
 
     it('더 보기는 검색어 · 범위와 커서를 함께 보낸다', async () => {
+      const first = Array.from({ length: 20 }, (_, index) => summary(`r${index + 1}`))
       const requests = installMockApi(({ params }) =>
-        params.cursor ? page([summary('r2')]) : page([summary('r1')], 'c2', 2),
+        params.cursor ? page([summary('r21')]) : page(first, 'c2', 21),
       )
       const store = useMailStore()
       await store.openSearch('회의', 'sent')
+      // 첫 쪽이 다 찼으면 이어 묻지 않는다
+      expect(listRequests(requests)).toHaveLength(1)
 
       await store.loadMore()
 
-      expect(requests[1]?.params).toEqual({ q: '회의', mailboxId: 'sent', cursor: 'c2', limit: 20 })
-      expect(ids(store.messages)).toEqual(['r1', 'r2'])
+      expect(listRequests(requests)[1]?.params).toEqual({ q: '회의', mailboxId: 'sent', cursor: 'c2', limit: 20 })
+      expect(store.messages).toHaveLength(21)
+      expect(store.messages.at(-1)?.id).toBe('r21')
     })
 
     it('메일함으로 돌아가면 보이던 결과를 버리고 그 메일함을 새로 연다', async () => {
@@ -186,11 +192,11 @@ describe('mail.store — 3단계 목록', () => {
       await store.openSearch('회의', SEARCH_SCOPE_ALL)
 
       await store.syncVisibleList()
-      expect(requests).toHaveLength(1)
+      expect(listRequests(requests)).toHaveLength(1)
 
       await store.syncVisibleList({ includeSearch: true })
-      expect(requests).toHaveLength(2)
-      expect(requests[1]?.params).toEqual({ q: '회의', limit: 20 })
+      expect(listRequests(requests)).toHaveLength(2)
+      expect(listRequests(requests)[1]?.params).toEqual({ q: '회의', limit: 20 })
     })
 
     it('실패해도 알리지 않고 목록을 그대로 둔다', async () => {
diff --git a/frontend/src/stores/mail.store.search14.spec.ts b/frontend/src/stores/mail.store.search14.spec.ts
new file mode 100644
index 0000000..9a8b3a9
--- /dev/null
+++ b/frontend/src/stores/mail.store.search14.spec.ts
@@ -0,0 +1,466 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { createPinia, setActivePinia } from 'pinia'
+
+import { SEARCH_SCOPE_ALL } from '@/shared/constants/mail'
+import { MAIL_SEARCH_FILL_MAX_REQUESTS } from '@/shared/constants/mail-search'
+import type { MessageDetail, MessageListItem, MessageSummary } from '@/shared/types/mail'
+import { NO_SEARCH_CONDITIONS } from '@/shared/utils/mail-search'
+import { useAuthStore } from '@/stores/auth.store'
+import { useToastStore } from '@/stores/toast.store'
+import {
+  fail,
+  flushPromises,
+  installMockApi,
+  ok,
+  restoreApiAdapter,
+  type MockRequest,
+  type MockResult,
+} from '@/test-utils/mock-api'
+import { useMailStore } from './mail.store'
+
+// 14단계 검색 — 이어 찾기 · 지난 메일 색인 상태 · 읽기 화면의 강조 쿼리 (계약 2절 "검색 — 14단계")
+
+const USER = { email: 'ara.kim@arasystem.test', name: '김아라' }
+
+function summary(id: string, partial: Partial<MessageSummary> = {}): MessageSummary {
+  return {
+    id,
+    threadId: `t-${id}`,
+    mailboxIds: ['inbox'],
+    from: { name: '이도윤', email: 'doyun.lee@arasystem.test' },
+    to: [],
+    subject: `계약 ${id}`,
+    preview: '',
+    receivedAt: '2026-11-05T01:00:00Z',
+    isRead: true,
+    isFlagged: false,
+    hasAttachment: false,
+    size: 100,
+    ...partial,
+  }
+}
+
+function item(id: string, partial: Partial<MessageListItem> = {}): MessageListItem {
+  return { ...summary(id), ...partial }
+}
+
+function detail(id: string, partial: Partial<MessageDetail> = {}): MessageDetail {
+  return {
+    ...summary(id),
+    cc: [],
+    bcc: [],
+    replyTo: [],
+    sentAt: null,
+    messageId: null,
+    references: [],
+    htmlBody: '<p>본문</p>',
+    textBody: '본문',
+    hasBlockedImages: false,
+    attachments: [],
+    ...partial,
+  }
+}
+
+function page(items: MessageListItem[], nextCursor: string | null, total: number | null = null): MockResult {
+  return ok({ items, pageInfo: { hasNext: nextCursor !== null, nextCursor, total } })
+}
+
+function deferred() {
+  let resolve: (value: MockResult) => void = () => undefined
+  const promise = new Promise<MockResult>((done) => {
+    resolve = done
+  })
+  return { promise, resolve }
+}
+
+const listRequests = (requests: MockRequest[]) => requests.filter((request) => request.url === '/messages')
+const ids = (list: readonly { id: string }[]) => list.map((entry) => entry.id)
+
+describe('mail.store — 14단계 검색', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia())
+    useAuthStore().markAuthenticated(USER)
+  })
+
+  afterEach(() => {
+    useToastStore().clear()
+    restoreApiAdapter()
+  })
+
+  describe('이어 찾기 — hasNext 인데 항목이 적거나 0개인 쪽 (색인 방식)', () => {
+    it('빈 쪽이면 커서로 이어 묻는다 — 찾을 때까지 "찾는 중", 한 쪽이 차면 멈춘다', async () => {
+      const full = Array.from({ length: 20 }, (_, index) => item(`r${index + 1}`))
+      const second = deferred()
+      const requests = installMockApi(({ url, params }) => {
+        if (url === '/search-index') return ok({ status: 'ready', done: 10, total: 10 })
+        if (!params.cursor) return page([], 'c2', null)
+        if (params.cursor === 'c2') return second.promise
+        return page([], null)
+      })
+      const store = useMailStore()
+
+      const opening = store.openSearch('계약', SEARCH_SCOPE_ALL)
+      await flushPromises()
+      expect(store.listStatus).toBe('loading')
+      expect(listRequests(requests).map((request) => request.params.cursor)).toEqual([undefined, 'c2'])
+
+      second.resolve(page(full, 'c3', null))
+      await opening
+
+      expect(store.listStatus).toBe('ready')
+      expect(store.messages).toHaveLength(20)
+      // 한 쪽이 찼다 — 더 묻지 않는다 (남은 것은 [메일 더 보기])
+      expect(listRequests(requests)).toHaveLength(2)
+      expect(store.hasMore).toBe(true)
+      expect(store.isLoadingMore).toBe(false)
+      expect(listRequests(requests)[1]?.params).toEqual({ q: '계약', cursor: 'c2', limit: 20 })
+    })
+
+    it(`빈 쪽이 이어지면 ${MAIL_SEARCH_FILL_MAX_REQUESTS}번까지만 묻고 멈춘다 — 결과 없음이 아니라 더 찾을 것이 남은 상태(hasMore)`, async () => {
+      let cursor = 0
+      const requests = installMockApi(({ url }) => {
+        if (url === '/search-index') return ok({ status: 'ready', done: 10, total: 10 })
+        cursor += 1
+        return page([], `c${cursor + 1}`, null)
+      })
+      const store = useMailStore()
+
+      await store.openSearch('계약', 'inbox')
+
+      expect(listRequests(requests)).toHaveLength(MAIL_SEARCH_FILL_MAX_REQUESTS)
+      expect(store.listStatus).toBe('ready')
+      expect(store.messages).toEqual([])
+      expect(store.hasMore).toBe(true)
+
+      // [더 찾기] — 같은 횟수만큼 더 묻는다
+      await store.loadMore()
+      expect(listRequests(requests)).toHaveLength(MAIL_SEARCH_FILL_MAX_REQUESTS * 2)
+    })
+
+    it('하나라도 찾으면 먼저 보이고 뒤에서 잇는다(isLoadingMore) — 더 없으면(hasNext false) 멈춘다', async () => {
+      const second = deferred()
+      installMockApi(({ url, params }) => {
+        if (url === '/search-index') return ok({ status: 'ready', done: 10, total: 10 })
+        return params.cursor ? second.promise : page([item('r1'), item('r2')], 'c2', 7)
+      })
+      const store = useMailStore()
+
+      const opening = store.openSearch('계약', SEARCH_SCOPE_ALL)
+      await flushPromises()
+      expect(store.listStatus).toBe('ready')
+      expect(ids(store.messages)).toEqual(['r1', 'r2'])
+      expect(store.isLoadingMore).toBe(true)
+
+      second.resolve(page([item('r3')], null, null))
+      await opening
+
+      expect(ids(store.messages)).toEqual(['r1', 'r2', 'r3'])
+      expect(store.isLoadingMore).toBe(false)
+      expect(store.hasMore).toBe(false)
+      // 다음 쪽의 total 은 null 이다 — 첫 쪽의 수를 남긴다
+      expect(store.pageInfo?.total).toBe(7)
+    })
+
+    it('더 보기도 한 쪽을 더 찾을 때까지 잇는다 — 메일함 목록은 지금처럼 한 번만 묻는다', async () => {
+      const full = Array.from({ length: 20 }, (_, index) => item(`r${index + 1}`))
+      const requests = installMockApi(({ url, params }) => {
+        if (url === '/search-index') return ok({ status: 'ready', done: 10, total: 10 })
+        if (!params.cursor) return page(full, 'c2', null)
+        if (params.cursor === 'c2') return page([], 'c3', null)
+        if (params.cursor === 'c3') return page([item('r21')], 'c4', null)
+        return page([item('r22')], null, null)
+      })
+      const store = useMailStore()
+      await store.openSearch('계약', SEARCH_SCOPE_ALL)
+
+      await store.loadMore()
+
+      expect(listRequests(requests).map((request) => request.params.cursor)).toEqual([undefined, 'c2', 'c3', 'c4'])
+      expect(store.messages).toHaveLength(22)
+
+      // 메일함 목록 — 빈 쪽이어도 이어 묻지 않는다
+      requests.length = 0
+      installMockApi(({ params }) => (params.cursor ? page([], 'm3') : page([], 'm2')))
+      await store.openMailbox('inbox')
+      expect(store.messages).toEqual([])
+      expect(store.hasMore).toBe(true)
+    })
+
+    it('이어 묻다 실패하면 받은 데까지 보인다 — 알림은 한 번(인터셉터), [더 찾기]로 다시 잇는다', async () => {
+      installMockApi(({ url, params }) => {
+        if (url === '/search-index') return ok({ status: 'ready', done: 10, total: 10 })
+        return params.cursor ? fail(503, 'MAIL_001') : page([], 'c2', null)
+      })
+      const store = useMailStore()
+
+      await store.openSearch('계약', SEARCH_SCOPE_ALL)
+
+      expect(store.listStatus).toBe('ready')
+      expect(store.listError).toBeNull()
+      expect(store.hasMore).toBe(true)
+      expect(store.isLoadingMore).toBe(false)
+      expect(useToastStore().toasts).toHaveLength(1)
+    })
+
+    it('보이는 채로 다시 찾을 때 첫 쪽이 비고 더 있으면 "찾는 중"(loading)으로 잇는다 — 옛 결과를 남기지 않는다', async () => {
+      let round = 1
+      const second = deferred()
+      installMockApi(({ url, params }) => {
+        if (url === '/search-index') return ok({ status: 'ready', done: 10, total: 10 })
+        if (round === 1) return page([item('old')], null, 1)
+        return params.cursor ? second.promise : page([], 'c2', null)
+      })
+      const store = useMailStore()
+      await store.openSearch('계약', SEARCH_SCOPE_ALL)
+      expect(ids(store.messages)).toEqual(['old'])
+
+      round = 2
+      const again = store.openSearch('계약', SEARCH_SCOPE_ALL, { force: true })
+      await flushPromises()
+      expect(store.listStatus).toBe('loading')
+      expect(store.messages).toEqual([])
+      expect(store.isRefreshing).toBe(false)
+
+      second.resolve(page([item('new')], null, null))
+      await again
+      expect(store.listStatus).toBe('ready')
+      expect(ids(store.messages)).toEqual(['new'])
+    })
+
+    it('뒤에서 이어 받는 중에 더 보기([다음] · [더 찾기])를 부르면 새로 묻지 않고 그 일이 끝나기를 기다린다', async () => {
+      const second = deferred()
+      const requests = installMockApi(({ url, params }) => {
+        if (url === '/search-index') return ok({ status: 'ready', done: 10, total: 10 })
+        if (!params.cursor) return page([item('r1')], 'c2', null)
+        return second.promise
+      })
+      const store = useMailStore()
+      const opening = store.openSearch('계약', SEARCH_SCOPE_ALL)
+      await flushPromises()
+      expect(store.isLoadingMore).toBe(true)
+
+      let done = false
+      const more = store.loadMore().then(() => {
+        done = true
+      })
+      await flushPromises()
+      expect(done).toBe(false)
+      expect(listRequests(requests)).toHaveLength(2)
+
+      second.resolve(page([item('r2')], null, null))
+      await more
+      await opening
+      expect(ids(store.messages)).toEqual(['r1', 'r2'])
+      expect(listRequests(requests)).toHaveLength(2)
+      expect(store.isLoadingMore).toBe(false)
+    })
+
+    it('보이는 채로 새로 고치는 중에는 더 보기가 묻지 않는다 — 옛 커서로 붙이지 않고, 끝나면 새 커서로', async () => {
+      const first = Array.from({ length: 20 }, (_, index) => item(`m${index + 1}`))
+      let round = 1
+      const reload = deferred()
+      const requests = installMockApi(({ params }) => {
+        if (round === 1) return page(first, 'c2', 40)
+        return params.cursor ? page([item('m21')], null, 40) : reload.promise
+      })
+      const store = useMailStore()
+      await store.openMailbox('inbox')
+
+      round = 2
+      const reopening = store.openMailbox('inbox')
+      await flushPromises()
+      expect(store.isRefreshing).toBe(true)
+      await store.loadMore()
+      expect(listRequests(requests).filter((request) => request.params.cursor)).toEqual([])
+
+      reload.resolve(page(first, 'c2b', 40))
+      await reopening
+      await store.loadMore()
+      expect(listRequests(requests).map((request) => request.params.cursor).filter(Boolean)).toEqual(['c2b'])
+      expect(store.messages).toHaveLength(21)
+    })
+
+    it('이어 묻는 사이 다른 검색을 열면 앞 검색의 응답은 버린다', async () => {
+      const late = deferred()
+      installMockApi(({ url, params }) => {
+        if (url === '/search-index') return ok({ status: 'ready', done: 10, total: 10 })
+        if (params.q === '계약') return params.cursor ? late.promise : page([], 'c2', null)
+        return page([item('n1')], null, 1)
+      })
+      const store = useMailStore()
+
+      const first = store.openSearch('계약', SEARCH_SCOPE_ALL)
+      await flushPromises()
+      await store.openSearch('견적', SEARCH_SCOPE_ALL)
+      late.resolve(page([item('old')], null, null))
+      await first
+
+      expect(store.search?.q).toBe('견적')
+      expect(ids(store.messages)).toEqual(['n1'])
+      expect(store.isLoadingMore).toBe(false)
+    })
+  })
+
+  describe('조건 · 목록 맞추기', () => {
+    it('검색어와 조건을 합친 낱말이 8개를 넘는 검색(손으로 고친 주소)은 묻지 않는다 — 결과 없이 ready, 알림 없음 · 맞추기도 묻지 않는다', async () => {
+      const requests = installMockApi(({ url }) =>
+        url === '/search-index' ? ok({ status: 'ready', done: 10, total: 10 }) : page([item('x')], null, 1),
+      )
+      const store = useMailStore()
+      const conditions = { ...NO_SEARCH_CONDITIONS, body: '여섯 일곱 여덟 아홉' }
+
+      await store.openSearch('하나 둘 셋 넷 다섯', SEARCH_SCOPE_ALL, { conditions })
+      await store.syncVisibleList({ includeSearch: true })
+
+      expect(listRequests(requests)).toEqual([])
+      expect(store.listStatus).toBe('ready')
+      expect(store.messages).toEqual([])
+      expect(store.pageInfo).toBeNull()
+      expect(store.listError).toBeNull()
+      expect(useToastStore().toasts).toEqual([])
+    })
+
+    it('조건과 함께 찾는다 — 커서 요청에도 같은 조건을 싣는다', async () => {
+      const conditions = { ...NO_SEARCH_CONDITIONS, from: '이도윤', hasAttachment: true }
+      const requests = installMockApi(({ url, params }) => {
+        if (url === '/search-index') return ok({ status: 'ready', done: 10, total: 10 })
+        return params.cursor ? page([], null) : page([], 'c2', null)
+      })
+      const store = useMailStore()
+
+      await store.openSearch('', 'inbox', { conditions })
+
+      expect(listRequests(requests).map((request) => request.params)).toEqual([
+        { mailboxId: 'inbox', from: '이도윤', hasAttachment: 'true', limit: 20 },
+        { mailboxId: 'inbox', from: '이도윤', hasAttachment: 'true', cursor: 'c2', limit: 20 },
+      ])
+      expect(store.search).toEqual({ kind: 'search', q: '', scope: 'inbox', conditions })
+    })
+
+    it('읽음 표시의 응답(요약 — 강조 없음)으로 맞춰도 목록 줄의 강조는 남는다', async () => {
+      const highlight = { subject: [[0, 2] as const], preview: { text: '…계약서 초안', ranges: [[1, 3] as const] } }
+      installMockApi(({ url, method }) => {
+        if (url === '/search-index') return ok({ status: 'ready', done: 10, total: 10 })
+        if (method === 'PATCH') return ok(item('r1', { isRead: true }))
+        if (url === '/messages') return page([item('r1', { isRead: false, searchHighlight: highlight })], null, 1)
+        return ok(detail('r1', { isRead: false }))
+      })
+      const store = useMailStore()
+      await store.openSearch('계약', SEARCH_SCOPE_ALL)
+
+      await store.openMessage('r1', { q: '계약' })
+      await flushPromises()
+
+      expect(store.messages[0]?.isRead).toBe(true)
+      expect(store.messages[0]?.searchHighlight).toEqual(highlight)
+    })
+  })
+
+  describe('지난 메일 색인의 상태 (GET /search-index)', () => {
+    it('검색을 시작할 때 조용히 묻는다 — building · ready 를 기억하고, 같은 검색이 보이면 다시 묻지 않는다', async () => {
+      let status = 'building'
+      const requests = installMockApi(({ url }) =>
+        url === '/search-index' ? ok({ status, done: 3, total: 40 }) : page([item('r1')], null, 1),
+      )
+      const store = useMailStore()
+
+      await store.openSearch('계약', SEARCH_SCOPE_ALL)
+      await flushPromises()
+      expect(store.searchIndexStatus).toBe('building')
+      const indexRequests = () => requests.filter((request) => request.url === '/search-index')
+      expect(indexRequests()).toHaveLength(1)
+      expect(indexRequests()[0]?.config.silent).toBe(true)
+
+      await store.openSearch('계약', SEARCH_SCOPE_ALL)
+      expect(indexRequests()).toHaveLength(1)
+
+      status = 'ready'
+      await store.openSearch('계약', SEARCH_SCOPE_ALL, { force: true })
+      await flushPromises()
+      expect(store.searchIndexStatus).toBe('ready')
+    })
+
+    it('못 받거나 모르는 값이면 모르는 것(null)으로 — 알리지 않는다', async () => {
+      let broken = true
+      installMockApi(({ url }) => {
+        if (url === '/search-index') return broken ? fail(503, 'SYS_001') : ok({ status: 'paused', done: 0, total: null })
+        return page([], null, 0)
+      })
+      const store = useMailStore()
+
+      await store.openSearch('계약', SEARCH_SCOPE_ALL)
+      await flushPromises()
+      expect(store.searchIndexStatus).toBeNull()
+      expect(useToastStore().toasts).toEqual([])
+
+      broken = false
+      await store.openSearch('견적', SEARCH_SCOPE_ALL)
+      await flushPromises()
+      expect(store.searchIndexStatus).toBeNull()
+    })
+
+    it('늦게 온 앞 응답은 새 응답을 덮지 않는다 · 로그아웃하면 지운다', async () => {
+      const slow = deferred()
+      let calls = 0
+      installMockApi(({ url }) => {
+        if (url !== '/search-index') return page([], null, 0)
+        calls += 1
+        return calls === 1 ? slow.promise : ok({ status: 'ready', done: 1, total: 1 })
+      })
+      const store = useMailStore()
+
+      void store.openSearch('계약', SEARCH_SCOPE_ALL)
+      await store.openSearch('견적', SEARCH_SCOPE_ALL)
+      await flushPromises()
+      slow.resolve(ok({ status: 'building', done: 0, total: 10 }))
+      await flushPromises()
+      expect(store.searchIndexStatus).toBe('ready')
+
+      store.reset()
+      expect(store.searchIndexStatus).toBeNull()
+    })
+  })
+
+  describe('읽기 화면의 강조 쿼리', () => {
+    it('검색 결과에서 연 메일은 강조 쿼리와 함께 받는다 — 같은 쿼리면 다시 받지 않고, 쿼리가 바뀌면(메일함에서 열면) 다시 받는다', async () => {
+      const requests = installMockApi(({ url }) => ok(detail(url.split('/').pop() ?? 'm1')))
+      const detailRequests = () => requests.filter((request) => request.url === '/messages/m1')
+      const store = useMailStore()
+
+      await store.openMessage('m1', { q: '계약', subject: '견적' })
+      expect(detailRequests()[0]?.params).toEqual({ q: '계약', subject: '견적' })
+      expect(store.selectedHighlight).toEqual({ q: '계약', subject: '견적' })
+
+      await store.openMessage('m1', { q: '계약', subject: '견적' })
+      expect(detailRequests()).toHaveLength(1)
+
+      // 같은 메일을 메일함에서 다시 열었다 — 강조가 든 본문을 쓰지 않고 쿼리 없이 다시 받는다
+      await store.openMessage('m1')
+      expect(detailRequests()).toHaveLength(2)
+      expect(detailRequests()[1]?.params).toEqual({})
+      expect(store.selectedHighlight).toBeNull()
+    })
+
+    it('[이미지 보기]는 같은 강조 쿼리와 함께 받는다 — 강조 · 제목도 새 응답으로', async () => {
+      const highlight = { subject: [[0, 2] as const], attachments: {}, textBody: [] }
+      const requests = installMockApi(({ params }) =>
+        ok(
+          detail('m1', {
+            hasBlockedImages: params.images !== 'show',
+            imagesShown: params.images === 'show',
+            htmlBody: params.images === 'show' ? '<p><mark>계약</mark> <img src="/api/mail-images/abc"></p>' : '<p><mark>계약</mark></p>',
+            searchHighlight: highlight,
+          }),
+        ),
+      )
+      const store = useMailStore()
+      await store.openMessage('m1', { q: '계약' })
+
+      expect(await store.showImages()).toBe(true)
+
+      expect(requests.at(-1)?.params).toEqual({ images: 'show', q: '계약' })
+      expect(store.selected?.imagesShown).toBe(true)
+      expect(store.selected?.searchHighlight).toEqual(highlight)
+    })
+  })
+})
diff --git a/frontend/src/stores/mail.store.threads.spec.ts b/frontend/src/stores/mail.store.threads.spec.ts
new file mode 100644
index 0000000..de46c7c
--- /dev/null
+++ b/frontend/src/stores/mail.store.threads.spec.ts
@@ -0,0 +1,541 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { createPinia, setActivePinia } from 'pinia'
+
+import type { ConversationSummary, Mailbox, MessageSummary, MessagesPatch } from '@/shared/types/mail'
+import { useAuthStore } from '@/stores/auth.store'
+import { useToastStore } from '@/stores/toast.store'
+import {
+  fail,
+  flushPromises,
+  installMockApi,
+  ok,
+  restoreApiAdapter,
+  type MockRequest,
+  type MockResult,
+} from '@/test-utils/mock-api'
+import { useMailStore } from './mail.store'
+
+// 14단계 3차 — 목록을 대화로 묶어 보기 (계약 2절 "대화로 묶어 보기"): 출처 · 늦은 응답 · 더 보기 · 맞추기 · 고르기 · 여러 통 처리
+
+const USER = { email: 'ara.kim@arasystem.test', name: '김아라' }
+
+function mailbox(id: string, role: Mailbox['role'], name: string, unreadCount = 0): Mailbox {
+  return { id, name, role, parentId: null, sortOrder: 0, totalCount: 10, unreadCount }
+}
+
+const MAILBOXES = [
+  mailbox('inbox', 'inbox', '받은편지함', 2),
+  mailbox('sent', 'sent', '보낸편지함'),
+  mailbox('archive', 'archive', '보관함'),
+  mailbox('trash', 'trash', '휴지통'),
+]
+
+function summary(id: string, partial: Partial<MessageSummary> = {}): MessageSummary {
+  return {
+    id,
+    threadId: `t-${id}`,
+    mailboxIds: ['inbox'],
+    from: { name: '이도윤', email: 'doyun.lee@arasystem.test' },
+    to: [],
+    subject: `제목 ${id}`,
+    preview: '',
+    receivedAt: '2026-11-05T01:00:00Z',
+    isRead: true,
+    isFlagged: false,
+    hasAttachment: false,
+    size: 100,
+    pendingSend: null,
+    ...partial,
+  }
+}
+
+function conversation(id: string, messageIds: string[], partial: Partial<ConversationSummary> = {}): ConversationSummary {
+  return {
+    id,
+    latest: summary(messageIds[0] ?? id),
+    participants: [{ name: '이도윤', email: 'doyun.lee@arasystem.test' }],
+    messageCount: messageIds.length,
+    messageIds,
+    pendingSendIds: [],
+    isRead: true,
+    isFlagged: false,
+    hasAttachment: false,
+    ...partial,
+  }
+}
+
+function threadsPage(items: ConversationSummary[], nextCursor: string | null = null, total: number | null = items.length) {
+  return ok({ items, pageInfo: { hasNext: nextCursor !== null, nextCursor, total }, basis: 'index' })
+}
+
+function messagesPage(items: MessageSummary[]) {
+  return ok({ items, pageInfo: { hasNext: false, nextCursor: null, total: items.length } })
+}
+
+/** 응답을 테스트가 정할 때까지 붙잡아 둔다 */
+function held() {
+  let resolve: (result: MockResult) => void = () => undefined
+  const promise = new Promise<MockResult>((done) => {
+    resolve = done
+  })
+  return { promise, resolve }
+}
+
+const rowIds = (rows: readonly { id: string }[]) => rows.map((row) => row.id)
+const threadRequests = (requests: MockRequest[]) => requests.filter((request) => request.url === '/conversations')
+const patches = (requests: MockRequest[]) =>
+  requests.filter((request) => request.method === 'PATCH' && request.url === '/messages').map((request) => request.data as MessagesPatch)
+
+describe('mail.store — 대화로 묶어 보기 (14단계)', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia())
+    useAuthStore().markAuthenticated(USER)
+  })
+
+  afterEach(() => {
+    useToastStore().clear()
+    restoreApiAdapter()
+  })
+
+  /** 메일함 목록과 묶은 목록의 첫 쪽을 받은 상태로 — handler 가 undefined 를 주면 기본 응답 */
+  async function openThreads(
+    rows: ConversationSummary[],
+    handler?: (request: MockRequest) => MockResult | Promise<MockResult> | undefined,
+  ) {
+    const requests = installMockApi((request) => {
+      const custom = handler?.(request)
+      if (custom) return custom
+      if (request.url === '/mailboxes') return ok({ items: MAILBOXES, pageInfo: { hasNext: false, nextCursor: null, total: 4 } })
+      if (request.url === '/mail-quota') return ok({ usedBytes: 0, limitBytes: null, attachmentMaxBytes: 1, attachmentTotalMaxBytes: 1 })
+      if (request.url === '/conversations') return threadsPage(rows)
+      if (request.url === '/messages' && request.method === 'GET') return messagesPage([])
+      if (request.url === '/message-deletions') return ok({ deletedIds: (request.data as { ids: string[] }).ids, skippedIds: [] })
+      if (request.url === '/messages' && request.method === 'PATCH') {
+        return ok({ updatedIds: (request.data as MessagesPatch).ids, failedIds: [] })
+      }
+      return ok(null)
+    })
+    const store = useMailStore()
+    await store.loadMailboxes()
+    await store.openConversations('inbox')
+    return { store, requests }
+  }
+
+  describe('출처 · 늦은 응답', () => {
+    it('켜면 GET /conversations?mailboxId= 의 첫 쪽 — 한 줄이 대화 하나, 메일 목록은 비어 있고 가리키는 메일함은 그 메일함', async () => {
+      const { store, requests } = await openThreads([conversation('c1', ['m3', 'm2']), conversation('c2', ['m1'])])
+
+      expect(threadRequests(requests).map((request) => request.params)).toEqual([{ mailboxId: 'inbox', limit: 20 }])
+      expect(threadRequests(requests)[0]?.config.silent).toBe(true)
+      expect(store.isConversationList).toBe(true)
+      expect(rowIds(store.conversations)).toEqual(['c1', 'c2'])
+      expect(store.messages).toEqual([])
+      expect(store.rowCount).toBe(2)
+      expect(store.currentMailboxId).toBe('inbox')
+      expect(store.listedSummaries.map((message) => message.id)).toEqual(['m3', 'm1'])
+      expect(store.pageInfo?.total).toBe(2)
+    })
+
+    it('켜고 끌 때 앞 목록의 응답을 버리고 처음 쪽부터 받는다 — 늦게 온 메일 목록이 묶은 목록을 덮지 않는다', async () => {
+      const messages = held()
+      const { store, requests } = await openThreads([conversation('c1', ['m1'])], (request) =>
+        request.url === '/messages' && request.method === 'GET' ? messages.promise : undefined,
+      )
+      const opening = store.openMailbox('inbox')
+      expect(store.listStatus).toBe('loading')
+      expect(store.conversations).toEqual([])
+
+      const reopened = store.openConversations('inbox')
+      messages.resolve(messagesPage([summary('late')]))
+      await Promise.all([opening, reopened])
+
+      expect(store.messages).toEqual([])
+      expect(rowIds(store.conversations)).toEqual(['c1'])
+      expect(threadRequests(requests)).toHaveLength(2)
+    })
+
+    it('끄면 메일 목록으로 — 보이는 채로 새로 고치던 묶은 목록의 늦은 응답은 버린다', async () => {
+      const threads = held()
+      let calls = 0
+      const { store } = await openThreads([conversation('c1', ['m1'])], (request) => {
+        if (request.url !== '/conversations') return undefined
+        calls += 1
+        return calls === 1 ? undefined : threads.promise
+      })
+      const refreshing = store.openConversations('inbox')
+      const switched = store.openMailbox('inbox')
+      threads.resolve(threadsPage([conversation('late', ['m9'])]))
+      await Promise.all([refreshing, switched])
+
+      expect(store.isConversationList).toBe(false)
+      expect(store.conversations).toEqual([])
+    })
+
+    it('버린 목록 요청은 끊는다 — 켜고 끌 때 · 메일함을 바꿀 때 · 세션이 끝날 때 (리뷰 L7)', async () => {
+      const messages = held()
+      const threads = held()
+      const { store, requests } = await openThreads([], (request) => {
+        if (request.url === '/messages' && request.method === 'GET') return messages.promise
+        if (request.url === '/conversations' && request.params.mailboxId === 'archive') return threads.promise
+        return undefined
+      })
+      const signals = (url: string) => requests.filter((request) => request.url === url).map((request) => request.config.signal)
+
+      // 요청이 나간 뒤 바꾼다 (나가기 전에 바꾸면 보내지도 않는다)
+      void store.openMailbox('inbox')
+      await flushPromises()
+      void store.openConversations('archive')
+      await flushPromises()
+      expect(signals('/messages').at(-1)?.aborted).toBe(true)
+      expect(signals('/conversations').at(-1)?.aborted).toBe(false)
+
+      useAuthStore().clearAuth()
+      await flushPromises()
+      expect(signals('/conversations').at(-1)?.aborted).toBe(true)
+      messages.resolve(messagesPage([summary('late')]))
+      threads.resolve(threadsPage([conversation('late', ['m9'])]))
+      await flushPromises()
+      expect(store.messages).toEqual([])
+      expect(store.conversations).toEqual([])
+    })
+
+    it('세션이 바뀌면(다른 계정) 늦게 온 묶은 목록을 버린다', async () => {
+      const threads = held()
+      const { store } = await openThreads([], (request) =>
+        request.url === '/conversations' && request.params.mailboxId === 'archive' ? threads.promise : undefined,
+      )
+      void store.openConversations('archive')
+      useAuthStore().markAuthenticated({ email: 'other@arasystem.test', name: '다른 사람' })
+      await flushPromises()
+      threads.resolve(threadsPage([conversation('late', ['m9'])]))
+      await flushPromises()
+
+      expect(store.conversations).toEqual([])
+      expect(store.listSource).toBeNull()
+    })
+  })
+
+  describe('더 보기 · 맞추기', () => {
+    it('더 보기 — 커서를 그대로 보내고 이미 있는 줄은 건너뛴다. 다음 쪽의 total 이 없으면 첫 쪽의 수를 남긴다', async () => {
+      const { store, requests } = await openThreads([], (request) => {
+        if (request.url !== '/conversations') return undefined
+        return request.params.cursor === 'p2'
+          ? threadsPage([conversation('c2', ['m2']), conversation('c3', ['m1'])], null, null)
+          : threadsPage([conversation('c1', ['m3']), conversation('c2', ['m2'])], 'p2', 6)
+      })
+      await store.openConversations('sent')
+      expect(store.hasMore).toBe(true)
+
+      await store.loadMore()
+
+      expect(threadRequests(requests).at(-1)?.params).toEqual({ mailboxId: 'sent', cursor: 'p2', limit: 20 })
+      expect(rowIds(store.conversations)).toEqual(['c1', 'c2', 'c3'])
+      expect(store.pageInfo?.total).toBe(6)
+      expect(store.hasMore).toBe(false)
+    })
+
+    it('새 메일 확인 — 불러온 줄 수만큼(최대 100줄) 조용히 다시 받고, 맨 위 새 메일 수를 알린다', async () => {
+      let rows = [conversation('c1', ['m2']), conversation('c2', ['m1'])]
+      const { store, requests } = await openThreads([], (request) => (request.url === '/conversations' ? threadsPage(rows) : undefined))
+      await store.openConversations('sent')
+
+      rows = [conversation('c2', ['m5', 'm4', 'm1']), conversation('c1', ['m2'])]
+      await store.syncVisibleList()
+
+      const last = threadRequests(requests).at(-1)
+      expect(last?.params).toEqual({ mailboxId: 'sent', limit: 20 })
+      expect(last?.config.silent).toBe(true)
+      expect(rowIds(store.conversations)).toEqual(['c2', 'c1'])
+      expect(store.listSync?.addedAbove).toBe(2)
+    })
+
+    it('맞추는 사이 이 탭이 줄을 바꿨으면 그 응답은 버리고 한 번 더 맞춘다 — 보내는 중인 읽음이 옛 값을 덮어쓴다', async () => {
+      const sync = held()
+      const patch = held()
+      let calls = 0
+      const unread = () => threadsPage([conversation('c1', ['m2', 'm1'], { isRead: false })])
+      const { store } = await openThreads([], (request) => {
+        if (request.url === '/conversations') {
+          calls += 1
+          return calls === 2 ? sync.promise : unread()
+        }
+        if (request.url === '/messages' && request.method === 'PATCH') return patch.promise
+        return undefined
+      })
+      expect(store.conversations[0]?.isRead).toBe(false)
+
+      const syncing = store.syncVisibleList()
+      store.toggleCheck('c1')
+      const marking = store.patchChecked({ isRead: true })
+      expect(store.conversations[0]?.isRead).toBe(true)
+
+      // 서버는 아직 옛 값(안 읽음)을 준다 — 이 탭이 바꾼 뒤라 버리고 한 번 더 받는다
+      sync.resolve(unread())
+      await syncing
+      expect(calls).toBe(3)
+      expect(store.conversations[0]?.isRead).toBe(true)
+
+      patch.resolve(ok({ updatedIds: ['m2', 'm1'], failedIds: [] }))
+      await marking
+      expect(store.conversations[0]?.isRead).toBe(true)
+    })
+  })
+
+  describe('고르기 — 붙잡힌 메일은 뺀다', () => {
+    const ROWS = [
+      conversation('c1', ['m4', 'm3'], { pendingSendIds: ['m4'] }),
+      conversation('held', ['m2'], { pendingSendIds: ['m2'] }),
+      conversation('c3', ['m1']),
+    ]
+
+    it('메일이 모두 붙잡힌 줄은 고를 수 없다 — 하나 · 모두 고르기가 건너뛴다', async () => {
+      const { store } = await openThreads(ROWS)
+
+      store.toggleCheck('held')
+      expect(store.checkedCount).toBe(0)
+      store.toggleCheckAll()
+      expect([...store.checkedIds]).toEqual(['c1', 'c3'])
+      expect(store.checkState).toBe('all')
+    })
+
+    it('여러 통 처리가 보낼 메일은 고른 줄의 메일에서 붙잡힌 메일을 뺀 것 — 도구 줄의 수는 줄 수다', async () => {
+      const { store } = await openThreads(ROWS)
+
+      store.toggleCheckAll()
+      expect(store.checkedCount).toBe(2)
+      expect(store.checkedActionIds).toEqual(['m3', 'm1'])
+      expect(store.checkedMessages).toEqual([])
+      expect(rowIds(store.checkedConversations)).toEqual(['c1', 'c3'])
+    })
+
+    it('켜고 끄면 고른 것을 푼다', async () => {
+      const { store } = await openThreads(ROWS)
+      store.toggleCheck('c3')
+      await store.openMailbox('inbox')
+      expect(store.checkedCount).toBe(0)
+    })
+  })
+
+  describe('여러 통 처리', () => {
+    it('읽음 표시 — 고른 줄의 메일을 100통씩 PATCH /messages, 줄을 먼저 바꾸고 끝나면 메일함 개수를 다시 받는다', async () => {
+      const many = Array.from({ length: 150 }, (_, index) => `m${index}`)
+      const { store, requests } = await openThreads([conversation('big', many, { isRead: false })])
+      const mailboxLoads = requests.filter((request) => request.url === '/mailboxes').length
+
+      store.toggleCheck('big')
+      const marking = store.patchChecked({ isRead: true })
+      expect(store.conversations[0]?.isRead).toBe(true)
+      await marking
+      await flushPromises()
+
+      expect(patches(requests).map((patch) => [patch.ids.length, patch.isRead])).toEqual([
+        [100, true],
+        [50, true],
+      ])
+      expect(patches(requests).flatMap((patch) => patch.ids)).toEqual(many)
+      expect(requests.filter((request) => request.url === '/mailboxes').length).toBe(mailboxLoads + 1)
+      // 고른 것은 그대로 둔다
+      expect(store.checkedCount).toBe(1)
+    })
+
+    it('서버가 바꾸지 못한 메일이 든 줄은 앞 값으로 되돌리고 목록을 다시 맞춘다', async () => {
+      const sync = held()
+      let calls = 0
+      const { store, requests } = await openThreads(
+        [conversation('c1', ['m2', 'm1'], { isRead: false }), conversation('c2', ['m3'], { isRead: false })],
+        (request) => {
+          if (request.url === '/conversations' && ++calls > 1) return sync.promise
+          return request.url === '/messages' && request.method === 'PATCH'
+            ? ok({ updatedIds: ['m2', 'm3'], failedIds: ['m1'] })
+            : undefined
+        },
+      )
+
+      store.toggleCheckAll()
+      await store.patchChecked({ isRead: true })
+      await flushPromises()
+
+      // 이 탭이 먼저 되돌린다 — m1 을 바꾸지 못한 c1 만
+      expect(store.conversations.map((row) => [row.id, row.isRead])).toEqual([
+        ['c1', false],
+        ['c2', true],
+      ])
+      // 그리고 서버 기준으로 다시 맞춘다
+      expect(threadRequests(requests)).toHaveLength(2)
+      sync.resolve(threadsPage([conversation('c1', ['m2', 'm1'], { isRead: false }), conversation('c2', ['m3'])]))
+      await flushPromises()
+      expect(store.conversations.map((row) => [row.id, row.isRead])).toEqual([
+        ['c1', false],
+        ['c2', true],
+      ])
+    })
+
+    it('옮기기 — 고른 줄의 메일을 보내고 다 옮긴 줄은 빼며 대화 수를 줄인다. 되돌리기는 그 메일함으로, 끝나면 목록을 다시 맞춘다', async () => {
+      const sync = held()
+      let calls = 0
+      const { store, requests } = await openThreads(
+        [conversation('c1', ['m4', 'm3'], { pendingSendIds: ['m4'] }), conversation('c2', ['m2', 'm1'])],
+        (request) => (request.url === '/conversations' && ++calls > 1 ? sync.promise : undefined),
+      )
+
+      store.toggleCheckAll()
+      const result = await store.moveChecked('archive')
+      await flushPromises()
+
+      expect(patches(requests)).toEqual([{ ids: ['m3', 'm2', 'm1'], mailboxId: 'archive' }])
+      // 붙잡힌 메일(m4)이 남은 줄은 남는다
+      expect(rowIds(store.conversations)).toEqual(['c1'])
+      expect(store.conversations[0]?.messageIds).toEqual(['m4'])
+      expect(store.pageInfo?.total).toBe(1)
+      expect(result.origins).toEqual([{ mailboxId: 'inbox', ids: ['m3', 'm2', 'm1'] }])
+      expect(store.checkedCount).toBe(0)
+      // 남은 줄의 마지막 메일 · 통 수를 서버 값으로 — 목록을 다시 맞춘다
+      expect(threadRequests(requests)).toHaveLength(2)
+      sync.resolve(threadsPage([conversation('c1', ['m4'], { pendingSendIds: ['m4'], messageCount: 2 })]))
+      await flushPromises()
+      expect(store.conversations.map((row) => [row.id, row.messageCount])).toEqual([['c1', 2]])
+    })
+
+    it('영구 삭제 — 고른 줄의 메일을 POST /message-deletions', async () => {
+      const { store, requests } = await openThreads([conversation('c1', ['m2', 'm1']), conversation('c2', ['m0'])])
+
+      store.toggleCheck('c1')
+      await store.purgeChecked()
+
+      expect(requests.filter((request) => request.url === '/message-deletions').map((request) => request.data)).toEqual([
+        { ids: ['m2', 'm1'] },
+      ])
+      expect(rowIds(store.conversations)).toEqual(['c2'])
+    })
+
+    it('줄의 별 — 중요 표시한 메일이 있으면 모두 풀고 없으면 모두 표시한다. 메일이 모두 붙잡힌 줄은 보내지 않는다', async () => {
+      const { store, requests } = await openThreads([
+        conversation('c1', ['m3', 'm2'], { pendingSendIds: ['m3'] }),
+        conversation('c2', ['m1'], { isFlagged: true }),
+        conversation('held', ['m0'], { pendingSendIds: ['m0'] }),
+      ])
+
+      await store.toggleConversationFlag('c1')
+      await store.toggleConversationFlag('c2')
+      await store.toggleConversationFlag('held')
+
+      expect(patches(requests)).toEqual([
+        { ids: ['m2'], isFlagged: true },
+        { ids: ['m1'], isFlagged: false },
+      ])
+      expect(store.conversations.map((row) => row.isFlagged)).toEqual([true, false, false])
+    })
+  })
+
+  describe('별 — 줄의 중요 표시가 붙잡힌 메일에만 있을 때 (리뷰 L1)', () => {
+    it('붙잡힌 메일이 든 줄을 풀면 줄을 미리 풀지 않고 서버 기준으로 한 번 맞춘다 — 그래도 중요 표시면 heldFlagged', async () => {
+      let rows = [conversation('c1', ['m2', 'm1'], { isFlagged: true, pendingSendIds: ['m2'] })]
+      const { store, requests } = await openThreads([], (request) => (request.url === '/conversations' ? threadsPage(rows) : undefined))
+      await store.openConversations('sent')
+      const syncs = threadRequests(requests).length
+
+      const result = await store.toggleConversationFlag('c1')
+
+      expect(patches(requests)).toEqual([{ ids: ['m1'], isFlagged: false }])
+      expect(threadRequests(requests).length).toBe(syncs + 1)
+      expect(result).toEqual({ heldFlagged: true })
+      expect(store.conversations[0]?.isFlagged).toBe(true)
+
+      // 붙잡힌 메일에는 표시가 없었다 — 다시 맞추면 풀린다
+      rows = [conversation('c1', ['m2', 'm1'], { isFlagged: false, pendingSendIds: ['m2'] })]
+      store.conversations.splice(0, 1, conversation('c1', ['m2', 'm1'], { isFlagged: true, pendingSendIds: ['m2'] }))
+      expect(await store.toggleConversationFlag('c1')).toEqual({ heldFlagged: false })
+      expect(store.conversations[0]?.isFlagged).toBe(false)
+    })
+
+    it('붙잡힌 메일이 없는 줄은 다시 맞추지 않는다', async () => {
+      const { store, requests } = await openThreads([conversation('c1', ['m2', 'm1'], { isFlagged: true })])
+      const syncs = threadRequests(requests).length
+
+      expect(await store.toggleConversationFlag('c1')).toEqual({ heldFlagged: false })
+      expect(store.conversations[0]?.isFlagged).toBe(false)
+      expect(threadRequests(requests).length).toBe(syncs)
+    })
+
+    it('읽기 화면의 별(한 통)이 실패하면 그 메일이 든 줄을 앞 값 그대로 되돌린다', async () => {
+      const { store, requests } = await openThreads(
+        [conversation('c1', ['m3', 'm2'], { isFlagged: false, latest: summary('m3', { isFlagged: false }) })],
+        (request) => (request.method === 'PATCH' && request.url === '/messages/m3' ? fail(503, 'MAIL_001') : undefined),
+      )
+
+      const toggling = store.toggleFlag('m3')
+      expect([store.conversations[0]?.isFlagged, store.conversations[0]?.latest.isFlagged]).toEqual([true, true])
+      await toggling
+
+      expect(requests.filter((request) => request.url === '/messages/m3')).toHaveLength(1)
+      expect([store.conversations[0]?.isFlagged, store.conversations[0]?.latest.isFlagged]).toEqual([false, false])
+    })
+
+    it('읽기 화면의 별(한 통)로 줄의 다른 메일이 중요인 줄을 풀어도 줄은 중요 그대로다 — 실패하면 앞 값', async () => {
+      const { store } = await openThreads(
+        [conversation('c1', ['m3', 'm2'], { isFlagged: true, latest: summary('m3', { isFlagged: true }) })],
+        (request) => (request.method === 'PATCH' && request.url === '/messages/m3' ? fail(503, 'MAIL_001') : undefined),
+      )
+
+      const toggling = store.toggleFlag('m3')
+      expect([store.conversations[0]?.isFlagged, store.conversations[0]?.latest.isFlagged]).toEqual([true, false])
+      await toggling
+      expect([store.conversations[0]?.isFlagged, store.conversations[0]?.latest.isFlagged]).toEqual([true, true])
+    })
+  })
+
+  describe('읽기 화면과 함께', () => {
+    it('연 메일을 읽음으로 — 한 통뿐인 줄은 줄도 읽음, 여러 통인 줄은 다른 메일을 몰라 그대로(다음 맞추기가 고친다)', async () => {
+      const { store } = await openThreads(
+        [
+          conversation('one', ['m1'], { isRead: false, latest: summary('m1', { isRead: false }) }),
+          conversation('two', ['m3', 'm2'], { isRead: false, latest: summary('m3', { isRead: false }) }),
+        ],
+        (request) => {
+          if (request.method === 'PATCH' && request.url.startsWith('/messages/')) {
+            return ok(summary(request.url.slice('/messages/'.length), { isRead: true }))
+          }
+          return undefined
+        },
+      )
+
+      await store.markRead({ id: 'm1', isRead: false, mailboxIds: ['inbox'] })
+      await store.markRead({ id: 'm3', isRead: false, mailboxIds: ['inbox'] })
+
+      expect(store.conversations.map((row) => [row.id, row.isRead, row.latest.isRead])).toEqual([
+        ['one', true, true],
+        ['two', false, true],
+      ])
+    })
+
+    it('줄 기준의 도우미 — 메일이 든 줄 · 그 줄을 누르면 열 메일 · 목록에 든 메일 · 뺀 뒤 이어서 열 메일', async () => {
+      const { store } = await openThreads([conversation('c1', ['m5']), conversation('c2', ['m4', 'm3']), conversation('c3', ['m2'])])
+
+      expect(store.rowIndexOfMessage('m3')).toBe(1)
+      expect(store.rowMessageIdAt(2)).toBe('m2')
+      expect(store.rowMessageIdAt(3)).toBeNull()
+      expect(store.isListedMessage('m3')).toBe(true)
+      expect(store.neighborAfterRemoval('m4')).toBe('m3')
+      expect(store.neighborAfterRemoval('m5')).toBe('m4')
+    })
+
+    it('읽기 화면의 삭제(한 통) — 줄에 메일이 남으면 줄은 남고 그 메일만 빠진다(목록에 든 메일이 아니다), 목록을 다시 맞춘다', async () => {
+      const sync = held()
+      let calls = 0
+      const { store, requests } = await openThreads([conversation('c1', ['m4', 'm3'])], (request) =>
+        request.url === '/conversations' && ++calls > 1 ? sync.promise : undefined,
+      )
+
+      await store.moveMessages([summary('m4')], 'trash')
+      await flushPromises()
+
+      expect(rowIds(store.conversations)).toEqual(['c1'])
+      expect(store.conversations[0]?.messageIds).toEqual(['m3'])
+      expect(store.isListedMessage('m4')).toBe(false)
+      expect(threadRequests(requests)).toHaveLength(2)
+      sync.resolve(threadsPage([conversation('c1', ['m3'])]))
+      await flushPromises()
+      expect(store.conversations[0]?.latest.id).toBe('m3')
+    })
+  })
+})
diff --git a/frontend/src/stores/mail.store.ts b/frontend/src/stores/mail.store.ts
index 37b9a90..5cd3919 100644
--- a/frontend/src/stores/mail.store.ts
+++ b/frontend/src/stores/mail.store.ts
@@ -1,9 +1,10 @@
-import { ref, watch } from 'vue'
+import { computed, ref, watch } from 'vue'
 import { defineStore } from 'pinia'
 
 import { useMail } from '@/composables/useMail'
 import { useAuthStore } from '@/stores/auth.store'
 import { createBulkActions } from './mail/bulk'
+import { createConversationState } from './mail/conversation'
 import { createListState } from './mail/list'
 import { createMailboxAdmin } from './mail/mailbox-admin'
 import { createMailboxesState } from './mail/mailboxes'
@@ -14,13 +15,15 @@ import { createSelection } from './mail/selection'
 export type { BulkResult } from '@/shared/utils/mail-bulk'
 export type { BulkMoveResult, FlagChanges, LoadStatus, MailBulkResult, MoveOptions, SearchOrigin } from './mail/types'
 export type { MailboxOperationOutcome, MailboxOperationProgress } from './mail/mailbox-admin'
+export type { ConversationDetailState } from './mail/conversation'
 
-// 메일 도메인 스토어 — 메일함 · 사용량 · 보이는 목록(메일함 · 검색 결과 · 예약됨) · 고른 메일 · 열린 메일
+// 메일 도메인 스토어 — 메일함 · 사용량 · 보이는 목록(메일함 · 대화로 묶은 메일함 · 검색 결과 · 예약됨) · 고른 메일 · 열린 메일
 // 한 스토어를 기능별 모듈(stores/mail/*)로 나눠 조립한다 — 화면은 이 스토어 하나만 본다.
 //   mailboxes.ts 메일함 · 사용량 | list.ts 보이는 목록 · 이 탭이 바꾼 것 | selection.ts 고른 메일
 //   message.ts 열린 메일 · 읽음 · 중요 표시 · 외부 이미지 보기 | bulk.ts 여러 통 처리 (읽기 화면의 한 통 삭제 · 스팸 신고 포함)
 //   mailbox-admin.ts 메일함 만들기 · 이름 바꾸기 · 오래 걸리는 처리(모두 읽음 · 비우기 · 메일함 지우기)
 //   scheduled.ts 예약됨 개수 · 붙잡은 발송 취소(보내기 취소 · 예약 취소 — 9단계) · 엔진이 풀었는지 다시 보기
+//   conversation.ts 읽기 화면의 같은 대화 · 펼친 줄의 본문 (14단계)
 //
 // 오류 처리 원칙:
 //   - 화면 영역이 오류 상태를 직접 그리는 첫 조회(메일함·목록·본문)는 silent 로 부르고 상태에 담는다
@@ -39,7 +42,7 @@ export const useMailStore = defineStore('mail', () => {
   const list = createListState({ mailApi, mailboxes: mailboxState, opened })
   const selection = createSelection(list)
   const message = createMessageActions({ mailApi, mailboxes: mailboxState, list, opened })
-  const bulk = createBulkActions({ mailApi, mailboxes: mailboxState, list, selection })
+  const bulk = createBulkActions({ mailApi, mailboxes: mailboxState, list, selection, opened })
   const admin = createMailboxAdmin({ mailApi, mailboxes: mailboxState, list })
   const scheduled = createScheduledState({
     mailApi,
@@ -48,6 +51,49 @@ export const useMailStore = defineStore('mail', () => {
     opened,
     sessionGeneration: () => authStore.generation,
   })
+  const conversation = createConversationState({
+    mailApi,
+    list,
+    opened,
+    markRead: message.markRead,
+    sessionGeneration: () => authStore.generation,
+  })
+
+  /**
+   * 엔진이 붙잡은 발송을 풀었는지 다시 본다 — 보이는 목록 · 열린 메일 · 예약됨 수(scheduled.ts)와
+   * 같은 대화에 붙잡힌 메일이 있으면 그 칸도 (14단계 — 풀어도 바뀜 소식이 오지 않는다, usePendingSendRefresh)
+   */
+  async function refreshPendingSends(): Promise<void> {
+    await Promise.all([scheduled.refreshPendingSends(), conversation.refreshHeldConversation()])
+  }
+
+  /** 열린 메일을 닫는다(주소에 메일이 없다) — 같은 대화 칸도 비운다. 칸이 없는 동안 받아 둔 대화를 다시 받거나 지켜보지 않게 */
+  function closeMessage() {
+    opened.closeMessage()
+    conversation.reset()
+  }
+
+  /**
+   * 메일함들의 통 수(totalCount)를 메일함마다 — 같은 대화 칸을 다시 받을지 가르는 기준 (14단계).
+   * 새 메일 · 지움 · 옮김은 어느 메일함의 통 수를 바꾸고, 읽음 · 중요 표시는 바꾸지 않는다(안 읽은 수만 바뀐다).
+   * 메일함 목록은 새 메일 확인 · 실시간 소식(MailLayout 의 syncCounts) · 이 탭의 옮기기 · 지우기 · 보내기 뒤에 다시 받는다
+   */
+  const mailboxTotalsKey = computed(() => {
+    // 모양이 틀린 메일함 응답(배열이 아님)이면 비교하지 않는다 — 앞 값이 없을 때처럼 건너뛴다
+    const list: unknown = mailboxState.mailboxes.value
+    if (!Array.isArray(list)) return ''
+    return mailboxState.mailboxes.value
+      .map((mailbox) => `${mailbox.id}:${mailbox.totalCount}`)
+      .sort()
+      .join('|')
+  })
+
+  // 통 수가 바뀌면 같은 대화 칸을 다시 받게 한다 — 읽음 · 중요 표시만 바뀐 소식으로는 받지 않는다(그러면 메일을 열 때마다 다시 받는다.
+  // 칸의 안 읽은 줄은 이 탭에서 바꾼 읽음을 바로 적고 — conversation.ts — 다른 탭 · 기기에서 바꾼 읽음은 다음에 받을 때 보인다).
+  // 처음 받은 메일함 목록 · 비울 때(로그아웃)는 견줄 앞 값이 없어 건너뛴다. 칸이 없으면 소식만 오르고 아무도 받지 않는다
+  watch(mailboxTotalsKey, (next, previous) => {
+    if (next && previous) conversation.requestConversationRefresh()
+  })
 
   /** 쓰기를 마치거나 취소하면 돌아갈 화면 (보던 메일함·메일·검색 결과) */
   const lastBrowseLocation = ref<string | null>(null)
@@ -83,6 +129,7 @@ export const useMailStore = defineStore('mail', () => {
   function reset() {
     admin.reset()
     scheduled.reset()
+    conversation.reset()
     mailboxState.reset()
     list.reset()
     selection.clearChecked()
@@ -122,7 +169,16 @@ export const useMailStore = defineStore('mail', () => {
     currentMailbox: list.currentMailbox,
     search: list.search,
     searchOrigin: list.searchOrigin,
+    searchIndexStatus: list.searchIndexStatus,
     messages: list.messages,
+    // 대화로 묶은 메일함 (14단계) — 줄 기준의 도우미는 메일 목록에서도 그대로 쓴다
+    conversations: list.conversations,
+    isConversationList: list.isConversationList,
+    rowCount: list.rowCount,
+    listedSummaries: list.listedSummaries,
+    rowIndexOfMessage: list.rowIndexOfMessage,
+    rowMessageIdAt: list.rowMessageIdAt,
+    isListedMessage: list.isListedMessage,
     pageInfo: list.pageInfo,
     listStatus: list.listStatus,
     listError: list.listError,
@@ -132,6 +188,7 @@ export const useMailStore = defineStore('mail', () => {
     hasMore: list.hasMore,
     neighborAfterRemoval: list.neighborAfterRemoval,
     openMailbox: list.openMailbox,
+    openConversations: list.openConversations,
     openScheduled: list.openScheduled,
     openSearch: list.openSearch,
     rememberSearchOrigin: list.rememberSearchOrigin,
@@ -142,6 +199,8 @@ export const useMailStore = defineStore('mail', () => {
     checkedIds: selection.checkedIds,
     checkedCount: selection.checkedCount,
     checkedMessages: selection.checkedMessages,
+    checkedConversations: selection.checkedConversations,
+    checkedActionIds: selection.checkedActionIds,
     checkState: selection.checkState,
     toggleCheck: selection.toggleCheck,
     checkRangeTo: selection.checkRangeTo,
@@ -152,9 +211,10 @@ export const useMailStore = defineStore('mail', () => {
     selected: opened.selected,
     selectedStatus: opened.selectedStatus,
     selectedError: opened.selectedError,
+    selectedHighlight: opened.selectedHighlight,
     imagesLoadingId: opened.imagesLoadingId,
     openMessage: message.openMessage,
-    closeMessage: opened.closeMessage,
+    closeMessage,
     markRead: message.markRead,
     showImages: message.showImages,
     applyLargeFileLink: message.applyLargeFileLink,
@@ -167,9 +227,32 @@ export const useMailStore = defineStore('mail', () => {
     loadScheduledCount: scheduled.loadScheduledCount,
     cancelPendingSend: scheduled.cancelPendingSend,
     isCancellingPendingSend: scheduled.isCancellingPendingSend,
-    refreshPendingSends: scheduled.refreshPendingSends,
+    refreshPendingSends,
+    // 같은 대화 (14단계)
+    conversationMessageId: conversation.conversationMessageId,
+    conversationItems: conversation.conversationItems,
+    conversationPageInfo: conversation.conversationPageInfo,
+    conversationStatus: conversation.conversationStatus,
+    conversationError: conversation.conversationError,
+    conversationLoadingMore: conversation.conversationLoadingMore,
+    conversationRefreshSeq: conversation.conversationRefreshSeq,
+    conversationExpandedIds: conversation.conversationExpandedIds,
+    conversationDetails: conversation.conversationDetails,
+    conversationCount: conversation.conversationCount,
+    hasMoreConversation: conversation.hasMoreConversation,
+    conversationVisible: conversation.conversationVisible,
+    conversationFailed: conversation.conversationFailed,
+    conversationBusy: conversation.conversationBusy,
+    loadConversation: conversation.loadConversation,
+    retryConversation: conversation.retryConversation,
+    refreshConversation: conversation.refreshConversation,
+    requestConversationRefresh: conversation.requestConversationRefresh,
+    loadMoreConversation: conversation.loadMoreConversation,
+    toggleConversationMessage: conversation.toggleConversationMessage,
+    retryConversationDetail: conversation.retryConversationDetail,
     // 여러 통 처리 · 한 통 삭제
     patchChecked: bulk.patchChecked,
+    toggleConversationFlag: bulk.toggleConversationFlag,
     moveMessages: bulk.moveMessages,
     moveChecked: bulk.moveChecked,
     purgeMessages: bulk.purgeMessages,
diff --git a/frontend/src/stores/mail/bulk.ts b/frontend/src/stores/mail/bulk.ts
index 1c04be5..1aa9d6c 100644
--- a/frontend/src/stores/mail/bulk.ts
+++ b/frontend/src/stores/mail/bulk.ts
@@ -3,8 +3,11 @@
 // (그사이 다른 창이 휴지통으로 옮긴 메일을 확인 없이 영구 삭제하게 된다).
 // 끝났을 때 보이는 목록이 다른 목록으로 바뀌어 있으면(sourceSeq) 그 목록 · 고른 것은 건드리지 않고, 개수와
 // (메일함 목록이면) 그 목록을 서버 기준으로 다시 맞춘다 (settleStale).
+// 대화로 묶은 메일함(14단계 — 계약 2절 "대화로 묶어 보기")은 고른 줄의 메일에서 붙잡힌 메일을 뺀 것(selection 의 checkedActionIds)을
+// 같은 여러 통 API 로 100통씩 보낸다. 줄마다 어느 메일이 안 읽었는지 몰라 메일함 개수는 끝난 뒤 서버 기준으로 맞추고,
+// 옮기거나 지운 뒤에는 목록을 다시 맞춘다 — 메일이 남은 줄의 마지막 메일 · 통 수를 서버 값으로 (list.syncVisibleList)
 import { MAIL_BULK_MAX_IDS } from '@/shared/constants/mail'
-import type { MessageSummary } from '@/shared/types/mail'
+import type { ConversationSummary, MessageSummary } from '@/shared/types/mail'
 import {
   emptyBulkResult,
   groupByOrigin,
@@ -13,9 +16,11 @@ import {
   type BulkOrigin,
   type BulkResult,
 } from '@/shared/utils/mail-bulk'
+import { conversationActionIds, conversationActionIdsOf, isConversationHeld } from '@/shared/utils/mail-conversation-list'
 import { isAllMailboxSearch, scopeMailboxIdOf } from '@/shared/utils/mail-list-source'
 import type { ListState } from './list'
 import type { MailboxesState } from './mailboxes'
+import type { OpenedMessage } from './message'
 import type { SelectionState } from './selection'
 import type { BulkMoveResult, FlagChanges, MailApi, MailBulkResult, MoveOptions } from './types'
 
@@ -24,8 +29,12 @@ interface BulkDeps {
   mailboxes: MailboxesState
   list: ListState
   selection: SelectionState
+  opened: OpenedMessage
 }
 
+/** 옮기기에 쓰는 메일 — id 와 되돌릴 곳을 정할 메일함만 본다 (대화 목록은 줄의 메일 id 만 안다) */
+type MoveTarget = Pick<MessageSummary, 'id' | 'mailboxIds'>
+
 /** 요청 하나의 ids 한도(100)로 나눠 차례로 보낸다 */
 function sendBulk(ids: readonly string[], send: BulkChunkSender): Promise<BulkResult> {
   return sendInChunks(ids, MAIL_BULK_MAX_IDS, send)
@@ -35,7 +44,7 @@ function hasLeftovers(result: BulkResult): boolean {
   return result.skippedIds.length > 0 || result.unsentIds.length > 0
 }
 
-export function createBulkActions({ mailApi, mailboxes, list, selection }: BulkDeps) {
+export function createBulkActions({ mailApi, mailboxes, list, selection, opened }: BulkDeps) {
   /** 지금 목록이 시작할 때의 목록인지 — 아니면 끝난 일을 그 목록에 적용하지 않는다 */
   function captureList(): () => boolean {
     const identity = list.sourceSeq.value
@@ -57,6 +66,7 @@ export function createBulkActions({ mailApi, mailboxes, list, selection }: BulkD
    * 고른 것은 그대로 둔다. 알림은 띄우지 않는다 (목록이 바로 바뀐다 — 요청 실패는 인터셉터가 알린다)
    */
   async function patchChecked(changes: FlagChanges): Promise<MailBulkResult> {
+    if (list.isConversationList.value) return patchConversations(selection.checkedConversations.value, changes)
     const targets = selection.checkedMessages.value
     if (targets.length === 0) return { ...emptyBulkResult(), stale: false }
     const isStale = captureList()
@@ -80,6 +90,8 @@ export function createBulkActions({ mailApi, mailboxes, list, selection }: BulkD
     list.endPending(ids, changes)
 
     if (isStale()) {
+      // 다른 목록이라 목록은 되돌리지 않는다 — 같은 대화 칸의 읽음만 바꾸기 전으로 (14단계. 같은 목록이면 아래의 되돌림이 칸에도 알린다)
+      if (changes.isRead !== undefined) list.restoreLocalReads(new Set([...result.skippedIds, ...result.unsentIds]))
       settleStale()
       return { ...result, stale: true }
     }
@@ -87,14 +99,80 @@ export function createBulkActions({ mailApi, mailboxes, list, selection }: BulkD
       const original = before.get(id)
       if (!original) continue
       flip(original, -1)
-      list.setLocalFlags(id, { isRead: original.isRead, isFlagged: original.isFlagged })
+      // 바꾼 표시만 되돌린다 — 중요 표시가 실패했을 때 읽음까지 고른 때의 값으로 적으면 그사이 읽은 것 · 같은 대화 칸의 값을 덮는다 (14단계)
+      const revert: FlagChanges = {}
+      if (changes.isRead !== undefined) revert.isRead = original.isRead
+      if (changes.isFlagged !== undefined) revert.isFlagged = original.isFlagged
+      list.setLocalFlags(id, revert)
     }
     if (changes.isRead !== undefined) void mailboxes.loadMailboxes({ background: true })
     return { ...result, stale: false }
   }
 
+  /**
+   * 대화 줄의 읽음 · 중요 표시 (14단계) — 줄의 메일(붙잡힌 메일은 빼고)에 보낸다. 화면을 먼저 바꾸고, 서버가 바꾸지 못했거나 보내지 못한
+   * 메일이 든 줄은 앞 값으로 되돌린 뒤 목록을 서버 기준으로 다시 맞춘다(줄의 다른 메일은 바뀌었을 수 있다). 고른 것은 그대로 둔다.
+   * 안 읽은 수는 줄마다 몰라 미리 고치지 않고 끝난 뒤 메일함 목록을 다시 받는다. 줄의 별(중요 표시)도 이 길이다 (toggleConversationFlag)
+   */
+  async function patchConversations(
+    rows: readonly ConversationSummary[],
+    changes: FlagChanges,
+  ): Promise<MailBulkResult> {
+    const ids = conversationActionIdsOf(rows)
+    if (ids.length === 0) return { ...emptyBulkResult(), stale: false }
+    const isStale = captureList()
+    const targets = new Set(ids)
+    // 줄은 바꿀 때마다 새 객체로 바꿔 끼우므로(withConversationFlags) 받은 그대로가 앞 값이다
+    const originals = [...rows]
+    const current = opened.selected.value
+    const openedBefore =
+      current && targets.has(current.id) ? { id: current.id, isRead: current.isRead, isFlagged: current.isFlagged } : null
+
+    list.setFlagsOf(targets, changes)
+    list.beginPending(ids, changes)
+    const result = await sendBulk(ids, async (chunkIds) => {
+      const patched = await mailApi.updateMessages({ ids: chunkIds, ...changes })
+      return { done: patched.updatedIds, skipped: patched.failedIds }
+    })
+    list.endPending(ids, changes)
+    const failed = new Set([...result.skippedIds, ...result.unsentIds])
+    // 같은 대화 칸의 읽음을 바꾸기 전으로 — 줄은 메일마다의 앞 값을 몰라 칸이 아는 값으로, 목록이 바뀌었어도 (14단계)
+    if (changes.isRead !== undefined) list.restoreLocalReads(failed)
+
+    if (isStale()) {
+      settleStale()
+      return { ...result, stale: true }
+    }
+    if (failed.size > 0) {
+      list.restoreConversationFlags(originals.filter((row) => conversationActionIds(row).some((id) => failed.has(id))))
+      const shown = opened.selected.value
+      if (openedBefore && shown?.id === openedBefore.id && failed.has(openedBefore.id)) {
+        opened.selected.value = { ...shown, isRead: openedBefore.isRead, isFlagged: openedBefore.isFlagged }
+      }
+      void list.syncVisibleList()
+    }
+    if (changes.isRead !== undefined) void mailboxes.loadMailboxes({ background: true })
+    return { ...result, stale: false }
+  }
+
+  /**
+   * 대화 줄의 별 — 줄에 중요 표시한 메일이 있으면 모두 풀고, 없으면 모두 표시한다 (메일이 모두 붙잡힌 줄은 바꾸지 않는다).
+   * 붙잡힌 메일은 빼고 보내므로(계약) 그 메일이 든 줄을 풀었으면 서버 기준으로 한 번 맞춰 본다 — 줄의 중요 표시가 붙잡힌 메일에만 있었으면
+   * 줄은 그대로 중요 표시이고, heldFlagged 로 알린다(화면이 그 까닭을 알린다 — 메일을 열어 바꾼다)
+   */
+  async function toggleConversationFlag(rowId: string): Promise<{ heldFlagged: boolean }> {
+    const row = list.conversations.value.find((entry) => entry.id === rowId)
+    if (!row || isConversationHeld(row)) return { heldFlagged: false }
+    const flag = !row.isFlagged
+    const result = await patchConversations([row], { isFlagged: flag })
+    const hasHeld = conversationActionIds(row).length < row.messageIds.length
+    if (flag || !hasHeld || result.stale || result.unsentIds.length > 0) return { heldFlagged: false }
+    await list.syncVisibleList()
+    return { heldFlagged: list.conversations.value.find((entry) => entry.id === rowId)?.isFlagged === true }
+  }
+
   /** 되돌리기에 쓸 원래 메일함 — 목록이 가리키는 메일함, 없으면(전체 검색) 옮길 곳이 아닌 첫 메일함 */
-  function originMailboxOf(message: MessageSummary, targetId: string): string | null {
+  function originMailboxOf(message: MoveTarget, targetId: string): string | null {
     const scopeId = scopeMailboxIdOf(list.listSource.value)
     if (scopeId && message.mailboxIds.includes(scopeId)) return scopeId
     return message.mailboxIds.find((id) => id !== targetId) ?? message.mailboxIds[0] ?? null
@@ -125,9 +203,10 @@ export function createBulkActions({ mailApi, mailboxes, list, selection }: BulkD
    * 스팸 신고 · 스팸 아님은 스팸 표시(isJunk)를 같은 요청에 함께 보낸다 (계약 2절 "스팸 · 원문").
    * 응답을 받은 뒤 옮긴 메일(updatedIds)만 목록에서 빼고 개수를 다시 맞춘다. 그대로 둔 메일 · 보내지 못한 메일이 있으면
    * (503 은 일부만 바뀌었을 수 있다) 보이는 목록을 서버 기준으로 다시 맞춘다. targets 는 고른 메일이거나 열린 메일 한 통이다
+   * (대화 목록은 고른 줄의 메일 — moveChecked). 대화 목록은 늘 다시 맞춘다 — 메일이 남은 줄의 마지막 메일 · 통 수가 바뀐다
    */
   async function moveMessages(
-    targets: readonly MessageSummary[],
+    targets: readonly MoveTarget[],
     targetId: string,
     options: MoveOptions = {},
   ): Promise<BulkMoveResult> {
@@ -152,15 +231,22 @@ export function createBulkActions({ mailApi, mailboxes, list, selection }: BulkD
       settleStale()
     } else {
       applyMoved(result.doneIds, targetId)
-      if (hasLeftovers(result)) void list.syncVisibleList({ includeSearch: true })
+      if (hasLeftovers(result) || list.isConversationList.value) void list.syncVisibleList({ includeSearch: true })
       mailboxes.syncCounts()
     }
     return { ...result, origins: groupByOrigin(result.doneIds, origins), stale, ...junk }
   }
 
+  /** 고른 줄의 옮길 메일 — 메일 목록은 고른 메일, 대화 목록은 고른 줄의 메일(그 메일함에 든 것 — 되돌리기는 그 메일함으로) */
+  function checkedMoveTargets(): MoveTarget[] {
+    if (!list.isConversationList.value) return selection.checkedMessages.value
+    const mailboxId = scopeMailboxIdOf(list.listSource.value)
+    return selection.checkedActionIds.value.map((id) => ({ id, mailboxIds: mailboxId ? [mailboxId] : [] }))
+  }
+
   /** 고른 메일을 옮긴다 — 하나라도 옮겼으면 고른 것을 푼다 (요청이 통째로 실패했으면 다시 해 볼 수 있게 둔다) */
   async function moveChecked(targetId: string, options: MoveOptions = {}): Promise<BulkMoveResult> {
-    const result = await moveMessages(selection.checkedMessages.value, targetId, options)
+    const result = await moveMessages(checkedMoveTargets(), targetId, options)
     if (!result.stale && result.doneIds.length > 0) selection.clearChecked()
     return result
   }
@@ -182,15 +268,15 @@ export function createBulkActions({ mailApi, mailboxes, list, selection }: BulkD
       settleStale()
     } else {
       list.removeFromList(new Set(result.doneIds))
-      if (hasLeftovers(result)) void list.syncVisibleList({ includeSearch: true })
+      if (hasLeftovers(result) || list.isConversationList.value) void list.syncVisibleList({ includeSearch: true })
       mailboxes.syncCounts()
     }
     return { ...result, stale }
   }
 
-  /** 고른 메일을 영구 삭제한다 — 하나라도 지웠으면 고른 것을 푼다 */
+  /** 고른 메일을 영구 삭제한다 — 하나라도 지웠으면 고른 것을 푼다 (대화 목록은 고른 줄의 메일) */
   async function purgeChecked(): Promise<MailBulkResult> {
-    const result = await purgeMessages(selection.checkedMessages.value.map((message) => message.id))
+    const result = await purgeMessages(selection.checkedActionIds.value)
     if (!result.stale && result.doneIds.length > 0) selection.clearChecked()
     return result
   }
@@ -220,5 +306,13 @@ export function createBulkActions({ mailApi, mailboxes, list, selection }: BulkD
     return total
   }
 
-  return { patchChecked, moveMessages, moveChecked, purgeMessages, purgeChecked, restoreMoved }
+  return {
+    patchChecked,
+    toggleConversationFlag,
+    moveMessages,
+    moveChecked,
+    purgeMessages,
+    purgeChecked,
+    restoreMoved,
+  }
 }
diff --git a/frontend/src/stores/mail/conversation.ts b/frontend/src/stores/mail/conversation.ts
new file mode 100644
index 0000000..16409c1
--- /dev/null
+++ b/frontend/src/stores/mail/conversation.ts
@@ -0,0 +1,625 @@
+// 메일 스토어 모듈 — 읽기 화면의 "같은 대화" (14단계 — 계약 2절 "대화 — 14단계", mail.store.ts 가 조립한다)
+// 읽기 화면에 연 메일 하나의 같은 대화(GET /messages/{id}/conversation — 오래된 차례)를 받아 둔다. 칸은 MessageConversation, 받는 때는 useConversationSync 가 정한다.
+//   - 받기(loadConversation): 같은 대화의 다른 메일로 옮기면 보이던 줄을 둔 채 그 메일로 새로 받는다 — 커서는 그 메일에서만 통해 다 받을 때까지 [더 보기]를 내린다.
+//     처음 받을 때는 두 통 넘게 모이는 대로 보이며 뒤에서 잇는다
+//   - 다시 받기(refreshConversation — 메일함들의 통 수가 바뀜 · 쓰기 화면에서 돌아옴): 보이는 채로 처음 쪽부터 다시 받아 한 번에 바꾼다.
+//     한 번에 하나 — 그사이 온 요청은 끝난 뒤 한 번 더. [더 보기]로 더 받은 대화는 저절로 다시 받지 않는다(받아 둔 줄이 처음 쪽으로 줄지 않게)
+//   - 붙잡힌 메일(보내기 취소 · 예약)은 엔진이 풀어도 바뀜 소식이 오지 않는다 — 보낼 시각이 지나면 다시 받는다(refreshHeldConversation — usePendingSendRefresh).
+//     [더 보기]로 더 받은 대화는 그 메일만 GET /messages/{id} 로 고친다
+//   - 이어 받기: 엔진 방식은 hasNext 인데 항목이 적거나 0개인 쪽이 온다 — 새로 한 쪽(100통)이 차거나 더 없을 때까지 MAIL_CONVERSATION_FILL_MAX_REQUESTS 번까지 묻고,
+//     남으면 [더 보기](loadMoreConversation)
+//   - 묻는 동안은 conversationBusy — 칸이 받기가 끝난 때부터 다시 받기의 간격을 센다(useConversationSync)
+// 늦게 온 응답 막기: 받는 일마다 순번(runSeq — 받기 · 다시 받기 · 더 받기), 다른 대화로 바꾸거나 비울 때 대화 순번(conversationSeq), 세션 세대.
+// 오류: 받기는 알리지 않고(silent) 칸이 "같은 대화를 불러오지 못했습니다" + [다시 시도]를 그린다 — 없는 메일(404 RES_001 · 이 경로가 없는 옛 서버)은 칸 없이.
+//   다시 받기 · 처음 받을 때 이어 받기의 실패는 알리지 않고 받은 데까지 둔다. [더 보기]는 사용자가 누른 일이라 인터셉터가 알린다.
+// 펼친 줄(toggleConversationMessage): 그 메일을 검색 쿼리 없이 받아 둔다(칸에는 강조가 없다). 받았을 때 아직 펼쳐 있고 안 읽은 메일이면 읽기 화면에서 연 것과
+//   같은 길(markRead — 목록 · 메일함 개수도 맞춘다)로 읽음. 이 탭이 아는 값(열린 메일 · 보이는 목록 · 이 칸이 읽음으로 바꾼 것)을 먼저 본다 —
+//   받아 둔 대화가 옛 값이어도 같은 메일을 두 번 읽음으로 바꾸지 않게. 받아 둔 본문은 접힌 줄의 것을 최근 MAIL_CONVERSATION_DETAIL_CACHE_MAX 개만 둔다.
+//   그사이 지워진 메일(본문이 404 RES_001)은 대화를 다시 받아 그 줄을 뺀다([더 보기]로 더 받은 대화는 그 줄만 뺀다)
+// 이 탭이 바꾼 읽음 (2026-11-07 — 칸이 안 읽은 줄을 굵게 그린다): 목록 · 열린 메일에 읽음을 적을 때마다(list.ts 의 watchLocalReads — 펼친 줄 · 읽기 화면에서
+//   연 메일 · 목록과 여러 통 처리의 읽음 · 안 읽음 표시 · 실패해 되돌림 · 서버가 돌려준 요약 · 메일함 ⋯ › 모두 읽음) 칸의 줄에도 바로 적는다.
+//   받는 동안 바꾼 것 · 받기를 시작할 때 보내던 것은 받은 값보다 이 탭의 값을 믿는다 — 받은 쪽은 그 바꿈이 서버에 닿기 전의 값일 수 있다.
+//   다른 탭 · 기기에서 바꾼 읽음은 다음에 칸을 받을 때 보인다 (읽음만 바뀐 소식으로는 다시 받지 않는다 — mail.store.ts)
+import { computed, ref, shallowRef } from 'vue'
+
+import { toApiError, type ApiError } from '@/composables/useApi'
+import type { MailRequestOptions } from '@/composables/useMail'
+import {
+  MAIL_CONVERSATION_DETAIL_CACHE_MAX,
+  MAIL_CONVERSATION_FILL_MAX_REQUESTS,
+  MAIL_CONVERSATION_PAGE_SIZE,
+} from '@/shared/constants/mail-conversation'
+import type { MessageDetail, MessageSummary } from '@/shared/types/mail'
+import type { PageInfo } from '@/shared/types/pagination'
+import {
+  appendConversationPage,
+  conversationCountOf,
+  hasConversation,
+  nextConversationCursor,
+} from '@/shared/utils/mail-conversation'
+import { isHeldMessage, pendingSendOf } from '@/shared/utils/pending-send'
+import type { ListState } from './list'
+import type { OpenedMessage } from './message'
+import type { LoadStatus, MailApi } from './types'
+
+/** 펼친 줄의 본문 — 받는 중 · 받음 · 못 받음 */
+export type ConversationDetailState =
+  | { status: 'loading' }
+  | { status: 'ready'; detail: MessageDetail }
+  | { status: 'error'; error: ApiError }
+
+/** 모은 쪽 */
+interface Gathered {
+  items: MessageSummary[]
+  pageInfo: PageInfo
+}
+
+/** 이 탭이 바꾼 읽음 하나 — 마지막으로 적은 값 · 그때의 차례 · 바꾸기 전에 칸이 알던 값(모르면 null — 되돌릴 때 쓴다) */
+interface LocalRead {
+  isRead: boolean
+  seq: number
+  before: boolean | null
+}
+
+/** 받기를 시작할 때 — 그때의 차례와 그때 읽음을 보내던 메일 */
+interface LocalReadMark {
+  seq: number
+  sending: ReadonlySet<string>
+}
+
+interface ConversationDeps {
+  mailApi: MailApi
+  list: ListState
+  opened: OpenedMessage
+  /** 읽기 화면에서 연 것과 같은 읽음 처리 (message.ts) — 읽음이 됐으면(이미 읽음 포함) true */
+  markRead: (message: Pick<MessageSummary, 'id' | 'isRead' | 'mailboxIds'>) => Promise<boolean>
+  /** 지금 세션의 세대 (authStore.generation) — 기다리는 사이 세션이 바뀌었으면 늦은 응답을 버린다 */
+  sessionGeneration: () => number
+}
+
+/** 받은 메일의 요약 칸만 — 줄에 본문을 싣지 않는다 (붙잡힌 메일을 그 메일로 고칠 때) */
+function summaryOf(detail: MessageDetail): MessageSummary {
+  return {
+    id: detail.id,
+    threadId: detail.threadId,
+    mailboxIds: detail.mailboxIds,
+    from: detail.from,
+    to: detail.to,
+    subject: detail.subject,
+    preview: detail.preview,
+    receivedAt: detail.receivedAt,
+    isRead: detail.isRead,
+    isFlagged: detail.isFlagged,
+    hasAttachment: detail.hasAttachment,
+    size: detail.size,
+    pendingSend: pendingSendOf(detail.pendingSend),
+  }
+}
+
+export function createConversationState({ mailApi, list, opened, markRead, sessionGeneration }: ConversationDeps) {
+  /** 칸이 가리키는 메일 — 읽기 화면에 연 메일 */
+  const conversationMessageId = ref<string | null>(null)
+  /** 같은 대화 — 오래된 차례, 지금 메일도 든다 */
+  const conversationItems = ref<MessageSummary[]>([])
+  const conversationPageInfo = ref<PageInfo | null>(null)
+  const conversationStatus = ref<LoadStatus>('idle')
+  const conversationError = ref<ApiError | null>(null)
+  /** 뒤에서 이어 받는 중 — 처음 받을 때의 이어 받기 · [더 보기] */
+  const conversationLoadingMore = ref<boolean>(false)
+  /** 다시 받아 달라는 소식의 차례 — 메일함들의 통 수가 바뀌면 오르고(mail.store.ts) useConversationSync 가 모아 받는다 */
+  const conversationRefreshSeq = ref<number>(0)
+  /** 펼친 줄 */
+  const conversationExpandedIds = ref<ReadonlySet<string>>(new Set())
+  /** 받아 둔 본문 — 넣은 차례가 최근에 본 차례다(접힌 줄의 것은 최근 MAIL_CONVERSATION_DETAIL_CACHE_MAX 개만). 다른 대화로 바꾸면 비운다 */
+  const conversationDetails = shallowRef<ReadonlyMap<string, ConversationDetailState>>(new Map())
+  /** 지금 대화를 묻는 요청 수 — 앞 메일의 늦은 요청도 끝날 때까지 센다 */
+  const conversationInFlight = ref<number>(0)
+
+  /** 칸 제목의 통 수 — 모르면 null */
+  const conversationCount = computed<number | null>(() =>
+    conversationCountOf(conversationItems.value, conversationPageInfo.value),
+  )
+  /** 받을 쪽이 남았다 — [더 보기] */
+  const hasMoreConversation = computed<boolean>(() => nextConversationCursor(conversationPageInfo.value) !== null)
+  /** 칸을 보인다 — 받았고 다른 메일이 있다 (한 통뿐이면 칸이 없다) */
+  const conversationVisible = computed<boolean>(
+    () =>
+      conversationStatus.value === 'ready' && hasConversation(conversationItems.value, conversationPageInfo.value),
+  )
+  /** 받지 못했다 — 칸 자리에 짧은 안내 + [다시 시도]. 없는 메일(RES_001)이면 칸 없이 */
+  const conversationFailed = computed<boolean>(
+    () => conversationStatus.value === 'error' && conversationError.value?.code !== 'RES_001',
+  )
+  /** 대화를 묻는 중 — 끝나면 칸이 다시 받기의 간격을 그때부터 센다 (실제로 물었을 때만 켜진다) */
+  const conversationBusy = computed<boolean>(() => conversationInFlight.value > 0)
+
+  let runSeq = 0
+  let conversationSeq = 0
+  /** [더 보기]로 더 받았다 — 저절로 다시 받지 않는다 */
+  let extended = false
+  let refreshing: Promise<void> | null = null
+  let refreshAgain = false
+  /** 이 칸이 읽음으로 바꿨거나 읽기 화면에서 본 메일 — 받아 둔 대화가 옛 값이어도 읽음으로 본다 */
+  const markedRead = new Set<string>()
+  /**
+   * 이 탭이 바꾼 읽음 (머리말) — 화면에 그리지 않으므로 반응형이 아니다. 받기를 시작할 때 그때 보내던 것만 남기고 잊는다(그 뒤 받은 값이 담는다),
+   * 비울 때(reset) 모두 잊는다 — 메일 id 는 계정마다 겹칠 수 있다
+   */
+  const localReads = new Map<string, LocalRead>()
+  let localReadSeq = 0
+
+  /** 받는 일 하나의 확인 — 그 뒤 다른 일이 시작됐거나 · 다른 대화 · 세션이 바뀌었으면 false */
+  function liveCheck(messageId: string): () => boolean {
+    const seq = runSeq
+    const conversation = conversationSeq
+    const session = sessionGeneration()
+    return () =>
+      seq === runSeq &&
+      conversation === conversationSeq &&
+      session === sessionGeneration() &&
+      conversationMessageId.value === messageId
+  }
+
+  /** 묻는 동안 conversationBusy 를 켠다 */
+  async function tracked<T>(work: () => Promise<T>): Promise<T> {
+    conversationInFlight.value += 1
+    try {
+      return await work()
+    } finally {
+      conversationInFlight.value -= 1
+    }
+  }
+
+  // ── 이 탭이 바꾼 읽음 (머리말) ─────────────────────────────
+
+  /** 칸의 줄에 읽음을 적는다 — 바뀌는 줄이 없으면 그대로 둔다 */
+  function writeReads(reads: ReadonlyMap<string, boolean>) {
+    const items = conversationItems.value
+    if (!items.some((item) => reads.has(item.id) && reads.get(item.id) !== item.isRead)) return
+    conversationItems.value = items.map((item) => {
+      const isRead = reads.get(item.id)
+      return isRead === undefined || isRead === item.isRead ? item : { ...item, isRead }
+    })
+  }
+
+  /** 목록 · 열린 메일에 읽음을 적었다 — 칸의 줄에도 적고, 바꾼 차례와 바꾸기 전 값을 둔다 */
+  function noteLocalRead(ids: Iterable<string>, isRead: boolean) {
+    localReadSeq += 1
+    const shown = new Map(conversationItems.value.map((item) => [item.id, item.isRead]))
+    const reads = new Map<string, boolean>()
+    for (const id of ids) {
+      localReads.set(id, { isRead, seq: localReadSeq, before: shown.get(id) ?? localReads.get(id)?.isRead ?? null })
+      reads.set(id, isRead)
+    }
+    writeReads(reads)
+  }
+
+  /** 바꾸지 못한 메일 — 칸이 알던 앞 값으로 되돌린다. 앞 값을 모르면 이 탭의 값을 잊는다(다음에 받은 값을 믿는다) */
+  function restoreLocalRead(ids: Iterable<string>) {
+    localReadSeq += 1
+    const reads = new Map<string, boolean>()
+    for (const id of ids) {
+      const local = localReads.get(id)
+      if (!local) continue
+      if (local.before === null) {
+        localReads.delete(id)
+        continue
+      }
+      localReads.set(id, { isRead: local.before, seq: localReadSeq, before: local.isRead })
+      reads.set(id, local.before)
+    }
+    writeReads(reads)
+  }
+
+  /** 메일함 ⋯ › 모두 읽음이 끝났다 — 칸에 든 그 메일함의 안 읽은 메일을 읽음으로 */
+  function noteMailboxRead(mailboxId: string) {
+    const ids = conversationItems.value
+      .filter((item) => !item.isRead && item.mailboxIds.includes(mailboxId))
+      .map((item) => item.id)
+    if (ids.length > 0) noteLocalRead(ids, true)
+  }
+
+  list.watchLocalReads({ changed: noteLocalRead, restored: restoreLocalRead, mailboxRead: noteMailboxRead })
+
+  /**
+   * 받기를 시작한다 — 지금 차례와 지금 읽음을 보내는 메일을 적어 두고, 나머지는 잊는다
+   * (그 바꿈은 서버에 닿았다 — 이제 받는 값에 들어 있다)
+   */
+  function markLocalReads(): LocalReadMark {
+    const sending = new Set<string>()
+    for (const id of [...localReads.keys()]) {
+      if (list.pendingFlagsOf(id)?.isRead !== undefined) sending.add(id)
+      else localReads.delete(id)
+    }
+    return { seq: localReadSeq, sending }
+  }
+
+  /**
+   * 받은 쪽에 이 탭이 아는 읽음을 덮는다 — 지금 읽음을 보내는 중이면 그 값, 받기를 시작한 뒤 바꿨거나 그때 보내던 메일이면 이 탭이 적은 값
+   * (받은 값은 그 바꿈이 서버에 닿기 전의 값일 수 있다). 그 밖은 받은 값이다 — 다른 탭 · 기기에서 바꾼 읽음도 이때 보인다
+   */
+  function withLocalReads(items: readonly MessageSummary[], mark: LocalReadMark): MessageSummary[] {
+    return items.map((item) => {
+      const local = localReads.get(item.id)
+      const known = local && (local.seq > mark.seq || mark.sending.has(item.id)) ? local.isRead : undefined
+      const isRead = list.pendingFlagsOf(item.id)?.isRead ?? known ?? item.isRead
+      return isRead === item.isRead ? item : { ...item, isRead }
+    })
+  }
+
+  /**
+   * 쪽을 받아 모은다 — from 이 없으면 처음 쪽부터, 있으면 그 다음 쪽부터. 새로 한 쪽이 차거나 · 더 없거나 · 요청이 FILL_MAX 번이 될 때까지.
+   * 쪽마다 onPage(지금까지 모은 것, 더 묻는지). 그사이 다른 일이 시작됐으면 null — 받은 것을 쓰지 않는다. 실패는 그대로 던진다.
+   * 받은 쪽에는 이 탭이 받는 동안 바꾼 읽음을 덮는다 (withLocalReads)
+   */
+  function gather(
+    messageId: string,
+    from: Gathered | null,
+    live: () => boolean,
+    options: MailRequestOptions,
+    onPage?: (gathered: Gathered, continuing: boolean) => void,
+  ): Promise<Gathered | null> {
+    let cursor = from ? nextConversationCursor(from.pageInfo) : null
+    if (from && cursor === null) return Promise.resolve(from)
+    return tracked(async () => {
+      const mark = markLocalReads()
+      let items: MessageSummary[] = from ? [...from.items] : []
+      let pageInfo: PageInfo | null = from?.pageInfo ?? null
+      let added = 0
+      let requests = 0
+      let continuing = true
+      while (continuing) {
+        const page = await mailApi.getConversation(
+          messageId,
+          { limit: MAIL_CONVERSATION_PAGE_SIZE, ...(cursor ? { cursor } : {}) },
+          options,
+        )
+        requests += 1
+        if (!live()) return null
+        const merged = appendConversationPage(items, pageInfo, page)
+        items = withLocalReads(merged.items, mark)
+        pageInfo = merged.pageInfo
+        added += merged.added
+        cursor = nextConversationCursor(pageInfo)
+        continuing =
+          cursor !== null && added < MAIL_CONVERSATION_PAGE_SIZE && requests < MAIL_CONVERSATION_FILL_MAX_REQUESTS
+        onPage?.({ items, pageInfo }, continuing)
+      }
+      return pageInfo ? { items, pageInfo } : null
+    })
+  }
+
+  /** 받은 쪽을 보인다 — 대화에서 빠진 메일의 펼침은 접는다 */
+  function show(gathered: Gathered) {
+    conversationItems.value = gathered.items
+    conversationPageInfo.value = gathered.pageInfo
+    const ids = new Set(gathered.items.map((item) => item.id))
+    const expanded = [...conversationExpandedIds.value]
+    if (expanded.some((id) => !ids.has(id))) conversationExpandedIds.value = new Set(expanded.filter((id) => ids.has(id)))
+  }
+
+  /** 받아 둔 본문을 고친 뒤, 접힌 줄의 것이 상한을 넘으면 오래 보지 않은 것부터 버린다 (펼친 줄의 것은 늘 둔다) */
+  function setDetails(update: (details: Map<string, ConversationDetailState>) => void) {
+    const next = new Map(conversationDetails.value)
+    update(next)
+    const collapsed = [...next.keys()].filter((id) => !conversationExpandedIds.value.has(id))
+    for (const id of collapsed.slice(0, Math.max(0, collapsed.length - MAIL_CONVERSATION_DETAIL_CACHE_MAX))) {
+      next.delete(id)
+    }
+    conversationDetails.value = next
+  }
+
+  /** 그 줄의 본문 — 가장 최근에 본 것으로 둔다(Map 의 끝으로) */
+  function setDetail(id: string, state: ConversationDetailState) {
+    setDetails((details) => {
+      details.delete(id)
+      details.set(id, state)
+    })
+  }
+
+  function collapse(id: string) {
+    if (!conversationExpandedIds.value.has(id)) return
+    const next = new Set(conversationExpandedIds.value)
+    next.delete(id)
+    conversationExpandedIds.value = next
+    // 방금 접은 줄의 본문이 가장 최근이다 — 상한을 넘은 접힌 줄의 본문을 버린다
+    const state = conversationDetails.value.get(id)
+    if (state) setDetail(id, state)
+  }
+
+  /** 그 줄을 뺀다 — 그사이 지워진 메일([더 보기]로 더 받은 대화라 다시 받지 않을 때). 아는 통 수도 하나 줄인다 */
+  function dropItem(id: string) {
+    if (!conversationItems.value.some((item) => item.id === id)) return
+    const info = conversationPageInfo.value
+    show({
+      items: conversationItems.value.filter((item) => item.id !== id),
+      pageInfo: info ? { ...info, total: info.total === null ? null : Math.max(0, info.total - 1) } : { hasNext: false, nextCursor: null, total: null },
+    })
+  }
+
+  /**
+   * 그 메일의 같은 대화를 받는다 (읽기 화면에 메일을 열 때 — useConversationSync).
+   * 같은 메일을 이미 받았거나 받는 중이면 그대로 둔다(다시 받기는 refreshConversation). 같은 대화의 다른 메일이면 보이던 줄을 둔 채 새로 받는다
+   */
+  async function loadConversation(messageId: string): Promise<void> {
+    const status = conversationStatus.value
+    if (conversationMessageId.value === messageId && (status === 'ready' || status === 'loading')) return
+    const keep = status === 'ready' && conversationItems.value.some((item) => item.id === messageId)
+    const previousId = conversationMessageId.value
+    conversationMessageId.value = messageId
+    runSeq += 1
+    extended = false
+    conversationLoadingMore.value = false
+    if (keep) {
+      // 앞 메일은 읽기 화면이 열었다 — 읽음으로 바꿨다. 이제 지금 메일인 줄은 펼침을 접는다.
+      // 옛 커서는 옛 메일의 것이라 새로 받을 때까지 [더 보기]를 내린다(남은 쪽이 있다는 것은 그대로 — 통 수를 짐작하지 않게)
+      if (previousId) markedRead.add(previousId)
+      collapse(messageId)
+      const info = conversationPageInfo.value
+      if (info) conversationPageInfo.value = { ...info, nextCursor: null }
+    } else {
+      conversationSeq += 1
+      conversationItems.value = []
+      conversationPageInfo.value = null
+      conversationStatus.value = 'loading'
+      conversationError.value = null
+      conversationExpandedIds.value = new Set()
+      conversationDetails.value = new Map()
+      markedRead.clear()
+    }
+    const live = liveCheck(messageId)
+    // 처음 받을 때는 쪽마다 보인다 — 두 통 넘게 모였거나 · 다른 메일이 있다는 수(total)를 받았거나 · 더 묻지 않으면 칸을 그리고 뒤에서 잇는다
+    // (지금 메일 한 통만 받고 이어 묻는 동안은 그리지 않는다 — 남은 쪽이 모두 휴지통의 메일이면 칸이 없다)
+    const onPage = keep
+      ? undefined
+      : (gathered: Gathered, continuing: boolean) => {
+          show(gathered)
+          conversationLoadingMore.value = continuing
+          const count = conversationCountOf(gathered.items, gathered.pageInfo)
+          if (!continuing || gathered.items.length > 1 || (count !== null && count > 1)) conversationStatus.value = 'ready'
+        }
+    try {
+      const gathered = await gather(messageId, null, live, { silent: true }, onPage)
+      if (!gathered) return
+      show(gathered)
+      conversationStatus.value = 'ready'
+      conversationError.value = null
+      conversationLoadingMore.value = false
+    } catch (error) {
+      if (!live()) return
+      conversationLoadingMore.value = false
+      // 받은 쪽이 있으면(이어 받다 실패 · 같은 대화의 줄을 둔 채) 받은 데까지 둔다
+      if (keep || conversationItems.value.length > 0) {
+        conversationStatus.value = 'ready'
+        return
+      }
+      conversationStatus.value = 'error'
+      conversationError.value = toApiError(error)
+    }
+  }
+
+  /** [다시 시도] — 받지 못한 대화를 처음부터 */
+  function retryConversation(): Promise<void> {
+    const messageId = conversationMessageId.value
+    if (!messageId || conversationStatus.value !== 'error') return Promise.resolve()
+    return loadConversation(messageId)
+  }
+
+  async function refreshOnce(): Promise<void> {
+    const messageId = conversationMessageId.value
+    if (!messageId || conversationStatus.value !== 'ready' || extended || conversationLoadingMore.value) return
+    runSeq += 1
+    const live = liveCheck(messageId)
+    try {
+      const gathered = await gather(messageId, null, live, { silent: true })
+      if (gathered) show(gathered)
+    } catch {
+      // 알리지 않는다 — 다음 소식에서 다시 받는다
+    }
+  }
+
+  /**
+   * 보이는 채로 다시 받는다 (메일함들의 통 수가 바뀜 · 쓰기 화면에서 돌아옴 — 때는 useConversationSync 가 모은다).
+   * 받은 것이 없거나 · 받는 중이거나 · [더 보기]로 더 받았으면 묻지 않는다. 한 번에 하나 — 그사이 온 요청은 끝난 뒤 한 번 더
+   */
+  function refreshConversation(): Promise<void> {
+    if (refreshing) {
+      refreshAgain = true
+      return refreshing
+    }
+    const run = (async () => {
+      do {
+        refreshAgain = false
+        await refreshOnce()
+      } while (refreshAgain)
+    })().finally(() => {
+      if (refreshing === run) refreshing = null
+    })
+    refreshing = run
+    return run
+  }
+
+  /** 붙잡힌 메일 하나를 그 메일로 고친다 — 다 보냈으면 표시가 내려가고, 그사이 지워졌으면(404) 줄을 뺀다. 실패는 알리지 않는다 */
+  async function refreshHeldItem(id: string): Promise<void> {
+    const conversation = conversationSeq
+    const session = sessionGeneration()
+    try {
+      const detail = await tracked(() => mailApi.getMessage(id, { silent: true }))
+      if (conversation !== conversationSeq || session !== sessionGeneration()) return
+      const fresh = summaryOf(detail)
+      conversationItems.value = conversationItems.value.map((item) => (item.id === id ? fresh : item))
+    } catch (error) {
+      if (conversation !== conversationSeq || session !== sessionGeneration()) return
+      if (toApiError(error).code === 'RES_001') dropItem(id)
+    }
+  }
+
+  /**
+   * 붙잡힌 메일(보내기 취소 · 예약)이 있을 때만 다시 본다 — 엔진이 풀어도 바뀜 소식이 오지 않는다 (usePendingSendRefresh).
+   * [더 보기]로 더 받은 대화는 처음 쪽부터 다시 받지 않고 그 메일만 고친다
+   */
+  async function refreshHeldConversation(): Promise<void> {
+    const held = conversationItems.value.filter((item) => isHeldMessage(item))
+    if (held.length === 0 || conversationStatus.value !== 'ready') return
+    if (!extended) {
+      await refreshConversation()
+      return
+    }
+    await Promise.all(held.map((item) => refreshHeldItem(item.id)))
+  }
+
+  /** 다시 받아 달라는 소식 — 모아 받는 것은 칸(useConversationSync)이 한다 */
+  function requestConversationRefresh() {
+    conversationRefreshSeq.value += 1
+  }
+
+  /** [더 보기] — 다음 쪽부터 한 쪽이 찰 때까지 이어 받는다. 실패는 인터셉터가 알리고 받은 데까지 둔다 */
+  async function loadMoreConversation(): Promise<void> {
+    const messageId = conversationMessageId.value
+    const pageInfo = conversationPageInfo.value
+    if (!messageId || !pageInfo || conversationStatus.value !== 'ready' || conversationLoadingMore.value) return
+    if (nextConversationCursor(pageInfo) === null) return
+    runSeq += 1
+    const live = liveCheck(messageId)
+    conversationLoadingMore.value = true
+    try {
+      await gather(messageId, { items: conversationItems.value, pageInfo }, live, {}, (gathered) => {
+        // 처음 쪽보다 더 받았다 — 이제 저절로 다시 받지 않는다
+        extended = true
+        show(gathered)
+      })
+    } catch {
+      // 인터셉터가 알렸다 — [더 보기]가 남는다
+    } finally {
+      if (live()) conversationLoadingMore.value = false
+    }
+  }
+
+  // ── 펼친 줄 ─────────────────────────────────────────
+
+  function setItemRead(id: string, isRead: boolean) {
+    writeReads(new Map([[id, isRead]]))
+  }
+
+  /** 이 탭이 아는 읽음 — 열린 메일 · 보이는 목록 · 이 칸이 읽음으로 바꾼 것, 모르면 받아 둔 대화의 값 */
+  function knownRead(id: string, fallback: boolean): boolean {
+    const current = opened.selected.value
+    if (current?.id === id) return current.isRead
+    const listed = list.listedSummary(id)
+    if (listed) return listed.isRead
+    return markedRead.has(id) || fallback
+  }
+
+  /** 펼쳐 본 메일을 읽음으로 — 안 읽은 메일일 때만, 실패하면(markRead 가 목록 · 개수를 되돌렸다) 이 칸의 표시도 되돌린다 */
+  async function readExpanded(id: string, detail: MessageDetail): Promise<void> {
+    const item = conversationItems.value.find((entry) => entry.id === id)
+    if (!item) return
+    if (detail.isRead || knownRead(id, item.isRead)) {
+      if (!item.isRead) setItemRead(id, true)
+      return
+    }
+    const conversation = conversationSeq
+    markedRead.add(id)
+    setItemRead(id, true)
+    const done = await markRead({ id, isRead: false, mailboxIds: detail.mailboxIds })
+    if (done || conversation !== conversationSeq) return
+    markedRead.delete(id)
+    setItemRead(id, false)
+  }
+
+  /** 그사이 지워진 메일 — 대화를 다시 받아 그 줄을 뺀다. [더 보기]로 더 받은 대화는 다시 받지 않으니 그 줄만 뺀다 */
+  function forgetMissing(id: string) {
+    if (extended) dropItem(id)
+    else void refreshConversation()
+  }
+
+  /**
+   * 펼친 줄의 본문을 받는다 — 검색 쿼리 없이(강조 없음), 알리지 않고 줄 안에 그린다. 받았을 때 아직 펼쳐 있으면 읽음으로.
+   * 그사이 대화 · 세션이 바뀌었으면 버린다(읽음으로도 바꾸지 않는다). 그사이 지워진 메일(RES_001)이면 그 줄을 뺀다
+   */
+  async function loadConversationDetail(id: string): Promise<void> {
+    const conversation = conversationSeq
+    const session = sessionGeneration()
+    const stale = () => conversation !== conversationSeq || session !== sessionGeneration()
+    setDetail(id, { status: 'loading' })
+    try {
+      const detail = await mailApi.getMessage(id, { silent: true })
+      if (stale()) return
+      setDetail(id, { status: 'ready', detail })
+      if (conversationExpandedIds.value.has(id)) void readExpanded(id, detail)
+    } catch (error) {
+      if (stale()) return
+      const apiError = toApiError(error)
+      setDetail(id, { status: 'error', error: apiError })
+      if (apiError.code === 'RES_001') forgetMissing(id)
+    }
+  }
+
+  /** 줄을 펴고 접는다 — 지금 메일의 줄은 펴지 않는다. 처음 펴면 본문을 받고, 받아 둔 본문이면 바로 읽음으로 */
+  function toggleConversationMessage(id: string): void {
+    if (id === conversationMessageId.value || !conversationItems.value.some((item) => item.id === id)) return
+    if (conversationExpandedIds.value.has(id)) {
+      collapse(id)
+      return
+    }
+    conversationExpandedIds.value = new Set([...conversationExpandedIds.value, id])
+    const state = conversationDetails.value.get(id)
+    if (state?.status === 'ready') {
+      setDetail(id, state)
+      void readExpanded(id, state.detail)
+    } else if (state?.status !== 'loading') {
+      void loadConversationDetail(id)
+    }
+  }
+
+  /** 펼친 줄의 본문 [다시 시도] */
+  function retryConversationDetail(id: string): Promise<void> {
+    return conversationDetails.value.get(id)?.status === 'error' ? loadConversationDetail(id) : Promise.resolve()
+  }
+
+  function reset() {
+    runSeq += 1
+    conversationSeq += 1
+    conversationMessageId.value = null
+    conversationItems.value = []
+    conversationPageInfo.value = null
+    conversationStatus.value = 'idle'
+    conversationError.value = null
+    conversationLoadingMore.value = false
+    conversationExpandedIds.value = new Set()
+    conversationDetails.value = new Map()
+    extended = false
+    refreshing = null
+    refreshAgain = false
+    markedRead.clear()
+    localReads.clear()
+  }
+
+  return {
+    conversationMessageId,
+    conversationItems,
+    conversationPageInfo,
+    conversationStatus,
+    conversationError,
+    conversationLoadingMore,
+    conversationRefreshSeq,
+    conversationExpandedIds,
+    conversationDetails,
+    conversationCount,
+    hasMoreConversation,
+    conversationVisible,
+    conversationFailed,
+    conversationBusy,
+    loadConversation,
+    retryConversation,
+    refreshConversation,
+    refreshHeldConversation,
+    requestConversationRefresh,
+    loadMoreConversation,
+    toggleConversationMessage,
+    retryConversationDetail,
+    reset,
+  }
+}
+
+export type ConversationState = ReturnType<typeof createConversationState>
diff --git a/frontend/src/stores/mail/list.ts b/frontend/src/stores/mail/list.ts
index b2bb79a..8dea9a4 100644
--- a/frontend/src/stores/mail/list.ts
+++ b/frontend/src/stores/mail/list.ts
@@ -1,27 +1,68 @@
-// 메일 스토어 모듈 — 보이는 목록(메일함 또는 검색 결과): 열기 · 더 보기 · 새 메일 확인으로 맞추기 · 이 탭이 바꾼 것 (mail.store.ts 가 조립한다)
+// 메일 스토어 모듈 — 보이는 목록(메일함 · 대화로 묶은 메일함 · 검색 결과 · 예약됨): 열기 · 더 보기 · 새 메일 확인으로 맞추기 · 이 탭이 바꾼 것
+// (mail.store.ts 가 조립한다)
+//
+// 대화로 묶은 메일함 (14단계 — 계약 2절 "대화로 묶어 보기"): 출처가 conversations 면 줄은 conversations(대화 하나가 한 줄)이고 messages 는 비어 있다.
+//   열기 · 더 보기 · 맞추기는 GET /conversations 로 같은 순번 규칙을 따른다. 이 탭이 바꾼 표시 · 뺀 메일은 메일 id 로 받아 그 메일이 든 줄에 적는다
+//   (mail-conversation-list.ts — 줄의 메일을 모두 바꿨을 때만 줄 전체가 읽음 · 중요 해제). 출처를 몰라도 되게 줄 기준의 도우미를 둔다:
+//   rowCount · listedSummaries(줄마다 마지막 메일) · rowIndexOfMessage · rowMessageIdAt · isListedMessage · listedSummary
 //
 // 늦게 온 응답 막기:
-//   - listSeq: 목록을 새로 열 때마다(같은 목록을 보이는 채로 다시 불러올 때 포함) — 그 전에 보낸 목록 요청의 응답은 버린다
+//   - listSeq: 목록을 새로 열 때마다(같은 목록을 보이는 채로 다시 불러올 때 포함) — 그 전에 보낸 목록 요청의 응답은 버린다.
+//     그 요청은 끊기도 한다(listAbort — 짐작이 틀림 · 빠르게 켜고 끔 · 메일함 바꿈, 엔진 방식의 묶은 목록은 한 요청이 15초까지 — 14단계 리뷰 L7)
 //   - sourceSeq: 목록의 출처(메일함 · 검색)가 바뀔 때마다 — 고른 것을 풀고(selection.ts), 끝난 여러 통 처리가
 //     아직 같은 목록인지 본다(bulk.ts — 다른 목록이면 그 목록을 건드리지 않는다)
 //   - localGeneration: 이 탭이 목록 · 열린 메일을 바꿀 때마다(읽음 · 중요 표시 · 빼기 · 옮기기 · 보내던 표시가 끝남) —
 //     그 전에 떠난 새 메일 확인의 응답은 옛 상태라 버리고 한 번 더 맞춘다 (옮긴 메일이 되살아나거나 표시가 되돌아가지 않게)
+//
+// 같은 대화 칸에 알리기 (14단계 — 2026-11-07): 이 탭이 읽음을 적을 때마다(setFlagsOf · applySummary) 같은 대화 칸(conversation.ts)이
+// 듣는다(watchLocalReads) — 칸의 안 읽은 줄을 굵게 그리고, 칸은 읽음만 바뀐 소식으로 다시 받지 않기 때문이다.
+// 여러 통 처리가 바꾸지 못한 메일(restoreLocalReads)과 메일함 ⋯ › 모두 읽음이 끝남(noteMailboxRead)도 알린다
+//
+// 검색 결과 이어 받기 (14단계 — 계약 2절 "검색 — 14단계"): 서버(색인 방식)는 한 요청에 확인하는 메일 수에 상한이 있어 hasNext 인데 항목이
+// 적거나 0개인 쪽을 준다. 검색을 열 때 · 더 볼 때 한 쪽(20통)이 찰 때까지 커서로 이어 묻는다(MAIL_SEARCH_FILL_MAX_REQUESTS 번까지 — 넘으면
+// 사용자가 [더 찾기] · [메일 더 보기]로 잇는다). 하나도 찾기 전에는 "찾는 중"(loading), 하나라도 찾으면 보이며 뒤에서 잇는다(isLoadingMore).
+// 결과 없음은 더 찾을 것이 없을 때(hasNext false)만이다. 다음 쪽의 total 은 늘 null 이라 첫 쪽의 수를 남긴다.
+// 이어 받는 동안 누른 [다음] · [더 찾기]는 그 일이 끝나기를 기다리고(loadMore), 보이는 채로 새로 고치는 동안은 더 받지 않는다.
+// 검색을 시작할 때 지난 메일 색인의 상태(GET /search-index)를 조용히 묻는다 — 결과 머리의 "검색 준비 중" 줄 · 한 글자 안내 · 결과 없음의 한계 안내
 import { computed, ref, watch } from 'vue'
 
 import { toApiError, type ApiError } from '@/composables/useApi'
 import type { MailRequestOptions } from '@/composables/useMail'
 import { MAIL_LIST_SYNC_MAX } from '@/shared/constants/mail'
-import type { Mailbox, MessageSummary } from '@/shared/types/mail'
+import { MAIL_SEARCH_FILL_MAX_REQUESTS } from '@/shared/constants/mail-search'
+import type {
+  ConversationListPage,
+  ConversationSummary,
+  Mailbox,
+  MessageListItem,
+  MessageSummary,
+  SearchIndexStatus,
+} from '@/shared/types/mail'
 import { DEFAULT_PAGE_SIZE, type PageInfo, type PaginatedResult } from '@/shared/types/pagination'
+import {
+  appendConversationPage,
+  conversationHasMessage,
+  conversationNeighborAfterRemoval,
+  conversationRowIndexOf,
+  mergeRefreshedConversations,
+  withConversationFlags,
+  withConversationFlagsOf,
+  withoutConversationMessages,
+} from '@/shared/utils/mail-conversation-list'
 import { mergeRefreshedList } from '@/shared/utils/mail-list-merge'
 import {
+  isConversationSource,
+  isSearchTooLong,
   listQueryOf,
   sameListSource,
   scopeMailboxIdOf,
   SCHEDULED_LIST_SOURCE,
+  searchSourceOf,
+  type ConversationListSource,
   type MailListSource,
   type SearchListSource,
 } from '@/shared/utils/mail-list-source'
+import type { SearchConditions } from '@/shared/utils/mail-search'
 import { messagePendingSend, samePendingSend } from '@/shared/utils/pending-send'
 import type { MailboxesState } from './mailboxes'
 import type { OpenedMessage } from './message'
@@ -30,6 +71,16 @@ import type { FlagChanges, LoadStatus, MailApi, SearchOrigin } from './types'
 /** 목록 · 열린 메일에 바로 적는 표시 */
 type LocalChanges = Partial<Pick<MessageSummary, 'isRead' | 'isFlagged' | 'mailboxIds'>>
 
+/** 같은 대화 칸이 듣는 이 탭의 읽음 (머리말 — watchLocalReads, conversation.ts) */
+export interface LocalReadListener {
+  /** 그 메일들의 읽음을 이 값으로 적었다 — 먼저 바꿈 · 실패해 되돌림 · 서버가 돌려준 요약 */
+  changed: (ids: ReadonlySet<string>, isRead: boolean) => void
+  /** 그 메일들의 읽음을 바꾸기 전 값으로 — 여러 통 처리가 바꾸지 못한 메일 (메일마다의 앞 값은 칸이 안다) */
+  restored: (ids: ReadonlySet<string>) => void
+  /** 그 메일함의 메일을 모두 읽음으로 했다 — 메일함 ⋯ › 모두 읽음이 끝남 */
+  mailboxRead: (mailboxId: string) => void
+}
+
 interface ListDeps {
   mailApi: MailApi
   mailboxes: MailboxesState
@@ -37,7 +88,7 @@ interface ListDeps {
 }
 
 export function createListState({ mailApi, mailboxes, opened }: ListDeps) {
-  /** 목록의 출처 — 메일함 하나 또는 검색 결과 (mail-list-source.ts) */
+  /** 목록의 출처 — 메일함 하나 · 대화로 묶은 메일함 · 검색 결과 · 예약됨 (mail-list-source.ts) */
   const listSource = ref<MailListSource | null>(null)
   /** 목록의 출처가 바뀐 횟수 (위 설명) */
   const sourceSeq = ref<number>(0)
@@ -59,7 +110,26 @@ export function createListState({ mailApi, mailboxes, opened }: ListDeps) {
     listSource.value?.kind === 'search' ? listSource.value : null,
   )
   const searchOrigin = ref<SearchOrigin | null>(null)
-  const messages = ref<MessageSummary[]>([])
+  /**
+   * 지난 메일 색인의 상태 (14단계) — 검색을 시작할 때 묻는다. 모르면(아직 · 못 받음) null — 그때는 안내 줄 · 한계 안내를 보이지 않는다
+   */
+  const searchIndexStatus = ref<SearchIndexStatus | null>(null)
+  const messages = ref<MessageListItem[]>([])
+  /** 대화로 묶은 메일함의 줄 (14단계) — 그 출처일 때만 차고, 그때 messages 는 비어 있다 */
+  const conversations = ref<ConversationSummary[]>([])
+  /** 대화로 묶은 메일함을 보이는 중 */
+  const isConversationList = computed<boolean>(() => isConversationSource(listSource.value))
+  /** 보이는 줄 수 — 메일 목록은 메일, 대화 목록은 대화 */
+  const rowCount = computed<number>(() =>
+    isConversationList.value ? conversations.value.length : messages.value.length,
+  )
+  /**
+   * 보이는 목록의 메일 요약 — 메일 목록은 그 메일들, 대화 목록은 줄마다 마지막 메일 (붙잡은 발송 지켜보기 · 같은 대화 칸의 링크 등
+   * 줄 모양을 몰라도 되는 곳이 쓴다)
+   */
+  const listedSummaries = computed<MessageSummary[]>(() =>
+    isConversationList.value ? conversations.value.map((row) => row.latest) : messages.value,
+  )
   const pageInfo = ref<PageInfo | null>(null)
   const listStatus = ref<LoadStatus>('idle')
   const listError = ref<ApiError | null>(null)
@@ -75,11 +145,22 @@ export function createListState({ mailApi, mailboxes, opened }: ListDeps) {
   let listSeq = 0
   let listSyncSeq = 0
   let localGeneration = 0
+  /** 색인 상태 요청의 순번 — 늦게 온 응답이 새 응답을 덮어쓰지 않게 */
+  let searchIndexSeq = 0
+  /** 지금 이어 받는 일 (runLoading) — 그사이 누른 [다음] · [더 찾기]가 끝나기를 기다린다 */
+  let loading: Promise<void> | null = null
+  /**
+   * 지금 목록의 요청을 끊는 손잡이 — 목록을 새로 열거나 비우면 앞 목록의 요청(첫 쪽 · 더 보기 · 이어 찾기 · 맞추기)을 끊는다.
+   * 그 응답은 순번(listSeq)으로도 버리지만 서버 · 연결을 붙잡지 않게 (끊은 요청은 알리지 않는다 — useApi)
+   */
+  let listAbort = new AbortController()
   /**
    * 보내는 중인 읽음 · 중요 표시 — 그사이 도착한 목록(새 메일 확인)이 옛 값으로 되돌려 보이지 않게 덮어쓴다.
    * 화면에 그리지 않으므로 반응형이 아니다
    */
   const pendingFlags = new Map<string, FlagChanges>()
+  /** 같은 대화 칸 — 하나만 듣는다 (watchScheduledTotal 과 같은 결) */
+  let localReadListener: LocalReadListener | null = null
 
   // 출처가 바뀌면(어떻게 바꿨든) 그 수를 세고 알림 줄 정보를 비운다
   watch(
@@ -92,6 +173,13 @@ export function createListState({ mailApi, mailboxes, opened }: ListDeps) {
     { flush: 'sync' },
   )
 
+  /** 앞 목록의 요청을 끊고 새 손잡이를 준다 — 목록을 새로 열 때 · 비울 때 */
+  function renewListAbort(): AbortSignal {
+    listAbort.abort()
+    listAbort = new AbortController()
+    return listAbort.signal
+  }
+
   /** 같은 출처를 새 목록으로 다시 연다 (같은 검색어로 다시 찾기) — 출처가 바뀐 것과 같게 다룬다 */
   function renewSource() {
     sourceSeq.value += 1
@@ -105,34 +193,102 @@ export function createListState({ mailApi, mailboxes, opened }: ListDeps) {
   }
 
   function setLocalFlags(id: string, changes: LocalChanges) {
-    messages.value = messages.value.map((message) => (message.id === id ? { ...message, ...changes } : message))
-    if (opened.selected.value?.id === id) opened.selected.value = { ...opened.selected.value, ...changes }
+    setFlagsOf(new Set([id]), changes)
+  }
+
+  /**
+   * 여러 메일의 표시를 한 번에 — 목록 · 열린 메일 · 대화 줄(그 메일이 든 줄 — 줄의 메일을 모두 바꿨을 때만 줄 전체가 읽음 · 중요 해제다,
+   * mail-conversation-list.ts 의 withConversationFlags). 읽음이면 같은 대화 칸에도 알린다
+   */
+  function setFlagsOf(ids: ReadonlySet<string>, changes: LocalChanges) {
+    if (ids.size === 0) return
+    messages.value = messages.value.map((message) => (ids.has(message.id) ? { ...message, ...changes } : message))
+    if (conversations.value.length > 0) {
+      conversations.value = conversations.value.map((row) => withConversationFlags(row, ids, changes))
+    }
+    const current = opened.selected.value
+    if (current && ids.has(current.id)) opened.selected.value = { ...current, ...changes }
+    bumpLocalChange()
+    if (changes.isRead !== undefined) localReadListener?.changed(ids, changes.isRead)
+  }
+
+  /** 대화 줄의 읽음 · 중요 표시를 앞 값으로 되돌린다 — 보내지 못한 메일이 든 줄 (여러 통 처리 — bulk.ts) */
+  function restoreConversationFlags(originals: readonly ConversationSummary[]) {
+    if (originals.length === 0) return
+    const byId = new Map(originals.map((row) => [row.id, row]))
+    conversations.value = conversations.value.map((row) => {
+      const original = byId.get(row.id)
+      return original ? withConversationFlagsOf(row, original) : row
+    })
     bumpLocalChange()
   }
 
-  /** 서버가 돌려준 요약으로 목록 · 열린 메일을 맞춘다 */
+  /**
+   * 서버가 돌려준 요약으로 목록 · 열린 메일을 맞춘다 — 요약(PATCH 응답)에는 검색 강조가 없으므로 목록 줄의 강조는 그대로 둔다 (14단계).
+   * 대화 줄은 그 메일이 마지막 메일이면 바꿔 끼우고, 표시는 setFlagsOf 와 같은 규칙으로 적는다. 읽음은 같은 대화 칸에도 알린다
+   */
   function applySummary(summary: MessageSummary) {
-    messages.value = messages.value.map((message) => (message.id === summary.id ? summary : message))
+    messages.value = messages.value.map((message) => {
+      if (message.id !== summary.id) return message
+      return message.searchHighlight === undefined ? summary : { ...summary, searchHighlight: message.searchHighlight }
+    })
+    if (conversations.value.length > 0) {
+      const ids = new Set([summary.id])
+      const flags = { isRead: summary.isRead, isFlagged: summary.isFlagged }
+      conversations.value = conversations.value.map((row) => {
+        if (row.latest.id !== summary.id && !conversationHasMessage(row, summary.id)) return row
+        return withConversationFlags(row.latest.id === summary.id ? { ...row, latest: summary } : row, ids, flags)
+      })
+    }
     if (opened.selected.value?.id === summary.id) opened.selected.value = { ...opened.selected.value, ...summary }
     bumpLocalChange()
+    localReadListener?.changed(new Set([summary.id]), summary.isRead)
   }
 
-  /** 목록에서 뺀다 — 전체 개수도 그만큼 줄인다 */
+  /** 같은 대화 칸이 이 탭의 읽음을 듣는다 (머리말) */
+  function watchLocalReads(listener: LocalReadListener) {
+    localReadListener = listener
+  }
+
+  /**
+   * 여러 통 처리가 바꾸지 못한 메일 — 같은 대화 칸의 읽음을 바꾸기 전으로 (bulk.ts). 대화 목록의 줄은 메일마다의 앞 값을 몰라
+   * (restoreConversationFlags 는 줄째 되돌린다) 칸이 아는 앞 값으로, 끝났을 때 목록이 바뀌어 있었으면 목록 대신 칸만
+   */
+  function restoreLocalReads(ids: ReadonlySet<string>) {
+    if (ids.size > 0) localReadListener?.restored(ids)
+  }
+
+  /** 메일함 ⋯ › 모두 읽음이 끝났다 — 같은 대화 칸에 든 그 메일함의 메일도 읽음으로 (mailbox-admin.ts — 목록은 서버 기준으로 다시 맞춘다) */
+  function noteMailboxRead(mailboxId: string) {
+    localReadListener?.mailboxRead(mailboxId)
+  }
+
+  /** 목록에서 뺀다 — 전체 개수도 그만큼 줄인다 (대화 줄은 메일이 모두 빠진 줄만 빠지고 그 수를 센다) */
   function removeFromList(ids: ReadonlySet<string>) {
     if (ids.size === 0) return
     const before = messages.value.length
     messages.value = messages.value.filter((message) => !ids.has(message.id))
-    const removed = before - messages.value.length
+    let removed = before - messages.value.length
+    if (conversations.value.length > 0) {
+      const result = withoutConversationMessages(conversations.value, ids)
+      conversations.value = result.rows
+      removed += result.removedRows
+    }
     if (removed > 0 && pageInfo.value && pageInfo.value.total !== null) {
       pageInfo.value = { ...pageInfo.value, total: Math.max(0, pageInfo.value.total - removed) }
     }
     bumpLocalChange()
   }
 
-  /** 목록에 남긴 채 메일함만 바꾼다 (전체 메일함 검색 결과에서 옮긴 메일) */
+  /** 목록에 남긴 채 메일함만 바꾼다 (전체 메일함 검색 결과에서 옮긴 메일 · 이 목록의 메일함으로 옮긴 메일) */
   function relocate(ids: ReadonlySet<string>, mailboxId: string) {
     if (ids.size === 0) return
     messages.value = messages.value.map((message) => (ids.has(message.id) ? { ...message, mailboxIds: [mailboxId] } : message))
+    if (conversations.value.length > 0) {
+      conversations.value = conversations.value.map((row) =>
+        ids.has(row.latest.id) ? { ...row, latest: { ...row.latest, mailboxIds: [mailboxId] } } : row,
+      )
+    }
     const current = opened.selected.value
     if (current && ids.has(current.id)) opened.selected.value = { ...current, mailboxIds: [mailboxId] }
     bumpLocalChange()
@@ -156,8 +312,13 @@ export function createListState({ mailApi, mailboxes, opened }: ListDeps) {
     bumpLocalChange()
   }
 
+  /** 그 메일에 보내는 중인 읽음 · 중요 표시 — 없으면 undefined (같은 표시를 두 번 보내지 않게 — message.ts 의 markRead) */
+  function pendingFlagsOf(id: string): FlagChanges | undefined {
+    return pendingFlags.get(id)
+  }
+
   /** 보내는 중인 읽음 · 중요 표시를 덮어쓴다 */
-  function withPendingFlags(items: readonly MessageSummary[]): MessageSummary[] {
+  function withPendingFlags<T extends MessageSummary>(items: readonly T[]): T[] {
     if (pendingFlags.size === 0) return [...items]
     return items.map((item) => {
       const pending = pendingFlags.get(item.id)
@@ -165,6 +326,29 @@ export function createListState({ mailApi, mailboxes, opened }: ListDeps) {
     })
   }
 
+  /**
+   * 대화 줄에 보내는 중인 표시를 덮어쓴다 — 같은 값으로 보내는 메일끼리 모아 적는다(줄의 메일을 모두 보내는 중이면 줄 전체가 그 값 —
+   * 여러 통 처리가 도는 사이 새 메일 확인이 옛 값으로 줄을 되돌리지 않게)
+   */
+  function withPendingConversationFlags(rows: readonly ConversationSummary[]): ConversationSummary[] {
+    if (pendingFlags.size === 0) return [...rows]
+    const groups = new Map<string, { ids: Set<string>; changes: FlagChanges }>()
+    for (const [id, pending] of pendingFlags) {
+      for (const [key, value] of Object.entries(pending) as [keyof FlagChanges, boolean | undefined][]) {
+        if (value === undefined) continue
+        const name = `${key}:${String(value)}`
+        const group = groups.get(name) ?? { ids: new Set<string>(), changes: { [key]: value } }
+        group.ids.add(id)
+        groups.set(name, group)
+      }
+    }
+    return rows.map((row) => {
+      let next = row
+      for (const group of groups.values()) next = withConversationFlags(next, group.ids, group.changes)
+      return next
+    })
+  }
+
   /**
    * 다시 받은 목록의 값으로 열린 메일의 표시(읽음 · 중요 · 메일함 · 붙잡은 발송)를 맞춘다 — 엔진이 붙잡은 발송을 풀었으면(9단계)
    * 읽기 화면의 예약 안내 줄 · 보내지 않은 메일의 삭제 확인도 함께 내려간다
@@ -191,13 +375,49 @@ export function createListState({ mailApi, mailboxes, opened }: ListDeps) {
     }
   }
 
-  /** 지운 뒤 이어서 보여 줄 메일 — 다음 메일, 없으면 이전 메일 (목록 밖의 메일이면 null) */
+  /**
+   * 지운 뒤 이어서 보여 줄 메일 — 다음 메일, 없으면 이전 메일 (목록 밖의 메일이면 null).
+   * 대화 목록은 같은 결로 그 줄의 다음 칸(더 오래된 메일), 없으면 앞 칸, 줄이 비면 다음 줄 · 앞 줄의 마지막 메일 (mail-conversation-list.ts)
+   */
   function neighborAfterRemoval(id: string): string | null {
+    if (isConversationList.value) return conversationNeighborAfterRemoval(conversations.value, id)
     const index = messages.value.findIndex((message) => message.id === id)
     if (index === -1) return null
     return messages.value[index + 1]?.id ?? messages.value[index - 1]?.id ?? null
   }
 
+  // ── 줄 기준의 도우미 (출처를 몰라도 되게 — 머리말) ───────────────────
+
+  /** 그 메일이 든 줄의 차례 — 대화 목록은 그 줄의 마지막 메일이거나 줄에 든 메일. 목록 밖이면 -1 */
+  function rowIndexOfMessage(id: string): number {
+    if (isConversationList.value) return conversationRowIndexOf(conversations.value, id)
+    return messages.value.findIndex((message) => message.id === id)
+  }
+
+  /** 그 줄을 누르면 열 메일 — 대화 목록은 그 줄의 마지막 메일. 없는 줄이면 null */
+  function rowMessageIdAt(index: number): string | null {
+    if (index < 0) return null
+    if (isConversationList.value) return conversations.value[index]?.latest.id ?? null
+    return messages.value[index]?.id ?? null
+  }
+
+  /** 보이는 목록에 든 메일인가 — 뺀 뒤 다음 메일로 넘어갈지 가른다 (대화 목록은 줄에 든 메일 — 뺀 옛 마지막 메일은 아니다) */
+  function isListedMessage(id: string): boolean {
+    if (isConversationList.value) return conversations.value.some((row) => conversationHasMessage(row, id))
+    return messages.value.some((message) => message.id === id)
+  }
+
+  /** 그 메일이 든 대화 줄 — 지금 값 그대로 (한 통의 표시가 실패하면 이 값으로 되돌린다 — message.ts). 메일 목록이면 빈 배열 */
+  function conversationsWith(id: string): ConversationSummary[] {
+    return conversations.value.filter((row) => row.latest.id === id || conversationHasMessage(row, id))
+  }
+
+  /** 보이는 목록이 아는 그 메일의 요약 — 대화 목록은 줄의 마지막 메일만 안다. 모르면 null */
+  function listedSummary(id: string): MessageSummary | null {
+    if (isConversationList.value) return conversations.value.find((row) => row.latest.id === id)?.latest ?? null
+    return messages.value.find((message) => message.id === id) ?? null
+  }
+
   // ── 목록 열기 · 맞추기 ───────────────────────────────
 
   /**
@@ -205,14 +425,23 @@ export function createListState({ mailApi, mailboxes, opened }: ListDeps) {
    * cursor 는 해석하지 않고 그대로 넘긴다
    */
   function fetchPage(
-    source: MailListSource,
+    source: Exclude<MailListSource, ConversationListSource>,
     page: { cursor?: string; limit: number },
     options?: MailRequestOptions,
-  ): Promise<PaginatedResult<MessageSummary>> {
+  ): Promise<PaginatedResult<MessageListItem>> {
     if (source.kind === 'scheduled') return mailApi.listScheduledMessages(page, options)
     return mailApi.listMessages({ ...listQueryOf(source), ...page }, options)
   }
 
+  /** 대화로 묶은 메일함의 한 쪽 — GET /conversations (14단계). cursor 는 해석하지 않고 그대로 넘긴다 */
+  function fetchConversations(
+    source: ConversationListSource,
+    page: { cursor?: string; limit: number },
+    options?: MailRequestOptions,
+  ): Promise<ConversationListPage> {
+    return mailApi.listConversations({ mailboxId: source.mailboxId, ...page }, options)
+  }
+
   /** 예약됨 목록의 전체 수를 받았다 — 메일함 패널의 「예약됨」 개수가 이 값을 쓴다 (scheduled.ts) */
   let onScheduledTotal: ((total: number | null) => void) | null = null
 
@@ -224,45 +453,146 @@ export function createListState({ mailApi, mailboxes, opened }: ListDeps) {
     if (source.kind === 'scheduled') onScheduledTotal?.(info.total)
   }
 
+  /**
+   * 받은 쪽을 목록 뒤에 붙인다 — 이미 있는 메일은 건너뛴다(그사이 새 메일이 와서 경계가 밀렸을 수 있다). 붙인 수를 돌려준다.
+   * 다음 쪽의 total 이 없으면(색인 검색은 첫 쪽에서만 센다 — 14단계) 아는 수를 남긴다
+   */
+  function appendPage(page: PaginatedResult<MessageListItem>): number {
+    const known = new Set(messages.value.map((message) => message.id))
+    const fresh = page.items.filter((item) => !known.has(item.id))
+    messages.value = [...messages.value, ...fresh]
+    pageInfo.value = { ...page.pageInfo, total: page.pageInfo.total ?? pageInfo.value?.total ?? null }
+    return fresh.length
+  }
+
+  /** 검색 결과를 더 이어 받을까 — 서버에 더 있고(hasNext · 커서) 이번에 찾은 것이 한 쪽에 못 미친다 */
+  function wantsMoreResults(source: MailListSource, found: number): boolean {
+    return (
+      source.kind === 'search' &&
+      found < DEFAULT_PAGE_SIZE &&
+      pageInfo.value?.hasNext === true &&
+      Boolean(pageInfo.value.nextCursor)
+    )
+  }
+
+  /**
+   * 검색 결과 이어 받기 (머리말) — 한 쪽이 찰 때까지 · 더 없을 때까지 · 요청이 MAIL_SEARCH_FILL_MAX_REQUESTS 번이 될 때까지 커서로 묻는다.
+   * found · requests 는 이번에 이미 찾은 수 · 보낸 요청 수. 하나라도 찾으면 목록을 보인다. 그사이 목록을 새로 열었으면 멈춘다.
+   * 실패는 그대로 던진다 — 부르는 쪽이 받은 데까지 보인다 (알림은 인터셉터가 띄운다)
+   */
+  async function continueSearch(source: SearchListSource, seq: number, found: number, requests: number): Promise<void> {
+    let total = found
+    let sent = requests
+    while (seq === listSeq && sent < MAIL_SEARCH_FILL_MAX_REQUESTS && wantsMoreResults(source, total)) {
+      const cursor = pageInfo.value?.nextCursor
+      if (!cursor) return
+      const page = await fetchPage(source, { cursor, limit: DEFAULT_PAGE_SIZE }, { signal: listAbort.signal })
+      sent += 1
+      if (seq !== listSeq) return
+      total += appendPage(page)
+      if (messages.value.length > 0 && listStatus.value === 'loading') listStatus.value = 'ready'
+    }
+  }
+
+  /**
+   * 이어 받는 일 하나를 돌린다 — 도는 동안 isLoadingMore. [다음] · [더 찾기]가 그사이 다시 누르면 새로 묻지 않고 이 일이 끝나기를 기다린다(loadMore).
+   * 실패는 삼킨다 — 알림은 인터셉터가 띄웠고 받은 데까지 보인다. 그사이 다른 목록을 열었으면 그 목록이 표시를 맡는다(openList)
+   */
+  async function runLoading(seq: number, work: () => Promise<void>): Promise<void> {
+    isLoadingMore.value = true
+    const run = work().catch(() => undefined)
+    loading = run
+    await run
+    if (loading === run) loading = null
+    if (seq === listSeq) isLoadingMore.value = false
+  }
+
   /**
    * 목록 열기 — 첫 페이지를 불러온다. 다른 목록이면 고른 것이 풀린다 (메일함을 바꾸거나 검색하면 선택을 푼다).
    * 같은 목록으로 돌아오면(쓰기 화면에서 복귀 등) 보이던 목록을 둔 채 새로 고친다.
+   * 검색 결과가 한 쪽에 못 미치고 서버에 더 있으면 이어 받는다 (머리말 "검색 결과 이어 받기") — 첫 쪽이 비었으면 보이던 채로 다시 찾을 때도 "찾는 중"(뼈대).
+   * 검색어와 조건을 합친 낱말이 서버 한도를 넘는 검색(손으로 고친 주소)은 묻지 않는다 — 목록 틀이 그 까닭을 보인다 (isSearchTooLong)
+   * 대화로 묶은 메일함(14단계)은 GET /conversations 의 첫 쪽이다 — 줄 모양만 다르고 같은 순번 · 상태를 쓴다
    */
   async function openList(next: MailListSource): Promise<void> {
     const keepVisible = sameListSource(listSource.value, next) && listStatus.value === 'ready'
     listSource.value = next
     listSeq += 1
     const seq = listSeq
+    // 앞 목록의 요청은 끊는다 — 이어 받던 일도 이제 쓰지 않는다 (그 응답은 순번으로도 버린다)
+    const signal = renewListAbort()
+    isLoadingMore.value = false
+
+    if (isSearchTooLong(next)) {
+      messages.value = []
+      conversations.value = []
+      pageInfo.value = null
+      listError.value = null
+      isRefreshing.value = false
+      listStatus.value = 'ready'
+      return
+    }
 
     if (keepVisible) {
       isRefreshing.value = true
     } else {
       messages.value = []
+      conversations.value = []
       pageInfo.value = null
       listStatus.value = 'loading'
       listError.value = null
     }
 
-    try {
-      const page = await fetchPage(
-        next,
-        { limit: DEFAULT_PAGE_SIZE },
-        // 처음 여는 목록은 목록 영역이 오류 상태("다시 시도")를 직접 그린다
-        { silent: keepVisible ? undefined : true },
-      )
+    // 처음 여는 목록은 목록 영역이 오류 상태("다시 시도")를 직접 그린다
+    const firstOptions: MailRequestOptions = { silent: keepVisible ? undefined : true, signal }
+
+    /** 첫 쪽을 받지 못했다 — 보이는 채로 새로 고치던 것이면 그대로 두고, 아니면 오류 상태 */
+    const failFirst = (error: unknown) => {
       if (seq !== listSeq) return
-      messages.value = page.items
-      pageInfo.value = page.pageInfo
-      listStatus.value = 'ready'
-      listError.value = null
-      reportTotal(next, page.pageInfo)
-    } catch (error) {
-      if (seq !== listSeq || keepVisible) return
+      isRefreshing.value = false
+      if (keepVisible) return
       listStatus.value = 'error'
       listError.value = toApiError(error)
-    } finally {
-      if (seq === listSeq) isRefreshing.value = false
     }
+
+    if (next.kind === 'conversations') {
+      let rows: ConversationListPage
+      try {
+        rows = await fetchConversations(next, { limit: DEFAULT_PAGE_SIZE }, firstOptions)
+      } catch (error) {
+        failFirst(error)
+        return
+      }
+      if (seq !== listSeq) return
+      conversations.value = rows.items
+      pageInfo.value = rows.pageInfo
+      listError.value = null
+      isRefreshing.value = false
+      listStatus.value = 'ready'
+      return
+    }
+
+    let page: PaginatedResult<MessageListItem>
+    try {
+      page = await fetchPage(next, { limit: DEFAULT_PAGE_SIZE }, firstOptions)
+    } catch (error) {
+      failFirst(error)
+      return
+    }
+    if (seq !== listSeq) return
+    messages.value = page.items
+    pageInfo.value = page.pageInfo
+    listError.value = null
+    isRefreshing.value = false
+    reportTotal(next, page.pageInfo)
+
+    if (next.kind === 'search' && wantsMoreResults(next, page.items.length)) {
+      // 하나라도 찾았으면 보이며 뒤에서 잇는다 — 하나도 없으면 "찾는 중"(뼈대)으로 잇는다
+      listStatus.value = page.items.length > 0 ? 'ready' : 'loading'
+      await runLoading(seq, () => continueSearch(next, seq, page.items.length, 1))
+      if (seq !== listSeq) return
+    }
+    listStatus.value = 'ready'
   }
 
   /** 메일함 열기 — 같은 메일함으로 돌아오면 보이던 목록을 둔 채 새로 고친다 */
@@ -270,21 +600,52 @@ export function createListState({ mailApi, mailboxes, opened }: ListDeps) {
     await openList({ kind: 'mailbox', mailboxId })
   }
 
+  /**
+   * 대화로 묶은 메일함 열기 (14단계) — 같은 목록으로 돌아오면 보이던 줄을 둔 채 새로 고친다.
+   * 묶기를 켜고 끄면 출처가 바뀌어 앞 목록의 응답을 버리고 처음 쪽부터 받는다 (메일함 화면이 설정에 따라 부른다)
+   */
+  async function openConversations(mailboxId: string): Promise<void> {
+    await openList({ kind: 'conversations', mailboxId })
+  }
+
   /** 예약됨 열기 (9단계) — 같은 목록으로 돌아오면 보이던 목록을 둔 채 새로 고친다 (보낸 메일은 저절로 빠진다) */
   async function openScheduled(): Promise<void> {
     await openList(SCHEDULED_LIST_SOURCE)
   }
 
   /**
-   * 검색 결과 열기 (계약 2절 "검색") — scope 는 메일함 id 또는 전체(SEARCH_SCOPE_ALL).
-   * 같은 검색 결과가 이미 보이면(결과에서 연 메일에서 돌아오는 등) 다시 찾지 않는다 — 보던 결과가 저절로 바뀌지 않게.
-   * force 면(같은 검색어로 다시 Enter) 보이는 채로 다시 찾는다 — 다시 찾는 것도 검색이라 고른 것을 푼다
+   * 지난 메일 색인의 상태를 조용히 묻는다 (14단계 — 검색을 시작할 때). 늦게 온 응답은 버리고, 실패하면 모르는 것(null)으로 둔다 —
+   * 안내 줄 없이 지금처럼 보인다
    */
-  async function openSearch(q: string, scope: string, options: { force?: boolean } = {}): Promise<void> {
-    const next: SearchListSource = { kind: 'search', q, scope }
+  async function refreshSearchIndex(): Promise<void> {
+    searchIndexSeq += 1
+    const seq = searchIndexSeq
+    try {
+      const state = await mailApi.getSearchIndex({ silent: true })
+      if (seq !== searchIndexSeq) return
+      const status: unknown = state?.status
+      searchIndexStatus.value = status === 'building' || status === 'ready' ? status : null
+    } catch {
+      if (seq === searchIndexSeq) searchIndexStatus.value = null
+    }
+  }
+
+  /**
+   * 검색 결과 열기 (계약 2절 "검색" · "검색 — 14단계") — scope 는 메일함 id 또는 전체(SEARCH_SCOPE_ALL), conditions 는 조건(없으면 검색어로만).
+   * 같은 검색 결과가 이미 보이면(결과에서 연 메일에서 돌아오는 등) 다시 찾지 않는다 — 보던 결과가 저절로 바뀌지 않게.
+   * force 면(같은 검색어로 다시 Enter) 보이는 채로 다시 찾는다 — 다시 찾는 것도 검색이라 고른 것을 푼다.
+   * 찾을 때마다 지난 메일 색인의 상태도 묻는다
+   */
+  async function openSearch(
+    q: string,
+    scope: string,
+    options: { force?: boolean; conditions?: SearchConditions | null } = {},
+  ): Promise<void> {
+    const next = searchSourceOf(q, scope, options.conditions)
     const shown = sameListSource(listSource.value, next)
     if (shown && !options.force && (listStatus.value === 'ready' || listStatus.value === 'loading')) return
     if (shown && options.force) renewSource()
+    void refreshSearchIndex()
     await openList(next)
   }
 
@@ -299,27 +660,40 @@ export function createListState({ mailApi, mailboxes, opened }: ListDeps) {
     if (listSource.value) await openList(listSource.value)
   }
 
-  /** 다음 페이지 — pageInfo.nextCursor 를 해석하지 않고 그대로 보낸다 */
+  /**
+   * 다음 페이지 — pageInfo.nextCursor 를 해석하지 않고 그대로 보낸다.
+   * 검색 결과는 한 쪽(20통)을 더 찾을 때까지 이어 묻는다 (머리말 — [메일 더 보기] · [더 찾기] · 목록 보기의 [다음]).
+   * 이미 이어 받는 중이면 새로 묻지 않고 그 일이 끝나기를 기다린다 — [다음]이 그 뒤에 온 메일로 넘어가게.
+   * 보이는 채로 새로 고치는 중이면 묻지 않는다 — 옛 커서로 붙이면 새 첫 쪽과 사이가 빈다
+   */
   async function loadMore(): Promise<void> {
+    if (isLoadingMore.value) {
+      await loading
+      return
+    }
     const cursor = pageInfo.value?.nextCursor
     const source = listSource.value
-    if (!cursor || !source || isLoadingMore.value) return
+    if (!cursor || !source || isRefreshing.value) return
 
     const seq = listSeq
-    isLoadingMore.value = true
-    try {
-      const page = await fetchPage(source, { cursor, limit: DEFAULT_PAGE_SIZE })
-      if (seq !== listSeq) return
-      // 그사이 새 메일이 와서 경계가 밀렸을 수 있다 — 이미 있는 메일은 건너뛴다
-      const known = new Set(messages.value.map((message) => message.id))
-      messages.value = [...messages.value, ...page.items.filter((item) => !known.has(item.id))]
-      pageInfo.value = page.pageInfo
-      reportTotal(source, page.pageInfo)
-    } catch {
-      // 알림은 인터셉터가 띄웠다 — 버튼을 다시 누를 수 있게 그대로 둔다
-    } finally {
-      isLoadingMore.value = false
+    const signal = listAbort.signal
+    if (source.kind === 'conversations') {
+      await runLoading(seq, async () => {
+        const page = await fetchConversations(source, { cursor, limit: DEFAULT_PAGE_SIZE }, { signal })
+        if (seq !== listSeq) return
+        const merged = appendConversationPage(conversations.value, pageInfo.value, page)
+        conversations.value = merged.rows
+        pageInfo.value = merged.pageInfo
+      })
+      return
     }
+    await runLoading(seq, async () => {
+      const page = await fetchPage(source, { cursor, limit: DEFAULT_PAGE_SIZE }, { signal })
+      if (seq !== listSeq) return
+      const added = appendPage(page)
+      reportTotal(source, page.pageInfo)
+      if (source.kind === 'search') await continueSearch(source, seq, added, 1)
+    })
   }
 
   /**
@@ -327,23 +701,45 @@ export function createListState({ mailApi, mailboxes, opened }: ListDeps) {
    * 고른 메일 · 열린 메일은 그대로, 다시 받은 범위 밖의 메일은 그대로 둔다(mail-list-merge.ts). 실패는 알리지 않는다.
    * 검색 결과는 새 메일 확인으로 저절로 바꾸지 않는다 — includeSearch 는 사용자가 한 일(되돌리기 · 여러 통 처리) 뒤에만 준다.
    * 묻는 사이 이 탭이 목록을 바꿨으면(localGeneration) 그 응답은 버리고 한 번 더 맞춘다.
-   * 예약됨(9단계)은 늘 맞춘다 — 보낸 메일이 저절로 빠진다. 새로 생긴 줄은 새 메일이 아니라 "새 메일 N통" 줄을 띄우지 않는다
+   * 예약됨(9단계)은 늘 맞춘다 — 보낸 메일이 저절로 빠진다. 새로 생긴 줄은 새 메일이 아니라 "새 메일 N통" 줄을 띄우지 않는다.
+   * 대화로 묶은 메일함(14단계)은 불러온 줄 수만큼(최대 100줄) GET /conversations 로 같은 규칙으로 맞춘다 (mail-conversation-list.ts)
    */
   async function syncVisibleList(options: { includeSearch?: boolean } = {}, attempt = 0): Promise<void> {
     const source = listSource.value
     if (!source || listStatus.value !== 'ready') return
-    if (source.kind === 'search' && !options.includeSearch) return
+    if (source.kind === 'search' && (!options.includeSearch || isSearchTooLong(source))) return
 
     const seq = listSeq
     const generation = localGeneration
-    const limit = Math.min(MAIL_LIST_SYNC_MAX, Math.max(DEFAULT_PAGE_SIZE, messages.value.length))
+    const limit = Math.min(MAIL_LIST_SYNC_MAX, Math.max(DEFAULT_PAGE_SIZE, rowCount.value))
+
+    /** 받은 응답을 쓸까 — 그사이 목록을 새로 열었으면 버리고, 이 탭이 목록을 바꿨으면 버리고 한 번 더 맞춘다 */
+    async function accepts(): Promise<boolean> {
+      if (seq !== listSeq || listStatus.value !== 'ready') return false
+      if (generation === localGeneration) return true
+      if (attempt === 0) await syncVisibleList(options, attempt + 1)
+      return false
+    }
+
     try {
-      const page = await fetchPage(source, { limit }, { silent: true })
-      if (seq !== listSeq || listStatus.value !== 'ready') return
-      if (generation !== localGeneration) {
-        if (attempt === 0) await syncVisibleList(options, attempt + 1)
+      if (source.kind === 'conversations') {
+        const rows = await fetchConversations(source, { limit }, { silent: true, signal: listAbort.signal })
+        if (!(await accepts())) return
+        const mergedRows = mergeRefreshedConversations({
+          current: conversations.value,
+          currentPageInfo: pageInfo.value,
+          fetched: withPendingConversationFlags(rows.items),
+          fetchedPageInfo: rows.pageInfo,
+        })
+        conversations.value = mergedRows.rows
+        pageInfo.value = mergedRows.pageInfo
+        refreshSelectedFrom(mergedRows.rows.map((row) => row.latest))
+        listSyncSeq += 1
+        listSync.value = { seq: listSyncSeq, addedAbove: mergedRows.addedAbove }
         return
       }
+      const page = await fetchPage(source, { limit }, { silent: true, signal: listAbort.signal })
+      if (!(await accepts())) return
       const merged = mergeRefreshedList({
         current: messages.value,
         currentPageInfo: pageInfo.value,
@@ -363,9 +759,13 @@ export function createListState({ mailApi, mailboxes, opened }: ListDeps) {
 
   function reset() {
     listSeq += 1
+    renewListAbort()
+    searchIndexSeq += 1
     listSource.value = null
     searchOrigin.value = null
+    searchIndexStatus.value = null
     messages.value = []
+    conversations.value = []
     pageInfo.value = null
     listStatus.value = 'idle'
     listError.value = null
@@ -382,7 +782,12 @@ export function createListState({ mailApi, mailboxes, opened }: ListDeps) {
     currentMailbox,
     search,
     searchOrigin,
+    searchIndexStatus,
     messages,
+    conversations,
+    isConversationList,
+    rowCount,
+    listedSummaries,
     pageInfo,
     listStatus,
     listError,
@@ -391,14 +796,26 @@ export function createListState({ mailApi, mailboxes, opened }: ListDeps) {
     listSync,
     hasMore,
     setLocalFlags,
+    setFlagsOf,
+    restoreConversationFlags,
     applySummary,
+    watchLocalReads,
+    restoreLocalReads,
+    noteMailboxRead,
     removeFromList,
     relocate,
     beginPending,
     endPending,
+    pendingFlagsOf,
     neighborAfterRemoval,
+    rowIndexOfMessage,
+    rowMessageIdAt,
+    isListedMessage,
+    listedSummary,
+    conversationsWith,
     openList,
     openMailbox,
+    openConversations,
     openScheduled,
     openSearch,
     rememberSearchOrigin,
diff --git a/frontend/src/stores/mail/mailbox-admin.ts b/frontend/src/stores/mail/mailbox-admin.ts
index 181bbda..f755534 100644
--- a/frontend/src/stores/mail/mailbox-admin.ts
+++ b/frontend/src/stores/mail/mailbox-admin.ts
@@ -142,6 +142,8 @@ export function createMailboxAdmin({ mailApi, mailboxes, list }: MailboxAdminDep
    */
   function settle(kind: MailboxOperationKind, mailboxId: string) {
     mailboxes.syncCounts()
+    // 모두 읽음 — 같은 대화 칸에 든 그 메일함 메일도 읽음으로 (14단계 — 칸은 읽음만 바뀐 소식으로 다시 받지 않는다)
+    if (kind === 'read') list.noteMailboxRead(mailboxId)
     const source = list.listSource.value
     if (kind === 'delete' || !source || scopeMailboxIdOf(source) !== mailboxId) return
     if (kind === 'read') void list.syncVisibleList({ includeSearch: true })
diff --git a/frontend/src/stores/mail/message.ts b/frontend/src/stores/mail/message.ts
index c2fac4c..0e30be5 100644
--- a/frontend/src/stores/mail/message.ts
+++ b/frontend/src/stores/mail/message.ts
@@ -1,10 +1,15 @@
 // 메일 스토어 모듈 — 열린 메일(읽기 화면)과 그 동작: 열기 · 읽음 처리 · 중요 표시 · 다른 메일함으로 옮기기 (mail.store.ts 가 조립한다)
 // "열린 메일"(selectedId)은 여러 통 처리의 "고른 메일"(checkedIds — selection.ts)과 다르다.
+// 검색 결과에서 연 메일(14단계)은 검색 쿼리(q · from · to · subject · body)와 함께 받아 맞은 곳이 강조된 본문이다 — 강조 쿼리가 다르면
+// (같은 메일을 메일함에서 다시 열었을 때 등) 같은 메일이어도 다시 받는다. 강조가 든 본문은 읽기 화면에 보이기만 한다 —
+// 답장 · 전달의 원문 · 인쇄는 쿼리 없이 따로 받는다 (계약 2절 "검색 — 14단계", ComposePage · MailPrintPage)
 import { ref } from 'vue'
 
 import { toApiError, type ApiError } from '@/composables/useApi'
 import type { MessageLargeFile, ShareLink } from '@/shared/types/large-file'
-import type { MessageDetail } from '@/shared/types/mail'
+import type { MessageDetail, MessageHighlightQuery } from '@/shared/types/mail'
+import { mailboxListIdOf } from '@/shared/utils/mail-list-source'
+import { messageHighlightKey } from '@/shared/utils/mail-search'
 import type { ListState } from './list'
 import type { MailboxesState } from './mailboxes'
 import type { FlagChanges, LoadStatus, MailApi } from './types'
@@ -17,6 +22,8 @@ export function createOpenedMessage() {
   const selectedError = ref<ApiError | null>(null)
   /** 외부 이미지를 보이는 본문을 받는 중인 메일 — 읽기 화면의 [이미지 보기]가 기다린다 (9단계) */
   const imagesLoadingId = ref<string | null>(null)
+  /** 열린 메일을 받은 강조 쿼리 (14단계 — 검색 결과에서 연 메일만, 그 밖에는 null). [이미지 보기] · [다시 시도]가 같은 쿼리로 받는다 */
+  const selectedHighlight = ref<MessageHighlightQuery | null>(null)
   /** 메일을 빠르게 바꿀 때 늦게 온 본문 응답이 덮어쓰지 않게 */
   let detailSeq = 0
 
@@ -41,6 +48,7 @@ export function createOpenedMessage() {
     selectedStatus.value = 'idle'
     selectedError.value = null
     imagesLoadingId.value = null
+    selectedHighlight.value = null
   }
 
   return {
@@ -49,6 +57,7 @@ export function createOpenedMessage() {
     selectedStatus,
     selectedError,
     imagesLoadingId,
+    selectedHighlight,
     nextDetailSeq,
     currentDetailSeq,
     isCurrentDetail,
@@ -66,9 +75,13 @@ interface MessageActionsDeps {
 }
 
 export function createMessageActions({ mailApi, mailboxes, list, opened }: MessageActionsDeps) {
-  /** 읽음 처리 — 화면을 먼저 바꾸고, 실패하면 되돌린다 */
-  async function markRead(message: Pick<MessageDetail, 'id' | 'isRead' | 'mailboxIds'>) {
-    if (message.isRead) return
+  /**
+   * 읽음 처리 — 화면을 먼저 바꾸고, 실패하면 되돌린다. 읽음이 됐으면(이미 읽음 · 읽음으로 보내는 중 포함) true, 되돌렸으면 false
+   * (같은 대화 칸의 펼친 줄이 자기 표시를 되돌릴지 본다 — conversation.ts).
+   * 같은 메일을 읽음으로 보내는 중이면(여러 통 처리 · 앞선 읽음 처리) 다시 보내지 않는다 — 안 읽은 수를 두 번 빼지 않게
+   */
+  async function markRead(message: Pick<MessageDetail, 'id' | 'isRead' | 'mailboxIds'>): Promise<boolean> {
+    if (message.isRead || list.pendingFlagsOf(message.id)?.isRead === true) return true
     // 주소로 바로 들어오면 메일함 목록보다 본문이 먼저 올 수 있다 — 그러면 아래 개수 조정이
     // 늦게 온 메일함 응답에 덮어쓰이므로, 읽음 처리가 끝난 뒤 서버 기준으로 다시 맞춘다
     const resync = mailboxes.mailboxCountsMayBeOverwritten()
@@ -81,25 +94,32 @@ export function createMessageActions({ mailApi, mailboxes, list, opened }: Messa
       list.endPending([message.id], changes)
       list.applySummary(summary)
       if (resync || mailboxes.mailboxCountsMayBeOverwritten()) void mailboxes.loadMailboxes({ background: true })
+      return true
     } catch {
       list.endPending([message.id], changes)
       list.setLocalFlags(message.id, { isRead: false })
       mailboxes.adjustUnread(message.mailboxIds, 1)
+      return false
     }
   }
 
-  /** 메일 열기 — 조회만으로는 읽음 처리되지 않으므로 열린 뒤 PATCH {isRead:true} 를 보낸다 */
-  async function openMessage(id: string): Promise<void> {
+  /**
+   * 메일 열기 — 조회만으로는 읽음 처리되지 않으므로 열린 뒤 PATCH {isRead:true} 를 보낸다.
+   * highlight 는 검색 결과에서 연 메일의 강조 쿼리(14단계 — 그 밖에는 null). 같은 메일을 같은 쿼리로 이미 열었으면 다시 받지 않는다
+   */
+  async function openMessage(id: string, highlight: MessageHighlightQuery | null = null): Promise<void> {
     opened.selectedId.value = id
-    if (opened.selected.value?.id === id && opened.selectedStatus.value === 'ready') return
+    const sameHighlight = messageHighlightKey(opened.selectedHighlight.value) === messageHighlightKey(highlight)
+    if (opened.selected.value?.id === id && opened.selectedStatus.value === 'ready' && sameHighlight) return
 
     const seq = opened.nextDetailSeq()
     opened.selected.value = null
     opened.selectedStatus.value = 'loading'
     opened.selectedError.value = null
     opened.imagesLoadingId.value = null
+    opened.selectedHighlight.value = highlight
     try {
-      const detail = await mailApi.getMessage(id, { silent: true })
+      const detail = await mailApi.getMessage(id, { silent: true, highlight })
       if (!opened.isCurrentDetail(seq)) return
       opened.selected.value = detail
       opened.selectedStatus.value = 'ready'
@@ -113,6 +133,7 @@ export function createMessageActions({ mailApi, mailboxes, list, opened }: Messa
 
   /**
    * [이미지 보기] — 열린 메일을 `images=show` 로 다시 받아 본문만 바꾼다 (9단계 "외부 이미지 보기" — 그 메일만, 다시 열면 설정대로).
+   * 검색 결과에서 연 메일은 같은 강조 쿼리와 함께 받는다(14단계 — 강조가 그대로 남게).
    * 그사이 다른 메일을 열었거나 닫았으면(순번이 바뀜) 늦은 응답을 버린다. 읽음 · 중요 · 메일함 표시는 지금 값 그대로 둔다.
    * 실패는 인터셉터가 알리고 안내 줄은 그대로 남는다. 바꿨으면 true
    */
@@ -122,12 +143,15 @@ export function createMessageActions({ mailApi, mailboxes, list, opened }: Messa
     const id = current.id
     const seq = opened.currentDetailSeq()
     opened.imagesLoadingId.value = id
+    const highlight = opened.selectedHighlight.value
     try {
-      const detail = await mailApi.getMessage(id, { showImages: true })
+      const detail = await mailApi.getMessage(id, { showImages: true, highlight })
       const latest = opened.selected.value
       if (!opened.isCurrentDetail(seq) || latest?.id !== id) return false
       opened.selected.value = {
         ...latest,
+        // 강조가 든 본문이면 제목 · 첨부 이름 · 글 본문은 NFC 로 맞춘 글이고 위치는 새 본문 기준이다 — 함께 바꾼다 (14단계)
+        ...(highlight ? { subject: detail.subject, searchHighlight: detail.searchHighlight ?? null } : {}),
         htmlBody: detail.htmlBody,
         textBody: detail.textBody,
         hasBlockedImages: detail.hasBlockedImages,
@@ -146,14 +170,17 @@ export function createMessageActions({ mailApi, mailboxes, list, opened }: Messa
     }
   }
 
-  /** 중요 표시 토글 — 화면을 먼저 바꾸고, 실패하면 되돌린다 */
+  /**
+   * 중요 표시 토글 — 화면을 먼저 바꾸고, 실패하면 되돌린다. 대화로 묶은 목록(14단계)은 한 통만 바꾸면 줄의 표시를 다 알 수 없어
+   * (다른 메일 · 붙잡힌 메일에도 표시가 있을 수 있다) 실패하면 그 메일이 든 줄을 앞 값 그대로 되돌린다 — 여러 통 처리와 같은 결 (리뷰 L1)
+   */
   async function toggleFlag(id: string): Promise<void> {
-    const current =
-      list.messages.value.find((message) => message.id === id) ??
-      (opened.selected.value?.id === id ? opened.selected.value : null)
+    // 대화로 묶은 목록은 줄의 마지막 메일만 안다 — 모르면 열린 메일의 값으로 (14단계)
+    const current = list.listedSummary(id) ?? (opened.selected.value?.id === id ? opened.selected.value : null)
     if (!current) return
 
     const changes: FlagChanges = { isFlagged: !current.isFlagged }
+    const rowsBefore = list.conversationsWith(id)
     list.setLocalFlags(id, changes)
     list.beginPending([id], changes)
     try {
@@ -163,6 +190,7 @@ export function createMessageActions({ mailApi, mailboxes, list, opened }: Messa
     } catch {
       list.endPending([id], changes)
       list.setLocalFlags(id, { isFlagged: current.isFlagged })
+      list.restoreConversationFlags(rowsBefore)
     }
   }
 
@@ -180,7 +208,9 @@ export function createMessageActions({ mailApi, mailboxes, list, opened }: Messa
     mailboxes.syncCounts()
     const source = list.listSource.value
     const trashId = mailboxes.mailboxByRole('trash')?.id ?? null
-    if (source?.kind === 'mailbox' && (source.mailboxId === mailboxId || source.mailboxId === trashId)) {
+    // 메일함 목록(대화로 묶은 목록 포함 — 14단계)이 옮긴 곳이나 휴지통이면 다시 받는다
+    const listMailboxId = mailboxListIdOf(source)
+    if (source && listMailboxId !== null && (listMailboxId === mailboxId || listMailboxId === trashId)) {
       void list.openList(source)
     }
     return true
diff --git a/frontend/src/stores/mail/scheduled.ts b/frontend/src/stores/mail/scheduled.ts
index 10edba0..0a5bcad 100644
--- a/frontend/src/stores/mail/scheduled.ts
+++ b/frontend/src/stores/mail/scheduled.ts
@@ -12,7 +12,7 @@ import { toApiError } from '@/composables/useApi'
 import type { MailRequestOptions } from '@/composables/useMail'
 import { SCHEDULED_COUNT_PAGE_SIZE } from '@/shared/constants/mail-send-later'
 import type { MessageSummary, ScheduledMessageCancel } from '@/shared/types/mail'
-import { sameListSource } from '@/shared/utils/mail-list-source'
+import { mailboxListIdOf, sameListSource } from '@/shared/utils/mail-list-source'
 import { messagePendingSend, pendingSendOf, samePendingSend } from '@/shared/utils/pending-send'
 import type { ListState } from './list'
 import type { MailboxesState } from './mailboxes'
@@ -83,7 +83,7 @@ export function createScheduledState({ mailApi, mailboxes, list, opened, session
    * 모두 알리지 않는다. 다 끝나면 돌아온다
    */
   async function refreshPendingSends(): Promise<void> {
-    const includeSearch = list.messages.value.some((message) => messagePendingSend(message) !== null)
+    const includeSearch = list.listedSummaries.value.some((message) => messagePendingSend(message) !== null)
     await Promise.all([list.syncVisibleList({ includeSearch }), refreshOpenedPendingSend(), loadScheduledCount()])
   }
 
@@ -105,8 +105,11 @@ export function createScheduledState({ mailApi, mailboxes, list, opened, session
     }
     // 기다리는 사이 세션이 바뀌었으면(다른 계정 — 메일 id 가 겹칠 수 있다) 목록 · 열린 메일을 건드리지 않는다 (스토어도 이미 비웠다)
     if (sessionGeneration() !== session) return result
-    // 다른 목록으로 옮겨 갔으면 그 목록에는 이 메일이 없다 — 빼지 않고 서버 기준으로 맞추기만 한다
-    if (sameListSource(list.listSource.value, source) && (source?.kind === 'scheduled' || source?.kind === 'mailbox')) {
+    // 다른 목록으로 옮겨 갔으면 그 목록에는 이 메일이 없다 — 빼지 않고 서버 기준으로 맞추기만 한다 (대화로 묶은 메일함도 메일함이다 — 14단계)
+    if (
+      sameListSource(list.listSource.value, source) &&
+      (source?.kind === 'scheduled' || mailboxListIdOf(source) !== null)
+    ) {
       list.removeFromList(new Set([id]))
     }
     const current = opened.selected.value
diff --git a/frontend/src/stores/mail/selection.ts b/frontend/src/stores/mail/selection.ts
index bf954b7..2117761 100644
--- a/frontend/src/stores/mail/selection.ts
+++ b/frontend/src/stores/mail/selection.ts
@@ -1,11 +1,14 @@
 // 메일 스토어 모듈 — 고른 메일(여러 통 처리의 체크) (mail.store.ts 가 조립한다)
 // 고를 수 있는 것은 불러온 메일까지다. 목록에서 빠진 메일은 고른 것에서도 빠지고(새 메일 확인으로 맞출 때 남은 메일의 선택은 그대로),
-// 목록의 출처가 바뀌면(메일함을 바꾸거나 검색하면) 모두 푼다 (계약 2절 "여러 통 한꺼번에")
+// 목록의 출처가 바뀌면(메일함을 바꾸거나 검색하면 · 대화로 묶기를 켜고 끄면) 모두 푼다 (계약 2절 "여러 통 한꺼번에")
 // 아직 보내지 않은 메일(붙잡은 발송 — 보내는 중 · 예약, 9단계)은 고를 수 없다: 옮기거나 지워도 엔진은 그 시각에 보낸다 — 취소해야만 보낸편지함을 떠난다.
 // 하나 고르기 · 범위 · 모두 고르기가 모두 건너뛰고, 고른 메일(checkedMessages — 여러 통 처리가 쓰는 것)에도 들지 않는다 (pending-send.ts 의 isHeldMessage)
+// 대화로 묶은 메일함(14단계 — 계약 2절 "대화로 묶어 보기")은 줄(대화 id)을 고른다. 여러 통 처리는 고른 줄의 메일에서 붙잡힌 메일을 뺀 것에 한다
+// (checkedActionIds), 줄의 메일이 모두 붙잡힌 메일이면 그 줄은 고를 수 없다 (mail-conversation-list.ts 의 isConversationHeld)
 import { computed, shallowRef, watch } from 'vue'
 
-import type { MessageSummary } from '@/shared/types/mail'
+import type { ConversationSummary, MessageSummary } from '@/shared/types/mail'
+import { conversationActionIdsOf, isConversationHeld } from '@/shared/utils/mail-conversation-list'
 import {
   checkAllState,
   checkRange,
@@ -16,24 +19,44 @@ import {
 import { isHeldMessage } from '@/shared/utils/pending-send'
 import type { ListState } from './list'
 
-export function createSelection(list: Pick<ListState, 'messages' | 'sourceSeq'>) {
-  /** 고른 메일 id — 바꿀 때는 새 모음으로 바꿔 끼운다 */
+export function createSelection(
+  list: Pick<ListState, 'messages' | 'conversations' | 'isConversationList' | 'sourceSeq'>,
+) {
+  /** 고른 줄 id(메일 목록은 메일 id, 대화 목록은 대화 id) — 바꿀 때는 새 모음으로 바꿔 끼운다 */
   const checkedIds = shallowRef<ReadonlySet<string>>(new Set())
-  /** Shift + 클릭 범위의 기준 — 마지막으로 누른 메일 */
+  /** Shift + 클릭 범위의 기준 — 마지막으로 누른 줄 */
   let checkAnchorId: string | null = null
 
-  /** 고를 수 있는 메일 id — 목록 순서 그대로, 붙잡은 발송은 뺀다 */
+  /** 고를 수 있는 줄 id — 목록 순서 그대로, 붙잡은 발송(대화 목록은 메일이 모두 붙잡힌 줄)은 뺀다 */
   const selectableIds = computed<string[]>(() =>
-    list.messages.value.filter((message) => !isHeldMessage(message)).map((message) => message.id),
+    list.isConversationList.value
+      ? list.conversations.value.filter((row) => !isConversationHeld(row)).map((row) => row.id)
+      : list.messages.value.filter((message) => !isHeldMessage(message)).map((message) => message.id),
   )
+  /** 고른 줄 수 — 대화 목록은 대화 수 */
   const checkedCount = computed<number>(() => checkedIds.value.size)
-  /** 고른 메일 — 목록 순서 그대로 (붙잡은 발송은 고른 것에 남아 있어도 넣지 않는다 — 여러 통 처리가 이것만 보낸다) */
+  /**
+   * 고른 메일 — 목록 순서 그대로 (붙잡은 발송은 고른 것에 남아 있어도 넣지 않는다 — 여러 통 처리가 이것만 보낸다).
+   * 대화 목록에서는 비어 있다 — 고른 대화(checkedConversations)와 그 메일(checkedActionIds)을 본다
+   */
   const checkedMessages = computed<MessageSummary[]>(() =>
-    checkedIds.value.size === 0
+    checkedIds.value.size === 0 || list.isConversationList.value
       ? []
       : list.messages.value.filter((message) => checkedIds.value.has(message.id) && !isHeldMessage(message)),
   )
-  /** 표 머리 고르기 상자의 상태 — 고를 수 있는 메일 기준 */
+  /** 고른 대화 — 목록 순서 그대로 (메일이 모두 붙잡힌 줄은 넣지 않는다). 메일 목록에서는 비어 있다 */
+  const checkedConversations = computed<ConversationSummary[]>(() =>
+    checkedIds.value.size === 0 || !list.isConversationList.value
+      ? []
+      : list.conversations.value.filter((row) => checkedIds.value.has(row.id) && !isConversationHeld(row)),
+  )
+  /** 여러 통 처리가 보낼 메일 — 메일 목록은 고른 메일, 대화 목록은 고른 줄의 메일(붙잡힌 메일은 빼고 겹치지 않게) */
+  const checkedActionIds = computed<string[]>(() =>
+    list.isConversationList.value
+      ? conversationActionIdsOf(checkedConversations.value)
+      : checkedMessages.value.map((message) => message.id),
+  )
+  /** 표 머리 고르기 상자의 상태 — 고를 수 있는 줄 기준 */
   const checkState = computed<CheckAllState>(() => checkAllState(checkedIds.value, selectableIds.value))
 
   function isSelectable(id: string): boolean {
@@ -45,27 +68,27 @@ export function createSelection(list: Pick<ListState, 'messages' | 'sourceSeq'>)
     checkAnchorId = null
   }
 
-  /** 하나 고르기 · 풀기 — 고르기 상자 · Ctrl(⌘) + 클릭. 고를 수 없는 메일이면 아무것도 하지 않는다 */
+  /** 하나 고르기 · 풀기 — 고르기 상자 · Ctrl(⌘) + 클릭. 고를 수 없는 줄이면 아무것도 하지 않는다 */
   function toggleCheck(id: string) {
     if (!isSelectable(id)) return
     checkedIds.value = toggleChecked(checkedIds.value, id)
     checkAnchorId = id
   }
 
-  /** Shift + 클릭 — 마지막으로 누른 메일부터 이 메일까지 (고를 수 없는 메일은 건너뛴다) */
+  /** Shift + 클릭 — 마지막으로 누른 줄부터 이 줄까지 (고를 수 없는 줄은 건너뛴다) */
   function checkRangeTo(id: string) {
     if (!isSelectable(id)) return
     checkedIds.value = checkRange(checkedIds.value, selectableIds.value, checkAnchorId, id)
     checkAnchorId = id
   }
 
-  /** 표 머리 상자 — 고를 수 있는 메일을 모두 고르거나(일부만 골랐어도) 모두 고른 상태면 푼다 */
+  /** 표 머리 상자 — 고를 수 있는 줄을 모두 고르거나(일부만 골랐어도) 모두 고른 상태면 푼다 */
   function toggleCheckAll() {
     if (checkState.value === 'all') clearChecked()
     else checkedIds.value = new Set(selectableIds.value)
   }
 
-  // 목록에서 빠진 메일 · 고를 수 없게 된 메일은 고른 것에서도 뺀다
+  // 목록에서 빠진 줄 · 고를 수 없게 된 줄은 고른 것에서도 뺀다
   watch(
     selectableIds,
     (ids) => {
@@ -78,7 +101,18 @@ export function createSelection(list: Pick<ListState, 'messages' | 'sourceSeq'>)
   // 다른 목록으로 바뀌면 모두 푼다
   watch(list.sourceSeq, clearChecked, { flush: 'sync' })
 
-  return { checkedIds, checkedCount, checkedMessages, checkState, clearChecked, toggleCheck, checkRangeTo, toggleCheckAll }
+  return {
+    checkedIds,
+    checkedCount,
+    checkedMessages,
+    checkedConversations,
+    checkedActionIds,
+    checkState,
+    clearChecked,
+    toggleCheck,
+    checkRangeTo,
+    toggleCheckAll,
+  }
 }
 
 export type SelectionState = ReturnType<typeof createSelection>
diff --git a/frontend/src/styles/tokens.css b/frontend/src/styles/tokens.css
index 50b48d4..589118c 100644
--- a/frontend/src/styles/tokens.css
+++ b/frontend/src/styles/tokens.css
@@ -87,6 +87,9 @@
   --color-warning-border: #f0d9a8; /* 노란 줄 안의 흰 단추 테두리 — 읽기 화면 [이미지 보기] (디자인 원본 MailReadTools) */
   --color-success-text: #067647; /* 서명 "저장했습니다" (디자인 원본 Settings) */
   --color-status-live: #12b76a; /* 실시간 연결 "연결되어 있습니다" 점 (디자인 원본 SettingsNotify) */
+  /* 검색에서 맞은 말 — 글자색은 그대로 (14단계 디자인 원본 Search14). 짝: shared/utils/mail-html.ts 의 본문 틀 mark 색 —
+     본문 틀(iframe)은 이 변수를 읽지 못해 같은 값을 적어 둔다, 한쪽을 고치면 둘 다 */
+  --color-search-mark: #fce7a4;
   --color-star: #b7791f;
 
   /* ── 간격 (이름의 숫자 = px) ─────────────── */
@@ -139,7 +142,8 @@
   /*
    * 밀도를 위한 작은 조작 영역 — 클릭 영역 44px 기준의 의도된 예외 (디자인 README "디자인 원칙", 사용자 확정).
    * 목록 표의 별 버튼(폭 32px · 행 높이를 채움), "분할 | 목록" 전환(바깥 36px),
-   * 설정 화면의 전환 단추 · 서명 그림의 크기 줄(작게 · 보통 · 원본 · 그림 빼기 — 36px, 캔버스 확정값)에만 쓴다.
+   * 설정 화면의 전환 단추 · 서명 그림의 크기 줄(작게 · 보통 · 원본 · 그림 빼기 — 36px, 캔버스 확정값),
+   * 14단계 검색 칸 안의 [조건](32px — 아래 14단계 주석)에만 쓴다.
    */
   --size-compact-control: 2rem; /* 32px */
   --size-segment-item: 1.875rem; /* 30px — 전환 버튼 한 칸 높이 (테두리·안쪽 여백 포함 36px) */
@@ -181,6 +185,14 @@
    *   연락처 창의 이메일 · 전화번호 줄(종류 · 값) · [이메일 · 전화번호 더하기] · 회사 · 부서 · 직책 칸 높이 40(--size-filter-control) · 줄 ✕ 36×40(--size-filter-remove) ·
    *   구성원 넣기 창의 「내 연락처 | 사내 직원」 36(--size-segment-item-lg — .segmented) · 찾기 칸 40(--size-filter-control)
    */
+  /*
+   * 14단계(검색 · 조건 검색) 밀도 예외 — 새 토큰 없이 위의 것을 다시 쓴다 (디자인 README "14단계 — 검색 · 대화 묶기", 사용자 확정 캔버스 Search14).
+   *   검색 칸 안의 [조건] 높이 32(--size-compact-control) ·
+   *   「조건으로 찾기」 패널의 칸(보낸 사람 · 받는 사람 · 제목 · 내용 · 기간 · 날짜) · [조건 지우기] · [찾기] 높이 40(--size-filter-control) ·
+   *   결과 머리 아래 조건 줄 높이 40(--size-row-min) · 줄 안의 [조건 지우기] 36(--size-notice-action) ·
+   *   읽기 화면 "같은 대화" 칸에서 펼친 줄의 [답장] · [이 메일만 열기] 36(--size-notice-action — 캔버스 Thread14) ·
+   *   목록 머리의 [대화로 묶기] 높이 36(--size-notice-action — 캔버스 ListThreads14, 분할 보기는 아이콘만 36×36)
+   */
   --size-status-dot: 0.5rem; /* 8px — 설정 › 알림의 실시간 연결 점 */
   --size-option-input: 1.125rem; /* 18px — 설정 화면의 고르기 상자 · 라디오 (줄 전체가 44px 로 눌린다) */
   --form-max-width: 26.25rem; /* 420px — 비밀번호 칸 (디자인 원본 SettingsAccount) */
diff --git a/frontend/src/test-utils/search-text-samples.ts b/frontend/src/test-utils/search-text-samples.ts
new file mode 100644
index 0000000..10054f9
--- /dev/null
+++ b/frontend/src/test-utils/search-text-samples.ts
@@ -0,0 +1,137 @@
+// 메일 검색의 접기 · 글자 두 개 묶음 · 맞은 곳 · 말머리 떼기 표본 — 단위 테스트 전용 (앱 코드에서 import 하지 않는다)
+// 화면의 미리 확인(shared/utils/search-match.ts — 한 글자 안내)과 서버의 색인 · 찾기 · 강조(backend `src/shared/utils/search-text.ts` · `subject-base.ts`)를 같은 표로 본다.
+
+/**
+ * ⚠️ backend `test/search-text-samples.ts` 와 **같은 표**다(행과 순서까지 그대로).
+ *    한쪽을 고치면 둘 다 고친다 — 접기 · 위치 규칙을 바꾸면 두 쪽 함수와 두 표를 함께 (서버가 준 맞은 곳의 위치를 화면이 그대로 그린다).
+ * 답은 손으로 적었고 두 쪽 테스트가 함수의 결과와 견준다.
+ */
+
+/** 접기 — [넣은 글, 접은 글]. 접은 글은 NFC 원문과 UTF-16 길이가 늘 같다 */
+export const FOLD_SAMPLES: readonly (readonly [input: string, folded: string])[] = [
+  ['계약서', '계약서'],
+  ['Project PLAN', 'project plan'],
+  // 전각 ASCII → 반각 (대문자는 소문자로까지)
+  ['ＡＢＣ１２３！', 'abc123!'],
+  ['ＲＥ：회의', 're:회의'],
+  ['［공지］', '[공지]'],
+  // 공백류(전각 공백 · 줄바꿈 · 탭 · NBSP · CR)는 띄어쓰기 하나로 1:1 (색인 판 2) — 이어진 공백을 줄이지는 않는다(위치를 지킨다)
+  ['회의\u3000일정', '회의 일정'],
+  ['계약\n갱신\t안내\u00a0끝', '계약 갱신 안내 끝'],
+  ['a\r\n\nb', 'a   b'],
+  // 소문자가 코드 포인트 하나 · 같은 길이일 때만 — 'İ'(U+0130)는 'i̇' 두 글자가 되므로 그대로
+  ['İstanbul', 'İstanbul'],
+  ['ÀÉÎÕÜ', 'àéîõü'],
+  ['ΣΑΣ', 'σασ'],
+  // 풀어 쓴 한글(NFD)은 NFC 로 모은다
+  ['\u1112\u1161\u11ab\u1100\u1173\u11af', '한글'],
+  // ㈜ 는 그대로 (NFKC 가 아니다 — 길이를 바꾸지 않는다)
+  ['㈜아라', '㈜아라'],
+  // BMP 밖 글자 — Deseret 대문자는 소문자로(둘 다 두 단위), 이모지는 그대로
+  ['\u{10400}😀', '\u{10428}😀'],
+  ['', ''],
+]
+
+/** 글자 두 개 묶음 — [접은 글, 묶음(나온 차례, 겹치지 않게)] */
+export const GRAM_SAMPLES: readonly (readonly [fold: string, grams: readonly string[]])[] = [
+  ['계약서', ['계약', '약서']],
+  ['회의 일정', ['회의', '일정']],
+  ['계약', ['계약']],
+  ['계', []],
+  ['a b c', []],
+  ['aaaa', ['aa']],
+  ['ab\nab\tab', ['ab']],
+  // 전각 공백 · NBSP 도 공백이다
+  ['회의\u3000일정\u00a0안내', ['회의', '일정', '안내']],
+  // 문장부호는 글자다 — 're:' 의 'e:' 도 묶음
+  ['re:회의', ['re', 'e:', ':회', '회의']],
+  // BMP 밖 글자는 코드 포인트 하나
+  ['😀😁', ['😀😁']],
+  ['', []],
+]
+
+/** 맞은 곳 — [원문(NFC), 찾는 말들, 맞은 곳들 [시작, 끝) UTF-16] — 겹치거나 맞닿으면 합친다 */
+export const MATCH_SAMPLES: readonly (readonly [
+  original: string,
+  terms: readonly string[],
+  ranges: readonly (readonly [number, number])[],
+])[] = [
+  ['계약서를 보냈습니다', ['계약'], [[0, 2]]],
+  ['Project plan', ['PROJ'], [[0, 4]]],
+  ['ＡＢＣ 주문', ['abc'], [[0, 3]]],
+  [
+    '회의 회의록 회의실',
+    ['회의'],
+    [
+      [0, 2],
+      [3, 5],
+      [7, 9],
+    ],
+  ],
+  // 겹치는 자리도 찾아 합친다
+  ['aaa', ['aa'], [[0, 3]]],
+  // 맞닿은 두 말은 하나로
+  ['계약서', ['계약', '서'], [[0, 3]]],
+  [
+    '회의 일정 안내',
+    ['일정', '회의'],
+    [
+      [0, 2],
+      [3, 5],
+    ],
+  ],
+  // 구절은 줄바꿈 · NBSP 로 갈린 글에도 맞는다 (공백류 → 띄어쓰기 1:1) — 위치는 원문 그대로
+  ['계약\n갱신 안내', ['계약 갱신'], [[0, 5]]],
+  ['계약\u00a0갱신', ['계약 갱신'], [[0, 5]]],
+  // 구절은 띄어쓰기까지 그대로
+  ['회의 일정 안내', ['회의 일정'], [[0, 5]]],
+  ['회의  일정', ['회의 일정'], []],
+  [
+    '[공지] Re: 회의',
+    ['공지', 're'],
+    [
+      [1, 3],
+      [5, 7],
+    ],
+  ],
+  // 빈 말은 건너뛴다 · 없는 말은 맞은 곳 없음
+  ['계약', ['', '없음'], []],
+  // BMP 밖 글자 앞뒤에서도 UTF-16 위치
+  ['😀계약', ['계약'], [[2, 4]]],
+  ['', ['계약'], []],
+]
+
+/** 말머리 떼기 — [제목, 말머리를 뗀 접기 글] */
+export const SUBJECT_BASE_SAMPLES: readonly (readonly [subject: string, base: string])[] = [
+  ['회의 일정 안내', '회의 일정 안내'],
+  ['Re: 회의 일정 안내', '회의 일정 안내'],
+  ['RE: Re: FW: 회의 일정 안내', '회의 일정 안내'],
+  ['Re:회의', '회의'],
+  ['Fwd: 견적서', '견적서'],
+  ['AW: WG: Angebot', 'angebot'],
+  // 한국어 Outlook — 엔진은 떼지 않는다
+  ['회신: 회의 일정 안내', '회의 일정 안내'],
+  ['답장: 회신: 전달: 회의', '회의'],
+  ['회신 : 회의', '회의'],
+  // 수 · 전각 쌍점
+  ['Re[2]: 회의', '회의'],
+  ['RE(3): 회의', '회의'],
+  ['Re：회의', '회의'],
+  ['ＲＥ： 회의', '회의'],
+  // 대괄호 꼬리표 (여러 겹 · 말머리와 섞여도)
+  ['[공지] 회의 일정', '회의 일정'],
+  ['Re: [공지] [중요] 회의', '회의'],
+  ['[외부] RE: 견적', '견적'],
+  // 공백은 하나로 · 대소문자 없이
+  ['  Re:   회의    일정  ', '회의 일정'],
+  ['Project PLAN', 'project plan'],
+  // 쌍점이 없으면 말머리가 아니다
+  ['Re 회의', 're 회의'],
+  ['Reply to 회의', 'reply to 회의'],
+  ['Regarding: 회의', 'regarding: 회의'],
+  ['회신드립니다', '회신드립니다'],
+  // 다 떼면 빈 글
+  ['Re:', ''],
+  ['[공지]', ''],
+  ['', ''],
+]
diff --git a/mail/README.md b/mail/README.md
index f6b241d..2cbfdac 100644
--- a/mail/README.md
+++ b/mail/README.md
@@ -826,10 +826,15 @@ sudo docker exec "${PROJECT_NAME}-backend" node -e "const s=require('net').conne
 | clamav-updater (freshclam) | 1g | 수십 MB | 처음 기동(서명 전체를 받아 읽어 봄) 0.7GB, 평소 갱신은 daily 만 |
 | mail | 1g | 0.1~0.3GB (큰 메일 뒤 0.4GB 남짓까지 쌓인다 — 2026-11-03) | 메일 한 통을 받을 때 그 크기 × 5.5 쯤 더 — 받는 한도 50MiB(setup)면 +0.3GB 남짓. 운영에서 106.4MB 한 통이 1g 를 넘었다(2026-11-03 — 개발 104MB 는 984/1024MiB · 서버 B 는 이전하는 동안만 2g, [큰 메일](#큰-메일-운영-2026-11-03) · [받는 메일 크기](#엔진-한도)) |
 | backend | 1g | 0.3~0.5GB | 조각 · 받기는 스트림이라 파일 크기와 상관없다 |
-| db · frontend · mail-resolver | 512m · 512m · 128m | 작다 | |
-| **합** | **6.15GB** | 2.5~3GB | 나머지 1.8GB 남짓을 커널 · dockerd · 페이지 캐시가 쓴다 |
-| restic (백업 — 13단계, compose 밖) | 1g | 돌 때만 — 매일 03:30 몇 분 | 0.63GB (데이터 1.2GB — 2026-10-31 MinIO). 그때는 합이 7.15GB — 사용이 적은 새벽이라 둔다. 복원 연습은 엔진 1g · DB 512m 를 더 띄운다(한 달에 한 번 — 낮에 하지 않는다) |
+| db | 1g (14단계에 512m 에서) | 0.16GB 안팎(색인을 채우는 동안도) · 찾기 시험 동안 최대 0.24GB (2026-11-05 · 그때는 공유 버퍼 128MB · 한도 512m) | 공유 버퍼(`shared_buffers` 256MB — compose 의 `command`)가 차고 그 위로 표 · 색인의 페이지 캐시(한도 안에서 줄여 쓴다). 메일 검색은 이것이 메모리에 있을 때만 1초 안이다 — 캐시가 비면 3~8배(1만 통 · 색인 121MB) |
+| frontend · mail-resolver | 512m · 128m | 작다 | |
+| **합** | **6.65GB** | 2.5~3GB (14단계 전 — db 는 공유 버퍼가 찬 만큼 는다) | 나머지 1.3GB 남짓을 커널 · dockerd · 페이지 캐시가 쓴다 |
+| restic (백업 — 13단계, compose 밖) | 1g | 돌 때만 — 매일 03:30 몇 분 | 0.63GB (데이터 1.2GB — 2026-10-31 MinIO). 그때는 합이 7.65GB — 사용이 적은 새벽이라 둔다. 복원 연습은 엔진 1g · DB 512m(스크립트에 고정 — compose 의 db 한도를 따르지 않는다)를 더 띄워 합이 8.15GB 로 8GB 를 넘는다(14단계부터 — 그 전은 7.65GB. 한 달에 한 번 — 낮에 하지 않는다) |
 
+- **db 1g · 공유 버퍼 256MB 를 운영에 올릴 때**(14단계 배포와 함께 — 한 번): 다음 `up` 이 db 를 다시 만든다 — 수 초 멈추고(데이터는 `DB_DATA_DIR` 그대로) 떠 있는 backend 는 다시 붙는다(그동안의 요청은 실패).
+  퇴근 뒤 · 백업(03:30) · 복원 연습을 피해 `git pull` → `sudo docker compose --env-file .env.production up -d db`(db 만 먼저) → `sudo docker stats --no-stream "${PROJECT_NAME}-db"` 의 한도 `1GiB` ·
+  `sudo docker exec "${PROJECT_NAME}-db" sh -c 'psql -U "$POSTGRES_USER" -d "$POSTGRES_DB" -Atc "show shared_buffers"'` 가 `256MB` → 14단계의 `up -d --build`.
+  mail 이 이전 때의 2g(`docker update`)로 남아 있으면 먼저 되돌린다([큰 메일](#큰-메일-운영-2026-11-03) 3. — 그대로면 합이 7.65GB · 백업 때 8.65GB).
 - **ClamAV 의 `ConcurrentDatabaseReload` 를 켜지 않는다**(기본은 켬) — 켜면 서명을 다시 읽는 동안(하루 몇 번) 두 벌(2GB 남짓)을 들어 2g 한도에서 죽는다.
   한도를 올려 켜려면 합이 8GB 를 넘지 않는지 다시 본다.
 - 서명은 해마다 는다 — `docker stats` 의 clamav 가 한도의 80%(1.6GB)를 넘으면 한도를 올리거나(합을 다시 본다) 서버를 키운다.
@@ -1722,7 +1727,7 @@ sudo rm -f /root/imapsync/mailcow-master.pass /root/imapsync/migration.pass
      `[변경]` · `[유지]` 줄은 저장한 값이고, 엔진에 걸린 값은 리로드 뒤의 이 `[확인]` 줄이다(리로드가 실패하면 엔진은 옛 한도로 받는다).
   3. 메모리를 compose 의 값으로 — `sudo docker update --memory 1g --memory-swap 2g <PROJECT_NAME>-mail`.
 
-  받는 한도를 낮추기 전에 1g 로 돌리면 바깥 큰 메일 한 통에 엔진이 죽을 수 있다([엔진 한도](#엔진-한도) "받는 메일 크기"). 올린 채 두면 엔진에 2g 가 들고, [메모리 예산](#메모리-예산)의 합이 7.15GB, 백업이 도는 동안은 8.15GB 로 8GB 를 넘는다.
+  받는 한도를 낮추기 전에 1g 로 돌리면 바깥 큰 메일 한 통에 엔진이 죽을 수 있다([엔진 한도](#엔진-한도) "받는 메일 크기"). 올린 채 두면 엔진에 2g 가 들고, [메모리 예산](#메모리-예산)의 합이 7.65GB, 백업이 도는 동안은 8.65GB 로 8GB 를 넘는다(14단계의 db 1g 부터 — 그 전은 7.15 · 8.15GB).
 
 #### 개발에서 확인한 것 (imapsync — 2026-11-02)