diff --git a/.github/ISSUE_TEMPLATE/bug.yaml b/.github/ISSUE_TEMPLATE/bug.yaml
new file mode 100644
index 00000000..37542fba
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug.yaml
@@ -0,0 +1,55 @@
+name: 🐛 Bug
+description: 버그 리포트
+title: "제목"
+labels: ["bug"]
+
+body:
+  - type: textarea
+    id: reproduce
+    attributes:
+      label: 문제 상황 및 재현 방법 (필수)
+      description: 버그를 간략히 설명하고, 재현할 수 있는 최소 단계를 작성해주세요.
+      placeholder: |
+        (예시)
+        정원이 가득 찬 일정에 참여신청 시 500 에러 발생
+        
+        1. 정원이 가득 찬 일정 선택
+        2. POST /events/{해당 일정 id}/registrations 호출
+        3. 500 에러 발생
+    validations:
+      required: true
+
+  - type: textarea
+    id: expected
+    attributes:
+      label: 기대 동작 (필수)
+      description: 정상이라면 어떤 상태/응답이 나와야 하나요?
+      placeholder: |
+        (예시)
+        - 정원 초과 시 WAITLIST로 처리
+    validations:
+      required: true
+
+  - type: textarea
+    id: attachments
+    attributes:
+      label: 스크린샷 / 로그 (선택)
+      description: 가능하면 첨부해주세요. 이미지/파일은 이 입력칸에 드래그&드롭하면 업로드됩니다.
+      placeholder: |
+        (예시)
+        - Swagger 응답 캡처 첨부
+        - 서버 로그 일부 붙여넣기
+    validations:
+      required: false
+
+  - type: textarea
+    id: suspected_cause
+    attributes:
+      label: 예상 원인 (선택)
+      description: 원인을 추측할 수 있다면 간단히 작성해주세요. (모르겠다면 비워도 됩니다)
+      placeholder: |
+        (예시)
+        - null 검증이 누락된 것으로 보입니다.
+        - 예외가 GlobalExceptionHandler에서 처리되지 않는 것 같습니다.
+    validations:
+      required: false
diff --git a/.github/ISSUE_TEMPLATE/work.yaml b/.github/ISSUE_TEMPLATE/work.yaml
new file mode 100644
index 00000000..12293f44
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/work.yaml
@@ -0,0 +1,52 @@
+name: 🧩 Work
+description: 기능 추가, 리팩터링, 인프라, 문서 등 작업 이슈
+title: "제목"
+labels: ["work"]
+
+body:
+  - type: textarea
+    id: summary
+    attributes:
+      label: 작업 내용 (필수)
+      description: 무엇을 변경/추가하는지와 핵심 내용을 간단히 작성해주세요.
+      placeholder: |
+        (예시)
+        회원 탈퇴 API를 구현합니다.
+        - 로그인된 사용자가 탈퇴 요청 시 계정을 삭제합니다.
+    validations:
+      required: true
+
+  - type: textarea
+    id: background
+    attributes:
+      label: 배경 / 문제점 (선택)
+      description: 현재 상태와 이 작업이 필요한 이유를 간단히 작성해주세요.
+      placeholder: |
+        (예시)
+        - 탈퇴 로직의 부재로 새로운 계정 생성에 제약이 있어 테스트가 어렵습니다.
+        - 사용자가 탈퇴할 수 있는 기능이 필요합니다.
+    validations:
+      required: false
+
+  - type: textarea
+    id: goal
+    attributes:
+      label: 목표 / 기대 결과 (필수)
+      description: 이 작업이 완료되면 무엇이 달라지나요?
+      placeholder: |
+        (예시)
+        - 로그인된 사용자가 탈퇴 요청 시 계정이 삭제됩니다.
+        - 탈퇴 후 동일 이메일로 재가입이 가능합니다.
+    validations:
+      required: true
+
+  - type: checkboxes
+    id: impact
+    attributes:
+      label: 영향 범위 (해당 시 체크)
+      description: 해당 작업이 시스템에 미치는 영향이 있다면 체크해주세요.
+      options:
+        - label: DB 스키마 변경
+        - label: API 스펙 변경
+        - label: 환경 변수 추가/변경
+        - label: 동시성 / 트랜잭션 처리 영향
diff --git a/.github/PULL_REQUEST_TEMPLATE/dev.md b/.github/PULL_REQUEST_TEMPLATE/dev.md
new file mode 100644
index 00000000..558f1a66
--- /dev/null
+++ b/.github/PULL_REQUEST_TEMPLATE/dev.md
@@ -0,0 +1,35 @@
+## ✨ Feature PR (to dev)
+
+### 🧪 로컬 테스트 여부 (작업자 체크)
+- [ ] 로컬에서 Swagger 혹은 테스트 코드로 동작을 확인했습니다.
+- [ ] API 변경이 있다면 `src/main/resources/static/docs/openapi.yaml`을 함께 갱신했습니다.
+- [ ] `/docs/swagger-ui.html`에서 변경 API가 의도대로 보이는지 확인했습니다.
+
+### 📄 documentation 최신화 여부
+> 변경사항과 관련된 API의 swagger documentation이 실제 동작과 일치하는지 확인합니다.
+- [ ] (작업자) 확인하였습니다.
+- [ ] (리뷰어) 확인하였습니다.
+
+### 📌 작업 내용(what & why)
+
+-
+
+### 🔎 영향 범위
+  <!-- 해당하는 항목만 남기고 나머지는 삭제해주세요 -->                                                                                                                                                                                    
+- DB 스키마 변경
+- API 스펙 변경
+- 환경 변수 추가/변경
+- 동시성 / 트랜잭션 처리 영향
+
+### 📡 API 변경사항 (있다면)
+
+| Method    | URL | 변경 내용 |
+|-----------|-----|----------|
+| (예시) POST | /events | capacity 필드 추가 |
+
+### 👀 집중 리뷰 요청사항 (있다면)
+
+-
+
+### 🔥 관련 이슈
+- closes #
diff --git a/.github/PULL_REQUEST_TEMPLATE/main.md b/.github/PULL_REQUEST_TEMPLATE/main.md
new file mode 100644
index 00000000..15cd0692
--- /dev/null
+++ b/.github/PULL_REQUEST_TEMPLATE/main.md
@@ -0,0 +1,17 @@
+## 🚀 Production PR (to main)
+
+### 🧪 테스트 여부
+- [ ] dev 서버 배포 성공
+- [ ] CI 성공
+- [ ] 환경 변수 설정 확인
+- [ ] dev 서버에서 변경사항에 대해 의도대로 동작함을 확인
+- [ ] API 변경이 있다면 `src/main/resources/static/docs/openapi.yaml` 반영 완료
+
+### 📝 업데이트 사항 요약
+
+- 
+
+### 🔥 관련 이슈
+<!--hotfix 브랜치가 아닌 경우 (직접 연결된 이슈 없는 경우) 삭제-->
+- closes #
+
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
new file mode 100644
index 00000000..5d6af1b7
--- /dev/null
+++ b/.github/pull_request_template.md
@@ -0,0 +1,5 @@
+## PR 템플릿 선택
+>preview 클릭 후 원하는 템플릿으로 이동하세요.
+
+- ✨ [dev PR 템플릿](?expand=1&template=dev.md)
+- 🚀 [main PR 템플릿](?expand=1&template=main.md)
diff --git a/.github/scripts/slack-dm-notify.mjs b/.github/scripts/slack-dm-notify.mjs
new file mode 100644
index 00000000..685d29f7
--- /dev/null
+++ b/.github/scripts/slack-dm-notify.mjs
@@ -0,0 +1,309 @@
+import fs from "fs";
+
+/* =====================
+   0. Guard: secrets 없음 → 조용히 종료
+===================== */
+const token = process.env.SLACK_BOT_TOKEN;
+if (!token) {
+    console.log("No SLACK_BOT_TOKEN (likely fork PR). Skipping.");
+    process.exit(0);
+}
+
+/* =====================
+   1. Load event + user map
+===================== */
+const event = JSON.parse(
+    fs.readFileSync(process.env.GITHUB_EVENT_PATH, "utf8")
+);
+
+// user map: Secret 우선, 없으면 파일 fallback
+let userMap = {};
+if (process.env.SLACK_USER_MAP) {
+    userMap = JSON.parse(process.env.SLACK_USER_MAP);
+} else if (fs.existsSync(".github/slack-map.json")) {
+    userMap = JSON.parse(
+        fs.readFileSync(".github/slack-map.json", "utf8")
+    );
+}
+
+/* =====================
+   2. Utilities
+===================== */
+const uniq = (arr) => [...new Set(arr.filter(Boolean))];
+
+const extractMentions = (text) => {
+    if (!text) return [];
+    const re = /@([a-zA-Z0-9-]+)/g;
+    const out = [];
+    let m;
+    while ((m = re.exec(text)) !== null) out.push(m[1]);
+    return out;
+};
+
+const ghToSlack = (login) => userMap[login] || null;
+
+/* =====================
+   3. Slack API helpers
+===================== */
+async function slackPost(endpoint, body) {
+    const res = await fetch(`https://slack.com/api/${endpoint}`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(body),
+    });
+    if (res.status === 429) {
+        const err = new Error("ratelimited");
+        err.retryAfterMs = parseInt(res.headers.get("Retry-After") || "5", 10) * 1000;
+        throw err;
+    }
+    const json = await res.json();
+    if (!json.ok) throw new Error(json.error);
+    return json;
+}
+
+async function sendDM(userId, text) {
+    const { channel } = await slackPost("conversations.open", { users: userId });
+    await slackPost("chat.postMessage", { channel: channel.id, text });
+}
+
+/* =====================
+   4. GitHub API helper
+===================== */
+
+// 대기 중인 reviewer(requested_reviewers) + 이미 리뷰 제출한 reviewer 모두 반환
+async function fetchPRReviewers(prNumber) {
+    const repo = process.env.GITHUB_REPOSITORY;
+    const headers = {
+        Authorization: `Bearer ${process.env.GITHUB_TOKEN}`,
+        Accept: "application/vnd.github.v3+json",
+    };
+
+    const [prRes, reviewsRes] = await Promise.all([
+        fetch(`https://api.github.com/repos/${repo}/pulls/${prNumber}`, { headers }),
+        fetch(`https://api.github.com/repos/${repo}/pulls/${prNumber}/reviews`, { headers }),
+    ]);
+
+    const pr = await prRes.json();
+    const reviews = await reviewsRes.json();
+
+    const reviewers = new Set(
+        (pr.requested_reviewers || []).map((r) => r.login)
+    );
+    (Array.isArray(reviews) ? reviews : []).forEach((r) => {
+        if (r.user?.login) reviewers.add(r.user.login);
+    });
+
+    return [...reviewers];
+}
+
+/* =====================
+   5. Event handlers
+   각 핸들러는 { title, body, url, recipients } 를 반환
+===================== */
+
+// pull_request: opened, reopened, ready_for_review, review_requested, assigned
+function handlePullRequest(e) {
+    const pr = e.pull_request;
+    const title = `PR #${pr.number}: ${pr.title}`;
+    const url = pr.html_url;
+    const recipients = [];
+
+    // 리뷰 요청: 새로 요청된 reviewer에게만
+    if (e.action === "review_requested" && e.requested_reviewer) {
+        recipients.push(e.requested_reviewer.login);
+    }
+
+    // assign: 새로 assign된 사람에게만
+    if (e.action === "assigned") {
+        recipients.push(e.assignee?.login);
+    }
+
+    // 본문 멘션: 처음 열릴 때만
+    if (e.action === "opened") {
+        recipients.push(...extractMentions(pr.body));
+    }
+
+    return { title, body: pr.body, url, recipients };
+}
+
+// pull_request_review: submitted
+function handlePullRequestReview(e) {
+    const pr = e.pull_request;
+    const title = `PR #${pr.number}: ${pr.title}의 새 리뷰 (${e.review.state})`;
+    const url = e.review.html_url || pr.html_url;
+    const recipients = [
+        pr.user?.login,
+        ...extractMentions(e.review.body),
+    ];
+
+    return { title, body: e.review.body, url, recipients };
+}
+
+// pull_request_review_comment: created
+async function handlePullRequestReviewComment(e) {
+    const pr = e.pull_request;
+    const title = `PR #${pr.number} ${pr.title}의 새 코멘트`;
+    const url = e.comment.html_url;
+    const reviewers = await fetchPRReviewers(pr.number);
+    const recipients = [
+        pr.user?.login,
+        ...reviewers,
+        ...extractMentions(e.comment.body),
+    ];
+
+    return { title, body: e.comment.body, url, recipients };
+}
+
+// issue_comment on PR: created
+async function handleIssueCommentOnPR(e) {
+    const is = e.issue;
+    const title = `PR #${is.number}: ${is.title}의 새 코멘트`;
+    const url = e.comment.html_url;
+    const reviewers = await fetchPRReviewers(is.number);
+    const recipients = [
+        is.user?.login,
+        ...reviewers,
+        ...extractMentions(e.comment.body),
+    ];
+
+    return { title, body: e.comment.body, url, recipients };
+}
+
+// issue_comment on Issue: created
+function handleIssueComment(e) {
+    const is = e.issue;
+    const title = `Issue #${is.number}: ${is.title}의 새 코멘트`;
+    const url = e.comment.html_url;
+    const recipients = [
+        is.user?.login,
+        ...extractMentions(e.comment.body),
+    ];
+
+    return { title, body: e.comment.body, url, recipients };
+}
+
+// issues: opened, assigned
+function handleIssues(e) {
+    const is = e.issue;
+    const title = `Issue #${is.number}: ${is.title}`;
+    const url = is.html_url;
+    const recipients = [];
+
+    // assign: 새로 assign된 사람에게만
+    if (e.action === "assigned") {
+        recipients.push(e.assignee?.login);
+    }
+
+    // 본문 멘션: 처음 열릴 때만
+    if (e.action === "opened") {
+        recipients.push(...extractMentions(is.body));
+    }
+
+    return { title, body: is.body, url, recipients };
+}
+
+/* =====================
+   6. Notification builder (이벤트 디스패처)
+===================== */
+async function buildNotification(e) {
+    let result;
+
+    if (e.review && e.pull_request) {
+        result = handlePullRequestReview(e);
+    } else if (e.comment && e.pull_request) {
+        result = await handlePullRequestReviewComment(e);
+    } else if (e.comment && e.issue?.pull_request) {
+        result = await handleIssueCommentOnPR(e);
+    } else if (e.comment && e.issue) {
+        result = handleIssueComment(e);
+    } else if (e.pull_request) {
+        result = handlePullRequest(e);
+    } else if (e.issue) {
+        result = handleIssues(e);
+    } else {
+        return { recipients: [], text: "" };
+    }
+
+    const { title, body, url, recipients } = result;
+    const repo = process.env.GITHUB_REPOSITORY;
+    const action = e.action ? ` (${e.action})` : "";
+    const actor = e.sender?.login ? `@${e.sender.login}` : "someone";
+
+    const text =
+        `🔔 GitHub 알림${action}\n` +
+        `Repo: ${repo}\n` +
+        `By: ${actor}\n` +
+        `${title}\n` +
+        (body ? `${body}\n` : "") +
+        `🔗 ${url}`;
+
+    const sender = e.sender?.login;
+    return { recipients: uniq(recipients).filter((r) => r !== sender), text };
+}
+
+/* =====================
+   7. Main
+===================== */
+
+// 토큰/스코프/계정 문제 등 모든 요청에 영향을 주는 전역 오류 → 즉시 job 실패
+const FATAL_SLACK_ERRORS = new Set([
+    "invalid_auth",
+    "not_authed",
+    "account_inactive",
+    "token_revoked",
+    "token_expired",
+    "no_permission",
+    "missing_scope",
+]);
+
+const MAX_ATTEMPTS = 3;
+
+async function main() {
+    const { recipients, text } = await buildNotification(event);
+
+    const slackUsers = uniq(
+        recipients.map(ghToSlack).filter(Boolean)
+    );
+
+    if (slackUsers.length === 0) {
+        console.log("No matching Slack users. Skipping.");
+        return;
+    }
+
+    let successCount = 0;
+    for (const uid of slackUsers) {
+        let sent = false;
+        for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+            try {
+                await sendDM(uid, text);
+                sent = true;
+                break;
+            } catch (err) {
+                // 전역 오류: 재시도 없이 즉시 throw → job 실패
+                if (FATAL_SLACK_ERRORS.has(err.message)) throw err;
+
+                if (attempt === MAX_ATTEMPTS) {
+                    console.error(`Failed to DM ${uid} after ${MAX_ATTEMPTS} attempts: ${err.message}`);
+                    break;
+                }
+                const delay = err.retryAfterMs ?? 1000 * 2 ** (attempt - 1);
+                console.warn(`Retry ${attempt}/${MAX_ATTEMPTS} for ${uid} in ${delay}ms: ${err.message}`);
+                await new Promise((r) => setTimeout(r, delay));
+            }
+        }
+        if (sent) successCount++;
+    }
+
+    if (successCount === 0) {
+        throw new Error(`All ${slackUsers.length} DM(s) failed — check bot token and user mappings.`);
+    }
+    console.log(`Sent Slack DM to ${successCount}/${slackUsers.length} user(s).`);
+}
+
+main().catch((err) => {
+    console.error("Slack notify failed:", err.message);
+    process.exit(1);
+});
diff --git a/.github/workflows/_deploy.yml b/.github/workflows/_deploy.yml
new file mode 100644
index 00000000..3e26e43f
--- /dev/null
+++ b/.github/workflows/_deploy.yml
@@ -0,0 +1,52 @@
+name: deploy-template
+
+on:
+    workflow_call: #직접실행x
+        inputs:
+            ocir_repository:
+                required: true
+                type: string
+            dockerfile:
+                required: true
+                type: string
+                description: "Dockerfile path (e.g., api/Dockerfile)"
+        secrets:
+            OCI_AUTH_TOKEN:
+                required: true
+
+jobs:
+    deploy:
+        name: Deploy
+        runs-on: ubuntu-24.04-arm
+        permissions:
+            packages: read
+            contents: read
+
+        env:
+            IMAGE_TAG: ${{ github.run_number }} #github.* 변수들은 github 자체 내장
+            BUILD_NUMBER: ${{ github.run_number }}
+            OCIR_REGISTRY: yny.ocir.io #동일
+            OCIR_NAMESPACE: ax1dvc8vmenm # 같은 ocir내에서는 동일
+            OCIR_REPOSITORY: ${{ inputs.ocir_repository }}
+
+        steps:
+            - name: Checkout
+              uses: actions/checkout@v4
+
+            - name: Login to OCIR
+              run: echo "${{ secrets.OCI_AUTH_TOKEN }}" | docker login $OCIR_REGISTRY -u ax1dvc8vmenm/members/waffle-deployer --password-stdin
+            #알맞게 수정
+
+            - name: Docker build, tag, and push image to OCIR
+              id: build-push-image
+              run: |
+                  echo "${{ github.token }}" > .github_token
+                  docker build \
+                    --secret id=github_token,src=./.github_token \
+                    -f ${{ inputs.dockerfile }} \
+                    -t $OCIR_REGISTRY/$OCIR_NAMESPACE/$OCIR_REPOSITORY:$IMAGE_TAG \
+                    . \
+                    --platform linux/arm64
+                  rm -f .github_token
+                  docker push $OCIR_REGISTRY/$OCIR_NAMESPACE/$OCIR_REPOSITORY:$IMAGE_TAG
+                  echo "image=$OCIR_REGISTRY/$OCIR_NAMESPACE/$OCIR_REPOSITORY:$IMAGE_TAG" >> $GITHUB_OUTPUT
diff --git a/.github/workflows/cd-dev.yml b/.github/workflows/cd-dev.yml
new file mode 100644
index 00000000..3b20f82e
--- /dev/null
+++ b/.github/workflows/cd-dev.yml
@@ -0,0 +1,127 @@
+name: CD Pipeline - Dev Deploy
+
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: cd-dev
+  cancel-in-progress: true
+
+jobs:
+  deploy:
+    if: ${{ github.event_name == 'workflow_dispatch' || github.event.workflow_run.conclusion == 'success' }}
+    runs-on: ubuntu-latest
+    env:
+      DEPLOY_SHA: ${{ github.event.workflow_run.head_sha || github.sha }}
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ env.DEPLOY_SHA }}
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: picokosmos
+          password: ${{ secrets.DOCKER_PASSWORD }}
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          push: true
+          tags: |
+            docker.io/picokosmos/spring-app:dev
+            docker.io/picokosmos/spring-app:dev-${{ env.DEPLOY_SHA }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+      - name: Deploy to Dev Server
+        uses: appleboy/ssh-action@v1.0.3
+        env:
+          APP_DIR: ${{ secrets.APP_DIR }}
+        with:
+          host: ${{ secrets.DEV_HOST }}
+          username: ${{ secrets.DEV_USER }}
+          key: ${{ secrets.DEV_SSH_KEY }}
+          port: ${{ secrets.DEV_SSH_PORT }}
+          envs: APP_DIR
+          script: |
+            set -euo pipefail
+            if [ -n "${APP_DIR:-}" ]; then
+              cd "$APP_DIR"
+            else
+              cd ~/app
+            fi
+
+            # Create/update .env file with secrets
+            cat > .env << 'EOF'
+            SPRING_MAIL_USERNAME=${{ secrets.SPRING_MAIL_USERNAME }}
+            SPRING_MAIL_PASSWORD=${{ secrets.SPRING_MAIL_PASSWORD }}
+            DB_PASSWORD=${{ secrets.DB_PASSWORD }}
+            MYSQL_ROOT_PASSWORD=${{ secrets.MYSQL_ROOT_PASSWORD }}
+            JWT_SECRET=${{ secrets.JWT_SECRET }}
+            SENDGRID_API_KEY=${{ secrets.SENDGRID_API_KEY }}
+            GOOGLE_CLIENT_ID=${{ secrets.GOOGLE_CLIENT_ID }}
+            GOOGLE_CLIENT_SECRET=${{ secrets.GOOGLE_CLIENT_SECRET }}
+            GOOGLE_REDIRECT_URI=${{ secrets.DEV_GOOGLE_REDIRECT_URI }}
+            EMAIL_SERVICE_DOMAIN=${{ secrets.DEV_EMAIL_SERVICE_DOMAIN }}
+            EOF
+
+            # Pull latest docker-compose file
+            curl -fsSL https://raw.githubusercontent.com/${{ github.repository }}/${{ env.DEPLOY_SHA }}/docker-compose.dev.yml -o docker-compose.yml
+
+            # Pull latest images and restart
+            docker compose pull
+            docker compose up -d
+
+            # Clean up old images
+            docker image prune -f
+
+            # Show status
+            echo "=== Container Status ==="
+            docker compose ps
+
+            # Wait for app to be healthy
+            echo "=== Waiting for app to start ==="
+            sleep 30
+            docker compose logs --tail=50 app
+
+      - name: Health check
+        uses: appleboy/ssh-action@v1.0.3
+        env:
+          APP_DIR: ${{ secrets.APP_DIR }}
+        with:
+          host: ${{ secrets.DEV_HOST }}
+          username: ${{ secrets.DEV_USER }}
+          key: ${{ secrets.DEV_SSH_KEY }}
+          port: ${{ secrets.DEV_SSH_PORT }}
+          envs: APP_DIR
+          script: |
+            set -euo pipefail
+            if [ -n "${APP_DIR:-}" ]; then
+              cd "$APP_DIR"
+            else
+              cd ~/app
+            fi
+
+            echo "=== Waiting for app to be healthy ==="
+            for i in {1..30}; do
+              if curl -sf http://localhost:8080/actuator/health > /dev/null 2>&1; then
+                echo "App is healthy!"
+                exit 0
+              fi
+              echo "Attempt $i/30: App not ready yet, waiting 30s..."
+              sleep 30
+            done
+
+            echo "App failed to start. Logs:"
+            docker compose logs --tail=100
+            exit 1
diff --git a/.github/workflows/cd.yml b/.github/workflows/cd.yml
index dd1523dd..53f745b0 100644
--- a/.github/workflows/cd.yml
+++ b/.github/workflows/cd.yml
@@ -1,18 +1,27 @@
 name: CD Pipeline - EC2 Deploy
 
 on:
-  push:
-    branches:
-      - main
   workflow_dispatch:
 
+permissions:
+  contents: read
+
+concurrency:
+  group: cd-main
+  cancel-in-progress: false
+
 jobs:
   deploy:
+    if: ${{ github.event_name == 'workflow_dispatch' || github.event.workflow_run.conclusion == 'success' }}
     runs-on: ubuntu-latest
+    env:
+      DEPLOY_SHA: ${{ github.event.workflow_run.head_sha || github.sha }}
 
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
+        with:
+          ref: ${{ env.DEPLOY_SHA }}
 
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
@@ -30,7 +39,7 @@ jobs:
           push: true
           tags: |
             docker.io/picokosmos/spring-app:latest
-            docker.io/picokosmos/spring-app:${{ github.sha }}
+            docker.io/picokosmos/spring-app:${{ env.DEPLOY_SHA }}
           cache-from: type=gha
           cache-to: type=gha,mode=max
 
@@ -66,7 +75,7 @@ jobs:
             EOF
 
             # Pull latest docker-compose file
-            curl -fsSL https://raw.githubusercontent.com/${{ github.repository }}/main/docker-compose.prod.yml -o docker-compose.yml
+            curl -fsSL https://raw.githubusercontent.com/${{ github.repository }}/${{ env.DEPLOY_SHA }}/docker-compose.prod.yml -o docker-compose.yml
 
             # Pull latest images and restart
             docker compose pull
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 58f21177..80cda61f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,36 +1,59 @@
-name: ci.yml
+name: CI
 on:
   pull_request:
     branches:
       - main
+      - dev
   push:
     branches:
       - main
+      - dev
+
+permissions:
+  contents: read
 
 jobs:
-  build:
+  ci:
     runs-on: ubuntu-latest
+    timeout-minutes: 30
 
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
 
-      - name: Set up JDK 17
+      - name: Set up Node 20
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Lint OpenAPI YAML
+        run: npx @redocly/cli@latest lint src/main/resources/static/docs/openapi.yaml
+
+      - name: Set up JDK 21
         uses: actions/setup-java@v4
         with:
-          java-version: '17'
+          java-version: '21'
           distribution: 'temurin'
 
       - name: Setup Gradle
         uses: gradle/actions/setup-gradle@v3
 
-      - name: Build with Gradle
-        run: ./gradlew build -x test
-
       - name: Run ktlint
-        run: ./gradlew ktlintCheck
-        continue-on-error: true
+        run: ./gradlew ktlintCheck --no-daemon
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Run tests (includes integration tests)
+        run: ./gradlew test --no-daemon
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Run integration tests
-        run: ./gradlew test
-        continue-on-error: true
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: ci-test-report-${{ github.run_id }}
+          path: |
+            build/reports/tests/test
+            build/test-results/test
+          if-no-files-found: warn
diff --git a/.github/workflows/github-dm-notify.yml b/.github/workflows/github-dm-notify.yml
new file mode 100644
index 00000000..2c3dde16
--- /dev/null
+++ b/.github/workflows/github-dm-notify.yml
@@ -0,0 +1,35 @@
+name: GitHub -> Slack DM Notify
+
+on:
+  pull_request:
+    types: [opened, reopened, ready_for_review, review_requested, assigned]
+  pull_request_review:
+    types: [submitted]
+  pull_request_review_comment:
+    types: [created]
+  issues:
+    types: [opened, assigned]
+  issue_comment:
+    types: [created]
+
+permissions:
+  contents: read
+  pull-requests: read
+
+jobs:
+  notify:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Send Slack DMs
+        env:
+          SLACK_BOT_TOKEN: ${{ secrets.SLACK_BOT_TOKEN }}
+          SLACK_USER_MAP: ${{ secrets.SLACK_USER_MAP }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: node .github/scripts/slack-dm-notify.mjs
diff --git a/.github/workflows/oci-deploy-dev.yml b/.github/workflows/oci-deploy-dev.yml
new file mode 100644
index 00000000..24aee498
--- /dev/null
+++ b/.github/workflows/oci-deploy-dev.yml
@@ -0,0 +1,14 @@
+name: Deploy-api-dev
+
+on:
+    push:
+        branches: [dev] # 원하는 브랜치로 설정
+
+jobs:
+    deploy:
+        uses: ./.github/workflows/_deploy.yml
+        with:
+            ocir_repository: moiming-dev/moiming-server # ocir 레포에 맞게 설정
+            dockerfile: Dockerfile #dockerfile 경로 설정
+        secrets:
+            OCI_AUTH_TOKEN: ${{ secrets.OCI_AUTH_TOKEN }} # 와플 deployer 계정 토큰 필요
diff --git a/.github/workflows/oci-deploy-prod.yml b/.github/workflows/oci-deploy-prod.yml
new file mode 100644
index 00000000..17d17afa
--- /dev/null
+++ b/.github/workflows/oci-deploy-prod.yml
@@ -0,0 +1,29 @@
+name: Deploy-api-prod
+
+on:
+    push:
+        branches: [main] # 원하는 브랜치 설정
+
+jobs:
+    deploy:
+        uses: ./.github/workflows/_deploy.yml
+        with:
+            ocir_repository: moiming-prod/moiming-server
+            dockerfile: Dockerfile
+        secrets:
+            OCI_AUTH_TOKEN: ${{ secrets.OCI_AUTH_TOKEN }}
+
+    notify:
+        needs: deploy
+        runs-on: ubuntu-latest
+        steps:
+            - name: Slack Notify
+              uses: rtCamp/action-slack-notify@v2.3.3
+              env:
+                  SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}
+                  SLACK_CHANNEL: team-moiming-github
+                  SLACK_TITLE: NEW RELEASE
+                  SLACK_USERNAME: moiming-server
+                  SLACK_ICON: https://user-images.githubusercontent.com/35535636/103177470-2237cb00-48be-11eb-9211-3ffa567c8ac3.png
+                  #원하는 아이콘으로 바꾸기
+                  SLACK_MESSAGE: Check <https://argocd.wafflestudio.com|Argo CD> for updated environment
diff --git a/Dockerfile b/Dockerfile
index be00e2a1..61a5b703 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,11 +1,16 @@
-FROM gradle:8.5-jdk17 AS build
+FROM gradle:8.5-jdk21 AS build
 WORKDIR /app
 COPY build.gradle.kts settings.gradle.kts ./
 COPY gradle ./gradle
 COPY src ./src
-RUN gradle build --no-daemon -x test
+RUN gradle build --no-daemon -x test && \
+  BOOT_JAR=$(ls build/libs/*.jar | grep -v plain) && \
+  jar tf "$BOOT_JAR" | grep -q "oci-java-sdk-secrets" || (echo "ERROR: OCI SDK missing from fat JAR" && exit 1)
+#RUN --mount=type=secret,id=github_token GITHUB_TOKEN=$(cat /run/secrets/github_token) ./gradlew :api:bootJar
+#github_token을 받아서 waffle-spring에서 oci vault 라이브러리를 받아옴.
 
-FROM eclipse-temurin:17-jre
+
+FROM eclipse-temurin:21-jre
 WORKDIR /app
 COPY --from=build /app/build/libs/*.jar app.jar
 EXPOSE 8080
diff --git a/build.gradle.kts b/build.gradle.kts
index e669d039..5b8d2200 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -1,8 +1,8 @@
 import java.util.Properties
 
 plugins {
-    kotlin("jvm") version "1.9.25"
-    kotlin("plugin.spring") version "1.9.25"
+    kotlin("jvm") version "2.2.0"
+    kotlin("plugin.spring") version "2.2.0"
     id("org.springframework.boot") version "3.5.5"
     id("io.spring.dependency-management") version "1.1.7"
     id("org.flywaydb.flyway") version "9.22.3"
@@ -15,7 +15,7 @@ description = "seminar-2025-springboot-assignment"
 
 java {
     toolchain {
-        languageVersion = JavaLanguageVersion.of(17)
+        languageVersion = JavaLanguageVersion.of(21)
     }
 }
 
@@ -30,6 +30,13 @@ buildscript {
 
 repositories {
     mavenCentral()
+    maven {
+        url = uri("https://maven.pkg.github.com/wafflestudio/spring-waffle")
+        credentials {
+            username = "wafflestudio"
+            password = System.getenv("GITHUB_TOKEN")
+        }
+    }
 }
 
 dependencies {
@@ -37,7 +44,6 @@ dependencies {
     implementation("org.springframework.boot:spring-boot-starter-webflux")
     implementation("org.springframework.boot:spring-boot-starter-data-jdbc")
     implementation("org.springframework.boot:spring-boot-starter-data-redis")
-    implementation("org.springframework.boot:spring-boot-starter-actuator")
     implementation("org.springframework.boot:spring-boot-starter-mail")
     implementation("org.mindrot:jbcrypt:0.4")
     implementation("io.jsonwebtoken:jjwt-api:0.11.5")
@@ -56,11 +62,20 @@ dependencies {
     testImplementation("org.testcontainers:junit-jupiter")
     testImplementation("org.testcontainers:mysql")
     testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.1")
+    testImplementation("org.mockito.kotlin:mockito-kotlin:5.4.0")
     implementation("com.fasterxml.jackson.datatype:jackson-datatype-jsr310")
 
     // profile_image 업로드 관련 의존성 추가
     implementation(platform("software.amazon.awssdk:bom:2.41.19"))
     implementation("software.amazon.awssdk:s3")
+
+    // OCI Vault - SDK 직접 사용 (waffle-oci-vault 2.1.0은 Spring Boot 3.5와 호환 안됨)
+    implementation("com.oracle.oci.sdk:oci-java-sdk-secrets:3.80.1")
+    implementation("com.oracle.oci.sdk:oci-java-sdk-common-httpclient-jersey3:3.80.1")
+
+    // prometheus 의존성 추가
+    implementation("org.springframework.boot:spring-boot-starter-actuator")
+    implementation("io.micrometer:micrometer-registry-prometheus")
 }
 
 kotlin {
diff --git a/docker-compose.dev.yml b/docker-compose.dev.yml
new file mode 100644
index 00000000..b723e04d
--- /dev/null
+++ b/docker-compose.dev.yml
@@ -0,0 +1,98 @@
+version: "3.8"
+
+services:
+  app:
+    image: picokosmos/spring-app:dev
+    container_name: spring-app-dev
+    restart: unless-stopped
+    ports:
+      - "127.0.0.1:8080:8080"
+    environment:
+      GOOGLE_CLIENT_ID: ${GOOGLE_CLIENT_ID}
+      GOOGLE_CLIENT_SECRET: ${GOOGLE_CLIENT_SECRET}
+      GOOGLE_REDIRECT_URI: ${GOOGLE_REDIRECT_URI}
+      SPRING_DATASOURCE_URL: jdbc:mysql://mysql:3306/moisha?allowPublicKeyRetrieval=true
+      SPRING_DATASOURCE_USERNAME: user
+      SPRING_DATASOURCE_PASSWORD: ${DB_PASSWORD}
+      SPRING_DATA_REDIS_HOST: redis
+      SPRING_DATA_REDIS_PORT: 6379
+      SPRING_FLYWAY_ENABLED: "true"
+      SPRING_MAIL_USERNAME: ${SPRING_MAIL_USERNAME}
+      SPRING_MAIL_PASSWORD: ${SPRING_MAIL_PASSWORD}
+      JWT_SECRET: ${JWT_SECRET}
+      JWT_EXPIRATION_IN_MS: 86400000
+      SENDGRID_API_KEY: ${SENDGRID_API_KEY}
+      EMAIL_FROM_ADDRESS: picokosmos@gmail.com
+      EMAIL_FROM_NAME: 모이밍
+      EMAIL_SERVICE_DOMAIN: ${EMAIL_SERVICE_DOMAIN}
+      CORS_ALLOWED_ORIGINS: https://dev.moiming.app
+    depends_on:
+      mysql:
+        condition: service_healthy
+      redis:
+        condition: service_started
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8080/actuator/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 60s
+    deploy:
+      resources:
+        limits:
+          memory: 512M
+
+  mysql:
+    image: mysql:8.4
+    container_name: mysql-db-dev
+    restart: unless-stopped
+    environment:
+      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
+      MYSQL_DATABASE: moisha
+      MYSQL_USER: user
+      MYSQL_PASSWORD: ${DB_PASSWORD}
+    volumes:
+      - mysql_data_dev:/var/lib/mysql
+    healthcheck:
+      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-u", "root", "-p${MYSQL_ROOT_PASSWORD}"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+      start_period: 30s
+    deploy:
+      resources:
+        limits:
+          memory: 384M
+
+  redis:
+    image: redis:7-alpine
+    container_name: redis-cache-dev
+    restart: unless-stopped
+    command: redis-server --maxmemory 64mb --maxmemory-policy allkeys-lru
+    volumes:
+      - redis_data_dev:/data
+    deploy:
+      resources:
+        limits:
+          memory: 64M
+
+  prometheus:
+    image: prom/prometheus:latest
+    container_name: prometheus-dev
+    restart: unless-stopped
+    ports:
+      - "127.0.0.1:9090:9090"
+    volumes:
+      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
+      - prometheus_data_dev:/prometheus
+    command:
+      - "--config.file=/etc/prometheus/prometheus.yml"
+      - "--storage.tsdb.path=/prometheus"
+    depends_on:
+      app:
+        condition: service_healthy
+
+volumes:
+  mysql_data_dev:
+  redis_data_dev:
+  prometheus_data_dev:
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/common/email/client/JavaMailEmailClient.kt b/src/main/kotlin/com/wafflestudio/spring2025/common/email/client/JavaMailEmailClient.kt
index 5dd82a1b..a76969dc 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/common/email/client/JavaMailEmailClient.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/common/email/client/JavaMailEmailClient.kt
@@ -1,8 +1,12 @@
 package com.wafflestudio.spring2025.common.email.client
 
+import com.wafflestudio.spring2025.common.email.exception.EmailErrorCode
+import com.wafflestudio.spring2025.common.email.exception.EmailServiceUnavailableException
+import jakarta.mail.MessagingException
 import jakarta.mail.internet.MimeMessage
 import org.slf4j.LoggerFactory
 import org.springframework.context.annotation.Primary
+import org.springframework.mail.MailException
 import org.springframework.mail.javamail.JavaMailSender
 import org.springframework.mail.javamail.MimeMessageHelper
 import org.springframework.stereotype.Component
@@ -21,26 +25,24 @@ class JavaMailEmailClient(
         fromEmail: String,
         fromName: String,
     ) {
-        logger.info("메일링 임시 중단으로 발송 생략: $to")
-        return
+        // OCI Email Delivery의 SMTP 엔드포인트를 사용 (SDK가 아닌 SMTP 방식)
+        // 발신 주소는 OCI 콘솔 Approved Senders에 등록되어 있어야 합니다.
         try {
             val message: MimeMessage = javaMailSender.createMimeMessage()
-
-            val helper = MimeMessageHelper(message, true, "UTF-8")
+            val helper = MimeMessageHelper(message, "UTF-8")
 
             helper.setTo(to)
             helper.setSubject(subject)
-
             helper.setText(htmlContent, true)
-
             helper.setFrom("$fromName <$fromEmail>")
 
             javaMailSender.send(message)
-
-            logger.info("Gmail을 통해 메일 발송 성공: $to")
-        } catch (e: Exception) {
-            logger.error("Gmail 메일 발송 실패: $to", e)
-            throw RuntimeException("Email sending failed via Gmail", e)
+        } catch (e: MessagingException) {
+            logger.error("메일 구성 실패: to={}, subject={}", to, subject, e)
+            throw EmailServiceUnavailableException(EmailErrorCode.EMAIL_SERVICE_UNAVAILABLE)
+        } catch (e: MailException) {
+            logger.error("메일 전송 실패: to={}, subject={}", to, subject, e)
+            throw EmailServiceUnavailableException(EmailErrorCode.EMAIL_SERVICE_UNAVAILABLE)
         }
     }
 }
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/common/email/client/NoopEmailClient.kt b/src/main/kotlin/com/wafflestudio/spring2025/common/email/client/NoopEmailClient.kt
new file mode 100644
index 00000000..fc357e1b
--- /dev/null
+++ b/src/main/kotlin/com/wafflestudio/spring2025/common/email/client/NoopEmailClient.kt
@@ -0,0 +1,22 @@
+package com.wafflestudio.spring2025.common.email.client
+
+import org.slf4j.LoggerFactory
+import org.springframework.mail.javamail.JavaMailSender
+import org.springframework.stereotype.Component
+
+@Component
+class NoopEmailClient(
+    private val javaMailSender: JavaMailSender,
+) : EmailClient {
+    private val logger = LoggerFactory.getLogger(javaClass)
+
+    override fun sendEmail(
+        to: String,
+        subject: String,
+        htmlContent: String,
+        fromEmail: String,
+        fromName: String,
+    ) {
+        logger.info("메일링 중단으로 발송 생략: $to")
+    }
+}
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/common/email/service/EmailService.kt b/src/main/kotlin/com/wafflestudio/spring2025/common/email/service/EmailService.kt
index ee4e4b88..f05cf475 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/common/email/service/EmailService.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/common/email/service/EmailService.kt
@@ -1,16 +1,10 @@
 package com.wafflestudio.spring2025.common.email.service
 
-import com.wafflestudio.spring2025.common.email.exception.EmailErrorCode
-import com.wafflestudio.spring2025.common.email.exception.EmailServiceUnavailableException
+import com.wafflestudio.spring2025.common.email.client.EmailClient
 import com.wafflestudio.spring2025.config.EmailConfig
 import com.wafflestudio.spring2025.domain.registration.model.RegistrationStatus
-import jakarta.mail.MessagingException
-import jakarta.mail.internet.MimeMessage
 import org.slf4j.LoggerFactory
 import org.springframework.core.io.ClassPathResource
-import org.springframework.mail.MailException
-import org.springframework.mail.javamail.JavaMailSender
-import org.springframework.mail.javamail.MimeMessageHelper
 import org.springframework.stereotype.Service
 import java.nio.charset.StandardCharsets
 import java.time.Instant
@@ -19,8 +13,8 @@ import java.time.format.DateTimeFormatter
 
 @Service
 class EmailService(
-    private val javaMailSender: JavaMailSender,
     private val emailConfig: EmailConfig,
+    private val emailClient: EmailClient,
 ) {
     private val logger = LoggerFactory.getLogger(javaClass)
 
@@ -52,24 +46,13 @@ class EmailService(
         subject: String,
         htmlContent: String,
     ) {
-        try {
-            val message: MimeMessage = javaMailSender.createMimeMessage()
-            val helper = MimeMessageHelper(message, "UTF-8")
-
-            helper.setTo(to)
-            helper.setSubject(subject)
-            helper.setText(htmlContent, true)
-            helper.setFrom("${emailConfig.fromName} <${emailConfig.fromEmail}>")
-
-            // AWS SES 샌드박스 모드에서는 발신/수신 주소 모두 사전 인증(Verified)이 필요합니다.
-            javaMailSender.send(message)
-        } catch (e: MessagingException) {
-            logger.error("메일 구성 실패: to={}, subject={}", to, subject, e)
-            throw EmailServiceUnavailableException(EmailErrorCode.EMAIL_SERVICE_UNAVAILABLE)
-        } catch (e: MailException) {
-            logger.error("메일 전송 실패: to={}, subject={}", to, subject, e)
-            throw EmailServiceUnavailableException(EmailErrorCode.EMAIL_SERVICE_UNAVAILABLE)
-        }
+        emailClient.sendEmail(
+            to = to,
+            subject = subject,
+            htmlContent = htmlContent,
+            fromEmail = emailConfig.fromEmail,
+            fromName = emailConfig.fromName,
+        )
     }
 
     /**
@@ -116,6 +99,35 @@ class EmailService(
         val registrationStartsAt: Instant?,
         val registrationEndsAt: Instant?,
         val description: String?,
+        val publicId: String?,
+    )
+
+    data class EventCancellationEmailData(
+        val toEmail: String,
+        val name: String,
+        val eventTitle: String?,
+        val startsAt: Instant?,
+        val endsAt: Instant?,
+        val location: String?,
+        val description: String?,
+        val hostEmail: String,
+    )
+
+    data class DemotionEmailData(
+        val toEmail: String,
+        val name: String,
+        val eventTitle: String?,
+        val startsAt: Instant?,
+        val endsAt: Instant?,
+        val location: String?,
+        val newCapacity: Int,
+        val totalCount: Int,
+        val registrationStartsAt: Instant?,
+        val registrationEndsAt: Instant,
+        val description: String?,
+        val publicId: String,
+        val registrationPublicId: String,
+        val waitingNum: Int?,
     )
 
     fun sendRegistrationStatusEmail(data: RegistrationStatusEmailData) {
@@ -123,12 +135,12 @@ class EmailService(
             RegistrationStatus.CONFIRMED -> {
                 val htmlContent =
                     loadTemplate("registration-confirmed.html")
+                        .replace("{serviceDomain}", emailConfig.serviceDomain)
                         .replace("{name}", data.name)
                         .replace("{eventTitle}", formatEventTitle(data.eventTitle))
                         .replace("{eventDateRange}", formatEventDateRange(data.startsAt, data.endsAt, "-"))
                         .replace("{location}", formatLocation(data.location))
-                        .replace("{totalCount}", data.totalCount?.toString() ?: "null")
-                        .replace("{capacity}", data.capacity?.toString() ?: "null")
+                        .replace("{capacityDisplay}", formatCapacity(data.totalCount, data.capacity))
                         .replace(
                             "{registrationDateRange}",
                             formatRegistrationDateRange(data.registrationStartsAt, data.registrationEndsAt),
@@ -138,7 +150,7 @@ class EmailService(
 
                 sendHtmlEmail(
                     to = data.toEmail,
-                    subject = "모이밍 참여 신청 확정",
+                    subject = emailName("참여 확정", data.eventTitle),
                     htmlContent = htmlContent,
                 )
 
@@ -148,13 +160,13 @@ class EmailService(
             RegistrationStatus.WAITLISTED -> {
                 val htmlContent =
                     loadTemplate("registration-waitlisted.html")
+                        .replace("{serviceDomain}", emailConfig.serviceDomain)
                         .replace("{name}", data.name)
                         .replace("{waitingNum}", data.waitingNum?.toString() ?: "-")
                         .replace("{eventTitle}", formatEventTitle(data.eventTitle))
                         .replace("{eventDateRange}", formatEventDateRange(data.startsAt, data.endsAt, "-"))
                         .replace("{location}", formatLocation(data.location))
-                        .replace("{totalCount}", data.totalCount?.toString() ?: "null")
-                        .replace("{capacity}", data.capacity?.toString() ?: "null")
+                        .replace("{capacityDisplay}", formatCapacity(data.totalCount, data.capacity))
                         .replace(
                             "{registrationDateRange}",
                             formatRegistrationDateRange(data.registrationStartsAt, data.registrationEndsAt),
@@ -164,7 +176,7 @@ class EmailService(
 
                 sendHtmlEmail(
                     to = data.toEmail,
-                    subject = "모이밍 참여 신청 대기",
+                    subject = emailName("대기 등록", data.eventTitle),
                     htmlContent = htmlContent,
                 )
 
@@ -177,8 +189,7 @@ class EmailService(
                         .replace("{eventTitle}", formatEventTitle(data.eventTitle))
                         .replace("{eventDateRange}", formatEventDateRange(data.startsAt, data.endsAt, "-"))
                         .replace("{location}", formatLocation(data.location))
-                        .replace("{totalCount}", data.totalCount?.toString() ?: "null")
-                        .replace("{capacity}", data.capacity?.toString() ?: "null")
+                        .replace("{capacityDisplay}", formatCapacity(data.totalCount, data.capacity))
                         .replace(
                             "{registrationDateRange}",
                             formatRegistrationDateRange(data.registrationStartsAt, data.registrationEndsAt),
@@ -186,7 +197,7 @@ class EmailService(
 
                 sendHtmlEmail(
                     to = data.toEmail,
-                    subject = "모이밍 참여 신청 강제 취소",
+                    subject = emailName("강제 취소", data.eventTitle),
                     htmlContent = htmlContent,
                 )
 
@@ -201,26 +212,72 @@ class EmailService(
     fun sendRegistrationDeleteEmail(data: RegistrationDeleteEmailData) {
         val htmlContent =
             loadTemplate("registration-delete.html")
+                .replace("{serviceDomain}", emailConfig.serviceDomain)
                 .replace("{name}", data.name)
                 .replace("{eventTitle}", formatEventTitle(data.eventTitle))
                 .replace("{eventDateRange}", formatEventDateRange(data.startsAt, data.endsAt, "-"))
                 .replace("{location}", formatLocation(data.location))
-                .replace("{totalCount}", data.totalCount?.toString() ?: "null")
-                .replace("{capacity}", data.capacity?.toString() ?: "null")
+                .replace("{capacityDisplay}", formatCapacity(data.totalCount, data.capacity))
                 .replace(
                     "{registrationDateRange}",
                     formatRegistrationDateRange(data.registrationStartsAt, data.registrationEndsAt),
                 ).replace("{description}", formatDescription(data.description))
+                .replace("{publicId}", data.publicId ?: "-")
 
         sendHtmlEmail(
             to = data.toEmail,
-            subject = "모이밍 참여 신청 취소",
+            subject = emailName("참여 신청 취소", data.eventTitle),
             htmlContent = htmlContent,
         )
 
         logger.info("신청 삭제 정보가 ${data.toEmail} 로 전달되었습니다.")
     }
 
+    fun sendEventCancellationEmail(data: EventCancellationEmailData) {
+        val htmlContent =
+            loadTemplate("event-cancelled.html")
+                .replace("{name}", data.name)
+                .replace("{eventTitle}", formatEventTitle(data.eventTitle))
+                .replace("{eventDateRange}", formatEventDateRange(data.startsAt, data.endsAt, "-"))
+                .replace("{location}", formatLocation(data.location))
+                .replace("{hostEmail}", data.hostEmail)
+                .replace("{description}", formatDescription(data.description))
+
+        sendHtmlEmail(
+            to = data.toEmail,
+            subject = emailName("일정 취소", data.eventTitle),
+            htmlContent = htmlContent,
+        )
+
+        logger.info("일정 취소 정보가 ${data.toEmail} 로 전달되었습니다.")
+    }
+
+    fun sendDemotionEmail(data: DemotionEmailData) {
+        val htmlContent =
+            loadTemplate("registration-demoted.html")
+                .replace("{serviceDomain}", emailConfig.serviceDomain)
+                .replace("{name}", data.name)
+                .replace("{waitingNum}", data.waitingNum?.toString() ?: "-")
+                .replace("{capacityDisplay}", formatCapacity(data.totalCount, data.newCapacity))
+                .replace("{eventTitle}", formatEventTitle(data.eventTitle))
+                .replace("{eventDateRange}", formatEventDateRange(data.startsAt, data.endsAt, "-"))
+                .replace("{location}", formatLocation(data.location))
+                .replace(
+                    "{registrationDateRange}",
+                    formatRegistrationDateRange(data.registrationStartsAt, data.registrationEndsAt),
+                ).replace("{description}", formatDescription(data.description))
+                .replace("{publicId}", data.publicId)
+                .replace("{registrationPublicId}", data.registrationPublicId)
+
+        sendHtmlEmail(
+            to = data.toEmail,
+            subject = emailName("대기자로 전환", data.eventTitle),
+            htmlContent = htmlContent,
+        )
+
+        logger.info("정원 축소 대기 변경 알림이 ${data.toEmail} 로 전달되었습니다.")
+    }
+
     fun sendWaitlistPromotionEmail(
         toEmail: String,
         eventTitle: String?,
@@ -239,13 +296,13 @@ class EmailService(
     ) {
         val htmlContent =
             loadTemplate("registration-waitlist-promoted.html")
+                .replace("{serviceDomain}", emailConfig.serviceDomain)
                 .replace("{name}", name)
                 .replace("{waitingNum}", waitingNum?.toString() ?: "-")
                 .replace("{eventTitle}", formatEventTitle(eventTitle))
                 .replace("{eventDateRange}", formatEventDateRange(startsAt, endsAt, "~"))
                 .replace("{location}", formatLocation(location))
-                .replace("{totalCount}", totalCount?.toString() ?: "null")
-                .replace("{capacity}", capacity?.toString() ?: "null")
+                .replace("{capacityDisplay}", formatCapacity(totalCount, capacity))
                 .replace(
                     "{registrationDateRange}",
                     formatRegistrationDateRange(registrationStartsAt, registrationEndsAt),
@@ -255,7 +312,7 @@ class EmailService(
 
         sendHtmlEmail(
             to = toEmail,
-            subject = "모이밍 참여 신청 대기 후, 확정",
+            subject = emailName("참여 확정", eventTitle),
             htmlContent = htmlContent,
         )
 
@@ -274,6 +331,14 @@ class EmailService(
             location
         }
 
+    private fun emailName(
+        title: String,
+        eventTitle: String?,
+    ): String {
+        val safeEventTitle = if (eventTitle.isNullOrBlank()) "제목 미정 모임" else eventTitle
+        return "[모이밍] $title: $safeEventTitle"
+    }
+
     private fun formatEventDateRange(
         start: Instant?,
         end: Instant?,
@@ -302,6 +367,20 @@ class EmailService(
         }
     }
 
+    private fun formatCapacity(
+        totalCount: Int?,
+        capacity: Int?,
+    ): String {
+        if (capacity == null) return "${totalCount ?: "-"}명"
+        val confirmed = if (totalCount != null) minOf(totalCount, capacity) else capacity
+        val waitlisted = if (totalCount != null) maxOf(0, totalCount - capacity) else 0
+        return if (waitlisted > 0) {
+            "$confirmed/${capacity}명 (대기자 ${waitlisted}명)"
+        } else {
+            "$confirmed/${capacity}명"
+        }
+    }
+
     private fun formatDescription(description: String?): String {
         if (description == null) return "-"
         return description.replace("\r\n", "\n").replace("\n", "<br>")
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/common/image/controller/ImageController.kt b/src/main/kotlin/com/wafflestudio/spring2025/common/image/controller/ImageController.kt
index d774bdb0..1cdb9ea8 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/common/image/controller/ImageController.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/common/image/controller/ImageController.kt
@@ -4,10 +4,6 @@ import com.wafflestudio.spring2025.common.image.dto.ImageUploadResponse
 import com.wafflestudio.spring2025.common.image.service.ImageService
 import com.wafflestudio.spring2025.domain.auth.LoggedInUser
 import com.wafflestudio.spring2025.domain.user.model.User
-import io.swagger.v3.oas.annotations.Operation
-import io.swagger.v3.oas.annotations.Parameter
-import io.swagger.v3.oas.annotations.responses.ApiResponse
-import io.swagger.v3.oas.annotations.responses.ApiResponses
 import org.springframework.http.MediaType
 import org.springframework.http.ResponseEntity
 import org.springframework.web.bind.annotation.PostMapping
@@ -22,21 +18,12 @@ import org.springframework.web.multipart.MultipartFile
 class ImageController(
     private val imageService: ImageService,
 ) {
-    @Operation(summary = "이미지 업로드", description = "서버 저장소에 이미지를 업로드합니다.")
-    @ApiResponses(
-        value = [
-            ApiResponse(responseCode = "200", description = "이미지 업로드 성공"),
-            ApiResponse(responseCode = "400", description = "잘못된 요청 (파일 누락/형식 오류 등)"),
-            ApiResponse(responseCode = "401", description = "인증 실패 (유효하지 않은 토큰)"),
-        ],
-    )
     @PostMapping(
         consumes = [MediaType.MULTIPART_FORM_DATA_VALUE],
     )
     fun uploadImage(
-        @Parameter(hidden = true) @LoggedInUser user: User?,
+        @LoggedInUser user: User?,
         @RequestPart("image") image: MultipartFile,
-        @Parameter(description = "이미지를 저장할 상위 경로", required = false)
         @RequestParam(name = "prefix", required = false)
         prefix: String?,
     ): ResponseEntity<ImageUploadResponse> {
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/config/OciVaultPostProcessorBridge.kt b/src/main/kotlin/com/wafflestudio/spring2025/config/OciVaultPostProcessorBridge.kt
new file mode 100644
index 00000000..aaac34e7
--- /dev/null
+++ b/src/main/kotlin/com/wafflestudio/spring2025/config/OciVaultPostProcessorBridge.kt
@@ -0,0 +1,72 @@
+package com.wafflestudio.spring2025.config
+
+import com.fasterxml.jackson.core.json.JsonReadFeature
+import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import com.fasterxml.jackson.module.kotlin.readValue
+import com.oracle.bmc.Region
+import com.oracle.bmc.auth.InstancePrincipalsAuthenticationDetailsProvider
+import com.oracle.bmc.secrets.SecretsClient
+import com.oracle.bmc.secrets.model.Base64SecretBundleContentDetails
+import com.oracle.bmc.secrets.requests.GetSecretBundleRequest
+import org.springframework.boot.SpringApplication
+import org.springframework.boot.env.EnvironmentPostProcessor
+import org.springframework.core.env.ConfigurableEnvironment
+import org.springframework.core.env.MapPropertySource
+import java.util.Base64
+
+/**
+ * OCI Vault EnvironmentPostProcessor that replaces the broken waffle-oci-vault library.
+ * The library (2.1.0) implements org.springframework.boot.EnvironmentPostProcessor (wrong package)
+ * instead of org.springframework.boot.env.EnvironmentPostProcessor, making it incompatible
+ * with Spring Boot 3.x.
+ */
+class OciVaultPostProcessorBridge : EnvironmentPostProcessor {
+    private val objectMapper =
+        jacksonObjectMapper()
+            .enable(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS.mappedFeature())
+
+    override fun postProcessEnvironment(
+        environment: ConfigurableEnvironment,
+        application: SpringApplication,
+    ) {
+        val secretIds = environment.getProperty("oci.vault.secret-ids") ?: return
+        val regionId = environment.getProperty("oci.vault.region", "ap-chuncheon-1")
+        val region = Region.fromRegionId(regionId)
+
+        val authProvider =
+            try {
+                InstancePrincipalsAuthenticationDetailsProvider.builder().build()
+            } catch (e: Exception) {
+                System.err.println("[OciVault] Instance Principal auth failed: ${e.message}")
+                return
+            }
+
+        val secrets = mutableMapOf<String, Any>()
+
+        SecretsClient.builder().region(region).build(authProvider).use { client ->
+            for (secretId in secretIds.split(",").map { it.trim() }) {
+                try {
+                    val request =
+                        GetSecretBundleRequest
+                            .builder()
+                            .secretId(secretId)
+                            .build()
+                    val response = client.getSecretBundle(request)
+                    val content =
+                        response.secretBundle.secretBundleContent
+                            as? Base64SecretBundleContentDetails ?: continue
+                    val decoded = String(Base64.getDecoder().decode(content.content))
+                    val parsed: Map<String, String> = objectMapper.readValue(decoded)
+
+                    secrets.putAll(parsed)
+                } catch (e: Exception) {
+                    System.err.println("[OciVault] Failed to fetch secret $secretId: ${e.message}")
+                }
+            }
+        }
+
+        if (secrets.isNotEmpty()) {
+            environment.propertySources.addFirst(MapPropertySource("oci-vault-secrets", secrets))
+        }
+    }
+}
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/config/WebConfig.kt b/src/main/kotlin/com/wafflestudio/spring2025/config/WebConfig.kt
index ead78181..9d44a658 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/config/WebConfig.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/config/WebConfig.kt
@@ -21,6 +21,8 @@ class WebConfig(
     }
 
     override fun addCorsMappings(registry: CorsRegistry) {
+        val origins = corsProperties.getAllowedOriginsList()
+        if (origins.isEmpty()) return
         registry
             .addMapping("/**")
             .allowedOrigins(*corsProperties.getAllowedOriginsList().toTypedArray())
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/controller/AuthController.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/controller/AuthController.kt
index fae13d16..f35d874e 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/controller/AuthController.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/controller/AuthController.kt
@@ -5,10 +5,6 @@ import com.wafflestudio.spring2025.domain.auth.dto.LoginResponse
 import com.wafflestudio.spring2025.domain.auth.dto.SignupRequest
 import com.wafflestudio.spring2025.domain.auth.service.AuthService
 import com.wafflestudio.spring2025.domain.auth.service.EmailVerificationService
-import io.swagger.v3.oas.annotations.Operation
-import io.swagger.v3.oas.annotations.responses.ApiResponse
-import io.swagger.v3.oas.annotations.responses.ApiResponses
-import io.swagger.v3.oas.annotations.tags.Tag
 import jakarta.servlet.http.HttpServletRequest
 import org.springframework.http.ResponseEntity
 import org.springframework.web.bind.annotation.PathVariable
@@ -19,23 +15,10 @@ import org.springframework.web.bind.annotation.RestController
 
 @RestController
 @RequestMapping("/api/auth")
-@Tag(name = "Auth", description = "인증 API")
 class AuthController(
     private val authService: AuthService,
     private val emailVerificationService: EmailVerificationService,
 ) {
-    @Operation(
-        summary = "이메일 회원가입",
-        description = "새로운 사용자를 등록하고 인증 이메일을 발송합니다. 이메일 인증 후 가입이 완료됩니다.",
-    )
-    @ApiResponses(
-        value = [
-            ApiResponse(responseCode = "204", description = "인증 이메일 발송 성공"),
-            ApiResponse(responseCode = "400", description = "잘못된 요청 (유효하지 않은 email/password/name)"),
-            ApiResponse(responseCode = "409", description = "이미 존재하는 email"),
-            ApiResponse(responseCode = "503", description = "이메일 서비스 장애"),
-        ],
-    )
     @PostMapping("/signup")
     fun signup(
         @RequestBody signupRequest: SignupRequest,
@@ -51,16 +34,6 @@ class AuthController(
         return ResponseEntity.noContent().build()
     }
 
-    @Operation(
-        summary = "이메일 인증",
-        description = "이메일로 받은 인증 코드를 검증하고 회원가입을 완료합니다",
-    )
-    @ApiResponses(
-        value = [
-            ApiResponse(responseCode = "200", description = "인증 성공, 유저 등록 완료"),
-            ApiResponse(responseCode = "400", description = "유효하지 않거나 만료된 인증 코드"),
-        ],
-    )
     @PostMapping("/email-verification/{verificationCode}")
     fun verifyEmail(
         @PathVariable verificationCode: String,
@@ -69,13 +42,6 @@ class AuthController(
         return ResponseEntity.ok().build()
     }
 
-    @Operation(summary = "로그인", description = "email로 로그인하여 JWT 토큰을 발급받습니다")
-    @ApiResponses(
-        value = [
-            ApiResponse(responseCode = "200", description = "로그인 성공, JWT 토큰 반환"),
-            ApiResponse(responseCode = "401", description = "인증 실패"),
-        ],
-    )
     @PostMapping("/login")
     fun login(
         @RequestBody loginRequest: LoginRequest,
@@ -84,12 +50,6 @@ class AuthController(
         return ResponseEntity.ok(LoginResponse(token))
     }
 
-    @Operation(summary = "로그아웃", description = "현재 JWT 토큰을 블랙리스트에 추가하여 로그아웃합니다")
-    @ApiResponses(
-        value = [
-            ApiResponse(responseCode = "204", description = "로그아웃 성공"),
-        ],
-    )
     @PostMapping("/logout")
     fun logout(request: HttpServletRequest): ResponseEntity<Void> {
         val token = resolveToken(request)
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/controller/SocialAuthController.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/controller/SocialAuthController.kt
index b43a4ced..14da8c08 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/controller/SocialAuthController.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/controller/SocialAuthController.kt
@@ -4,9 +4,6 @@ import com.wafflestudio.spring2025.domain.auth.dto.LoginResponse
 import com.wafflestudio.spring2025.domain.auth.dto.SocialLoginRequest
 import com.wafflestudio.spring2025.domain.auth.model.SocialProvider
 import com.wafflestudio.spring2025.domain.auth.service.SocialAuthService
-import io.swagger.v3.oas.annotations.Operation
-import io.swagger.v3.oas.annotations.responses.ApiResponse
-import io.swagger.v3.oas.annotations.responses.ApiResponses
 import org.springframework.http.ResponseEntity
 import org.springframework.web.bind.annotation.PostMapping
 import org.springframework.web.bind.annotation.RequestBody
@@ -14,18 +11,10 @@ import org.springframework.web.bind.annotation.RequestMapping
 import org.springframework.web.bind.annotation.RestController
 
 @RestController
-@RequestMapping("api/auth/social")
+@RequestMapping("/api/auth/social")
 class SocialAuthController(
     private val socialAuthService: SocialAuthService,
 ) {
-    @Operation(summary = "소셜 로그인", description = "소셜 로그인을 요청합니다.")
-    @ApiResponses(
-        value = [
-            ApiResponse(responseCode = "200", description = "소셜 로그인 성공"),
-            ApiResponse(responseCode = "401", description = "인증 실패"),
-            ApiResponse(responseCode = "409", description = "이미 가입된 이메일"),
-        ],
-    )
     @PostMapping
     suspend fun social(
         @RequestBody socialLoginRequest: SocialLoginRequest,
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/dto/LoginRequest.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/dto/LoginRequest.kt
index bf17a881..0d5ffea7 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/dto/LoginRequest.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/dto/LoginRequest.kt
@@ -1,11 +1,6 @@
 package com.wafflestudio.spring2025.domain.auth.dto
 
-import io.swagger.v3.oas.annotations.media.Schema
-
-@Schema(description = "로그인 요청")
 data class LoginRequest(
-    @Schema(description = "사용자 이메일", example = "user@example.com", required = true)
     val email: String,
-    @Schema(description = "사용자 비밀번호", example = "mypassword", required = true)
     val password: String,
 )
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/dto/RegisterRequest.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/dto/RegisterRequest.kt
deleted file mode 100644
index 470bcb7f..00000000
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/dto/RegisterRequest.kt
+++ /dev/null
@@ -1,15 +0,0 @@
-package com.wafflestudio.spring2025.domain.auth.dto
-
-import io.swagger.v3.oas.annotations.media.Schema
-
-@Schema(description = "회원가입 요청")
-data class RegisterRequest(
-    @Schema(description = "사용자 이메일", example = "user@example.com", required = true)
-    val email: String,
-    @Schema(description = "사용자 이름", example = "홍길동", required = true)
-    val name: String,
-    @Schema(description = "비밀번호", example = "password123", required = true)
-    val password: String,
-    @Schema(description = "프로필 이미지 URL", example = "https://cdn.example.com/profile.png")
-    val profileImage: String? = null,
-)
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/dto/SignupRequest.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/dto/SignupRequest.kt
index 94c273ff..53618934 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/dto/SignupRequest.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/dto/SignupRequest.kt
@@ -1,15 +1,8 @@
 package com.wafflestudio.spring2025.domain.auth.dto
 
-import io.swagger.v3.oas.annotations.media.Schema
-
-@Schema(description = "회원가입 요청")
 data class SignupRequest(
-    @Schema(description = "사용자 이메일", example = "user@example.com", required = true)
     val email: String,
-    @Schema(description = "사용자 이름", example = "홍길동", required = true)
     val name: String,
-    @Schema(description = "비밀번호", example = "password123", required = true)
     val password: String,
-    @Schema(description = "프로필 이미지 URL", example = "https://cdn.example.com/profile.png")
     val profileImage: String? = null,
 )
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/dto/SocialLoginRequest.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/dto/SocialLoginRequest.kt
index f83e60f3..28fc2bad 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/dto/SocialLoginRequest.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/dto/SocialLoginRequest.kt
@@ -1,11 +1,6 @@
 package com.wafflestudio.spring2025.domain.auth.dto
 
-import io.swagger.v3.oas.annotations.media.Schema
-
-@Schema(description = "소셜 로그인 요청")
 data class SocialLoginRequest(
-    @Schema(description = "소셜로그인 제공자", example = "GOOGLE", required = true)
     val provider: String,
-    @Schema(description = "인가 코드 (authorization code)", required = true)
     val code: String,
 )
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/service/AuthService.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/service/AuthService.kt
index de4141b4..ceedbc89 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/service/AuthService.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/service/AuthService.kt
@@ -25,7 +25,7 @@ class AuthService(
         password: String,
     ): String {
         val user: User = userRepository.findByEmail(email) ?: throw LoginFailedException()
-        if (BCrypt.checkpw(password, user.passwordHash).not()) {
+        if (user.passwordHash == null || !BCrypt.checkpw(password, user.passwordHash)) {
             throw LoginFailedException()
         }
         val accessToken = jwtTokenProvider.createToken(user.id!!)
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/service/SocialAuthService.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/service/SocialAuthService.kt
index 2bca98f4..f119bc12 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/service/SocialAuthService.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/auth/service/SocialAuthService.kt
@@ -32,7 +32,7 @@ class SocialAuthService(
                 User(
                     email = userInfo.email,
                     name = userInfo.name,
-                    profileImage = userInfo.profilePicture,
+                    profileImage = null,
                     passwordHash = null,
                 ),
             )
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/event/controller/EventController.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/event/controller/EventController.kt
index 7ba5fae8..7e1a9de5 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/event/controller/EventController.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/event/controller/EventController.kt
@@ -10,8 +10,6 @@ import com.wafflestudio.spring2025.domain.event.dto.response.MyEventsInfiniteRes
 import com.wafflestudio.spring2025.domain.event.dto.response.UpdateEventResponse
 import com.wafflestudio.spring2025.domain.event.service.EventService
 import com.wafflestudio.spring2025.domain.user.model.User
-import io.swagger.v3.oas.annotations.Operation
-import io.swagger.v3.oas.annotations.tags.Tag
 import org.springframework.http.ResponseEntity
 import org.springframework.web.bind.annotation.DeleteMapping
 import org.springframework.web.bind.annotation.GetMapping
@@ -26,12 +24,10 @@ import java.time.Instant
 
 @RestController
 @RequestMapping("/api/events")
-@Tag(name = "Event", description = "이벤트 관리 API")
 class EventController(
     private val eventService: EventService,
 ) {
     @AuthRequired
-    @Operation(summary = "이벤트 생성", description = "새로운 이벤트를 생성합니다")
     @PostMapping // POST /api/events
     fun create(
         @LoggedInUser user: User,
@@ -54,7 +50,6 @@ class EventController(
         return ResponseEntity.ok(CreateEventResponse(publicId))
     }
 
-    @Operation(summary = "이벤트 상세 조회", description = "이벤트 상세 정보를 조회합니다")
     @GetMapping("/{publicId}") // GET /api/events/{publicId}
     fun getById(
         @LoggedInUser user: User?, // nullable
@@ -69,10 +64,6 @@ class EventController(
     }
 
     @AuthRequired
-    @Operation(
-        summary = "내가 만든 이벤트 목록 조회 (무한 스크롤)",
-        description = "로그인된 사용자가 생성한 이벤트 목록을 무한 스크롤 방식(cursor)으로 조회합니다",
-    )
     @GetMapping("/me")
     fun getMyEvents(
         @LoggedInUser user: User,
@@ -89,7 +80,6 @@ class EventController(
     }
 
     @AuthRequired
-    @Operation(summary = "이벤트 수정", description = "이벤트를 수정합니다")
     @PutMapping("/{publicId}") // PUT /api/events/{publicId}
     fun update(
         @LoggedInUser user: User,
@@ -116,7 +106,6 @@ class EventController(
     }
 
     @AuthRequired
-    @Operation(summary = "이벤트 삭제", description = "이벤트를 삭제합니다")
     @DeleteMapping("/{publicId}") // DELETE /api/events/{publicId}
     fun delete(
         @LoggedInUser user: User,
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/core/EventDto.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/core/EventDto.kt
index 6b0259f8..778ea5ca 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/core/EventDto.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/core/EventDto.kt
@@ -1,35 +1,20 @@
 package com.wafflestudio.spring2025.domain.event.dto.core
 
 import com.wafflestudio.spring2025.domain.event.model.Event
-import io.swagger.v3.oas.annotations.media.Schema
 
-@Schema(description = "일정 정보")
 data class EventDto(
-    @Schema(description = "일정 ID (publicId)")
     val id: String,
-    @Schema(description = "이벤트 제목")
     val title: String,
-    @Schema(description = "이벤트 설명")
     val description: String?,
-    @Schema(description = "장소")
     val location: String?,
-    @Schema(description = "시작 시간 (epoch milliseconds)")
     val startsAt: Long?,
-    @Schema(description = "종료 시간 (epoch milliseconds)")
     val endsAt: Long?,
-    @Schema(description = "정원")
     val capacity: Int?,
-    @Schema(description = "대기 명단 사용 여부")
     val waitlistEnabled: Boolean,
-    @Schema(description = "신청 시작 시간 (epoch milliseconds)")
     val registrationStartsAt: Long?,
-    @Schema(description = "신청 마감 시간 (epoch milliseconds)")
-    val registrationEndsAt: Long?,
-    @Schema(description = "작성자 ID")
+    val registrationEndsAt: Long,
     val createdBy: Long,
-    @Schema(description = "생성 일시 (epoch milliseconds)")
     val createdAt: Long?,
-    @Schema(description = "수정 일시 (epoch milliseconds)")
     val updatedAt: Long?,
 ) {
     constructor(event: Event) : this(
@@ -42,7 +27,7 @@ data class EventDto(
         capacity = event.capacity,
         waitlistEnabled = event.waitlistEnabled,
         registrationStartsAt = event.registrationStartsAt?.toEpochMilli(),
-        registrationEndsAt = event.registrationEndsAt?.toEpochMilli(),
+        registrationEndsAt = event.registrationEndsAt.toEpochMilli(),
         createdBy = event.createdBy,
         createdAt = event.createdAt?.toEpochMilli(),
         updatedAt = event.updatedAt?.toEpochMilli(),
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/request/CreateEventRequest.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/request/CreateEventRequest.kt
index dbd1f9d6..1c46a314 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/request/CreateEventRequest.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/request/CreateEventRequest.kt
@@ -1,38 +1,15 @@
 package com.wafflestudio.spring2025.domain.event.dto.request
 
-import io.swagger.v3.oas.annotations.media.Schema
 import java.time.Instant
 
-@Schema(description = "일정 생성 요청")
 data class CreateEventRequest(
-    @Schema(description = "이벤트 제목", example = "정기 모임")
     val title: String,
-    @Schema(description = "이벤트 설명", example = "정기 모임입니다")
     val description: String? = null,
-    @Schema(description = "장소", example = "강의실 101")
     val location: String? = null,
-    @Schema(
-        description = "시작 시간 (ISO-8601)",
-        example = "2026-02-02T18:00:00Z",
-    )
     val startsAt: Instant? = null,
-    @Schema(
-        description = "종료 시간 (ISO-8601)",
-        example = "2026-02-02T20:00:00Z",
-    )
     val endsAt: Instant? = null,
-    @Schema(description = "정원", example = "30")
     val capacity: Int,
-    @Schema(description = "대기 명단 사용 여부", example = "true")
     val waitlistEnabled: Boolean,
-    @Schema(
-        description = "신청 시작 시간 (ISO-8601)",
-        example = "2026-02-02T17:00:00Z",
-    )
     val registrationStartsAt: Instant? = null,
-    @Schema(
-        description = "신청 마감 시간 (ISO-8601)",
-        example = "2026-02-02T17:30:00Z",
-    )
-    val registrationEndsAt: Instant? = null,
+    val registrationEndsAt: Instant,
 )
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/request/UpdateEventRequest.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/request/UpdateEventRequest.kt
index e237b56c..2206d5c5 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/request/UpdateEventRequest.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/request/UpdateEventRequest.kt
@@ -1,38 +1,15 @@
 package com.wafflestudio.spring2025.domain.event.dto.request
 
-import io.swagger.v3.oas.annotations.media.Schema
 import java.time.Instant
 
-@Schema(description = "일정 수정 요청")
 data class UpdateEventRequest(
-    @Schema(description = "이벤트 제목", example = "정기 모임")
     val title: String? = null,
-    @Schema(description = "이벤트 설명", example = "정기 모임입니다")
     val description: String? = null,
-    @Schema(description = "장소", example = "강의실 101")
     val location: String? = null,
-    @Schema(
-        description = "시작 시간 (ISO-8601)",
-        example = "2026-02-02T18:00:00Z",
-    )
     val startsAt: Instant? = null,
-    @Schema(
-        description = "종료 시간 (ISO-8601)",
-        example = "2026-02-02T20:00:00Z",
-    )
     val endsAt: Instant? = null,
-    @Schema(description = "정원", example = "30")
     val capacity: Int? = null,
-    @Schema(description = "대기 명단 사용 여부", example = "true")
     val waitlistEnabled: Boolean? = null,
-    @Schema(
-        description = "신청 시작 시간 (ISO-8601)",
-        example = "2026-02-02T17:00:00Z",
-    )
     val registrationStartsAt: Instant? = null,
-    @Schema(
-        description = "신청 마감 시간 (ISO-8601)",
-        example = "2026-02-02T17:30:00Z",
-    )
     val registrationEndsAt: Instant? = null,
 )
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/response/EventDetailResponse.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/response/EventDetailResponse.kt
index d2850400..685cfd04 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/response/EventDetailResponse.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/response/EventDetailResponse.kt
@@ -1,97 +1,46 @@
 package com.wafflestudio.spring2025.domain.event.dto.response
 
-import io.swagger.v3.oas.annotations.media.Schema
 import java.time.Instant
 
-@Schema(description = "일정 상세 조회 응답")
 data class EventDetailResponse(
-    @Schema(description = "이벤트 정보")
     val event: EventInfo,
-    @Schema(description = "이벤트 생성자 정보")
     val creator: CreatorInfo,
-    @Schema(description = "조회자(viewer) 정보")
     val viewer: ViewerInfo,
-    @Schema(description = "조회자가 할 수 있는 동작")
     val capabilities: CapabilitiesInfo,
-    @Schema(description = "참여자 미리보기 목록")
     val guestsPreview: List<GuestPreview>,
 )
 
-@Schema(description = "이벤트 정보 블록")
 data class EventInfo(
-    @Schema(description = "이벤트 publicId", example = "dj8sadj10djnkas")
     val publicId: String,
-    @Schema(description = "이벤트 제목", example = "제2회 기획 세미나")
     val title: String,
-    @Schema(description = "이벤트 설명", example = "일정 상세 설명...", nullable = true)
     val description: String?,
-    @Schema(description = "장소", example = "서울대", nullable = true)
     val location: String?,
-    @Schema(description = "시작 시간 (ISO-8601)", example = "2026-02-02T18:00:00Z", nullable = true)
     val startsAt: Instant?,
-    @Schema(description = "종료 시간 (ISO-8601)", example = "2026-02-02T20:00:00Z", nullable = true)
     val endsAt: Instant?,
-    @Schema(description = "정원", example = "10", nullable = true)
     val capacity: Int?,
-    @Schema(description = "총 신청자 수(확정+대기 등)", example = "8")
-    val totalApplicants: Int,
-    @Schema(description = "신청 시작 시간 (ISO-8601)", example = "2026-02-02T17:00:00Z", nullable = true)
+    val confirmedCount: Int,
+    val waitlistCount: Int,
     val registrationStartsAt: Instant?,
-    @Schema(description = "신청 마감 시간 (ISO-8601)", example = "2026-02-02T17:00:00Z", nullable = true)
-    val registrationEndsAt: Instant?,
+    val registrationEndsAt: Instant,
 )
 
-@Schema(description = "생성자 정보 블록")
 data class CreatorInfo(
-    @Schema(description = "이름", example = "홍길동")
     val name: String,
-    @Schema(description = "이메일", example = "user@example.com")
     val email: String,
-    @Schema(description = "프로필 이미지", example = "https://example.com/profile.png", nullable = true)
     val profileImage: String?,
 )
 
-@Schema(description = "조회자(viewer) 정보 블록")
 data class ViewerInfo(
-    @Schema(
-        description = "viewer의 등록 상태 (RegistrationStatus 사용)",
-        example = "WAITLISTED",
-    )
     val status: ViewerStatus,
-    @Schema(
-        description = "viewer 이름 (비회원이면 null)",
-        example = "홍길동",
-        nullable = true,
-    )
     val name: String?,
-    @Schema(
-        description = "대기 순번 (WAITLISTED일 때만 숫자, 아니면 null)",
-        example = "3",
-        nullable = true,
-    )
     val waitlistPosition: Int?,
-    @Schema(
-        description = "registrationPublicId (게스트면 값, 아니면 null)",
-        example = "1",
-        nullable = true,
-    )
     val registrationPublicId: String?,
-    @Schema(
-        description = "예약 이메일(게스트면 guestEmail, 로그인 유저면 user email 등 정책에 따름)",
-        example = "skdfsj@gmaldkl",
-        nullable = true,
-    )
     val reservationEmail: String?,
 )
 
-@Schema(description = "가능한 동작 블록")
 data class CapabilitiesInfo(
-    @Schema(description = "공유 링크 가능 여부", example = "false")
     val shareLink: Boolean,
-    @Schema(description = "참여 신청 가능 여부(확정 자리 신청)", example = "false")
     val apply: Boolean,
-    @Schema(description = "대기 신청 가능 여부(정원 찼을 때)", example = "false")
     val wait: Boolean,
-    @Schema(description = "신청 취소 가능 여부", example = "true")
     val cancel: Boolean,
 )
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/response/GuestPreview.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/response/GuestPreview.kt
index 01781f48..2f3314a7 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/response/GuestPreview.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/response/GuestPreview.kt
@@ -1,21 +1,11 @@
 package com.wafflestudio.spring2025.domain.event.dto.response
 
-import io.swagger.v3.oas.annotations.media.Schema
-
 /**
  * 이벤트 참여자 미리보기 정보
  * (회원/비회원 포함)
  */
-@Schema(description = "참여자 미리보기 정보")
 data class GuestPreview(
-    @Schema(description = "참여자 ID (비회원이면 null)", example = "1", nullable = true)
     val id: Long?,
-    @Schema(description = "참여자 이름", example = "홍길동")
     val name: String,
-    @Schema(
-        description = "프로필 이미지 URL",
-        example = "https://example.com/profile.png",
-        nullable = true,
-    )
     val profileImage: String?,
 )
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/response/MyEventsInfiniteResponse.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/response/MyEventsInfiniteResponse.kt
index 26d15f6c..1cac6c53 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/response/MyEventsInfiniteResponse.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/response/MyEventsInfiniteResponse.kt
@@ -14,7 +14,8 @@ data class MyEventResponse(
     val startsAt: Instant?,
     val endsAt: Instant?,
     val registrationStartsAt: Instant?,
-    val registrationEndsAt: Instant?,
+    val registrationEndsAt: Instant,
     val capacity: Int?,
-    val totalApplicants: Int,
+    val confirmedCount: Int,
+    val waitlistCount: Int,
 )
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/response/MyRole.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/response/MyRole.kt
index d1a8b89a..c06024ed 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/response/MyRole.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/response/MyRole.kt
@@ -1,21 +1,15 @@
 package com.wafflestudio.spring2025.domain.event.dto.response
 
-import io.swagger.v3.oas.annotations.media.Schema
-
 /**
  * 요청자 역할
  * - CREATOR: 이벤트 생성자
  * - PARTICIPANT: 이벤트 참여자 (CONFIRMED / WAITLISTED)
  * - NONE: 로그인은 했지만 참여하지 않음
  */
-@Schema(description = "요청자 역할")
 enum class MyRole {
-    @Schema(description = "이벤트 생성자")
     CREATOR,
 
-    @Schema(description = "이벤트 참여자")
     PARTICIPANT,
 
-    @Schema(description = "이벤트 미참여자")
     NONE,
 }
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/response/UpdateEventResponse.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/response/UpdateEventResponse.kt
index cad30758..6b0a937d 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/response/UpdateEventResponse.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/response/UpdateEventResponse.kt
@@ -12,7 +12,7 @@ data class UpdateEventResponse(
     val capacity: Int?,
     val waitlistEnabled: Boolean,
     val registrationStartsAt: Instant?,
-    val registrationEndsAt: Instant?,
+    val registrationEndsAt: Instant,
 ) {
     companion object {
         fun from(event: Event): UpdateEventResponse =
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/response/ViewerStatus.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/response/ViewerStatus.kt
index a250a6db..d85fe72a 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/response/ViewerStatus.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/event/dto/response/ViewerStatus.kt
@@ -1,25 +1,17 @@
 package com.wafflestudio.spring2025.domain.event.dto.response
 
-import io.swagger.v3.oas.annotations.media.Schema
-
 /**
  * 이벤트 상세 조회 시,
  * "viewer(요청자)"가 해당 이벤트와 어떤 관계에 있는지를 나타내는 상태
  */
-@Schema(description = "이벤트 조회자(Viewer)의 상태")
 enum class ViewerStatus {
-    @Schema(description = "이벤트 생성자")
     HOST,
 
-    @Schema(description = "참여 확정된 사용자")
     CONFIRMED,
 
-    @Schema(description = "대기 중인 사용자")
     WAITLISTED,
 
-    @Schema(description = "강제 취소(차단)된 사용자")
     BANNED,
 
-    @Schema(description = "이벤트와 아무 관계 없는 사용자")
     NONE,
 }
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/event/exception/EventErrorCode.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/event/exception/EventErrorCode.kt
index a5a14793..9d77e7c4 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/event/exception/EventErrorCode.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/event/exception/EventErrorCode.kt
@@ -48,16 +48,6 @@ enum class EventErrorCode(
     ),
 
     // 모임 시간 검증
-    EVENT_STARTS_IN_PAST(
-        httpStatusCode = HttpStatus.BAD_REQUEST,
-        title = "모임 시작 시간이 유효하지 않습니다.",
-        message = "모임 시작 시간은\n현재 시간 이후여야 합니다.",
-    ),
-    EVENT_ENDS_IN_PAST(
-        httpStatusCode = HttpStatus.BAD_REQUEST,
-        title = "모임 종료 시간이 유효하지 않습니다.",
-        message = "모임 종료 시간은\n현재 시간 이후여야 합니다.",
-    ),
     EVENT_TIME_RANGE_INVALID(
         httpStatusCode = HttpStatus.BAD_REQUEST,
         title = "모임 시간이 유효하지 않습니다.",
@@ -65,11 +55,6 @@ enum class EventErrorCode(
     ),
 
     // 신청 기간 검증
-    REGISTRATION_STARTS_IN_PAST(
-        httpStatusCode = HttpStatus.BAD_REQUEST,
-        title = "신청 시작 시간이 유효하지 않습니다.",
-        message = "신청 시작 시간은\n현재 시간 이후여야 합니다.",
-    ),
     REGISTRATION_ENDS_IN_PAST(
         httpStatusCode = HttpStatus.BAD_REQUEST,
         title = "신청 마감 시간이 유효하지 않습니다.",
@@ -90,6 +75,11 @@ enum class EventErrorCode(
         title = "신청 기간이 유효하지 않습니다.",
         message = "신청 마감 시간이 모임 시작 시간보다\n빨라야 합니다.",
     ),
+    REGISTRATION_ENDS_AFTER_EVENT_END(
+        httpStatusCode = HttpStatus.BAD_REQUEST,
+        title = "신청 기간이 유효하지 않습니다.",
+        message = "신청 마감 시간이 모임 종료 시간보다\n빨라야 합니다.",
+    ),
 
     // 23xx - Conflict
     EVENT_FULL(
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/event/model/Event.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/event/model/Event.kt
index 683ef8b8..3f635d9d 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/event/model/Event.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/event/model/Event.kt
@@ -26,7 +26,7 @@ class Event(
     @Column("registration_starts_at")
     var registrationStartsAt: Instant? = null,
     @Column("registration_ends_at")
-    var registrationEndsAt: Instant? = null,
+    var registrationEndsAt: Instant,
     @Column("created_by")
     var createdBy: Long,
     @CreatedDate
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/event/repository/EventLockRepository.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/event/repository/EventLockRepository.kt
index 00c251ab..e9ff2f04 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/event/repository/EventLockRepository.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/event/repository/EventLockRepository.kt
@@ -7,11 +7,21 @@ import org.springframework.stereotype.Repository
 class EventLockRepository(
     private val jdbcTemplate: JdbcTemplate,
 ) {
-    fun lockById(eventId: Long) {
-        jdbcTemplate.queryForObject(
-            "SELECT id FROM events WHERE id = ? FOR UPDATE",
-            Long::class.java,
-            eventId,
-        )
+    fun lockIdByPublicId(publicId: String): Long? =
+        jdbcTemplate
+            .query(
+                "SELECT id FROM events WHERE public_id = ? FOR UPDATE",
+                { rs, _ -> rs.getLong("id") },
+                publicId,
+            ).firstOrNull()
+
+    fun lockById(eventId: Long): Boolean {
+        val result =
+            jdbcTemplate.query(
+                "SELECT id FROM events WHERE id = ? FOR UPDATE",
+                { rs, _ -> rs.getLong("id") },
+                eventId,
+            )
+        return result.isNotEmpty()
     }
 }
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/event/service/EventService.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/event/service/EventService.kt
index c76a6237..7d41b3e9 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/event/service/EventService.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/event/service/EventService.kt
@@ -1,5 +1,6 @@
 package com.wafflestudio.spring2025.domain.event.service
 
+import com.wafflestudio.spring2025.common.email.service.EmailService
 import com.wafflestudio.spring2025.common.image.service.ImageService
 import com.wafflestudio.spring2025.domain.event.dto.response.CapabilitiesInfo
 import com.wafflestudio.spring2025.domain.event.dto.response.CreatorInfo
@@ -15,22 +16,31 @@ import com.wafflestudio.spring2025.domain.event.exception.EventForbiddenExceptio
 import com.wafflestudio.spring2025.domain.event.exception.EventNotFoundException
 import com.wafflestudio.spring2025.domain.event.exception.EventValidationException
 import com.wafflestudio.spring2025.domain.event.model.Event
+import com.wafflestudio.spring2025.domain.event.repository.EventLockRepository
 import com.wafflestudio.spring2025.domain.event.repository.EventRepository
 import com.wafflestudio.spring2025.domain.registration.model.RegistrationStatus
 import com.wafflestudio.spring2025.domain.registration.repository.RegistrationRepository
+import com.wafflestudio.spring2025.domain.registration.service.WaitlistReconciliationService
 import com.wafflestudio.spring2025.domain.user.repository.UserRepository
 import org.springframework.data.domain.PageRequest
+import org.springframework.data.domain.Pageable
 import org.springframework.data.domain.Sort
 import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+import org.springframework.transaction.support.TransactionSynchronization
+import org.springframework.transaction.support.TransactionSynchronizationManager
 import java.time.Instant
 import java.util.UUID
 
 @Service
 class EventService(
     private val eventRepository: EventRepository,
+    private val eventLockRepository: EventLockRepository,
     private val registrationRepository: RegistrationRepository,
+    private val waitlistReconciliationService: WaitlistReconciliationService,
     private val userRepository: UserRepository,
     private val imageService: ImageService,
+    private val emailService: EmailService,
 ) {
     /**
      * 일정 생성
@@ -44,15 +54,18 @@ class EventService(
         capacity: Int?,
         waitlistEnabled: Boolean,
         registrationStartsAt: Instant?,
-        registrationEndsAt: Instant?,
+        registrationEndsAt: Instant,
         createdBy: Long,
     ): String {
-        validateCreateOrUpdate(
+        val actualRegistrationStartsAt = registrationStartsAt ?: Instant.now()
+
+        validateCreateConstraints(registrationEndsAt)
+        validateInvariantConstraints(
             title = title,
+            capacity = capacity,
             startsAt = startsAt,
             endsAt = endsAt,
-            capacity = capacity,
-            registrationStartsAt = registrationStartsAt,
+            registrationStartsAt = actualRegistrationStartsAt,
             registrationEndsAt = registrationEndsAt,
         )
 
@@ -66,7 +79,7 @@ class EventService(
                 endsAt = endsAt,
                 capacity = capacity,
                 waitlistEnabled = waitlistEnabled,
-                registrationStartsAt = registrationStartsAt,
+                registrationStartsAt = actualRegistrationStartsAt,
                 registrationEndsAt = registrationEndsAt,
                 createdBy = createdBy,
             )
@@ -84,10 +97,9 @@ class EventService(
         val event = getEventByPublicId(publicId)
         val eventId = requireNotNull(event.id) { "Event id is null: publicId=$publicId" }
 
-        val creatorUser =
-            userRepository.findById(event.createdBy).orElseThrow {
-                EventNotFoundException()
-            }
+        val userIdsToFetch = listOfNotNull(event.createdBy, requesterId).distinct()
+        val usersById = userRepository.findAllById(userIdsToFetch).associateBy { it.id!! }
+        val creatorUser = usersById[event.createdBy] ?: throw EventNotFoundException()
 
         val myReg =
             if (requesterId == null) {
@@ -109,17 +121,16 @@ class EventService(
                 .countByEventIdAndStatus(eventID = eventId, registrationStatus = RegistrationStatus.WAITLISTED)
                 .toInt()
 
-        val totalApplicants = confirmedCount + waitlistedCount
-
         val waitlistPosition: Int? =
             if (myReg?.status == RegistrationStatus.WAITLISTED) {
-                val waitlistedRegs =
-                    registrationRepository.findByEventIdAndStatusOrderByCreatedAtAsc(
-                        eventID = eventId,
-                        registrationStatus = RegistrationStatus.WAITLISTED,
-                    )
-                val idx = waitlistedRegs.indexOfFirst { it.id == myReg.id }
-                if (idx >= 0) idx + 1 else null
+                registrationRepository
+                    .findWaitlistPositionsByRegistrationPublicIds(
+                        eventId = eventId,
+                        status = RegistrationStatus.WAITLISTED,
+                        registrationPublicIds = listOf(myReg.registrationPublicId),
+                    ).firstOrNull()
+                    ?.waitlistNumber
+                    ?.toInt()
             } else {
                 null
             }
@@ -138,10 +149,7 @@ class EventService(
                     }
             }
 
-        val viewerName: String? =
-            requesterId?.let {
-                userRepository.findById(it).orElse(null)?.name
-            }
+        val viewerName: String? = requesterId?.let { usersById[it]?.name }
 
         val viewer =
             if (viewerStatus == ViewerStatus.NONE) {
@@ -172,18 +180,17 @@ class EventService(
                 registrationEndsAt = event.registrationEndsAt,
             )
 
-        val confirmedRegs =
+        val previewRegs =
             registrationRepository.findByEventIdAndStatusOrderByCreatedAtAsc(
                 eventID = eventId,
                 registrationStatus = RegistrationStatus.CONFIRMED,
+                pageable = Pageable.ofSize(5),
             )
 
-        val previewRegs = confirmedRegs.take(5)
-
         val previewUserIds =
             previewRegs.mapNotNull { it.userId }.distinct()
 
-        val usersById =
+        val previewUsersById =
             userRepository.findAllById(previewUserIds).associateBy { it.id!! }
 
         val guestsPreview =
@@ -196,7 +203,7 @@ class EventService(
                         profileImage = null,
                     )
                 } else {
-                    usersById[uid]?.let {
+                    previewUsersById[uid]?.let {
                         GuestPreview(
                             id = it.id!!,
                             name = it.name,
@@ -216,7 +223,8 @@ class EventService(
                     startsAt = event.startsAt,
                     endsAt = event.endsAt,
                     capacity = event.capacity,
-                    totalApplicants = totalApplicants,
+                    confirmedCount = confirmedCount,
+                    waitlistCount = waitlistedCount,
                     registrationStartsAt = event.registrationStartsAt,
                     registrationEndsAt = event.registrationEndsAt,
                 ),
@@ -263,19 +271,31 @@ class EventService(
         val sliced = fetched.take(pageSize)
         val nextCursor = sliced.lastOrNull()?.createdAt
 
+        val eventIds = sliced.map { requireNotNull(it.id) }
+
+        val confirmedCounts =
+            if (eventIds.isEmpty()) {
+                emptyMap()
+            } else {
+                registrationRepository
+                    .countByEventIdsAndStatuses(eventIds = eventIds, listOf(RegistrationStatus.CONFIRMED))
+                    .associate { it.eventId to it.totalCount.toInt() }
+            }
+
+        val waitlistedCounts =
+            if (eventIds.isEmpty()) {
+                emptyMap()
+            } else {
+                registrationRepository
+                    .countByEventIdsAndStatuses(eventIds = eventIds, listOf(RegistrationStatus.WAITLISTED))
+                    .associate { it.eventId to it.totalCount.toInt() }
+            }
+
         val responses =
             sliced.map { event ->
                 val eventId = requireNotNull(event.id)
-
-                val confirmedCount =
-                    registrationRepository
-                        .countByEventIdAndStatus(eventID = eventId, registrationStatus = RegistrationStatus.CONFIRMED)
-                        .toInt()
-
-                val waitlistedCount =
-                    registrationRepository
-                        .countByEventIdAndStatus(eventID = eventId, registrationStatus = RegistrationStatus.WAITLISTED)
-                        .toInt()
+                val confirmedCount = confirmedCounts[eventId] ?: 0
+                val waitlistedCount = waitlistedCounts[eventId] ?: 0
 
                 MyEventResponse(
                     publicId = event.publicId,
@@ -285,7 +305,8 @@ class EventService(
                     registrationStartsAt = event.registrationStartsAt,
                     registrationEndsAt = event.registrationEndsAt,
                     capacity = event.capacity,
-                    totalApplicants = confirmedCount + waitlistedCount,
+                    confirmedCount = confirmedCount,
+                    waitlistCount = waitlistedCount,
                 )
             }
 
@@ -296,6 +317,7 @@ class EventService(
         )
     }
 
+    @Transactional
     fun update(
         publicId: String,
         title: String?,
@@ -309,41 +331,96 @@ class EventService(
         registrationEndsAt: Instant?,
         requesterId: Long,
     ): Event {
-        val event = getEventByPublicId(publicId)
-        requireCreator(event, requesterId)
+        val eventForAuth = getEventByPublicId(publicId)
+        requireCreator(eventForAuth, requesterId)
+        val eventId = requireNotNull(eventForAuth.id) { "Event id is null: publicId=$publicId" }
+        if (!eventLockRepository.lockById(eventId)) throw EventNotFoundException()
+        val event = eventRepository.findById(eventId).orElseThrow { EventNotFoundException() }
+        val previousCapacity = event.capacity
+
+        val mergedTitle = title?.trim() ?: event.title
+        val mergedCapacity = capacity ?: event.capacity
+        val mergedStartsAt = startsAt ?: event.startsAt
+        val mergedEndsAt = endsAt ?: event.endsAt
+        val mergedRegistrationStartsAt = registrationStartsAt ?: event.registrationStartsAt
+        val mergedRegistrationEndsAt = registrationEndsAt ?: event.registrationEndsAt
+
+        validateInvariantConstraints(
+            title = mergedTitle,
+            capacity = mergedCapacity,
+            startsAt = mergedStartsAt,
+            endsAt = mergedEndsAt,
+            registrationStartsAt = mergedRegistrationStartsAt,
+            registrationEndsAt = mergedRegistrationEndsAt,
+        )
 
-        title?.let {
-            if (it.isBlank()) throw EventValidationException(EventErrorCode.EVENT_TITLE_BLANK)
-            event.title = it.trim()
-        }
+        event.title = mergedTitle
         description?.let { event.description = it }
         location?.let { event.location = it }
-        startsAt?.let { event.startsAt = it }
-        endsAt?.let { event.endsAt = it }
-        capacity?.let { event.capacity = it }
+        event.startsAt = mergedStartsAt
+        event.endsAt = mergedEndsAt
+        event.capacity = mergedCapacity
         waitlistEnabled?.let { event.waitlistEnabled = it }
-        registrationStartsAt?.let { event.registrationStartsAt = it }
-        registrationEndsAt?.let { event.registrationEndsAt = it }
-
-        validateCreateOrUpdate(
-            title = event.title,
-            startsAt = event.startsAt,
-            endsAt = event.endsAt,
-            capacity = event.capacity,
-            registrationStartsAt = event.registrationStartsAt,
-            registrationEndsAt = event.registrationEndsAt,
-        )
+        event.registrationStartsAt = mergedRegistrationStartsAt
+        event.registrationEndsAt = mergedRegistrationEndsAt
 
-        return eventRepository.save(event)
+        val savedEvent = eventRepository.save(event)
+        if (isCapacityIncreased(previousCapacity, savedEvent.capacity)) {
+            waitlistReconciliationService.reconcileWaitlist(eventId)
+        }
+        if (isCapacityDecreased(previousCapacity, savedEvent.capacity)) {
+            waitlistReconciliationService.demoteToWaitlist(eventId, savedEvent.capacity!!)
+        }
+        return savedEvent
     }
 
+    @Transactional
     fun delete(
         publicId: String,
         requesterId: Long,
     ) {
-        val event = getEventByPublicId(publicId)
+        val eventId = eventLockRepository.lockIdByPublicId(publicId) ?: throw EventNotFoundException()
+        val event = eventRepository.findById(eventId).orElseThrow { EventNotFoundException() }
         requireCreator(event, requesterId)
-        eventRepository.deleteById(requireNotNull(event.id))
+
+        // 알림 대상: CONFIRMED + WAITLISTED (BANNED 제외)
+        val registrationsToNotify =
+            registrationRepository.findByEventIdAndStatusIn(
+                eventID = eventId,
+                statuses = listOf(RegistrationStatus.CONFIRMED, RegistrationStatus.WAITLISTED),
+            )
+
+        // 이메일 데이터 구성 (삭제 전에 user 정보 조회)
+        val hostUser = userRepository.findById(event.createdBy).orElse(null)
+        val userIds = registrationsToNotify.mapNotNull { it.userId }.distinct()
+        val usersById = userRepository.findAllById(userIds).associateBy { it.id!! }
+
+        val emailDataList =
+            registrationsToNotify.mapNotNull { reg ->
+                val user = reg.userId?.let { usersById[it] }
+                val toEmail = user?.email ?: reg.guestEmail
+                if (toEmail.isNullOrBlank()) return@mapNotNull null
+                EmailService.EventCancellationEmailData(
+                    toEmail = toEmail,
+                    name = user?.name ?: reg.guestName ?: "참여자",
+                    eventTitle = event.title,
+                    startsAt = event.startsAt,
+                    endsAt = event.endsAt,
+                    location = event.location,
+                    description = event.description,
+                    hostEmail = hostUser?.email ?: "",
+                )
+            }
+
+        // FK 제약으로 인해 event 삭제 전 registrations 먼저 삭제
+        registrationRepository.deleteByEventId(eventId)
+        eventRepository.deleteById(eventId)
+
+        afterCommit {
+            emailDataList.forEach { data ->
+                emailService.sendEventCancellationEmail(data)
+            }
+        }
     }
 
     private fun getEventByPublicId(publicId: String): Event =
@@ -359,14 +436,22 @@ class EventService(
         }
     }
 
-    private fun validateCreateOrUpdate(
+    private fun validateCreateConstraints(
+        registrationEndsAt: Instant,
+        now: Instant = Instant.now(),
+    ) {
+        if (registrationEndsAt.isBefore(now)) {
+            throw EventValidationException(EventErrorCode.REGISTRATION_ENDS_IN_PAST)
+        }
+    }
+
+    private fun validateInvariantConstraints(
         title: String,
+        capacity: Int?,
         startsAt: Instant?,
         endsAt: Instant?,
-        capacity: Int?,
         registrationStartsAt: Instant?,
-        registrationEndsAt: Instant?,
-        now: Instant = Instant.now(),
+        registrationEndsAt: Instant,
     ) {
         // 제목 검증
         if (title.isBlank()) {
@@ -381,42 +466,51 @@ class EventService(
             throw EventValidationException(EventErrorCode.EVENT_CAPACITY_INVALID)
         }
 
-        // 모임 시간 검증
-        if (startsAt != null && startsAt.isBefore(now)) {
-            throw EventValidationException(EventErrorCode.EVENT_STARTS_IN_PAST)
-        }
-        if (endsAt != null && endsAt.isBefore(now)) {
-            throw EventValidationException(EventErrorCode.EVENT_ENDS_IN_PAST)
-        }
-        if (startsAt != null && endsAt != null && !startsAt.isBefore(endsAt)) {
+        // 모임 시간 검증: 일정 시작 ≤ 일정 끝
+        if (startsAt != null && endsAt != null && startsAt.isAfter(endsAt)) {
             throw EventValidationException(EventErrorCode.EVENT_TIME_RANGE_INVALID)
         }
 
-        // 신청 기간 검증
-        if (registrationStartsAt != null && registrationStartsAt.isBefore(now)) {
-            throw EventValidationException(EventErrorCode.REGISTRATION_STARTS_IN_PAST)
-        }
-        if (registrationEndsAt != null && registrationEndsAt.isBefore(now)) {
-            throw EventValidationException(EventErrorCode.REGISTRATION_ENDS_IN_PAST)
-        }
-        if (registrationStartsAt != null &&
-            registrationEndsAt != null &&
-            registrationStartsAt.isAfter(registrationEndsAt)
-        ) {
+        // 신청 기간 검증: 모집 시작 < 모집 마감 (strict)
+        if (registrationStartsAt != null && !registrationStartsAt.isBefore(registrationEndsAt)) {
             throw EventValidationException(EventErrorCode.REGISTRATION_TIME_RANGE_INVALID)
         }
-        if (registrationStartsAt != null &&
-            startsAt != null &&
-            registrationStartsAt.isAfter(startsAt)
-        ) {
+        // 모집 시작 ≤ 일정 시작
+        if (registrationStartsAt != null && startsAt != null && registrationStartsAt.isAfter(startsAt)) {
             throw EventValidationException(EventErrorCode.REGISTRATION_STARTS_AFTER_EVENT_START)
         }
-        if (registrationEndsAt != null &&
-            startsAt != null &&
-            registrationEndsAt.isAfter(startsAt)
-        ) {
+        // 모집 마감 ≤ 일정 시작
+        if (startsAt != null && registrationEndsAt.isAfter(startsAt)) {
             throw EventValidationException(EventErrorCode.REGISTRATION_ENDS_AFTER_EVENT_START)
         }
+        // 모집 마감 ≤ 일정 끝 (행사시작 없을 때도 직접 체크)
+        if (endsAt != null && registrationEndsAt.isAfter(endsAt)) {
+            throw EventValidationException(EventErrorCode.REGISTRATION_ENDS_AFTER_EVENT_END)
+        }
+    }
+
+    private fun isCapacityIncreased(
+        previousCapacity: Int?,
+        newCapacity: Int?,
+    ): Boolean = previousCapacity != null && newCapacity != null && newCapacity > previousCapacity
+
+    private fun isCapacityDecreased(
+        previousCapacity: Int?,
+        newCapacity: Int?,
+    ): Boolean = previousCapacity != null && newCapacity != null && newCapacity < previousCapacity
+
+    private fun afterCommit(action: () -> Unit) {
+        if (!TransactionSynchronizationManager.isActualTransactionActive()) {
+            action()
+            return
+        }
+        TransactionSynchronizationManager.registerSynchronization(
+            object : TransactionSynchronization {
+                override fun afterCommit() {
+                    action()
+                }
+            },
+        )
     }
 
     private fun buildCapabilities(
@@ -425,12 +519,12 @@ class EventService(
         confirmedCount: Int,
         waitlistEnabled: Boolean,
         registrationStartsAt: Instant?,
-        registrationEndsAt: Instant?,
+        registrationEndsAt: Instant,
         now: Instant = Instant.now(),
     ): CapabilitiesInfo {
         val withinWindow =
             (registrationStartsAt?.let { !now.isBefore(it) } ?: true) &&
-                (registrationEndsAt?.let { !now.isAfter(it) } ?: true)
+                !now.isAfter(registrationEndsAt)
 
         val isFull =
             capacity != null && confirmedCount >= capacity
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/controller/EventRegistrationController.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/controller/EventRegistrationController.kt
index 4fb815e9..213bc67d 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/controller/EventRegistrationController.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/controller/EventRegistrationController.kt
@@ -6,11 +6,6 @@ import com.wafflestudio.spring2025.domain.registration.dto.response.CreateRegist
 import com.wafflestudio.spring2025.domain.registration.dto.response.GetEventRegistrationsResponse
 import com.wafflestudio.spring2025.domain.registration.service.RegistrationService
 import com.wafflestudio.spring2025.domain.user.model.User
-import io.swagger.v3.oas.annotations.Operation
-import io.swagger.v3.oas.annotations.Parameter
-import io.swagger.v3.oas.annotations.responses.ApiResponse
-import io.swagger.v3.oas.annotations.responses.ApiResponses
-import io.swagger.v3.oas.annotations.tags.Tag
 import org.springframework.http.ResponseEntity
 import org.springframework.web.bind.annotation.GetMapping
 import org.springframework.web.bind.annotation.PathVariable
@@ -22,35 +17,9 @@ import org.springframework.web.bind.annotation.RestController
 
 @RestController
 @RequestMapping("/api/events/{eventId}/registrations")
-@Tag(name = "Registration", description = "이벤트 기준 신청 API")
 class EventRegistrationController(
     private val registrationService: RegistrationService,
 ) {
-    @Operation(
-        summary = "이벤트 참여 신청",
-        description =
-            "특정 이벤트에 신청합니다. 정원이 남아있으면 CONFIRMED로 등록되고, 정원이 찼으나 대기 명단이 허용된 경우 WAITLISTED로 등록됩니다. " +
-                "정원이 찼고 대기 명단이 비활성화된 경우 신청이 거절됩니다.",
-    )
-    @ApiResponses(
-        value = [
-            ApiResponse(responseCode = "200", description = "신청 성공"),
-            ApiResponse(
-                responseCode = "400",
-                description =
-                    "유효하지 않은 요청: 3003(Wrong guest name), 3004(Wrong guest email), 2204(Invalid registration window)",
-            ),
-            ApiResponse(
-                responseCode = "403",
-                description = "권한 없음: 3006(Banned user cannot register)",
-            ),
-            ApiResponse(responseCode = "404", description = "이벤트 없음: 2001(Event not found)"),
-            ApiResponse(
-                responseCode = "409",
-                description = "신청 불가: 3001(Registration already exists), 3005(Host cannot register), 2301(Event is full)",
-            ),
-        ],
-    )
     @PostMapping
     fun create(
         @PathVariable eventId: String,
@@ -67,17 +36,12 @@ class EventRegistrationController(
         return ResponseEntity.ok(registration)
     }
 
-    @Operation(
-        summary = "이벤트 신청 목록 조회",
-        description = "특정 이벤트에 속한 신청 목록을 조회합니다. 신청 상태(CONFIRMED/WAITLISTED/BANNED)와 신청 시각을 포함해 반환합니다.",
-    )
     @GetMapping
     fun list(
         @PathVariable eventId: String,
         @LoggedInUser user: User?,
         @RequestParam(required = false) status: String?,
         @RequestParam(required = false) orderBy: String?,
-        @Parameter(description = "다음 페이지 시작 offset (없으면 0부터)")
         @RequestParam(required = false) cursor: Int?,
     ): ResponseEntity<GetEventRegistrationsResponse> =
         ResponseEntity.ok(
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/controller/MyRegistrationController.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/controller/MyRegistrationController.kt
index 6da5b2c9..71022123 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/controller/MyRegistrationController.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/controller/MyRegistrationController.kt
@@ -5,9 +5,6 @@ import com.wafflestudio.spring2025.domain.auth.LoggedInUser
 import com.wafflestudio.spring2025.domain.registration.dto.response.GetMyRegistrationsResponse
 import com.wafflestudio.spring2025.domain.registration.service.RegistrationService
 import com.wafflestudio.spring2025.domain.user.model.User
-import io.swagger.v3.oas.annotations.Operation
-import io.swagger.v3.oas.annotations.Parameter
-import io.swagger.v3.oas.annotations.tags.Tag
 import org.springframework.http.ResponseEntity
 import org.springframework.web.bind.annotation.GetMapping
 import org.springframework.web.bind.annotation.RequestMapping
@@ -17,17 +14,12 @@ import org.springframework.web.bind.annotation.RestController
 @AuthRequired
 @RestController
 @RequestMapping("/api/registrations")
-@Tag(name = "Registration", description = "내 신청 조회 API")
 class MyRegistrationController(
     private val registrationService: RegistrationService,
 ) {
-    @Operation(
-        summary = "내 이벤트 신청 목록 조회",
-        description = "로그인한 사용자의 이벤트 신청 목록을 조회합니다. 최신 신청 순으로 반환되며 page/size로 페이징합니다.",
-    )
     @GetMapping("/me")
     fun myRegistrations(
-        @Parameter(hidden = true) @LoggedInUser user: User,
+        @LoggedInUser user: User,
         @RequestParam(defaultValue = "0") page: Int,
         @RequestParam(defaultValue = "20") size: Int,
     ): ResponseEntity<GetMyRegistrationsResponse> {
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/controller/RegistrationController.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/controller/RegistrationController.kt
index 2ffccbe6..28381a59 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/controller/RegistrationController.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/controller/RegistrationController.kt
@@ -1,7 +1,6 @@
 package com.wafflestudio.spring2025.domain.registration.controller
 
 import com.wafflestudio.spring2025.domain.auth.LoggedInUser
-import com.wafflestudio.spring2025.domain.registration.dto.request.DeleteRegistrationRequest
 import com.wafflestudio.spring2025.domain.registration.dto.request.UpdateRegistrationStatusRequest
 import com.wafflestudio.spring2025.domain.registration.dto.response.DeleteRegistrationResponse
 import com.wafflestudio.spring2025.domain.registration.dto.response.GetRegistrationResponse
@@ -10,8 +9,6 @@ import com.wafflestudio.spring2025.domain.registration.exception.RegistrationErr
 import com.wafflestudio.spring2025.domain.registration.exception.RegistrationValidationException
 import com.wafflestudio.spring2025.domain.registration.service.RegistrationService
 import com.wafflestudio.spring2025.domain.user.model.User
-import io.swagger.v3.oas.annotations.Operation
-import io.swagger.v3.oas.annotations.tags.Tag
 import org.springframework.http.ResponseEntity
 import org.springframework.web.bind.annotation.DeleteMapping
 import org.springframework.web.bind.annotation.GetMapping
@@ -23,16 +20,9 @@ import org.springframework.web.bind.annotation.RestController
 
 @RestController
 @RequestMapping("/api/registrations/{registrationId}")
-@Tag(name = "Registration", description = "신청 단건 리소스 API")
 class RegistrationController(
     private val registrationService: RegistrationService,
 ) {
-    @Operation(
-        summary = "신청 단건 상태 변경",
-        description =
-            "신청 단건 리소스의 상태를 변경합니다. " +
-                "사용자가 본인의 신청을 취소하는 경우와 관리자가 강제 취소/밴 처리하는 경우를 로직 레벨에서 구분합니다.",
-    )
     @PatchMapping
     fun updateStatus(
         @PathVariable registrationId: String,
@@ -45,11 +35,6 @@ class RegistrationController(
         return ResponseEntity.ok(response)
     }
 
-    @Operation(
-        summary = "신청 단건 정보 요청",
-        description =
-            "신청 단건의 정보를 반환합니다.",
-    )
     @GetMapping
     fun getRegistrationInformation(
         @PathVariable registrationId: String,
@@ -62,15 +47,12 @@ class RegistrationController(
     @DeleteMapping
     fun delete(
         @PathVariable registrationId: String,
-        @RequestBody request: DeleteRegistrationRequest,
         @LoggedInUser user: User?,
     ): ResponseEntity<DeleteRegistrationResponse> {
         val response =
             registrationService.delete(
                 registrationPublicId = registrationId,
                 userId = user?.id,
-                guestName = request.guestName,
-                guestEmail = request.guestEmail,
             )
 
         return ResponseEntity.ok(response)
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/core/RegistrationDto.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/core/RegistrationDto.kt
index e6764f91..33f1410e 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/core/RegistrationDto.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/core/RegistrationDto.kt
@@ -2,23 +2,14 @@ package com.wafflestudio.spring2025.domain.registration.dto.core
 
 import com.wafflestudio.spring2025.domain.registration.model.Registration
 import com.wafflestudio.spring2025.domain.registration.model.RegistrationStatus
-import io.swagger.v3.oas.annotations.media.Schema
 
-@Schema(description = "이벤트 신청 정보")
 data class RegistrationDto(
-    @Schema(description = "신청 공개 ID")
     val registrationPublicId: String,
-    @Schema(description = "사용자 ID")
     val userId: Long?,
-    @Schema(description = "이벤트 ID")
     val eventId: Long,
-    @Schema(description = "비회원 이름")
     val guestName: String?,
-    @Schema(description = "비회원 이메일")
     val guestEmail: String?,
-    @Schema(description = "신청 상태")
     val status: RegistrationStatus,
-    @Schema(description = "신청 일시 (epoch milliseconds)")
     val createdAt: Long,
 ) {
     constructor(registration: Registration) : this(
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/core/RegistrationWithEventDto.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/core/RegistrationWithEventDto.kt
index 5255eb9e..70c08a66 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/core/RegistrationWithEventDto.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/core/RegistrationWithEventDto.kt
@@ -2,13 +2,9 @@ package com.wafflestudio.spring2025.domain.registration.dto.core
 
 import com.wafflestudio.spring2025.domain.event.model.Event
 import com.wafflestudio.spring2025.domain.registration.model.Registration
-import io.swagger.v3.oas.annotations.media.Schema
 
-@Schema(description = "내 이벤트 신청 정보")
 data class RegistrationWithEventDto(
-    @Schema(description = "신청 정보")
     val registration: RegistrationDto,
-    @Schema(description = "이벤트 요약 정보")
     val event: EventSummaryDto,
 ) {
     constructor(registration: Registration, event: Event) : this(
@@ -17,17 +13,11 @@ data class RegistrationWithEventDto(
     )
 }
 
-@Schema(description = "이벤트 요약 정보")
 data class EventSummaryDto(
-    @Schema(description = "이벤트 ID")
     val id: Long,
-    @Schema(description = "이벤트 제목")
     val title: String,
-    @Schema(description = "장소")
     val location: String?,
-    @Schema(description = "시작 시간 (epoch milliseconds)")
     val startsAt: Long?,
-    @Schema(description = "종료 시간 (epoch milliseconds)")
     val endsAt: Long?,
 ) {
     constructor(event: Event) : this(
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/request/CreateRegistrationRequest.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/request/CreateRegistrationRequest.kt
index baf7052f..820bd1e5 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/request/CreateRegistrationRequest.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/request/CreateRegistrationRequest.kt
@@ -1,14 +1,10 @@
 package com.wafflestudio.spring2025.domain.registration.dto.request
 
 import com.fasterxml.jackson.annotation.JsonAlias
-import io.swagger.v3.oas.annotations.media.Schema
 
-@Schema(description = "이벤트 신청 요청")
 data class CreateRegistrationRequest(
-    @Schema(description = "비회원 이름")
     @JsonAlias("guest_name")
     val guestName: String? = null,
-    @Schema(description = "비회원 이메일")
     @JsonAlias("guest_email")
     val guestEmail: String? = null,
 )
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/request/DeleteRegistrationRequest.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/request/DeleteRegistrationRequest.kt
deleted file mode 100644
index 3f34c5f8..00000000
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/request/DeleteRegistrationRequest.kt
+++ /dev/null
@@ -1,11 +0,0 @@
-package com.wafflestudio.spring2025.domain.registration.dto.request
-
-import io.swagger.v3.oas.annotations.media.Schema
-
-@Schema(description = "이벤트 취소 요청")
-data class DeleteRegistrationRequest(
-    @Schema(description = "비회원 이름")
-    val guestName: String? = null,
-    @Schema(description = "비회원 이메일")
-    val guestEmail: String? = null,
-)
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/request/UpdateRegistrationStatusRequest.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/request/UpdateRegistrationStatusRequest.kt
index f87d15fb..2182cddc 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/request/UpdateRegistrationStatusRequest.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/request/UpdateRegistrationStatusRequest.kt
@@ -1,9 +1,7 @@
 package com.wafflestudio.spring2025.domain.registration.dto.request
 
 import com.wafflestudio.spring2025.domain.registration.model.RegistrationStatus
-import io.swagger.v3.oas.annotations.media.Schema
 
-@Schema(description = "이벤트 신청 상태 변경 요청")
 data class UpdateRegistrationStatusRequest(
     val status: RegistrationStatus? = null,
 )
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/response/CreateRegistrationResponse.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/response/CreateRegistrationResponse.kt
index eb4ea566..3abe25e8 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/response/CreateRegistrationResponse.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/response/CreateRegistrationResponse.kt
@@ -1,9 +1,5 @@
 package com.wafflestudio.spring2025.domain.registration.dto.response
 
-import io.swagger.v3.oas.annotations.media.Schema
-
-@Schema(description = "이벤트 신청 응답")
 data class CreateRegistrationResponse(
-    @Schema(description = "신청 id")
     val registrationPublicId: String,
 )
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/response/GetEventRegistrationsResponse.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/response/GetEventRegistrationsResponse.kt
index 39a7951b..c5837bd2 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/response/GetEventRegistrationsResponse.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/response/GetEventRegistrationsResponse.kt
@@ -3,36 +3,22 @@ package com.wafflestudio.spring2025.domain.registration.dto.response
 import com.wafflestudio.spring2025.domain.registration.model.Registration
 import com.wafflestudio.spring2025.domain.registration.model.RegistrationStatus
 import com.wafflestudio.spring2025.domain.user.model.User
-import io.swagger.v3.oas.annotations.media.Schema
 import java.time.Instant
 
-@Schema(description = "이벤트 신청 목록 조회 응답")
 data class GetEventRegistrationsResponse(
-    @Schema(description = "신청자 목록")
     val participants: List<EventRegistrationItem>,
-    @Schema(description = "필터에 따라 변하는 참여자 수")
     val totalCount: Int?,
-    @Schema(description = "다음 페이지 시작 offset (없으면 null)")
     val nextCursor: Int?,
-    @Schema(description = "다음 페이지 존재 여부")
     val hasNext: Boolean,
 )
 
-@Schema(description = "신청자 정보")
 data class EventRegistrationItem(
-    @Schema(description = "신청 공개 ID")
     val registrationId: String,
-    @Schema(description = "이름")
     val name: String,
-    @Schema(description = "이메일 (관리자 요청 시 노출)")
     val email: String?,
-    @Schema(description = "프로필 이미지 URL")
     val profileImage: String?,
-    @Schema(description = "신청 일시")
     val createdAt: Instant,
-    @Schema(description = "신청 상태")
     val status: RegistrationStatus,
-    @Schema(description = "대기 순번 (status가 WAITLISTED일 때만 아니면 null)")
     val waitingNum: Int?,
 ) {
     constructor(
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/response/GetMyRegistrationsResponse.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/response/GetMyRegistrationsResponse.kt
index 74c36966..0aca3e06 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/response/GetMyRegistrationsResponse.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/response/GetMyRegistrationsResponse.kt
@@ -3,42 +3,30 @@ package com.wafflestudio.spring2025.domain.registration.dto.response
 import com.wafflestudio.spring2025.domain.event.model.Event
 import com.wafflestudio.spring2025.domain.registration.model.Registration
 import com.wafflestudio.spring2025.domain.registration.model.RegistrationStatus
-import io.swagger.v3.oas.annotations.media.Schema
 import java.time.Instant
 
-@Schema(description = "내 이벤트 신청 목록 응답")
 data class GetMyRegistrationsResponse(
-    @Schema(description = "신청 목록")
     val registrations: List<MyRegistrationItem>,
 )
 
-@Schema(description = "내 이벤트 신청 요약")
 data class MyRegistrationItem(
-    @Schema(description = "이벤트 공개 ID")
     val publicId: String,
-    @Schema(description = "이벤트 제목")
     val title: String,
-    @Schema(description = "이벤트 시작 시간 (ISO-8601)")
     val startsAt: Instant?,
-    @Schema(description = "이벤트 종료 시간 (ISO-8601)")
     val endsAt: Instant?,
-    @Schema(description = "신청 시작 시간 (ISO-8601)")
     val registrationStartsAt: Instant?,
-    @Schema(description = "신청 마감 시간 (ISO-8601)")
     val registrationEndsAt: Instant?,
-    @Schema(description = "정원")
     val capacity: Int?,
-    @Schema(description = "현재 신청 수 + 대기 수")
-    val registrationCnt: Int,
-    @Schema(description = "신청 상태")
+    val confirmedCount: Int,
+    val waitlistCount: Int,
     val status: MyRegistrationStatus,
-    @Schema(description = "대기 순번 (WAITLISTED가 아니면 null)")
     val waitlistedNum: Int?,
 ) {
     constructor(
         registration: Registration,
         event: Event,
-        registrationCnt: Int,
+        confirmedCount: Int,
+        waitlistCount: Int,
         waitlistedNum: Int?,
     ) : this(
         publicId = event.publicId,
@@ -48,7 +36,8 @@ data class MyRegistrationItem(
         registrationStartsAt = event.registrationStartsAt,
         registrationEndsAt = event.registrationEndsAt,
         capacity = event.capacity,
-        registrationCnt = registrationCnt,
+        confirmedCount = confirmedCount,
+        waitlistCount = waitlistCount,
         status = MyRegistrationStatus.from(registration.status),
         waitlistedNum = waitlistedNum,
     )
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/response/GetRegistrationResponse.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/response/GetRegistrationResponse.kt
index e03dd30c..d241cd32 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/response/GetRegistrationResponse.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/response/GetRegistrationResponse.kt
@@ -1,9 +1,7 @@
 package com.wafflestudio.spring2025.domain.registration.dto.response
 
 import com.wafflestudio.spring2025.domain.registration.model.RegistrationStatus
-import io.swagger.v3.oas.annotations.media.Schema
 
-@Schema(description = "이벤트 신청 정보 요청 응답")
 data class GetRegistrationResponse(
     val status: RegistrationStatus,
     val guestName: String,
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/response/PatchRegistrationResponse.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/response/PatchRegistrationResponse.kt
index 5f8f534a..e328c6db 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/response/PatchRegistrationResponse.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/response/PatchRegistrationResponse.kt
@@ -1,8 +1,5 @@
 package com.wafflestudio.spring2025.domain.registration.dto.response
 
-import io.swagger.v3.oas.annotations.media.Schema
-
-@Schema(description = "이벤트 신청 상태 변경")
 data class PatchRegistrationResponse(
     val patchEmail: String? = null,
 )
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/response/RegistrationGuestsResponse.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/response/RegistrationGuestsResponse.kt
index 5d0d0855..fe52c458 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/response/RegistrationGuestsResponse.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/dto/response/RegistrationGuestsResponse.kt
@@ -1,29 +1,19 @@
 package com.wafflestudio.spring2025.domain.registration.dto.response
 
 import com.fasterxml.jackson.annotation.JsonProperty
-import io.swagger.v3.oas.annotations.media.Schema
 
-@Schema(description = "이벤트 참여자 명단 응답")
 data class RegistrationGuestsResponse(
-    @Schema(description = "확정 참여자 목록")
     val guests: List<Guest>,
     @JsonProperty("confirmed_count")
-    @Schema(description = "확정 참여자 수")
     val confirmedCount: Int,
     @JsonProperty("waiting_count")
-    @Schema(description = "대기 참여자 수")
     val waitingCount: Int,
 ) {
-    @Schema(description = "참여자 정보")
     data class Guest(
-        @Schema(description = "신청 공개 ID")
         val registrationPublicId: String,
-        @Schema(description = "이름")
         val name: String,
-        @Schema(description = "이메일 (관리자 요청 시 노출)")
         val email: String?,
         @JsonProperty("profile_image")
-        @Schema(description = "프로필 이미지 URL")
         val profileImage: String?,
     )
 }
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/exception/RegistrationErrorCode.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/exception/RegistrationErrorCode.kt
index cd978b1e..7f7d9d7a 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/exception/RegistrationErrorCode.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/exception/RegistrationErrorCode.kt
@@ -74,8 +74,8 @@ enum class RegistrationErrorCode(
 
     REGISTRATION_BLOCKED_BANNED(
         httpStatusCode = HttpStatus.FORBIDDEN,
-        title = "차단된 신청입니다.",
-        message = "차단된 신청은\n다시 신청할 수 없습니다.",
+        title = "차단된 사용자입니다.",
+        message = "해당 모임의 주최자에 의해\n차단되어 신청할 수 없습니다.",
     ),
 
     NOT_WITHIN_REGISTRATION_WINDOW(
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/repository/RegistrationRepository.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/repository/RegistrationRepository.kt
index 81ceeddf..5d6ddac1 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/repository/RegistrationRepository.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/repository/RegistrationRepository.kt
@@ -12,6 +12,8 @@ interface RegistrationRepository :
     PagingAndSortingRepository<Registration, Long> {
     fun findByEventId(eventId: Long): List<Registration>
 
+    fun deleteByEventId(eventId: Long)
+
     fun findByRegistrationPublicId(registrationPublicId: String): Registration?
 
     @Query(
@@ -39,6 +41,11 @@ interface RegistrationRepository :
         eventId: Long,
     ): Registration?
 
+    fun findByEventIdAndStatusIn(
+        eventID: Long,
+        statuses: Collection<RegistrationStatus>,
+    ): List<Registration>
+
     fun countByEventId(eventID: Long): Long
 
     fun countByEventIdAndStatus(
@@ -46,14 +53,45 @@ interface RegistrationRepository :
         registrationStatus: RegistrationStatus,
     ): Long
 
+    @Query(
+        """
+        SELECT COUNT(*)
+        FROM registrations
+        WHERE event_id = :eventId AND status = :status
+        FOR SHARE
+        """,
+    )
+    fun countByEventIdAndStatusWithLock(
+        eventId: Long,
+        status: RegistrationStatus,
+    ): Long
+
     fun findByEventIdAndStatusOrderByCreatedAtAsc(
         eventID: Long,
         registrationStatus: RegistrationStatus,
     ): List<Registration>
 
+    fun findByEventIdAndStatusOrderByCreatedAtAsc(
+        eventID: Long,
+        registrationStatus: RegistrationStatus,
+        pageable: Pageable,
+    ): List<Registration>
+
+    @Query(
+        """
+        SELECT * FROM registrations
+        WHERE event_id = :eventId AND status = :status
+        ORDER BY created_at DESC, id DESC
+        """,
+    )
+    fun findByEventIdAndStatusOrderByCreatedAtDescIdDesc(
+        eventId: Long,
+        status: RegistrationStatus,
+    ): List<Registration>
+
     @Query(
         """
-        SELECT event_id AS eventId, COUNT(*) AS totalCount
+        SELECT event_id, COUNT(*) AS total_count
         FROM registrations
         WHERE event_id IN (:eventIds) AND status IN (:statuses)
         GROUP BY event_id
@@ -66,9 +104,9 @@ interface RegistrationRepository :
 
     @Query(
         """
-        SELECT registration_public_id AS registrationPublicId,
-               event_id AS eventId,
-               ROW_NUMBER() OVER (PARTITION BY event_id ORDER BY created_at ASC, id ASC) AS waitlistNumber
+        SELECT registration_public_id,
+               event_id,
+               ROW_NUMBER() OVER (PARTITION BY event_id ORDER BY created_at ASC, id ASC) AS waitlist_number
         FROM registrations
         WHERE event_id IN (:eventIds) AND status = :status
         """,
@@ -83,7 +121,7 @@ interface RegistrationRepository :
         SELECT r.*
         FROM registrations r
         WHERE r.event_id = :eventId
-        ORDER BY r.created_at DESC, r.registration_public_id DESC
+        ORDER BY r.created_at ASC, r.registration_public_id ASC
         LIMIT :limit OFFSET :offset
         """,
     )
@@ -98,7 +136,7 @@ interface RegistrationRepository :
         SELECT r.*
         FROM registrations r
         WHERE r.event_id = :eventId AND r.status = :status
-        ORDER BY r.created_at DESC, r.registration_public_id DESC
+        ORDER BY r.created_at ASC, r.registration_public_id ASC
         LIMIT :limit OFFSET :offset
         """,
     )
@@ -148,7 +186,7 @@ interface RegistrationRepository :
                ranked.waitlist_number AS waitlist_number
         FROM (
             SELECT r.registration_public_id,
-                   ROW_NUMBER() OVER (ORDER BY r.created_at ASC, r.registration_public_id ASC) AS waitlist_number
+                   ROW_NUMBER() OVER (ORDER BY r.created_at ASC, r.id ASC) AS waitlist_number
             FROM registrations r
             WHERE r.event_id = :eventId AND r.status = :status
         ) ranked
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/service/RegistrationService.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/service/RegistrationService.kt
index eb02c22d..6aff4dd7 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/service/RegistrationService.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/service/RegistrationService.kt
@@ -28,6 +28,7 @@ import com.wafflestudio.spring2025.domain.user.model.User
 import com.wafflestudio.spring2025.domain.user.repository.UserRepository
 import org.springframework.dao.DuplicateKeyException
 import org.springframework.data.domain.PageRequest
+import org.springframework.data.domain.Pageable
 import org.springframework.stereotype.Service
 import org.springframework.transaction.annotation.Transactional
 import org.springframework.transaction.support.TransactionSynchronization
@@ -47,7 +48,7 @@ RegistrationService(
     private val userRepository: UserRepository,
     private val emailService: EmailService,
     private val imageService: ImageService,
-) {
+) : WaitlistReconciliationService {
     private val emailRegex = Regex("^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+$")
     private val tokenValidity = Duration.ofHours(24)
 
@@ -71,7 +72,7 @@ RegistrationService(
         val capacity = lockedEvent.capacity ?: throw IllegalStateException("이벤트의 capacity가 설정되어 있지 않습니다.")
         val currentConfirmed =
             registrationRepository
-                .countByEventIdAndStatus(eventPk, RegistrationStatus.CONFIRMED)
+                .countByEventIdAndStatusWithLock(eventPk, RegistrationStatus.CONFIRMED)
                 .toInt()
 
         val status =
@@ -96,6 +97,11 @@ RegistrationService(
                 registrationRepository.findByUserIdAndEventId(userId, eventPk)
             }
 
+        val userIdsToFetch = listOfNotNull(lockedEvent.createdBy, userId).distinct()
+        val fetchedUsersById = userRepository.findAllById(userIdsToFetch).associateBy { it.id!! }
+        val hostEmail = fetchedUsersById[lockedEvent.createdBy]?.email
+        val user = userId?.let { fetchedUsersById[it] }
+
         val saved =
             try {
                 if (existingRegistration != null) {
@@ -112,8 +118,7 @@ RegistrationService(
                         -> throw RegistrationConflictException(RegistrationErrorCode.REGISTRATION_ALREADY_EXISTS)
                     }
                 } else {
-                    val hostEmail = userRepository.findById(lockedEvent.createdBy).orElse(null)?.email
-                    val registrationEmail = userId?.let { userRepository.findById(it).orElse(null)?.email } ?: guestEmail
+                    val registrationEmail = user?.email ?: guestEmail
 
                     if (hostEmail != null && hostEmail == registrationEmail) {
                         throw RegistrationValidationException(RegistrationErrorCode.REGISTRATION_BLOCKED_HOST)
@@ -143,19 +148,11 @@ RegistrationService(
                 throw RegistrationConflictException(RegistrationErrorCode.REGISTRATION_ALREADY_EXISTS)
             }
 
-        val waitlistedNumber: Int? =
-            if (saved.status == RegistrationStatus.WAITLISTED) {
-                registrationRepository
-                    .countByEventIdAndStatus(eventPk, RegistrationStatus.WAITLISTED)
-                    .toInt()
-            } else {
-                null
-            }
-
-        val user =
-            userId?.let { id ->
-                userRepository.findById(id).orElse(null)
-            }
+        val waitlistedCount =
+            registrationRepository
+                .countByEventIdAndStatus(eventPk, RegistrationStatus.WAITLISTED)
+                .toInt()
+        val waitlistedNumber: Int? = if (saved.status == RegistrationStatus.WAITLISTED) waitlistedCount else null
 
         val recipientEmail = user?.email ?: guestEmail
 
@@ -164,10 +161,6 @@ RegistrationService(
                 registrationRepository
                     .countByEventIdAndStatus(eventPk, RegistrationStatus.CONFIRMED)
                     .toInt()
-            val waitlistedCount =
-                registrationRepository
-                    .countByEventIdAndStatus(eventPk, RegistrationStatus.WAITLISTED)
-                    .toInt()
             val totalCount = confirmedCount + waitlistedCount
 
             val emailData =
@@ -205,22 +198,9 @@ RegistrationService(
     fun delete(
         registrationPublicId: String,
         userId: Long?,
-        guestName: String?,
-        guestEmail: String?,
     ): DeleteRegistrationResponse {
-        if (userId == null) {
-            if (guestName.isNullOrBlank()) {
-                throw RegistrationValidationException(RegistrationErrorCode.REGISTRATION_WRONG_NAME)
-            }
-            if (guestEmail.isNullOrBlank()) {
-                throw RegistrationValidationException(RegistrationErrorCode.REGISTRATION_WRONG_EMAIL)
-            }
-        }
-
         deleteInternal(
             userId = userId,
-            guestName = guestName,
-            guestEmail = guestEmail,
             registrationPublicId = registrationPublicId,
         )
         return DeleteRegistrationResponse()
@@ -228,28 +208,31 @@ RegistrationService(
 
     private fun deleteInternal(
         userId: Long?,
-        guestName: String?,
-        guestEmail: String?,
         registrationPublicId: String,
     ) {
-        val registration =
+        // eventId를 얻기 위한 미리보기 조회 (락 없음)
+        val preview =
             registrationRepository.findByRegistrationPublicId(registrationPublicId)
                 ?: throw RegistrationNotFoundException()
 
+        // 이벤트 업데이트와 경합 시 취소 가능 시점 판정을 일관되게 하기 위해 선락
+        eventLockRepository.lockById(preview.eventId)
         val event =
-            eventRepository.findById(registration.eventId).orElseThrow { EventNotFoundException() }
+            eventRepository.findById(preview.eventId).orElseThrow { EventNotFoundException() }
+
+        // 이벤트 락 획득 후 registration 행 락
+        val registration =
+            registrationRepository.lockByRegistrationPublicId(registrationPublicId)
+                ?: throw RegistrationNotFoundException()
 
-        if (userId != null) {
+        if (registration.userId != null) {
             if (registration.userId != userId) {
                 throw RegistrationForbiddenException(RegistrationErrorCode.REGISTRATION_DELETE_UNAUTHORIZED)
             }
-        } else {
-            if (registration.userId != null ||
-                registration.guestName != guestName ||
-                registration.guestEmail != guestEmail
-            ) {
-                throw RegistrationForbiddenException(RegistrationErrorCode.REGISTRATION_DELETE_UNAUTHORIZED)
-            }
+        }
+
+        if (!isRegistrationEnabled(event)) {
+            throw RegistrationValidationException(RegistrationErrorCode.NOT_WITHIN_REGISTRATION_WINDOW)
         }
 
         val wasConfirmed = registration.status == RegistrationStatus.CONFIRMED
@@ -290,6 +273,7 @@ RegistrationService(
                     registrationStartsAt = event.registrationStartsAt,
                     registrationEndsAt = event.registrationEndsAt,
                     description = event.description,
+                    publicId = event.publicId,
                 )
 
             afterCommit {
@@ -323,11 +307,18 @@ RegistrationService(
                 event.id ?: throw EventNotFoundException()
             }
 
-        val countsByEventId =
+        val confirmedCountsByEventId =
+            registrationRepository
+                .countByEventIdsAndStatuses(
+                    eventIds = eventIds,
+                    statuses = listOf(RegistrationStatus.CONFIRMED),
+                ).associate { it.eventId to it.totalCount.toInt() }
+
+        val waitlistCountsByEventId =
             registrationRepository
                 .countByEventIdsAndStatuses(
                     eventIds = eventIds,
-                    statuses = listOf(RegistrationStatus.CONFIRMED, RegistrationStatus.WAITLISTED),
+                    statuses = listOf(RegistrationStatus.WAITLISTED),
                 ).associate { it.eventId to it.totalCount.toInt() }
 
         val waitlistedByRegistrationId =
@@ -348,7 +339,8 @@ RegistrationService(
                 MyRegistrationItem(
                     registration = registration,
                     event = event,
-                    registrationCnt = countsByEventId[registration.eventId] ?: 0,
+                    confirmedCount = confirmedCountsByEventId[registration.eventId] ?: 0,
+                    waitlistCount = waitlistCountsByEventId[registration.eventId] ?: 0,
                     waitlistedNum = waitlistedNumber,
                 )
             }
@@ -374,12 +366,8 @@ RegistrationService(
             registrationRepository.lockByRegistrationPublicId(registrationId)
                 ?: throw RegistrationNotFoundException()
 
-        if (!isRegistrationEnabled(event)) {
-            throw RegistrationValidationException(RegistrationErrorCode.NOT_WITHIN_REGISTRATION_WINDOW)
-        }
-
         val isHost = userId != null && userId == event.createdBy
-        val isRegistrant = userId != null && registration.userId == userId
+//        val isRegistrant = userId != null && registration.userId == userId
 
         if (status == RegistrationStatus.BANNED && !isHost) {
             throw RegistrationForbiddenException(RegistrationErrorCode.REGISTRATION_PATCH_UNAUTHORIZED)
@@ -567,13 +555,14 @@ RegistrationService(
         val status = registration.status
         val waitlistPosition =
             if (status == RegistrationStatus.WAITLISTED) {
-                val waitlistedRegs =
-                    registrationRepository.findByEventIdAndStatusOrderByCreatedAtAsc(
-                        registration.eventId,
-                        RegistrationStatus.WAITLISTED,
-                    )
-                val idx = waitlistedRegs.indexOfFirst { it.id == registration.id }
-                if (idx >= 0) idx + 1 else 0
+                registrationRepository
+                    .findWaitlistPositionsByRegistrationPublicIds(
+                        eventId = registration.eventId,
+                        status = RegistrationStatus.WAITLISTED,
+                        registrationPublicIds = listOf(registration.registrationPublicId),
+                    ).firstOrNull()
+                    ?.waitlistNumber
+                    ?.toInt() ?: 0
             } else {
                 0
             }
@@ -604,14 +593,9 @@ RegistrationService(
     }
 
     private fun isRegistrationEnabled(event: Event): Boolean {
-        val registrationStartsAt = event.registrationStartsAt
-        val registrationEndsAt = event.registrationEndsAt
         val now = Instant.now()
-
-        // null 정책: 시작/끝이 null이면 제한 없는 것으로 취급
-        val afterStart = registrationStartsAt?.let { !now.isBefore(it) } ?: true
-        val beforeEnd = registrationEndsAt?.let { !now.isAfter(it) } ?: true
-
+        val afterStart = event.registrationStartsAt?.let { !now.isBefore(it) } ?: true
+        val beforeEnd = !now.isAfter(event.registrationEndsAt)
         return afterStart && beforeEnd
     }
 
@@ -669,7 +653,72 @@ RegistrationService(
     }
 
     @Transactional
-    fun reconcileWaitlist(eventId: Long) {
+    override fun demoteToWaitlist(
+        eventId: Long,
+        newCapacity: Int,
+    ) {
+        eventLockRepository.lockById(eventId)
+
+        val event = eventRepository.findById(eventId).orElseThrow { EventNotFoundException() }
+
+        val confirmedRegs =
+            registrationRepository.findByEventIdAndStatusOrderByCreatedAtDescIdDesc(
+                eventId,
+                RegistrationStatus.CONFIRMED,
+            )
+
+        val excessCount = confirmedRegs.size - newCapacity
+        if (excessCount <= 0) return
+
+        val toDemote = confirmedRegs.take(excessCount)
+        toDemote.forEach { it.status = RegistrationStatus.WAITLISTED }
+        registrationRepository.saveAll(toDemote)
+
+        val waitlistedCount = registrationRepository.countByEventIdAndStatus(eventId, RegistrationStatus.WAITLISTED).toInt()
+        val totalCount = newCapacity + waitlistedCount
+
+        val demotedPublicIds = toDemote.map { it.registrationPublicId }
+        val waitlistPositions =
+            registrationRepository
+                .findWaitlistPositionsByRegistrationPublicIds(
+                    eventId = eventId,
+                    status = RegistrationStatus.WAITLISTED,
+                    registrationPublicIds = demotedPublicIds,
+                ).associate { it.registrationPublicId to it.waitlistNumber.toInt() }
+
+        val userIds = toDemote.mapNotNull { it.userId }.distinct()
+        val usersById = userRepository.findAllById(userIds).associateBy { it.id!! }
+
+        val emailDataList =
+            toDemote.mapNotNull { reg ->
+                val user = reg.userId?.let { usersById[it] }
+                val toEmail = user?.email ?: reg.guestEmail
+                if (toEmail.isNullOrBlank()) return@mapNotNull null
+                EmailService.DemotionEmailData(
+                    toEmail = toEmail,
+                    name = user?.name ?: reg.guestName ?: "참여자",
+                    eventTitle = event.title,
+                    startsAt = event.startsAt,
+                    endsAt = event.endsAt,
+                    location = event.location,
+                    newCapacity = newCapacity,
+                    totalCount = totalCount,
+                    registrationStartsAt = event.registrationStartsAt,
+                    registrationEndsAt = event.registrationEndsAt,
+                    description = event.description,
+                    publicId = event.publicId,
+                    registrationPublicId = reg.registrationPublicId,
+                    waitingNum = waitlistPositions[reg.registrationPublicId],
+                )
+            }
+
+        afterCommit {
+            emailDataList.forEach { emailService.sendDemotionEmail(it) }
+        }
+    }
+
+    @Transactional
+    override fun reconcileWaitlist(eventId: Long) {
         eventLockRepository.lockById(eventId)
 
         val event: Event = eventRepository.findById(eventId).orElseThrow { EventNotFoundException() }
@@ -677,35 +726,38 @@ RegistrationService(
 
         val capacity = event.capacity ?: throw IllegalStateException("이벤트의 capacity가 설정되어 있지 않습니다.")
         val confirmed =
-            registrationRepository.countByEventIdAndStatus(eventId, RegistrationStatus.CONFIRMED).toInt()
+            registrationRepository.countByEventIdAndStatusWithLock(eventId, RegistrationStatus.CONFIRMED).toInt()
         val available = capacity - confirmed
         if (available <= 0) return
 
-        val waitlistedRegs =
+        val totalWaitlisted =
+            registrationRepository.countByEventIdAndStatus(eventId, RegistrationStatus.WAITLISTED).toInt()
+
+        val promoted =
             registrationRepository.findByEventIdAndStatusOrderByCreatedAtAsc(
                 eventId,
                 RegistrationStatus.WAITLISTED,
+                Pageable.ofSize(available),
             )
 
         val waitlistNumbers =
-            waitlistedRegs.withIndex().associate { indexed ->
-                indexed.value.registrationPublicId to (indexed.index + 1)
+            promoted.withIndex().associate { (index, reg) ->
+                reg.registrationPublicId to (index + 1)
             }
 
-        val promoted = waitlistedRegs.take(available)
         promoted.forEach { it.status = RegistrationStatus.CONFIRMED }
         registrationRepository.saveAll(promoted)
 
         val confirmedAfter = confirmed + promoted.size
-        val remainingWaitlisted = waitlistedRegs.size - promoted.size
+        val remainingWaitlisted = totalWaitlisted - promoted.size
         val totalCount = confirmedAfter + remainingWaitlisted
 
+        val promotedUserIds = promoted.mapNotNull { it.userId }.distinct()
+        val promotedUsersById = userRepository.findAllById(promotedUserIds).associateBy { it.id!! }
+
         val emailDataList =
             promoted.mapNotNull { registration ->
-                val user: User? =
-                    registration.userId?.let { uid ->
-                        userRepository.findById(uid).orElse(null)
-                    }
+                val user: User? = registration.userId?.let { promotedUsersById[it] }
 
                 val recipientEmail = user?.email ?: registration.guestEmail
                 val recipientName = user?.name ?: registration.guestName ?: "참여자"
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/service/WaitlistReconciliationService.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/service/WaitlistReconciliationService.kt
new file mode 100644
index 00000000..07110e7c
--- /dev/null
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/registration/service/WaitlistReconciliationService.kt
@@ -0,0 +1,10 @@
+package com.wafflestudio.spring2025.domain.registration.service
+
+interface WaitlistReconciliationService {
+    fun reconcileWaitlist(eventId: Long)
+
+    fun demoteToWaitlist(
+        eventId: Long,
+        newCapacity: Int,
+    )
+}
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/user/controller/UserController.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/user/controller/UserController.kt
index 85c924bd..8f214cf1 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/user/controller/UserController.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/user/controller/UserController.kt
@@ -7,11 +7,6 @@ import com.wafflestudio.spring2025.domain.user.dto.PatchMeRequest
 import com.wafflestudio.spring2025.domain.user.dto.PatchMeResponse
 import com.wafflestudio.spring2025.domain.user.model.User
 import com.wafflestudio.spring2025.domain.user.service.UserService
-import io.swagger.v3.oas.annotations.Operation
-import io.swagger.v3.oas.annotations.Parameter
-import io.swagger.v3.oas.annotations.responses.ApiResponse
-import io.swagger.v3.oas.annotations.responses.ApiResponses
-import io.swagger.v3.oas.annotations.tags.Tag
 import org.springframework.http.ResponseEntity
 import org.springframework.web.bind.annotation.GetMapping
 import org.springframework.web.bind.annotation.PatchMapping
@@ -22,27 +17,19 @@ import org.springframework.web.bind.annotation.RestController
 @AuthRequired
 @RestController
 @RequestMapping("/api/users")
-@Tag(name = "User", description = "사용자 API")
 class UserController(
     private val userService: UserService,
 ) {
-    @Operation(summary = "본인 정보 조회", description = "로그인한 사용자의 정보를 조회합니다")
-    @ApiResponses(
-        value = [
-            ApiResponse(responseCode = "200", description = "사용자 정보 조회 성공"),
-            ApiResponse(responseCode = "401", description = "인증 실패 (유효하지 않은 토큰)"),
-        ],
-    )
     @AuthRequired
     @GetMapping("/me")
     fun me(
-        @Parameter(hidden = true) @LoggedInUser user: User,
+        @LoggedInUser user: User,
     ): ResponseEntity<GetMeResponse> = ResponseEntity.ok(userService.me(user))
 
     @AuthRequired
     @PatchMapping("/me")
     fun patchMe(
-        @Parameter(hidden = true) @LoggedInUser user: User,
+        @LoggedInUser user: User,
         @RequestBody request: PatchMeRequest,
     ): ResponseEntity<PatchMeResponse> {
         userService.patchMe(
@@ -54,41 +41,4 @@ class UserController(
         )
         return ResponseEntity.ok(userService.me(user))
     }
-
-//    @Operation(summary = "프로필 이미지 업로드", description = "로그인한 사용자의 프로필 이미지를 업로드(교체)합니다")
-//    @ApiResponses(
-//        value = [
-//            ApiResponse(responseCode = "204", description = "프로필 이미지 업로드 성공"),
-//            ApiResponse(responseCode = "400", description = "잘못된 요청 (파일 누락/형식 오류 등)"),
-//            ApiResponse(responseCode = "401", description = "인증 실패 (유효하지 않은 토큰)"),
-//        ],
-//    )
-//    @AuthRequired
-//    @PutMapping(
-//        "/me/profile-image",
-//        consumes = [MediaType.MULTIPART_FORM_DATA_VALUE],
-//    )
-//    fun uploadProfileImage(
-//        @Parameter(hidden = true) @LoggedInUser user: User?,
-//        @RequestPart("image") image: MultipartFile,
-//    ): ResponseEntity<Void> {
-//        userService.updateProfileImage(user, image)
-//        return ResponseEntity.noContent().build()
-//    }
-//
-//    @Operation(summary = "프로필 이미지 삭제", description = "로그인한 사용자의 프로필 이미지를 삭제(기본 이미지로 복귀)합니다")
-//    @ApiResponses(
-//        value = [
-//            ApiResponse(responseCode = "204", description = "프로필 이미지 삭제 성공"),
-//            ApiResponse(responseCode = "401", description = "인증 실패 (유효하지 않은 토큰)"),
-//        ],
-//    )
-//    @AuthRequired
-//    @DeleteMapping("/me/profile-image")
-//    fun deleteProfileImage(
-//        @Parameter(hidden = true) @LoggedInUser user: User?,
-//    ): ResponseEntity<Void> {
-//        userService.deleteProfileImage(user)
-//        return ResponseEntity.noContent().build()
-//    }
 }
diff --git a/src/main/kotlin/com/wafflestudio/spring2025/domain/user/identity/dto/core/UserIdentityDto.kt b/src/main/kotlin/com/wafflestudio/spring2025/domain/user/identity/dto/core/UserIdentityDto.kt
index 092180d5..1a0f9e05 100644
--- a/src/main/kotlin/com/wafflestudio/spring2025/domain/user/identity/dto/core/UserIdentityDto.kt
+++ b/src/main/kotlin/com/wafflestudio/spring2025/domain/user/identity/dto/core/UserIdentityDto.kt
@@ -1,19 +1,12 @@
 package com.wafflestudio.spring2025.domain.user.identity.dto.core
 
 import com.wafflestudio.spring2025.domain.user.identity.model.UserIdentity
-import io.swagger.v3.oas.annotations.media.Schema
 
-@Schema(description = "소셜 계정 정보")
 data class UserIdentityDto(
-    @Schema(description = "소셜 계정 ID")
     val id: Long,
-    @Schema(description = "사용자 ID")
     val userId: Long,
-    @Schema(description = "소셜 로그인 제공자")
     val provider: String,
-    @Schema(description = "제공자 사용자 ID")
     val providerUserId: String,
-    @Schema(description = "생성 일시 (epoch milliseconds)")
     val createdAt: Long,
 ) {
     constructor(identity: UserIdentity) : this(
diff --git a/src/main/resources/META-INF/spring.factories b/src/main/resources/META-INF/spring.factories
new file mode 100644
index 00000000..f8cf5e6f
--- /dev/null
+++ b/src/main/resources/META-INF/spring.factories
@@ -0,0 +1 @@
+org.springframework.boot.env.EnvironmentPostProcessor=com.wafflestudio.spring2025.config.OciVaultPostProcessorBridge
diff --git a/src/main/resources/application-local.yaml b/src/main/resources/application-local.yaml
new file mode 100644
index 00000000..920575c1
--- /dev/null
+++ b/src/main/resources/application-local.yaml
@@ -0,0 +1,7 @@
+spring:
+  config:
+    activate:
+      on-profile: local
+  data:
+    redis:
+      host: localhost
\ No newline at end of file
diff --git a/src/main/resources/application.yaml b/src/main/resources/application.yaml
index 29fc2f77..ee7ef521 100644
--- a/src/main/resources/application.yaml
+++ b/src/main/resources/application.yaml
@@ -9,10 +9,10 @@ spring:
     password: somepassword
     driver-class-name: com.mysql.cj.jdbc.Driver
   mail:
-    host: email-smtp.us-east-1.amazonaws.com
+    host: smtp.email.ap-chuncheon-1.oci.oraclecloud.com
     port: 587
-    username: ${AWS_SES_SMTP_USERNAME:YOUR_SES_SMTP_USERNAME}
-    password: ${AWS_SES_SMTP_PASSWORD:YOUR_SES_SMTP_PASSWORD}
+    username: ${OCI_EMAIL_SMTP_USERNAME:YOUR_OCI_SMTP_USERNAME}
+    password: ${OCI_EMAIL_SMTP_PASSWORD:YOUR_OCI_SMTP_PASSWORD}
     properties:
       mail:
         smtp:
@@ -34,7 +34,7 @@ spring:
     enabled: true
   data:
     redis:
-      host: localhost
+      host: moiming-valkey
       port: 6379
 
 jwt:
@@ -42,15 +42,15 @@ jwt:
   expiration-in-ms: 86400000
 
 email:
-  from-email: no-reply@moiming.app
+  from-email: moiming@wafflestudio.com
   from-name: 모이밍
 
 oauth:
   providers:
     google:
-      client-id: ${GOOGLE_CLIENT_ID}
-      client-secret: ${GOOGLE_CLIENT_SECRET}
-      redirect-uri: ${GOOGLE_REDIRECT_URI}
+      client-id: ${GOOGLE_CLIENT_ID:}
+      client-secret: ${GOOGLE_CLIENT_SECRET:}
+      redirect-uri: ${GOOGLE_REDIRECT_URI:}
 
 logging:
   level:
@@ -68,7 +68,7 @@ management:
   endpoints:
     web:
       exposure:
-        include: health
+        include: health,info,prometheus,metrics
   endpoint:
     health:
       show-details: always
@@ -87,9 +87,48 @@ aws:
   allowed-origins: >
     http://localhost:3000,
     http://localhost:5173,
-    https://www.moiming.app,
-    https://moiming.app,
-    https://api.moiming.app
+    https://moiming.wafflestudio.com,
+    https://dev.moiming.wafflestudio.com,
+    https://api.moiming.wafflestudio.com
+    https://api.dev.moiming.wafflestudio.com
 
 server:
   forward-headers-strategy: framework
+
+springdoc:
+  api-docs:
+    enabled: false
+  swagger-ui:
+    url: /docs/openapi.yaml
+    disable-swagger-default-url: true
+
+---
+spring:
+  config:
+    activate:
+      on-profile: dev
+  datasource:
+    url: jdbc:mysql://10.0.30.217:3306/moiming_dev?allowPublicKeyRetrieval=true
+    username: moiming-dev
+    password:
+cors:
+  allowed-origins: ""
+oci:
+  vault:
+    secret-ids: ocid1.vaultsecret.oc1.ap-chuncheon-1.amaaaaaat2m5lbqaa3m45icdqcka43cvyzb4kb3ktuatfobwusnsdd4bvzkq
+    region: ap-chuncheon-1
+
+---
+spring:
+  config:
+    activate:
+      on-profile: prod
+  datasource:
+    url: jdbc:mysql://10.0.30.217:3306/moiming_prod?allowPublicKeyRetrieval=true
+    username: moiming-prod
+cors:
+  allowed-origins: ""
+oci:
+  vault:
+    secret-ids: ocid1.vaultsecret.oc1.ap-chuncheon-1.amaaaaaat2m5lbqameflpkt7abivvrauqwheybzrkqipf7msv3ol6ikhd3aq
+    region: ap-chuncheon-1
diff --git a/src/main/resources/com/wafflestudio/spring2025/common/email/template/event-cancelled.html b/src/main/resources/com/wafflestudio/spring2025/common/email/template/event-cancelled.html
new file mode 100644
index 00000000..4d6fd334
--- /dev/null
+++ b/src/main/resources/com/wafflestudio/spring2025/common/email/template/event-cancelled.html
@@ -0,0 +1,102 @@
+<!DOCTYPE html>
+<html lang="ko">
+
+<head>
+    <meta charset="UTF-8">
+</head>
+
+<body
+    style="margin: 0; padding: 0; background-color: #ffffff; font-family: 'Apple SD Gothic Neo', 'Malgun Gothic', sans-serif;">
+    <table align="center" border="0" cellpadding="0" cellspacing="0" width="100%"
+        style="max-width: 450px; margin: 0 auto; background-color: #ffffff;">
+        <tr>
+            <td style="padding: 30px 20px;">
+
+                <table border="0" cellpadding="0" cellspacing="0" width="100%" style="margin-bottom: 30px;">
+                    <tr>
+                        <td>
+                            <img src="https://raw.githubusercontent.com/wafflestudio/moiming-web/refs/heads/main/public/moiming-logo.png"
+                                 alt="모이밍" width="120" style="display: block; border: 0;">
+                        </td>
+                    </tr>
+                </table>
+
+                <table border="0" cellpadding="0" cellspacing="0" width="100%" style="margin-bottom: 30px;">
+                    <tr>
+                        <td width="48" style="vertical-align: middle;">
+                            <div style="width: 48px; height: 48px; background-color: #EC221F; border-radius: 50%;">
+                                <table border="0" cellpadding="0" cellspacing="0" width="48" height="48">
+                                    <tr>
+                                        <td align="center" valign="middle" style="height: 48px; line-height: 0;">
+                                            <img src="https://raw.githubusercontent.com/wafflestudio/moiming-web/refs/heads/main/public/x.png"
+                                                 alt="x-mark" width="20" style="display: block; border: 0;">
+                                        </td>
+                                    </tr>
+                                </table>
+                            </div>
+                        </td>
+                        <td
+                            style="padding-left: 15px; font-size: 22px; font-weight: bold; line-height: 1.3; color: #111;">
+                            안녕하세요 {name}님<br>
+                            일정이 취소되었습니다.
+                        </td>
+                    </tr>
+                </table>
+
+                <div style="border: 1px solid #EAEAEA; border-radius: 12px; padding: 24px; margin-bottom: 30px;">
+                    <div style="font-size: 20px; font-weight: bold; color: #000; margin-bottom: 20px;">{eventTitle}
+                    </div>
+
+                    <table border="0" cellpadding="0" cellspacing="0" width="100%"
+                        style="font-size: 15px; color: #777; line-height: 1.6;">
+                        <tr>
+                            <td width="20" style="padding-bottom: 12px; vertical-align: middle;">
+                                <img src="https://raw.githubusercontent.com/wafflestudio/moiming-web/refs/heads/main/public/calendar.png"
+                                     alt="calendar" width="20" style="display: block; border: 0;">
+                            </td>
+                            <td style="padding-bottom: 12px; padding-left: 10px; vertical-align: middle;">
+                                일시 <span style="margin-left:8px; color:#444;">{eventDateRange}</span>
+                            </td>
+                        </tr>
+                        <tr>
+                            <td style="padding-bottom: 4px; vertical-align: middle;">
+                                <img src="https://raw.githubusercontent.com/wafflestudio/moiming-web/refs/heads/main/public/map-pin.png"
+                                     alt="map-pin" width="20" style="display: block; border: 0;">
+                            </td>
+                            <td style="padding-bottom: 4px; padding-left: 10px; vertical-align: middle;">
+                                장소 <span style="margin-left:8px; color:#444;">{location}</span>
+                            </td>
+                        </tr>
+                    </table>
+                </div>
+
+                <table border="0" cellpadding="0" cellspacing="0" width="100%"
+                    style="background-color: #F7F8F9; border-radius: 8px; margin-bottom: 30px;">
+                    <tr>
+                        <td style="padding: 14px 16px; font-size: 14px; color: #444; vertical-align: middle;">
+                            <table border="0" cellpadding="0" cellspacing="0">
+                                <tr>
+                                    <td style="vertical-align: middle; padding-right: 8px;">
+                                        <img src="https://raw.githubusercontent.com/wafflestudio/moiming-web/refs/heads/main/public/user.png"
+                                             alt="user" width="20" style="display: block; border: 0;">
+                                    </td>
+                                    <td style="vertical-align: middle;">
+                                        <strong style="font-weight: bold;">문의:</strong>
+                                        <span style="margin-left: 4px;">일정 주최자에게 연락 바랍니다 ({hostEmail})</span>
+                                    </td>
+                                </tr>
+                            </table>
+                        </td>
+                    </tr>
+                </table>
+
+                <div
+                    style="font-size: 16px; line-height: 1.7; color: #333; margin-bottom: 50px; white-space: wrap; word-break: break-all;">
+                    {description}</div>
+
+            </td>
+        </tr>
+    </table>
+</body>
+
+</html>
diff --git a/src/main/resources/com/wafflestudio/spring2025/common/email/template/registration-banned.html b/src/main/resources/com/wafflestudio/spring2025/common/email/template/registration-banned.html
index 7bd8a682..573ae045 100644
--- a/src/main/resources/com/wafflestudio/spring2025/common/email/template/registration-banned.html
+++ b/src/main/resources/com/wafflestudio/spring2025/common/email/template/registration-banned.html
@@ -73,7 +73,7 @@
                                      alt="user" width="20" style="display: block; border: 0;">
                             </td>
                             <td style="padding-bottom: 4px; padding-left: 10px; vertical-align: middle;">
-                                정원 <span style="margin-left:8px; color:#444;">{totalCount}/{capacity}명</span>
+                                정원 <span style="margin-left:8px; color:#444;">{capacityDisplay}</span>
                             </td>
                         </tr>
                     </table>
diff --git a/src/main/resources/com/wafflestudio/spring2025/common/email/template/registration-confirmed.html b/src/main/resources/com/wafflestudio/spring2025/common/email/template/registration-confirmed.html
index 69e8991a..4da10477 100644
--- a/src/main/resources/com/wafflestudio/spring2025/common/email/template/registration-confirmed.html
+++ b/src/main/resources/com/wafflestudio/spring2025/common/email/template/registration-confirmed.html
@@ -37,6 +37,7 @@
             </tr>
         </table>
 
+        <a href="{serviceDomain}/event/{publicId}?regId={registrationPublicId}" style="display: block; text-decoration: none; color: inherit;">
         <div style="border: 1px solid #EAEAEA; border-radius: 12px; padding: 24px; margin-bottom: 16px;">
             <div style="font-size: 22px; font-weight: bold; color: #000; margin-bottom: 20px;">{eventTitle}</div>
 
@@ -66,7 +67,7 @@
                              alt="user" width="18" style="display: block; border: 0;">
                     </td>
                     <td style="padding-bottom: 4px; padding-left: 10px; vertical-align: middle;">
-                        정원 <span style="margin-left:8px; color:#444;">{totalCount}/{capacity}명</span>
+                        정원 <span style="margin-left:8px; color:#444;">{capacityDisplay}</span>
                     </td>
                 </tr>
             </table>
@@ -74,6 +75,7 @@
                 style="text-align: right; color: #CCCCCC; font-size: 24px; line-height: 1; font-family: sans-serif; font-weight: 300; margin-top: -10px;">
                 &rsaquo;</div>
         </div>
+        </a>
 
         <table border="0" cellpadding="0" cellspacing="0"
             style="width: 100%; background-color: #F7F8F9; border-radius: 8px; margin-bottom: 40px;">
@@ -99,7 +101,7 @@
             style="font-size: 16px; line-height: 1.7; color: #333; margin-bottom: 50px; white-space: wrap; word-break: break-all;">
             {description}</div>
 
-        <a href="https://www.moiming.app/event/{publicId}?regId={registrationPublicId}"
+        <a href="{serviceDomain}/event/{publicId}?regId={registrationPublicId}"
             style="display: block; width: 100%; padding: 18px 0; background-color: #FEE9E7; border: 1px solid #900B09; border-radius: 10px; color: #900B09; font-size: 17px; font-weight: 600; text-align: center; text-decoration: none;">
             취소하기
         </a>
diff --git a/src/main/resources/com/wafflestudio/spring2025/common/email/template/registration-delete.html b/src/main/resources/com/wafflestudio/spring2025/common/email/template/registration-delete.html
index 6c216b92..0b02d08f 100644
--- a/src/main/resources/com/wafflestudio/spring2025/common/email/template/registration-delete.html
+++ b/src/main/resources/com/wafflestudio/spring2025/common/email/template/registration-delete.html
@@ -44,6 +44,7 @@
                 </tr>
             </table>
 
+            <a href="{serviceDomain}/event/{publicId}" style="display: block; text-decoration: none; color: inherit;">
             <div style="border: 1px solid #EAEAEA; border-radius: 12px; padding: 24px; margin-bottom: 16px;">
                 <div style="font-size: 20px; font-weight: bold; color: #000; margin-bottom: 20px;">{eventTitle}
                 </div>
@@ -74,7 +75,7 @@
                                  alt="user" width="20" style="display: block; border: 0;">
                         </td>
                         <td style="padding-bottom: 4px; padding-left: 10px; vertical-align: middle;">
-                            정원 <span style="margin-left:8px; color:#444;">{totalCount}/{capacity}명</span>
+                            정원 <span style="margin-left:8px; color:#444;">{capacityDisplay}</span>
                         </td>
                     </tr>
                 </table>
@@ -82,6 +83,7 @@
                         style="text-align: right; color: #CCCCCC; font-size: 24px; line-height: 1; font-family: sans-serif; font-weight: 300; margin-top: -10px;">
                     &rsaquo;</div>
             </div>
+            </a>
 
             <table border="0" cellpadding="0" cellspacing="0" width="100%"
                    style="background-color: #F7F8F9; border-radius: 8px; margin-bottom: 30px;">
diff --git a/src/main/resources/com/wafflestudio/spring2025/common/email/template/registration-demoted.html b/src/main/resources/com/wafflestudio/spring2025/common/email/template/registration-demoted.html
new file mode 100644
index 00000000..541ef4cd
--- /dev/null
+++ b/src/main/resources/com/wafflestudio/spring2025/common/email/template/registration-demoted.html
@@ -0,0 +1,122 @@
+<!DOCTYPE html>
+<html lang="ko">
+
+<head>
+    <meta charset="UTF-8">
+</head>
+
+<body
+    style="margin: 0; padding: 0; background-color: #ffffff; font-family: 'Apple SD Gothic Neo', 'Malgun Gothic', sans-serif;">
+    <table align="center" border="0" cellpadding="0" cellspacing="0" width="100%"
+        style="max-width: 450px; margin: 0 auto; background-color: #ffffff;">
+        <tr>
+            <td style="padding: 30px 20px;">
+
+                <table border="0" cellpadding="0" cellspacing="0" width="100%" style="margin-bottom: 30px;">
+                    <tr>
+                        <td>
+                            <img src="https://raw.githubusercontent.com/wafflestudio/moiming-web/refs/heads/main/public/moiming-logo.png"
+                                 alt="모이밍" width="120" style="display: block; border: 0;">
+                        </td>
+                    </tr>
+                </table>
+
+                <table border="0" cellpadding="0" cellspacing="0" width="100%" style="margin-bottom: 30px;">
+                    <tr>
+                        <td width="48" style="vertical-align: middle;">
+                            <div
+                                style="width: 48px; height: 48px; background-color: #F97316; border-radius: 50%; text-align: center;">
+                                <table border="0" cellpadding="0" cellspacing="0" width="48" height="48">
+                                    <tr>
+                                        <td align="center" valign="middle" height="48" style="height: 48px;">
+                                            <img src="https://raw.githubusercontent.com/wafflestudio/moiming-web/refs/heads/main/public/loader.png"
+                                                 alt="loader-mark" width="20" style="display: block; border: 0;">
+                                        </td>
+                                    </tr>
+                                </table>
+                            </div>
+                        </td>
+                        <td
+                            style="padding-left: 15px; font-size: 22px; font-weight: bold; line-height: 1.3; color: #111;">
+                            안녕하세요 {name}님<br>
+                            {waitingNum}번째 대기로 변경되었습니다.
+                        </td>
+                    </tr>
+                </table>
+
+                <a href="{serviceDomain}/event/{publicId}?regId={registrationPublicId}" style="display: block; text-decoration: none; color: inherit;">
+                <div style="border: 1px solid #EAEAEA; border-radius: 12px; padding: 24px; margin-bottom: 16px;">
+                    <div style="font-size: 20px; font-weight: bold; color: #000; margin-bottom: 20px;">{eventTitle}
+                    </div>
+
+                    <table border="0" cellpadding="0" cellspacing="0" width="100%"
+                        style="font-size: 15px; color: #777; line-height: 1.6;">
+                        <tr>
+                            <td width="20" style="padding-bottom: 12px; vertical-align: middle;">
+                                <img src="https://raw.githubusercontent.com/wafflestudio/moiming-web/refs/heads/main/public/calendar.png"
+                                     alt="calendar" width="18" style="display: block; border: 0;">
+                            </td>
+                            <td style="padding-bottom: 12px; padding-left: 10px; vertical-align: middle;">
+                                일시 <span style="margin-left:8px; color:#444;">{eventDateRange}</span>
+                            </td>
+                        </tr>
+                        <tr>
+                            <td style="padding-bottom: 12px; vertical-align: middle;">
+                                <img src="https://raw.githubusercontent.com/wafflestudio/moiming-web/refs/heads/main/public/map-pin.png"
+                                     alt="map-pin" width="18" style="display: block; border: 0;">
+                            </td>
+                            <td style="padding-bottom: 12px; padding-left: 10px; vertical-align: middle;">
+                                장소 <span style="margin-left:8px; color:#444;">{location}</span>
+                            </td>
+                        </tr>
+                        <tr>
+                            <td style="padding-bottom: 4px; vertical-align: middle;">
+                                <img src="https://raw.githubusercontent.com/wafflestudio/moiming-web/refs/heads/main/public/user.png"
+                                     alt="user" width="18" style="display: block; border: 0;">
+                            </td>
+                            <td style="padding-bottom: 4px; padding-left: 10px; vertical-align: middle;">
+                                정원 <span style="margin-left:8px; color:#444;">{capacityDisplay}</span>
+                            </td>
+                        </tr>
+                    </table>
+                    <div
+                        style="text-align: right; color: #CCCCCC; font-size: 24px; line-height: 1; font-family: sans-serif; font-weight: 300; margin-top: -10px;">
+                        &rsaquo;</div>
+                </div>
+                </a>
+
+                <table border="0" cellpadding="0" cellspacing="0" width="100%"
+                    style="background-color: #F7F8F9; border-radius: 8px; margin-bottom: 30px;">
+                    <tr>
+                        <td style="padding: 14px 16px; font-size: 14px; color: #444; vertical-align: middle;">
+                            <table border="0" cellpadding="0" cellspacing="0">
+                                <tr>
+                                    <td style="vertical-align: middle; padding-right: 8px;">
+                                        <img src="https://raw.githubusercontent.com/wafflestudio/moiming-web/refs/heads/main/public/clock.png"
+                                             alt="clock" width="16" style="display: block; border: 0;">
+                                    </td>
+                                    <td style="vertical-align: middle;">
+                                        <strong style="font-weight: bold;">신청 기간:</strong>
+                                        <span
+                                            style="margin-left: 4px;">{registrationDateRange}</span>
+                                    </td>
+                                </tr>
+                            </table>
+                        </td>
+                    </tr>
+                </table>
+
+                <div
+                    style="font-size: 16px; line-height: 1.7; color: #333; margin-bottom: 50px; white-space: wrap; word-break: break-all;">
+                    {description}</div>
+
+                <a href="{serviceDomain}/event/{publicId}?regId={registrationPublicId}"
+                    style="display: block; width: 100%; padding: 18px 0; background-color: #FEE9E7; border: 1px solid #900B09; border-radius: 10px; color: #900B09; font-size: 17px; font-weight: 600; text-align: center; text-decoration: none;">
+                    취소하기
+                </a>
+            </td>
+        </tr>
+    </table>
+</body>
+
+</html>
diff --git a/src/main/resources/com/wafflestudio/spring2025/common/email/template/registration-waitlist-promoted.html b/src/main/resources/com/wafflestudio/spring2025/common/email/template/registration-waitlist-promoted.html
index f9c23f1c..8cdc2f3f 100644
--- a/src/main/resources/com/wafflestudio/spring2025/common/email/template/registration-waitlist-promoted.html
+++ b/src/main/resources/com/wafflestudio/spring2025/common/email/template/registration-waitlist-promoted.html
@@ -37,6 +37,7 @@
             </tr>
         </table>
 
+        <a href="{serviceDomain}/event/{publicId}?regId={registrationPublicId}" style="display: block; text-decoration: none; color: inherit;">
         <div style="border: 1px solid #EAEAEA; border-radius: 12px; padding: 24px; margin-bottom: 16px;">
             <div style="font-size: 22px; font-weight: bold; color: #000; margin-bottom: 20px;">{eventTitle}</div>
 
@@ -66,7 +67,7 @@
                              alt="user" width="18" style="display: block; border: 0;">
                     </td>
                     <td style="padding-bottom: 4px; padding-left: 10px; vertical-align: middle;">
-                        정원 <span style="margin-left:8px; color:#444;">{totalCount}/{capacity}명</span>
+                        정원 <span style="margin-left:8px; color:#444;">{capacityDisplay}</span>
                     </td>
                 </tr>
             </table>
@@ -74,6 +75,7 @@
                 style="text-align: right; color: #CCCCCC; font-size: 24px; line-height: 1; font-family: sans-serif; font-weight: 300; margin-top: -10px;">
                 &rsaquo;</div>
         </div>
+        </a>
 
         <table border="0" cellpadding="0" cellspacing="0"
             style="width: 100%; background-color: #F7F8F9; border-radius: 8px; margin-bottom: 40px;">
@@ -99,7 +101,7 @@
             style="font-size: 16px; line-height: 1.7; color: #333; margin-bottom: 50px; white-space: wrap; word-break: break-all;">
             {description}</div>
 
-        <a href="https://www.moiming.app/event/{publicId}?regId={registrationPublicId}"
+        <a href="{serviceDomain}/event/{publicId}?regId={registrationPublicId}"
             style="display: block; width: 100%; padding: 18px 0; background-color: #FEE9E7; border: 1px solid #900B09; border-radius: 10px; color: #900B09; font-size: 17px; font-weight: 600; text-align: center; text-decoration: none;">
             취소하기
         </a>
diff --git a/src/main/resources/com/wafflestudio/spring2025/common/email/template/registration-waitlisted.html b/src/main/resources/com/wafflestudio/spring2025/common/email/template/registration-waitlisted.html
index 9edf0de0..491e2959 100644
--- a/src/main/resources/com/wafflestudio/spring2025/common/email/template/registration-waitlisted.html
+++ b/src/main/resources/com/wafflestudio/spring2025/common/email/template/registration-waitlisted.html
@@ -44,6 +44,7 @@
                     </tr>
                 </table>
 
+                <a href="{serviceDomain}/event/{publicId}?regId={registrationPublicId}" style="display: block; text-decoration: none; color: inherit;">
                 <div style="border: 1px solid #EAEAEA; border-radius: 12px; padding: 24px; margin-bottom: 16px;">
                     <div style="font-size: 20px; font-weight: bold; color: #000; margin-bottom: 20px;">{eventTitle}
                     </div>
@@ -74,7 +75,7 @@
                                      alt="user" width="18" style="display: block; border: 0;">
                             </td>
                             <td style="padding-bottom: 4px; padding-left: 10px; vertical-align: middle;">
-                                정원 <span style="margin-left:8px; color:#444;">{totalCount}/{capacity}명</span>
+                                정원 <span style="margin-left:8px; color:#444;">{capacityDisplay}</span>
                             </td>
                         </tr>
                     </table>
@@ -82,6 +83,7 @@
                         style="text-align: right; color: #CCCCCC; font-size: 24px; line-height: 1; font-family: sans-serif; font-weight: 300; margin-top: -10px;">
                         &rsaquo;</div>
                 </div>
+                </a>
 
                 <table border="0" cellpadding="0" cellspacing="0" width="100%"
                     style="background-color: #F7F8F9; border-radius: 8px; margin-bottom: 30px;">
@@ -108,7 +110,7 @@
                     style="font-size: 16px; line-height: 1.7; color: #333; margin-bottom: 50px; white-space: wrap; word-break: break-all;">
                     {description}</div>
 
-                <a href="https://www.moiming.app/event/{publicId}?regId={registrationPublicId}"
+                <a href="{serviceDomain}/event/{publicId}?regId={registrationPublicId}"
                     style="display: block; width: 100%; padding: 18px 0; background-color: #FEE9E7; border: 1px solid #900B09; border-radius: 10px; color: #900B09; font-size: 17px; font-weight: 600; text-align: center; text-decoration: none;">
                     취소하기
                 </a>
diff --git a/src/main/resources/db/migration/V14__make_registration_ends_at_not_null.sql b/src/main/resources/db/migration/V14__make_registration_ends_at_not_null.sql
new file mode 100644
index 00000000..9cdb2d8e
--- /dev/null
+++ b/src/main/resources/db/migration/V14__make_registration_ends_at_not_null.sql
@@ -0,0 +1,3 @@
+DELETE r FROM registrations r INNER JOIN events e ON r.event_id = e.id WHERE e.registration_ends_at IS NULL;
+DELETE FROM events WHERE registration_ends_at IS NULL;
+ALTER TABLE events MODIFY registration_ends_at DATETIME(6) NOT NULL;
diff --git a/src/main/resources/static/docs/openapi.yaml b/src/main/resources/static/docs/openapi.yaml
new file mode 100644
index 00000000..9f62c069
--- /dev/null
+++ b/src/main/resources/static/docs/openapi.yaml
@@ -0,0 +1,1257 @@
+openapi: 3.0.1
+info:
+  title: Moiming - Event Schedule Management System API
+  description: 모임 일정 관리 시스템 '모이밍' API 문서
+  version: "1.0"
+servers:
+- url: http://localhost:8080
+  description: Generated server url
+tags:
+- name: Event
+  description: 이벤트 관리 API
+- name: Registration
+  description: 신청 API
+- name: Auth
+  description: 인증 API
+- name: User
+  description: 사용자 API
+- name: Image
+  description: 이미지 API
+paths:
+  /api/events/{publicId}:
+    get:
+      security: []
+      tags:
+      - Event
+      summary: 이벤트 상세 조회
+      description: 이벤트 상세 정보를 조회합니다
+      parameters:
+      - name: publicId
+        in: path
+        required: true
+        schema:
+          type: string
+      responses:
+        "200":
+          description: OK
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/EventDetailResponse"
+    put:
+      tags:
+      - Event
+      summary: 이벤트 수정
+      description: 이벤트를 수정합니다
+      security:
+      - bearerAuth: []
+      parameters:
+      - name: publicId
+        in: path
+        required: true
+        schema:
+          type: string
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/UpdateEventRequest"
+        required: true
+      responses:
+        "200":
+          description: OK
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/UpdateEventResponse"
+        "401":
+          description: 인증 필요
+    delete:
+      tags:
+      - Event
+      summary: 이벤트 삭제
+      description: 이벤트를 삭제합니다
+      security:
+      - bearerAuth: []
+      parameters:
+      - name: publicId
+        in: path
+        required: true
+        schema:
+          type: string
+      responses:
+        "204":
+          description: No Content
+        "401":
+          description: 인증 필요
+  /api/images:
+    post:
+      security:
+      - bearerAuth: []
+      tags:
+      - Image
+      summary: 이미지 업로드
+      description: 서버 저장소에 이미지를 업로드합니다.
+      parameters:
+      - name: prefix
+        in: query
+        description: 이미지를 저장할 상위 경로
+        required: false
+        schema:
+          type: string
+      requestBody:
+        content:
+          multipart/form-data:
+            schema:
+              required:
+              - image
+              type: object
+              properties:
+                image:
+                  type: string
+                  format: binary
+      responses:
+        "200":
+          description: 이미지 업로드 성공
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/ImageUploadResponse"
+        "400":
+          description: 잘못된 요청 (파일 누락/형식 오류 등)
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/ErrorResponse"
+        "401":
+          description: 인증 실패 (유효하지 않은 토큰)
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/ErrorResponse"
+  /api/events:
+    post:
+      tags:
+      - Event
+      summary: 이벤트 생성
+      description: 새로운 이벤트를 생성합니다
+      security:
+      - bearerAuth: []
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/CreateEventRequest"
+        required: true
+      responses:
+        "200":
+          description: OK
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/CreateEventResponse"
+        "401":
+          description: 인증 필요
+  /api/events/{eventId}/registrations:
+    get:
+      security:
+      - bearerAuth: []
+      tags:
+      - Registration
+      summary: 이벤트 신청 목록 조회
+      description: 특정 이벤트에 속한 신청 목록을 조회합니다. 신청 상태(CONFIRMED/WAITLISTED/BANNED)와 신청
+        시각을 포함해 반환합니다.
+      parameters:
+      - name: eventId
+        in: path
+        required: true
+        schema:
+          type: string
+      - name: status
+        in: query
+        required: false
+        schema:
+          type: string
+      - name: orderBy
+        in: query
+        required: false
+        schema:
+          type: string
+      - name: cursor
+        in: query
+        description: 다음 페이지 시작 offset (없으면 0부터)
+        required: false
+        schema:
+          type: integer
+          format: int32
+      responses:
+        "200":
+          description: OK
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/GetEventRegistrationsResponse"
+    post:
+      security: []
+      tags:
+      - Registration
+      summary: 이벤트 참여 신청
+      description: "특정 이벤트에 신청합니다. 정원이 남아있으면 CONFIRMED로 등록되고, 정원이 찼으나 대기 명단이 허용된 경\
+        우 WAITLISTED로 등록됩니다. 정원이 찼고 대기 명단이 비활성화된 경우 신청이 거절됩니다."
+      parameters:
+      - name: eventId
+        in: path
+        required: true
+        schema:
+          type: string
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/CreateRegistrationRequest"
+        required: true
+      responses:
+        "200":
+          description: 신청 성공
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/CreateRegistrationResponse"
+        "409":
+          description: "신청 불가: REGISTRATION_ALREADY_EXISTS, REGISTRATION_BLOCKED_HOST, EVENT_FULL"
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/ErrorResponse"
+        "400":
+          description: "유효하지 않은 요청: REGISTRATION_WRONG_NAME, REGISTRATION_WRONG_EMAIL, NOT_WITHIN_REGISTRATION_WINDOW"
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/ErrorResponse"
+        "403":
+          description: "권한 없음: REGISTRATION_BLOCKED_BANNED"
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/ErrorResponse"
+        "404":
+          description: "이벤트 없음: EVENT_NOT_FOUND"
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/ErrorResponse"
+  /api/auth/social:
+    post:
+      security: []
+      tags:
+      - Auth
+      summary: 소셜 로그인
+      description: 소셜 로그인을 요청합니다.
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/SocialLoginRequest"
+        required: true
+      responses:
+        "200":
+          description: 소셜 로그인 성공
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/LoginResponse"
+        "409":
+          description: 이미 가입된 이메일
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/ErrorResponse"
+        "401":
+          description: 인증 실패
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/ErrorResponse"
+  /api/auth/signup:
+    post:
+      security: []
+      tags:
+      - Auth
+      summary: 이메일 회원가입
+      description: 새로운 사용자를 등록하고 인증 이메일을 발송합니다. 이메일 인증 후 가입이 완료됩니다.
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/SignupRequest"
+        required: true
+      responses:
+        "409":
+          description: 이미 존재하는 email
+        "204":
+          description: 인증 이메일 발송 성공
+        "400":
+          description: 잘못된 요청 (유효하지 않은 email/password/name)
+        "503":
+          description: 이메일 서비스 장애
+  /api/auth/logout:
+    post:
+      security:
+      - bearerAuth: []
+      tags:
+      - Auth
+      summary: 로그아웃
+      description: 현재 JWT 토큰을 블랙리스트에 추가하여 로그아웃합니다
+      responses:
+        "204":
+          description: 로그아웃 성공
+  /api/auth/login:
+    post:
+      security: []
+      tags:
+      - Auth
+      summary: 로그인
+      description: email로 로그인하여 JWT 토큰을 발급받습니다
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/LoginRequest"
+        required: true
+      responses:
+        "401":
+          description: 인증 실패
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/ErrorResponse"
+        "200":
+          description: "로그인 성공, JWT 토큰 반환"
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/LoginResponse"
+  /api/auth/email-verification/{verificationCode}:
+    post:
+      security: []
+      tags:
+      - Auth
+      summary: 이메일 인증
+      description: 이메일로 받은 인증 코드를 검증하고 회원가입을 완료합니다
+      parameters:
+      - name: verificationCode
+        in: path
+        required: true
+        schema:
+          type: string
+      responses:
+        "400":
+          description: 유효하지 않거나 만료된 인증 코드
+        "200":
+          description: "인증 성공, 유저 등록 완료"
+  /api/users/me:
+    get:
+      tags:
+      - User
+      summary: 본인 정보 조회
+      description: 로그인한 사용자의 정보를 조회합니다
+      security:
+      - bearerAuth: []
+      responses:
+        "401":
+          description: 인증 실패 (유효하지 않은 토큰)
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/ErrorResponse"
+        "200":
+          description: 사용자 정보 조회 성공
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/UserDto"
+    patch:
+      tags:
+      - User
+      summary: 본인 정보 수정
+      description: 로그인한 사용자의 정보를 수정합니다
+      security:
+      - bearerAuth: []
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/PatchMeRequest"
+        required: true
+      responses:
+        "200":
+          description: OK
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/UserDto"
+        "401":
+          description: 인증 필요
+  /api/registrations/{registrationId}:
+    get:
+      security: []
+      tags:
+      - Registration
+      summary: 신청 단건 정보 요청
+      description: 신청 단건의 정보를 반환합니다.
+      parameters:
+      - name: registrationId
+        in: path
+        required: true
+        schema:
+          type: string
+      responses:
+        "200":
+          description: OK
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/GetRegistrationResponse"
+    delete:
+      security: []
+      tags:
+      - Registration
+      summary: 신청 단건 취소
+      description: 신청 단건 리소스를 취소합니다.
+      parameters:
+      - name: registrationId
+        in: path
+        required: true
+        schema:
+          type: string
+      responses:
+        "200":
+          description: OK
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/DeleteRegistrationResponse"
+    patch:
+      security:
+      - bearerAuth: []
+      tags:
+      - Registration
+      summary: 신청 단건 상태 변경
+      description: 신청 단건 리소스의 상태를 변경합니다. 사용자가 본인의 신청을 취소하는 경우와 관리자가 강제 취소/밴 처리하는 경우를
+        로직 레벨에서 구분합니다.
+      parameters:
+      - name: registrationId
+        in: path
+        required: true
+        schema:
+          type: string
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/UpdateRegistrationStatusRequest"
+        required: true
+      responses:
+        "200":
+          description: OK
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/PatchRegistrationResponse"
+  /api/registrations/me:
+    get:
+      tags:
+      - Registration
+      summary: 내 이벤트 신청 목록 조회
+      description: 로그인한 사용자의 이벤트 신청 목록을 조회합니다. 최신 신청 순으로 반환되며 page/size로 페이징합니다.
+      security:
+      - bearerAuth: []
+      parameters:
+      - name: page
+        in: query
+        required: false
+        schema:
+          type: integer
+          format: int32
+          default: 0
+      - name: size
+        in: query
+        required: false
+        schema:
+          type: integer
+          format: int32
+          default: 20
+      responses:
+        "200":
+          description: OK
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/GetMyRegistrationsResponse"
+        "401":
+          description: 인증 필요
+  /api/events/me:
+    get:
+      tags:
+      - Event
+      summary: 내가 만든 이벤트 목록 조회 (무한 스크롤)
+      description: 로그인된 사용자가 생성한 이벤트 목록을 무한 스크롤 방식(cursor)으로 조회합니다
+      security:
+      - bearerAuth: []
+      parameters:
+      - name: cursor
+        in: query
+        required: false
+        schema:
+          type: string
+          format: date-time
+      - name: size
+        in: query
+        required: false
+        schema:
+          type: integer
+          format: int32
+          default: 5
+      responses:
+        "200":
+          description: OK
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/MyEventsInfiniteResponse"
+        "401":
+          description: 인증 필요
+components:
+  schemas:
+    UpdateEventRequest:
+      type: object
+      properties:
+        title:
+          type: string
+          description: 이벤트 제목
+          nullable: true
+          example: 정기 모임
+        description:
+          type: string
+          description: 이벤트 설명
+          nullable: true
+          example: 정기 모임입니다
+        location:
+          type: string
+          description: 장소
+          nullable: true
+          example: 강의실 101
+        startsAt:
+          type: string
+          description: 시작 시간 (ISO-8601)
+          format: date-time
+          nullable: true
+          example: 2026-02-02T18:00:00Z
+        endsAt:
+          type: string
+          description: 종료 시간 (ISO-8601)
+          format: date-time
+          nullable: true
+          example: 2026-02-02T20:00:00Z
+        capacity:
+          type: integer
+          description: 정원
+          format: int32
+          nullable: true
+          example: 30
+        waitlistEnabled:
+          type: boolean
+          description: 대기 명단 사용 여부
+          nullable: true
+          example: true
+        registrationStartsAt:
+          type: string
+          description: 신청 시작 시간 (ISO-8601)
+          format: date-time
+          nullable: true
+          example: 2026-02-02T17:00:00Z
+        registrationEndsAt:
+          type: string
+          description: 신청 마감 시간 (ISO-8601)
+          format: date-time
+          nullable: true
+          example: 2026-02-02T17:30:00Z
+      description: 일정 수정 요청
+    UpdateEventResponse:
+      required:
+      - registrationEndsAt
+      - title
+      - capacity
+      - waitlistEnabled
+      type: object
+      properties:
+        title:
+          type: string
+        description:
+          type: string
+          nullable: true
+        location:
+          type: string
+          nullable: true
+        startsAt:
+          type: string
+          format: date-time
+          nullable: true
+        endsAt:
+          type: string
+          format: date-time
+          nullable: true
+        capacity:
+          type: integer
+          format: int32
+          nullable: true
+        waitlistEnabled:
+          type: boolean
+        registrationStartsAt:
+          type: string
+          format: date-time
+          nullable: true
+        registrationEndsAt:
+          type: string
+          format: date-time
+    ImageUploadResponse:
+      required:
+      - key
+      - url
+      type: object
+      properties:
+        key:
+          type: string
+        url:
+          type: string
+    CreateEventRequest:
+      required:
+      - capacity
+      - registrationEndsAt
+      - title
+      - waitlistEnabled
+      type: object
+      properties:
+        title:
+          type: string
+          description: 이벤트 제목
+          example: 정기 모임
+        description:
+          type: string
+          description: 이벤트 설명
+          nullable: true
+          example: 정기 모임입니다
+        location:
+          type: string
+          description: 장소
+          nullable: true
+          example: 강의실 101
+        startsAt:
+          type: string
+          description: 시작 시간 (ISO-8601)
+          format: date-time
+          nullable: true
+          example: 2026-02-02T18:00:00Z
+        endsAt:
+          type: string
+          description: 종료 시간 (ISO-8601)
+          format: date-time
+          nullable: true
+          example: 2026-02-02T20:00:00Z
+        capacity:
+          type: integer
+          description: 정원
+          format: int32
+          example: 30
+        waitlistEnabled:
+          type: boolean
+          description: 대기 명단 사용 여부
+          example: true
+        registrationStartsAt:
+          type: string
+          description: 신청 시작 시간 (ISO-8601). null인 경우 요청 시점으로 자동 설정됩니다.
+          format: date-time
+          nullable: true
+          example: 2026-02-02T17:00:00Z
+        registrationEndsAt:
+          type: string
+          description: 신청 마감 시간 (ISO-8601)
+          format: date-time
+          example: 2026-02-02T17:30:00Z
+      description: 일정 생성 요청
+    CreateEventResponse:
+      required:
+      - publicId
+      type: object
+      properties:
+        publicId:
+          type: string
+    CreateRegistrationRequest:
+      type: object
+      properties:
+        guestName:
+          type: string
+          description: 비회원 이름
+          nullable: true
+        guestEmail:
+          type: string
+          description: 비회원 이메일
+          nullable: true
+      description: 이벤트 신청 요청
+    CreateRegistrationResponse:
+      required:
+      - registrationPublicId
+      type: object
+      properties:
+        registrationPublicId:
+          type: string
+          description: 신청 id
+      description: 이벤트 신청 응답
+    SocialLoginRequest:
+      required:
+      - code
+      - provider
+      type: object
+      properties:
+        provider:
+          type: string
+          description: 소셜로그인 제공자
+          example: GOOGLE
+        code:
+          type: string
+          description: 인가 코드 (authorization code)
+      description: 소셜 로그인 요청
+    LoginResponse:
+      required:
+      - token
+      type: object
+      properties:
+        token:
+          type: string
+    SignupRequest:
+      required:
+      - email
+      - name
+      - password
+      type: object
+      properties:
+        email:
+          type: string
+          description: 사용자 이메일
+          example: user@example.com
+        name:
+          type: string
+          description: 사용자 이름
+          example: 홍길동
+        password:
+          type: string
+          description: 비밀번호
+          example: password123
+        profileImage:
+          type: string
+          description: 프로필 이미지 URL
+          nullable: true
+          example: https://cdn.example.com/profile.png
+      description: 회원가입 요청
+    LoginRequest:
+      required:
+      - email
+      - password
+      type: object
+      properties:
+        email:
+          type: string
+          description: 사용자 이메일
+          example: user@example.com
+        password:
+          type: string
+          description: 사용자 비밀번호
+          example: mypassword
+      description: 로그인 요청
+    PatchMeRequest:
+      type: object
+      properties:
+        name:
+          type: string
+          nullable: true
+        email:
+          type: string
+          nullable: true
+        password:
+          type: string
+          nullable: true
+        profileImage:
+          type: string
+          nullable: true
+    UserDto:
+      required:
+      - email
+      - id
+      - name
+      type: object
+      properties:
+        id:
+          type: integer
+          format: int64
+        email:
+          type: string
+        name:
+          type: string
+        profileImage:
+          type: string
+          nullable: true
+    UpdateRegistrationStatusRequest:
+      type: object
+      properties:
+        status:
+          type: string
+          nullable: true
+          enum:
+          - HOST
+          - CONFIRMED
+          - WAITLISTED
+          - BANNED
+      description: 이벤트 신청 상태 변경 요청
+    PatchRegistrationResponse:
+      type: object
+      properties:
+        patchEmail:
+          type: string
+          nullable: true
+      description: 이벤트 신청 상태 변경
+    GetRegistrationResponse:
+      required:
+      - guestName
+      - registrationPublicId
+      - reservationEmail
+      - status
+      - waitlistPosition
+      type: object
+      properties:
+        status:
+          type: string
+          enum:
+          - HOST
+          - CONFIRMED
+          - WAITLISTED
+          - BANNED
+        guestName:
+          type: string
+        waitlistPosition:
+          type: integer
+          format: int32
+        registrationPublicId:
+          type: string
+        reservationEmail:
+          type: string
+      description: 이벤트 신청 정보 요청 응답
+    GetMyRegistrationsResponse:
+      required:
+      - registrations
+      type: object
+      properties:
+        registrations:
+          type: array
+          description: 신청 목록
+          items:
+            $ref: "#/components/schemas/MyRegistrationItem"
+      description: 내 이벤트 신청 목록 응답
+    MyRegistrationItem:
+      required:
+      - publicId
+      - confirmedCount
+      - waitlistCount
+      - status
+      - title
+      type: object
+      properties:
+        publicId:
+          type: string
+          description: 이벤트 공개 ID
+        title:
+          type: string
+          description: 이벤트 제목
+        startsAt:
+          type: string
+          description: 이벤트 시작 시간 (ISO-8601)
+          format: date-time
+          nullable: true
+        endsAt:
+          type: string
+          description: 이벤트 종료 시간 (ISO-8601)
+          format: date-time
+          nullable: true
+        registrationStartsAt:
+          type: string
+          description: 신청 시작 시간 (ISO-8601)
+          format: date-time
+          nullable: true
+        registrationEndsAt:
+          type: string
+          description: 신청 마감 시간 (ISO-8601)
+          format: date-time
+          nullable: true
+        capacity:
+          type: integer
+          description: 정원
+          format: int32
+          nullable: true
+        confirmedCount:
+          type: integer
+          description: 참여 확정자 수
+          format: int32
+        waitlistCount:
+          type: integer
+          description: 대기자 수
+          format: int32
+        status:
+          type: string
+          description: 신청 상태
+          enum:
+          - CONFIRMED
+          - WAITLISTED
+          - BANNED
+        waitlistedNum:
+          type: integer
+          description: 대기 순번 (WAITLISTED가 아니면 null)
+          format: int32
+          nullable: true
+      description: 내 이벤트 신청 요약
+    CapabilitiesInfo:
+      required:
+      - apply
+      - cancel
+      - shareLink
+      - wait
+      type: object
+      properties:
+        shareLink:
+          type: boolean
+          description: 공유 링크 가능 여부
+          example: false
+        apply:
+          type: boolean
+          description: 참여 신청 가능 여부(확정 자리 신청)
+          example: false
+        wait:
+          type: boolean
+          description: 대기 신청 가능 여부(정원 찼을 때)
+          example: false
+        cancel:
+          type: boolean
+          description: 신청 취소 가능 여부
+          example: true
+      description: 가능한 동작 블록
+    CreatorInfo:
+      required:
+      - email
+      - name
+      type: object
+      properties:
+        name:
+          type: string
+          description: 이름
+          example: 홍길동
+        email:
+          type: string
+          description: 이메일
+          example: user@example.com
+        profileImage:
+          type: string
+          description: 프로필 이미지
+          nullable: true
+          example: https://example.com/profile.png
+      description: 생성자 정보 블록
+    EventDetailResponse:
+      required:
+      - capabilities
+      - creator
+      - event
+      - guestsPreview
+      - viewer
+      type: object
+      properties:
+        event:
+          $ref: "#/components/schemas/EventInfo"
+        creator:
+          $ref: "#/components/schemas/CreatorInfo"
+        viewer:
+          $ref: "#/components/schemas/ViewerInfo"
+        capabilities:
+          $ref: "#/components/schemas/CapabilitiesInfo"
+        guestsPreview:
+          type: array
+          description: 참여자 미리보기 목록
+          items:
+            $ref: "#/components/schemas/GuestPreview"
+      description: 일정 상세 조회 응답
+    EventInfo:
+      required:
+      - publicId
+      - registrationEndsAt
+      - title
+      - confirmedCount
+      - waitlistCount
+      type: object
+      properties:
+        publicId:
+          type: string
+          description: 이벤트 publicId
+          example: dj8sadj10djnkas
+        title:
+          type: string
+          description: 이벤트 제목
+          example: 제2회 기획 세미나
+        description:
+          type: string
+          description: 이벤트 설명
+          nullable: true
+          example: 일정 상세 설명...
+        location:
+          type: string
+          description: 장소
+          nullable: true
+          example: 서울대
+        startsAt:
+          type: string
+          description: 시작 시간 (ISO-8601)
+          format: date-time
+          nullable: true
+          example: 2026-02-02T18:00:00Z
+        endsAt:
+          type: string
+          description: 종료 시간 (ISO-8601)
+          format: date-time
+          nullable: true
+          example: 2026-02-02T20:00:00Z
+        capacity:
+          type: integer
+          description: 정원
+          format: int32
+          nullable: true
+          example: 10
+        confirmedCount:
+          type: integer
+          description: 참여 확정 신청자 수
+          format: int32
+          example: 8
+        waitlistCount:
+          type: integer
+          description: 대기자 수
+          format: int32
+          example: 8
+        registrationStartsAt:
+          type: string
+          description: 신청 시작 시간 (ISO-8601)
+          format: date-time
+          nullable: true
+          example: 2026-02-02T17:00:00Z
+        registrationEndsAt:
+          type: string
+          description: 신청 마감 시간 (ISO-8601)
+          format: date-time
+          example: 2026-02-02T17:00:00Z
+      description: 이벤트 정보 블록
+    GuestPreview:
+      required:
+      - name
+      type: object
+      properties:
+        id:
+          type: integer
+          description: 참여자 ID (비회원이면 null)
+          format: int64
+          nullable: true
+          example: 1
+        name:
+          type: string
+          description: 참여자 이름
+          example: 홍길동
+        profileImage:
+          type: string
+          description: 프로필 이미지 URL
+          nullable: true
+          example: https://example.com/profile.png
+      description: 참여자 미리보기 정보
+    ViewerInfo:
+      required:
+      - status
+      type: object
+      properties:
+        status:
+          type: string
+          description: 이벤트 조회자(Viewer)의 상태
+          example: WAITLISTED
+          enum:
+          - HOST
+          - CONFIRMED
+          - WAITLISTED
+          - BANNED
+          - NONE
+        name:
+          type: string
+          description: viewer 이름 (비회원이면 null)
+          nullable: true
+          example: 홍길동
+        waitlistPosition:
+          type: integer
+          description: "대기 순번 (WAITLISTED일 때만 숫자, 아니면 null)"
+          format: int32
+          nullable: true
+          example: 3
+        registrationPublicId:
+          type: string
+          description: "registrationPublicId (게스트면 값, 아니면 null)"
+          nullable: true
+          example: "1"
+        reservationEmail:
+          type: string
+          description: "예약 이메일(게스트면 guestEmail, 로그인 유저면 user email 등 정책에 따름)"
+          nullable: true
+          example: skdfsj@gmaldkl
+      description: 조회자(viewer) 정보 블록
+    EventRegistrationItem:
+      required:
+      - createdAt
+      - name
+      - registrationId
+      - status
+      type: object
+      properties:
+        registrationId:
+          type: string
+          description: 신청 공개 ID
+        name:
+          type: string
+          description: 이름
+        email:
+          type: string
+          description: 이메일 (관리자 요청 시 노출)
+          nullable: true
+        profileImage:
+          type: string
+          description: 프로필 이미지 URL
+          nullable: true
+        createdAt:
+          type: string
+          description: 신청 일시
+          format: date-time
+        status:
+          type: string
+          description: 신청 상태
+          enum:
+          - HOST
+          - CONFIRMED
+          - WAITLISTED
+          - BANNED
+        waitingNum:
+          type: integer
+          description: 대기 순번 (status가 WAITLISTED일 때만 아니면 null)
+          format: int32
+          nullable: true
+      description: 신청자 정보
+    GetEventRegistrationsResponse:
+      required:
+      - hasNext
+      - participants
+      type: object
+      properties:
+        participants:
+          type: array
+          description: 신청자 목록
+          items:
+            $ref: "#/components/schemas/EventRegistrationItem"
+        totalCount:
+          type: integer
+          description: 필터에 따라 변하는 참여자 수
+          format: int32
+          nullable: true
+        nextCursor:
+          type: integer
+          description: 다음 페이지 시작 offset (없으면 null)
+          format: int32
+          nullable: true
+        hasNext:
+          type: boolean
+          description: 다음 페이지 존재 여부
+      description: 이벤트 신청 목록 조회 응답
+    MyEventResponse:
+      required:
+      - publicId
+      - registrationEndsAt
+      - title
+      - confirmedCount
+      - waitlistCount
+      type: object
+      properties:
+        publicId:
+          type: string
+        title:
+          type: string
+        startsAt:
+          type: string
+          format: date-time
+          nullable: true
+        endsAt:
+          type: string
+          format: date-time
+          nullable: true
+        registrationStartsAt:
+          type: string
+          format: date-time
+          nullable: true
+        registrationEndsAt:
+          type: string
+          format: date-time
+        capacity:
+          type: integer
+          format: int32
+          nullable: true
+        confirmedCount:
+          type: integer
+          format: int32
+        waitlistCount:
+          type: integer
+          format: int32
+    MyEventsInfiniteResponse:
+      required:
+      - events
+      - hasNext
+      type: object
+      properties:
+        events:
+          type: array
+          items:
+            $ref: "#/components/schemas/MyEventResponse"
+        nextCursor:
+          type: string
+          format: date-time
+          nullable: true
+        hasNext:
+          type: boolean
+    DeleteRegistrationResponse:
+      type: object
+    ErrorResponse:
+      required:
+      - code
+      - message
+      - title
+      type: object
+      properties:
+        code:
+          type: string
+          description: 에러 코드
+        title:
+          type: string
+          description: 에러 제목
+        message:
+          type: string
+          description: 에러 메시지
+      description: 에러 응답
+  securitySchemes:
+    bearerAuth:
+      type: http
+      description: JWT 토큰을 입력하세요
+      scheme: bearer
+      bearerFormat: JWT
diff --git a/src/main/resources/static/docs/swagger-ui.html b/src/main/resources/static/docs/swagger-ui.html
new file mode 100644
index 00000000..517735db
--- /dev/null
+++ b/src/main/resources/static/docs/swagger-ui.html
@@ -0,0 +1,36 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>MoiMing API Docs</title>
+    <link rel="stylesheet" href="/webjars/swagger-ui/swagger-ui.css" />
+    <style>
+      html,
+      body {
+        margin: 0;
+        height: 100%;
+      }
+      #swagger-ui {
+        height: 100%;
+      }
+    </style>
+  </head>
+  <body>
+    <div id="swagger-ui"></div>
+    <script src="/webjars/swagger-ui/swagger-ui-bundle.js"></script>
+    <script src="/webjars/swagger-ui/swagger-ui-standalone-preset.js"></script>
+    <script>
+      window.onload = function () {
+        window.ui = SwaggerUIBundle({
+          url: "/docs/openapi.yaml",
+          dom_id: "#swagger-ui",
+          deepLinking: true,
+          presets: [SwaggerUIBundle.presets.apis, SwaggerUIStandalonePreset],
+          plugins: [SwaggerUIBundle.plugins.DownloadUrl],
+          layout: "StandaloneLayout",
+        });
+      };
+    </script>
+  </body>
+</html>
diff --git a/src/test/kotlin/com/wafflestudio/spring2025/AuthIntegrationTest.kt b/src/test/kotlin/com/wafflestudio/spring2025/AuthIntegrationTest.kt
index 1d1c9a37..d670c9f3 100644
--- a/src/test/kotlin/com/wafflestudio/spring2025/AuthIntegrationTest.kt
+++ b/src/test/kotlin/com/wafflestudio/spring2025/AuthIntegrationTest.kt
@@ -1,153 +1,550 @@
 package com.wafflestudio.spring2025
 
 import com.fasterxml.jackson.databind.ObjectMapper
+import com.wafflestudio.spring2025.common.email.service.EmailService
 import com.wafflestudio.spring2025.domain.auth.dto.LoginRequest
 import com.wafflestudio.spring2025.domain.auth.dto.SignupRequest
+import com.wafflestudio.spring2025.domain.auth.model.SocialProvider
+import com.wafflestudio.spring2025.domain.user.identity.model.UserIdentity
+import com.wafflestudio.spring2025.domain.user.identity.repository.UserIdentityRepository
+import com.wafflestudio.spring2025.domain.user.model.PendingUser
+import com.wafflestudio.spring2025.domain.user.repository.PendingUserRepository
+import org.junit.jupiter.api.Assertions.assertNotEquals
+import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.Test
+import org.mindrot.jbcrypt.BCrypt
+import org.mockito.kotlin.any
+import org.mockito.kotlin.eq
+import org.mockito.kotlin.verify
 import org.springframework.beans.factory.annotation.Autowired
 import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc
 import org.springframework.boot.test.context.SpringBootTest
+import org.springframework.context.annotation.Import
 import org.springframework.http.MediaType
 import org.springframework.test.context.ActiveProfiles
+import org.springframework.test.context.bean.override.mockito.MockitoBean
 import org.springframework.test.web.servlet.MockMvc
 import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get
 import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post
 import org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath
 import org.springframework.test.web.servlet.result.MockMvcResultMatchers.status
 import org.testcontainers.junit.jupiter.Testcontainers
+import java.time.Instant
+import java.util.UUID
 
 @SpringBootTest
 @ActiveProfiles("test")
 @Testcontainers
 @AutoConfigureMockMvc
+@Import(TestContainerConfig::class)
 class AuthIntegrationTest
     @Autowired
     constructor(
         private val mvc: MockMvc,
         private val mapper: ObjectMapper,
         private val dataGenerator: DataGenerator,
+        private val pendingUserRepository: PendingUserRepository,
+        private val userIdentityRepository: UserIdentityRepository,
     ) {
+        // 실제 이메일 발송 방지: EmailService를 Mock으로 대체
+        @MockitoBean
+        private lateinit var emailService: EmailService
+
+        // =================================================================
+        // POST /api/auth/signup — 이메일 회원가입 요청 (인증 이메일 발송 트리거)
+        // =================================================================
+
         @Test
-        fun `should signup successfully`() {
-            // 회원가입할 수 있다
-            val email = "user1@example.com"
-            val name = "user1"
-            val password = "password123"
+        fun `유효한 데이터로 회원가입 요청 시 204를 반환하고 인증 이메일을 발송한다`() {
+            val email = "newuser-${UUID.randomUUID()}@example.com"
+            val request =
+                SignupRequest(
+                    email = email,
+                    name = "새사용자",
+                    password = "password123",
+                )
+
+            mvc
+                .perform(
+                    post("/api/auth/signup")
+                        .content(mapper.writeValueAsString(request))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isNoContent)
+
+            verify(emailService).sendVerificationEmail(eq(email), any())
+        }
+
+        @Test
+        fun `이메일이 빈 문자열이면 회원가입 요청 시 400을 반환한다`() {
+            val request = SignupRequest(email = "", name = "테스트유저", password = "password123")
+
+            mvc
+                .perform(
+                    post("/api/auth/signup")
+                        .content(mapper.writeValueAsString(request))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("BAD_EMAIL"))
+        }
+
+        @Test
+        fun `이메일 형식이 올바르지 않으면 회원가입 요청 시 400을 반환한다`() {
+            val request = SignupRequest(email = "not-an-email", name = "테스트유저", password = "password123")
+
+            mvc
+                .perform(
+                    post("/api/auth/signup")
+                        .content(mapper.writeValueAsString(request))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("BAD_EMAIL"))
+        }
+
+        @Test
+        fun `이름이 공백이면 회원가입 요청 시 400을 반환한다`() {
+            val request = SignupRequest(email = "user@example.com", name = "   ", password = "password123")
 
-            val request = SignupRequest(email, name, password)
             mvc
                 .perform(
-                    post("/api/v1/auth/signup")
+                    post("/api/auth/signup")
                         .content(mapper.writeValueAsString(request))
                         .contentType(MediaType.APPLICATION_JSON),
-                ).andExpect(status().isCreated)
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("BAD_NAME"))
         }
 
         @Test
-        fun `should return 400 error when email is blank during signup`() {
-            // 회원가입 시 이메일이 비어있으면 400 에러
-            val request = SignupRequest("", "user", "password")
+        fun `비밀번호가 8자 미만이면 회원가입 요청 시 400을 반환한다`() {
+            val request = SignupRequest(email = "user@example.com", name = "테스트유저", password = "pass1")
+
             mvc
                 .perform(
-                    post("/api/v1/auth/signup")
+                    post("/api/auth/signup")
                         .content(mapper.writeValueAsString(request))
                         .contentType(MediaType.APPLICATION_JSON),
                 ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("BAD_PASSWORD"))
         }
 
         @Test
-        fun `should return 409 error when email already exists during signup`() {
-            // 회원가입 시 이메일이 이미 존재하면 409 에러
-            val (user, token) = dataGenerator.generateUser()
-            val request = SignupRequest(user.email, user.name, "password", user.profileImage)
+        fun `비밀번호에 숫자가 없으면 회원가입 요청 시 400을 반환한다`() {
+            val request = SignupRequest(email = "user@example.com", name = "테스트유저", password = "onlyletters")
+
             mvc
                 .perform(
-                    post("/api/v1/auth/signup")
+                    post("/api/auth/signup")
+                        .content(mapper.writeValueAsString(request))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("BAD_PASSWORD"))
+        }
+
+        @Test
+        fun `비밀번호에 문자가 없으면 회원가입 요청 시 400을 반환한다`() {
+            val request = SignupRequest(email = "user@example.com", name = "테스트유저", password = "12345678")
+
+            mvc
+                .perform(
+                    post("/api/auth/signup")
+                        .content(mapper.writeValueAsString(request))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("BAD_PASSWORD"))
+        }
+
+        @Test
+        fun `인증 대기 중인 이메일로 회원가입 요청 시 409를 반환한다`() {
+            val email = "pending-${UUID.randomUUID()}@example.com"
+            pendingUserRepository.save(
+                PendingUser(
+                    email = email,
+                    name = "대기유저",
+                    passwordHash = BCrypt.hashpw("password123", BCrypt.gensalt()),
+                    verificationCode = UUID.randomUUID().toString(),
+                    expiresAt = Instant.now().plusSeconds(3600),
+                ),
+            )
+
+            val request = SignupRequest(email = email, name = "테스트유저", password = "password123")
+
+            mvc
+                .perform(
+                    post("/api/auth/signup")
                         .content(mapper.writeValueAsString(request))
                         .contentType(MediaType.APPLICATION_JSON),
                 ).andExpect(status().isConflict)
+                .andExpect(jsonPath("$.code").value("EMAIL_VERIFICATION_PENDING"))
+        }
+
+        @Test
+        fun `이미 이메일로 가입된 계정에 회원가입 요청 시 409를 반환한다`() {
+            val (user, _) = dataGenerator.generateUser()
+            val request = SignupRequest(email = user.email, name = "테스트유저", password = "password123")
+
+            mvc
+                .perform(
+                    post("/api/auth/signup")
+                        .content(mapper.writeValueAsString(request))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isConflict)
+                .andExpect(jsonPath("$.code").value("EMAIL_ACCOUNT_ALREADY_EXIST"))
+        }
+
+        @Test
+        fun `구글 소셜로 가입된 이메일로 회원가입 요청 시 409를 반환한다`() {
+            val (user, _) = dataGenerator.generateUser()
+            userIdentityRepository.save(
+                UserIdentity(
+                    userId = user.id!!,
+                    provider = SocialProvider.GOOGLE.name,
+                    providerUserId = "google-${UUID.randomUUID()}",
+                ),
+            )
+
+            val request = SignupRequest(email = user.email, name = "테스트유저", password = "password123")
+
+            mvc
+                .perform(
+                    post("/api/auth/signup")
+                        .content(mapper.writeValueAsString(request))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isConflict)
+                .andExpect(jsonPath("$.code").value("GOOGLE_ACCOUNT_ALREADY_EXIST"))
+        }
+
+        // =================================================================
+        // POST /api/auth/email-verification/{code} — 이메일 인증 완료
+        // =================================================================
+
+        @Test
+        fun `유효한 인증 코드로 이메일 인증 성공 시 200을 반환한다`() {
+            val verificationCode = UUID.randomUUID().toString()
+            pendingUserRepository.save(
+                PendingUser(
+                    email = "verify-${UUID.randomUUID()}@example.com",
+                    name = "인증유저",
+                    passwordHash = BCrypt.hashpw("password123", BCrypt.gensalt()),
+                    verificationCode = verificationCode,
+                    expiresAt = Instant.now().plusSeconds(3600),
+                ),
+            )
+
+            mvc
+                .perform(
+                    post("/api/auth/email-verification/$verificationCode"),
+                ).andExpect(status().isOk)
+        }
+
+        @Test
+        fun `존재하지 않는 인증 코드로 이메일 인증 시 400을 반환한다`() {
+            val invalidCode = UUID.randomUUID().toString()
+
+            mvc
+                .perform(
+                    post("/api/auth/email-verification/$invalidCode"),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("INVALID_VERIFICATION_CODE"))
+        }
+
+        @Test
+        fun `만료된 인증 코드로 이메일 인증 시 400을 반환한다`() {
+            val expiredCode = UUID.randomUUID().toString()
+            pendingUserRepository.save(
+                PendingUser(
+                    email = "expired-${UUID.randomUUID()}@example.com",
+                    name = "만료유저",
+                    passwordHash = BCrypt.hashpw("password123", BCrypt.gensalt()),
+                    verificationCode = expiredCode,
+                    expiresAt = Instant.now().minusSeconds(3600), // 이미 만료된 코드
+                ),
+            )
+
+            mvc
+                .perform(
+                    post("/api/auth/email-verification/$expiredCode"),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("INVALID_VERIFICATION_CODE"))
         }
 
+        // =================================================================
+        // POST /api/auth/login — 이메일 로그인
+        // =================================================================
+
         @Test
-        fun `should login with email successfully`() {
-            // 로그인할 수 있다
-            val password = "myPassword"
-            val (user, token) = dataGenerator.generateUserWithPassword(password)
+        fun `유효한 이메일과 비밀번호로 로그인 성공 시 200과 토큰을 반환한다`() {
+            val password = "myPassword1"
+            val (user, _) = dataGenerator.generateUserWithPassword(password)
             val request = LoginRequest(email = user.email, password = password)
+
             mvc
                 .perform(
-                    post("/api/v1/auth/login")
+                    post("/api/auth/login")
                         .content(mapper.writeValueAsString(request))
                         .contentType(MediaType.APPLICATION_JSON),
                 ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.token").isNotEmpty)
         }
 
         @Test
-        fun `should return 401 error when email is incorrect during login`() {
-            // 로그인 시 이메일이 틀렸다면 401 에러
-            val request = LoginRequest(email = "wrong@example.com", password = "something")
+        fun `존재하지 않는 이메일로 로그인 시 401을 반환한다`() {
+            val request = LoginRequest(email = "nonexistent@example.com", password = "password123")
+
             mvc
                 .perform(
-                    post("/api/v1/auth/login")
+                    post("/api/auth/login")
                         .content(mapper.writeValueAsString(request))
                         .contentType(MediaType.APPLICATION_JSON),
                 ).andExpect(status().isUnauthorized)
+                .andExpect(jsonPath("$.code").value("LOGIN_FAILED"))
         }
 
         @Test
-        fun `should retrieve own user information`() {
-            // 본인 정보를 조회할 수 있다
-            val (user, token) = dataGenerator.generateUser()
+        fun `잘못된 비밀번호로 로그인 시 401을 반환한다`() {
+            val (user, _) = dataGenerator.generateUserWithPassword("correctPassword1")
+            val request = LoginRequest(email = user.email, password = "wrongPassword9")
+
             mvc
                 .perform(
-                    get("/api/v1/users/me")
-                        .header("Authorization", "Bearer $token")
+                    post("/api/auth/login")
+                        .content(mapper.writeValueAsString(request))
                         .contentType(MediaType.APPLICATION_JSON),
-                ).andExpect(status().isOk)
-                .andExpect(jsonPath("$.email").value(user.email))
+                ).andExpect(status().isUnauthorized)
+                .andExpect(jsonPath("$.code").value("LOGIN_FAILED"))
         }
 
         @Test
-        fun `should return 401 when retrieving user information with invalid token`() {
-            // 유효하지 않은 토큰으로 본인 정보 조회 시 401
-            val (user, token) = dataGenerator.generateUser()
+        fun `비밀번호 없이 생성된 사용자(소셜 가입)로 이메일 로그인 시 401을 반환한다`() {
+            // DataGenerator.generateUser()는 passwordHash 없이 User 생성
+            val (user, _) = dataGenerator.generateUser()
+            val request = LoginRequest(email = user.email, password = "anyPassword1")
+
             mvc
                 .perform(
-                    get("/api/v1/users/me")
-                        .header("Authorization", "Bearer wrong")
+                    post("/api/auth/login")
+                        .content(mapper.writeValueAsString(request))
                         .contentType(MediaType.APPLICATION_JSON),
                 ).andExpect(status().isUnauthorized)
+                .andExpect(jsonPath("$.code").value("LOGIN_FAILED"))
         }
 
+        // =================================================================
+        // POST /api/auth/logout — 로그아웃 (JWT 블랙리스트 등록)
+        // =================================================================
+
         @Test
-        fun `should blacklist jwt`() {
-            val (user, token) = dataGenerator.generateUser()
+        fun `유효한 토큰으로 로그아웃 성공 시 204를 반환한다`() {
+            val (_, token) = dataGenerator.generateUser()
+
             mvc
                 .perform(
-                    get("/api/v1/users/me")
+                    post("/api/auth/logout")
                         .header("Authorization", "Bearer $token")
                         .contentType(MediaType.APPLICATION_JSON),
-                ).andExpect(status().isOk)
-                .andExpect(jsonPath("$.email").value(user.email))
+                ).andExpect(status().isNoContent)
+        }
+
+        @Test
+        fun `Authorization 헤더 없이 로그아웃 요청 시 204를 반환한다`() {
+            // /api/auth/logout은 @AuthRequired가 없으므로 인증 없이도 204 반환
+            mvc
+                .perform(
+                    post("/api/auth/logout")
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isNoContent)
+        }
+
+        // =================================================================
+        // GET /api/users/me — 로그아웃 블랙리스트 검증 (인증 흐름 관점)
+        // 기본 내 정보 조회 시나리오는 UserIntegrationTest에서 다룸
+        // =================================================================
+
+        @Test
+        fun `로그아웃 후 블랙리스트된 토큰으로 내 정보 조회 시 401을 반환한다`() {
+            val (_, token) = dataGenerator.generateUser()
+
+            // 로그아웃으로 토큰 블랙리스트 등록
             mvc
                 .perform(
-                    post("/api/v1/users/logout")
-                        .queryParam("token", token)
+                    post("/api/auth/logout")
                         .header("Authorization", "Bearer $token")
                         .contentType(MediaType.APPLICATION_JSON),
-                ).andExpect(status().isOk)
+                ).andExpect(status().isNoContent)
+
+            // 블랙리스트된 토큰으로 내 정보 조회 시 401
             mvc
                 .perform(
-                    post("/api/v1/users/logout")
-                        .queryParam("token", token)
+                    get("/api/users/me")
                         .header("Authorization", "Bearer $token")
                         .contentType(MediaType.APPLICATION_JSON),
                 ).andExpect(status().isUnauthorized)
+                .andExpect(jsonPath("$.code").value("AUTHENTICATION_REQUIRED"))
+        }
+
+        // =================================================================
+        // End-to-End: 회원가입 → 이메일 인증 → 로그인 → 내 정보 조회
+        // =================================================================
+
+        @Test
+        fun `회원가입 요청 후 이메일 인증을 완료하면 로그인 후 내 정보를 조회할 수 있다`() {
+            val email = "e2e-${UUID.randomUUID()}@example.com"
+            val name = "E2E유저"
+            val password = "password123"
+
+            // 1. 회원가입 요청 → 204 No Content (인증 이메일 발송)
             mvc
                 .perform(
-                    get("/api/v1/users/me")
+                    post("/api/auth/signup")
+                        .content(mapper.writeValueAsString(SignupRequest(email = email, name = name, password = password)))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isNoContent)
+
+            // 2. DB에서 PendingUser의 인증 코드 획득
+            val verificationCode = pendingUserRepository.findByEmail(email)!!.verificationCode
+
+            // 3. 이메일 인증 완료 → 200 OK (User 생성)
+            mvc
+                .perform(
+                    post("/api/auth/email-verification/$verificationCode"),
+                ).andExpect(status().isOk)
+
+            // 4. 로그인 → 200 OK + JWT 토큰
+            val loginResult =
+                mvc
+                    .perform(
+                        post("/api/auth/login")
+                            .content(mapper.writeValueAsString(LoginRequest(email = email, password = password)))
+                            .contentType(MediaType.APPLICATION_JSON),
+                    ).andExpect(status().isOk)
+                    .andExpect(jsonPath("$.token").isNotEmpty)
+                    .andReturn()
+
+            val token =
+                mapper
+                    .readTree(loginResult.response.contentAsString)
+                    .get("token")
+                    .asText()
+
+            // 5. 내 정보 조회 → 200 OK + 사용자 정보
+            mvc
+                .perform(
+                    get("/api/users/me")
                         .header("Authorization", "Bearer $token")
                         .contentType(MediaType.APPLICATION_JSON),
-                ).andExpect(status().isUnauthorized)
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.email").value(email))
+                .andExpect(jsonPath("$.name").value(name))
+        }
+
+        @Test
+        fun `이메일 인증 완료 후 동일한 인증 코드로 재인증 시도 시 400을 반환한다`() {
+            val verificationCode = UUID.randomUUID().toString()
+            pendingUserRepository.save(
+                PendingUser(
+                    email = "onetime-${UUID.randomUUID()}@example.com",
+                    name = "일회용인증",
+                    passwordHash = BCrypt.hashpw("password123", BCrypt.gensalt()),
+                    verificationCode = verificationCode,
+                    expiresAt = Instant.now().plusSeconds(3600),
+                ),
+            )
+
+            // 첫 번째 인증 → 성공
+            mvc
+                .perform(
+                    post("/api/auth/email-verification/$verificationCode"),
+                ).andExpect(status().isOk)
+
+            // 두 번째 인증 (PendingUser 삭제됨) → 실패
+            mvc
+                .perform(
+                    post("/api/auth/email-verification/$verificationCode"),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("INVALID_VERIFICATION_CODE"))
+        }
+
+        // =================================================================
+        // 이메일 인증 만료 후 재가입 요청 시나리오
+        // EmailVerificationService.createPendingUser:
+        //   만료된 PendingUser가 존재하면 삭제 후 새로운 PendingUser 생성
+        // =================================================================
+
+        @Test
+        fun `인증 코드가 만료된 이메일로 재가입 요청 시 기존 PendingUser를 교체하고 204를 반환한다`() {
+            val email = "reregister-${UUID.randomUUID()}@example.com"
+            val oldCode = UUID.randomUUID().toString()
+
+            // 만료된 PendingUser 사전 생성
+            pendingUserRepository.save(
+                PendingUser(
+                    email = email,
+                    name = "구사용자",
+                    passwordHash = BCrypt.hashpw("oldPassword1", BCrypt.gensalt()),
+                    verificationCode = oldCode,
+                    expiresAt = Instant.now().minusSeconds(3600), // 이미 만료
+                ),
+            )
+
+            // 동일 이메일로 재가입 요청 → 만료된 PendingUser 삭제 후 새로 생성 → 204
+            val request = SignupRequest(email = email, name = "신사용자", password = "newPassword1")
+            mvc
+                .perform(
+                    post("/api/auth/signup")
+                        .content(mapper.writeValueAsString(request))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isNoContent)
+
+            // 새로운 PendingUser가 생성됐는지 확인 (코드가 교체됨)
+            val newPendingUser = pendingUserRepository.findByEmail(email)!!
+            assertNotEquals(oldCode, newPendingUser.verificationCode)
+            assertTrue(newPendingUser.expiresAt.isAfter(Instant.now()))
+        }
+
+        @Test
+        fun `만료된 인증 코드로 인증 시도 후 동일 이메일로 재가입하면 새 코드로 인증할 수 있다`() {
+            val email = "reauth-${UUID.randomUUID()}@example.com"
+            val password = "password123"
+            val expiredCode = UUID.randomUUID().toString()
+
+            // 1. 만료된 PendingUser 사전 생성
+            pendingUserRepository.save(
+                PendingUser(
+                    email = email,
+                    name = "재인증유저",
+                    passwordHash = BCrypt.hashpw(password, BCrypt.gensalt()),
+                    verificationCode = expiredCode,
+                    expiresAt = Instant.now().minusSeconds(3600),
+                ),
+            )
+
+            // 2. 만료된 코드로 인증 시도 → 400
+            mvc
+                .perform(
+                    post("/api/auth/email-verification/$expiredCode"),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("INVALID_VERIFICATION_CODE"))
+
+            // 3. 동일 이메일로 재가입 요청 → 204 (만료된 PendingUser 삭제 후 신규 생성)
+            mvc
+                .perform(
+                    post("/api/auth/signup")
+                        .content(mapper.writeValueAsString(SignupRequest(email = email, name = "재인증유저", password = password)))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isNoContent)
+
+            // 4. 새로운 인증 코드로 이메일 인증 → 200
+            val newCode = pendingUserRepository.findByEmail(email)!!.verificationCode
+            mvc
+                .perform(
+                    post("/api/auth/email-verification/$newCode"),
+                ).andExpect(status().isOk)
+
+            // 5. 새로 가입된 계정으로 로그인 → 200
+            mvc
+                .perform(
+                    post("/api/auth/login")
+                        .content(mapper.writeValueAsString(LoginRequest(email = email, password = password)))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.token").isNotEmpty)
         }
     }
diff --git a/src/test/kotlin/com/wafflestudio/spring2025/DataGenerator.kt b/src/test/kotlin/com/wafflestudio/spring2025/DataGenerator.kt
index c55e17af..5e6313aa 100644
--- a/src/test/kotlin/com/wafflestudio/spring2025/DataGenerator.kt
+++ b/src/test/kotlin/com/wafflestudio/spring2025/DataGenerator.kt
@@ -40,4 +40,18 @@ class DataGenerator(
         val token = jwtTokenProvider.createToken(user.id!!)
         return user to token
     }
+
+    fun generateUserWithProfileImage(profileImageKey: String): Pair<User, String> {
+        val email = "user-${UUID.randomUUID()}@example.com"
+        val user =
+            userRepository.save(
+                User(
+                    email = email,
+                    name = "user",
+                    profileImage = profileImageKey,
+                ),
+            )
+        val token = jwtTokenProvider.createToken(user.id!!)
+        return user to token
+    }
 }
diff --git a/src/test/kotlin/com/wafflestudio/spring2025/EventIntegrationTest.kt b/src/test/kotlin/com/wafflestudio/spring2025/EventIntegrationTest.kt
new file mode 100644
index 00000000..aa96cba1
--- /dev/null
+++ b/src/test/kotlin/com/wafflestudio/spring2025/EventIntegrationTest.kt
@@ -0,0 +1,1320 @@
+package com.wafflestudio.spring2025
+
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.wafflestudio.spring2025.common.email.service.EmailService
+import com.wafflestudio.spring2025.domain.event.dto.request.CreateEventRequest
+import com.wafflestudio.spring2025.domain.event.dto.request.UpdateEventRequest
+import com.wafflestudio.spring2025.domain.event.model.Event
+import com.wafflestudio.spring2025.domain.event.repository.EventRepository
+import com.wafflestudio.spring2025.domain.registration.model.Registration
+import com.wafflestudio.spring2025.domain.registration.model.RegistrationStatus
+import com.wafflestudio.spring2025.domain.registration.repository.RegistrationRepository
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import org.mockito.kotlin.any
+import org.mockito.kotlin.never
+import org.mockito.kotlin.times
+import org.mockito.kotlin.verify
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc
+import org.springframework.boot.test.context.SpringBootTest
+import org.springframework.context.annotation.Import
+import org.springframework.http.MediaType
+import org.springframework.test.context.ActiveProfiles
+import org.springframework.test.context.bean.override.mockito.MockitoBean
+import org.springframework.test.web.servlet.MockMvc
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put
+import org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath
+import org.springframework.test.web.servlet.result.MockMvcResultMatchers.status
+import org.testcontainers.junit.jupiter.Testcontainers
+import java.time.Instant
+import java.util.UUID
+
+@SpringBootTest
+@ActiveProfiles("test")
+@Testcontainers
+@AutoConfigureMockMvc
+@Import(TestContainerConfig::class)
+class EventIntegrationTest
+    @Autowired
+    constructor(
+        private val mvc: MockMvc,
+        private val mapper: ObjectMapper,
+        private val dataGenerator: DataGenerator,
+        private val eventRepository: EventRepository,
+        private val registrationRepository: RegistrationRepository,
+    ) {
+        @MockitoBean
+        private lateinit var emailService: EmailService
+
+        // =================================================================
+        // Helpers
+        // =================================================================
+
+        private fun createEventInDb(
+            createdBy: Long,
+            title: String = "테스트 이벤트",
+            capacity: Int = 10,
+            waitlistEnabled: Boolean = false,
+            startsAt: Instant = Instant.now().plusSeconds(7200),
+            endsAt: Instant = Instant.now().plusSeconds(10800),
+            registrationStartsAt: Instant? = null,
+            registrationEndsAt: Instant = Instant.now().plusSeconds(5400),
+        ): Event =
+            eventRepository.save(
+                Event(
+                    publicId = UUID.randomUUID().toString(),
+                    title = title,
+                    capacity = capacity,
+                    waitlistEnabled = waitlistEnabled,
+                    startsAt = startsAt,
+                    endsAt = endsAt,
+                    registrationStartsAt = registrationStartsAt,
+                    registrationEndsAt = registrationEndsAt,
+                    createdBy = createdBy,
+                ),
+            )
+
+        /**
+         * 유효한 CreateEventRequest 기본값.
+         * - startsAt=now+7200, endsAt=now+10800 (미래)
+         * - registrationStartsAt=now+3600 < startsAt(+7200) ✓
+         * - registrationEndsAt=now+5400  < startsAt(+7200), > registrationStartsAt(+3600) ✓
+         */
+        private fun validCreateRequest(
+            title: String = "정기 모임",
+            capacity: Int = 30,
+            waitlistEnabled: Boolean = false,
+        ) = CreateEventRequest(
+            title = title,
+            description = "정기 모임입니다",
+            location = "강의실 101",
+            startsAt = Instant.now().plusSeconds(7200),
+            endsAt = Instant.now().plusSeconds(10800),
+            capacity = capacity,
+            waitlistEnabled = waitlistEnabled,
+            registrationStartsAt = Instant.now().plusSeconds(3600),
+            registrationEndsAt = Instant.now().plusSeconds(5400),
+        )
+
+        // =================================================================
+        // POST /api/events — 이벤트 생성
+        // =================================================================
+
+        @Test
+        fun `유효한 데이터로 이벤트 생성 시 200과 publicId를 반환한다`() {
+            val (_, token) = dataGenerator.generateUser()
+
+            mvc
+                .perform(
+                    post("/api/events")
+                        .header("Authorization", "Bearer $token")
+                        .content(mapper.writeValueAsString(validCreateRequest()))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.publicId").isNotEmpty)
+        }
+
+        @Test
+        fun `인증 없이 이벤트 생성 요청 시 401을 반환한다`() {
+            mvc
+                .perform(
+                    post("/api/events")
+                        .content(mapper.writeValueAsString(validCreateRequest()))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isUnauthorized)
+                .andExpect(jsonPath("$.code").value("AUTHENTICATION_REQUIRED"))
+        }
+
+        @Test
+        fun `제목이 공백인 이벤트 생성 요청 시 400을 반환한다`() {
+            val (_, token) = dataGenerator.generateUser()
+
+            mvc
+                .perform(
+                    post("/api/events")
+                        .header("Authorization", "Bearer $token")
+                        .content(mapper.writeValueAsString(validCreateRequest(title = "   ")))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("EVENT_TITLE_BLANK"))
+        }
+
+        @Test
+        fun `정원이 0인 이벤트 생성 요청 시 400을 반환한다`() {
+            val (_, token) = dataGenerator.generateUser()
+
+            mvc
+                .perform(
+                    post("/api/events")
+                        .header("Authorization", "Bearer $token")
+                        .content(mapper.writeValueAsString(validCreateRequest(capacity = 0)))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("EVENT_CAPACITY_INVALID"))
+        }
+
+        @Test
+        fun `정원이 음수인 이벤트 생성 요청 시 400을 반환한다`() {
+            val (_, token) = dataGenerator.generateUser()
+
+            mvc
+                .perform(
+                    post("/api/events")
+                        .header("Authorization", "Bearer $token")
+                        .content(mapper.writeValueAsString(validCreateRequest(capacity = -5)))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("EVENT_CAPACITY_INVALID"))
+        }
+
+        @Test
+        fun `모임 시작 시간이 신청 마감 시간보다 이르면 이벤트 생성 요청 시 400을 반환한다`() {
+            val (_, token) = dataGenerator.generateUser()
+            // registrationEndsAt(+5400) > startsAt(+3600) 위반
+            val request =
+                CreateEventRequest(
+                    title = "정기 모임",
+                    capacity = 10,
+                    waitlistEnabled = false,
+                    startsAt = Instant.now().plusSeconds(3600),
+                    endsAt = Instant.now().plusSeconds(7200),
+                    registrationEndsAt = Instant.now().plusSeconds(5400),
+                )
+
+            mvc
+                .perform(
+                    post("/api/events")
+                        .header("Authorization", "Bearer $token")
+                        .content(mapper.writeValueAsString(request))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("REGISTRATION_ENDS_AFTER_EVENT_START"))
+        }
+
+        @Test
+        fun `모임 시작 시간이 종료 시간보다 늦으면 이벤트 생성 요청 시 400을 반환한다`() {
+            val (_, token) = dataGenerator.generateUser()
+            val request =
+                CreateEventRequest(
+                    title = "정기 모임",
+                    capacity = 10,
+                    waitlistEnabled = false,
+                    startsAt = Instant.now().plusSeconds(7200),
+                    endsAt = Instant.now().plusSeconds(3600), // startsAt 보다 이전
+                    registrationEndsAt = Instant.now().plusSeconds(5400),
+                )
+
+            mvc
+                .perform(
+                    post("/api/events")
+                        .header("Authorization", "Bearer $token")
+                        .content(mapper.writeValueAsString(request))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("EVENT_TIME_RANGE_INVALID"))
+        }
+
+        @Test
+        fun `신청 시작 시간이 과거여도 이벤트를 생성할 수 있다`() {
+            val (_, token) = dataGenerator.generateUser()
+            // 과거 registrationStartsAt = 이미 모집이 시작된 것으로 허용
+            val request =
+                CreateEventRequest(
+                    title = "정기 모임",
+                    capacity = 10,
+                    waitlistEnabled = false,
+                    registrationStartsAt = Instant.now().minusSeconds(3600),
+                    registrationEndsAt = Instant.now().plusSeconds(5400),
+                )
+
+            mvc
+                .perform(
+                    post("/api/events")
+                        .header("Authorization", "Bearer $token")
+                        .content(mapper.writeValueAsString(request))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+        }
+
+        @Test
+        fun `신청 마감 시간이 과거이면 이벤트 생성 요청 시 400을 반환한다`() {
+            val (_, token) = dataGenerator.generateUser()
+            val request =
+                CreateEventRequest(
+                    title = "정기 모임",
+                    capacity = 10,
+                    waitlistEnabled = false,
+                    registrationEndsAt = Instant.now().minusSeconds(3600),
+                )
+
+            mvc
+                .perform(
+                    post("/api/events")
+                        .header("Authorization", "Bearer $token")
+                        .content(mapper.writeValueAsString(request))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("REGISTRATION_ENDS_IN_PAST"))
+        }
+
+        @Test
+        fun `신청 마감 시간이 신청 시작 시간보다 이르면 이벤트 생성 요청 시 400을 반환한다`() {
+            val (_, token) = dataGenerator.generateUser()
+            val request =
+                CreateEventRequest(
+                    title = "정기 모임",
+                    capacity = 10,
+                    waitlistEnabled = false,
+                    registrationStartsAt = Instant.now().plusSeconds(5400),
+                    registrationEndsAt = Instant.now().plusSeconds(3600), // 시작보다 이전
+                )
+
+            mvc
+                .perform(
+                    post("/api/events")
+                        .header("Authorization", "Bearer $token")
+                        .content(mapper.writeValueAsString(request))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("REGISTRATION_TIME_RANGE_INVALID"))
+        }
+
+        @Test
+        fun `신청 시작 시간이 모임 시작 시간보다 늦으면 이벤트 생성 요청 시 400을 반환한다`() {
+            val (_, token) = dataGenerator.generateUser()
+            // startsAt=+3600, registrationStartsAt=+5400 → 신청 시작이 모임 시작보다 늦음
+            val request =
+                CreateEventRequest(
+                    title = "정기 모임",
+                    capacity = 10,
+                    waitlistEnabled = false,
+                    startsAt = Instant.now().plusSeconds(3600),
+                    endsAt = Instant.now().plusSeconds(7200),
+                    registrationStartsAt = Instant.now().plusSeconds(5400),
+                    registrationEndsAt = Instant.now().plusSeconds(7200),
+                )
+
+            mvc
+                .perform(
+                    post("/api/events")
+                        .header("Authorization", "Bearer $token")
+                        .content(mapper.writeValueAsString(request))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("REGISTRATION_STARTS_AFTER_EVENT_START"))
+        }
+
+        @Test
+        fun `신청 마감 시간이 모임 시작 시간보다 늦으면 이벤트 생성 요청 시 400을 반환한다`() {
+            val (_, token) = dataGenerator.generateUser()
+            // startsAt=+3600, registrationEndsAt=+5400 → 신청 마감이 모임 시작보다 늦음
+            val request =
+                CreateEventRequest(
+                    title = "정기 모임",
+                    capacity = 10,
+                    waitlistEnabled = false,
+                    startsAt = Instant.now().plusSeconds(3600),
+                    endsAt = Instant.now().plusSeconds(7200),
+                    registrationEndsAt = Instant.now().plusSeconds(5400),
+                )
+
+            mvc
+                .perform(
+                    post("/api/events")
+                        .header("Authorization", "Bearer $token")
+                        .content(mapper.writeValueAsString(request))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("REGISTRATION_ENDS_AFTER_EVENT_START"))
+        }
+
+        // =================================================================
+        // GET /api/events/{publicId} — 이벤트 상세 조회
+        // =================================================================
+
+        @Test
+        fun `존재하지 않는 publicId로 이벤트 상세 조회 시 404를 반환한다`() {
+            mvc
+                .perform(
+                    get("/api/events/${UUID.randomUUID()}"),
+                ).andExpect(status().isNotFound)
+                .andExpect(jsonPath("$.code").value("EVENT_NOT_FOUND"))
+        }
+
+        @Test
+        fun `비로그인 사용자가 이벤트 상세 조회 시 200과 올바른 응답 구조를 반환한다`() {
+            val (creator, _) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = creator.id!!, title = "공개 이벤트", capacity = 10)
+
+            mvc
+                .perform(
+                    get("/api/events/${event.publicId}"),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.event.publicId").value(event.publicId))
+                .andExpect(jsonPath("$.event.title").value("공개 이벤트"))
+                .andExpect(jsonPath("$.event.capacity").value(10))
+                .andExpect(jsonPath("$.event.confirmedCount").value(0))
+                .andExpect(jsonPath("$.event.waitlistCount").value(0))
+                .andExpect(jsonPath("$.creator.name").value(creator.name))
+                .andExpect(jsonPath("$.creator.email").value(creator.email))
+                .andExpect(jsonPath("$.viewer.status").value("NONE"))
+                .andExpect(jsonPath("$.viewer.name").value(null as Any?))
+                .andExpect(jsonPath("$.viewer.waitlistPosition").value(null as Any?))
+                .andExpect(jsonPath("$.capabilities.shareLink").value(false))
+                .andExpect(jsonPath("$.capabilities.apply").value(true)) // 정원 여유 있고 신청 기간 제한 없음
+                .andExpect(jsonPath("$.capabilities.wait").value(false))
+                .andExpect(jsonPath("$.capabilities.cancel").value(false))
+                .andExpect(jsonPath("$.guestsPreview").isArray)
+                .andExpect(jsonPath("$.viewer.registrationPublicId").value(null as Any?))
+                .andExpect(jsonPath("$.viewer.reservationEmail").value(null as Any?))
+        }
+
+        @Test
+        fun `로그인한 이벤트 주최자가 상세 조회 시 viewerStatus가 HOST이고 shareLink가 true이다`() {
+            val (host, token) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = host.id!!)
+
+            mvc
+                .perform(
+                    get("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $token"),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.viewer.status").value("HOST"))
+                .andExpect(jsonPath("$.viewer.name").value(host.name))
+                .andExpect(jsonPath("$.capabilities.shareLink").value(true))
+                .andExpect(jsonPath("$.capabilities.apply").value(false))
+                .andExpect(jsonPath("$.capabilities.wait").value(false))
+                .andExpect(jsonPath("$.capabilities.cancel").value(false))
+        }
+
+        @Test
+        fun `로그인했지만 참여하지 않은 사용자가 이벤트 조회 시 viewerStatus가 NONE이고 이름이 포함된다`() {
+            val (creator, _) = dataGenerator.generateUser()
+            val (viewer, viewerToken) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = creator.id!!)
+
+            mvc
+                .perform(
+                    get("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $viewerToken"),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.viewer.status").value("NONE"))
+                .andExpect(jsonPath("$.viewer.name").value(viewer.name))
+        }
+
+        @Test
+        fun `정원이 찬 이벤트를 비로그인 사용자가 조회 시 apply는 false이다`() {
+            val (creator, _) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = creator.id!!, capacity = 1, waitlistEnabled = false)
+
+            registrationRepository.save(
+                Registration(
+                    userId = creator.id!!,
+                    eventId = event.id!!,
+                    status = RegistrationStatus.CONFIRMED,
+                ),
+            )
+
+            mvc
+                .perform(
+                    get("/api/events/${event.publicId}"),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.capabilities.apply").value(false))
+                .andExpect(jsonPath("$.capabilities.wait").value(false))
+        }
+
+        @Test
+        fun `정원이 찬 이벤트에서 waitlistEnabled이면 비로그인 사용자 조회 시 wait가 true이다`() {
+            val (creator, _) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = creator.id!!, capacity = 1, waitlistEnabled = true)
+
+            registrationRepository.save(
+                Registration(
+                    userId = creator.id!!,
+                    eventId = event.id!!,
+                    status = RegistrationStatus.CONFIRMED,
+                ),
+            )
+
+            mvc
+                .perform(
+                    get("/api/events/${event.publicId}"),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.capabilities.apply").value(false))
+                .andExpect(jsonPath("$.capabilities.wait").value(true))
+        }
+
+        @Test
+        fun `신청 기간이 지난 이벤트를 비로그인 사용자가 조회 시 apply와 wait 모두 false이다`() {
+            val (creator, _) = dataGenerator.generateUser()
+            // registrationEndsAt이 과거 → withinWindow = false
+            val event =
+                eventRepository.save(
+                    Event(
+                        publicId = UUID.randomUUID().toString(),
+                        title = "마감된 이벤트",
+                        capacity = 10,
+                        waitlistEnabled = true,
+                        startsAt = Instant.now().plusSeconds(3600),
+                        endsAt = Instant.now().plusSeconds(7200),
+                        registrationStartsAt = Instant.now().minusSeconds(7200),
+                        registrationEndsAt = Instant.now().minusSeconds(3600), // 이미 마감
+                        createdBy = creator.id!!,
+                    ),
+                )
+
+            mvc
+                .perform(
+                    get("/api/events/${event.publicId}"),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.capabilities.apply").value(false))
+                .andExpect(jsonPath("$.capabilities.wait").value(false))
+        }
+
+        @Test
+        fun `CONFIRMED 참가자가 이벤트 조회 시 viewerStatus가 CONFIRMED이고 cancel이 true이다`() {
+            val (creator, _) = dataGenerator.generateUser()
+            val (participant, participantToken) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = creator.id!!)
+
+            registrationRepository.save(
+                Registration(
+                    userId = participant.id!!,
+                    eventId = event.id!!,
+                    status = RegistrationStatus.CONFIRMED,
+                ),
+            )
+
+            mvc
+                .perform(
+                    get("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $participantToken"),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.viewer.status").value("CONFIRMED"))
+                .andExpect(jsonPath("$.viewer.registrationPublicId").isNotEmpty)
+                .andExpect(jsonPath("$.viewer.reservationEmail").value(null as Any?))
+                .andExpect(jsonPath("$.capabilities.cancel").value(true))
+                .andExpect(jsonPath("$.capabilities.apply").value(false))
+        }
+
+        @Test
+        fun `WAITLISTED 참가자가 이벤트 조회 시 viewerStatus가 WAITLISTED이고 waitlistPosition이 포함된다`() {
+            val (creator, _) = dataGenerator.generateUser()
+            val (waiter, waiterToken) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = creator.id!!, capacity = 1, waitlistEnabled = true)
+
+            // 정원 채우기 (1명 확정)
+            registrationRepository.save(
+                Registration(
+                    userId = creator.id!!,
+                    eventId = event.id!!,
+                    status = RegistrationStatus.CONFIRMED,
+                ),
+            )
+            // 대기 등록
+            registrationRepository.save(
+                Registration(
+                    userId = waiter.id!!,
+                    eventId = event.id!!,
+                    status = RegistrationStatus.WAITLISTED,
+                ),
+            )
+
+            mvc
+                .perform(
+                    get("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $waiterToken"),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.viewer.status").value("WAITLISTED"))
+                .andExpect(jsonPath("$.viewer.waitlistPosition").value(1))
+                .andExpect(jsonPath("$.viewer.registrationPublicId").isNotEmpty)
+                .andExpect(jsonPath("$.viewer.reservationEmail").value(null as Any?))
+                .andExpect(jsonPath("$.capabilities.cancel").value(true))
+        }
+
+        @Test
+        fun `confirmedCnt는 참여자(확정) 수를 반영한다`() {
+            val (creator, _) = dataGenerator.generateUser()
+            val (user1, _) = dataGenerator.generateUser()
+            val (user2, _) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = creator.id!!, capacity = 2, waitlistEnabled = true)
+
+            registrationRepository.save(Registration(userId = creator.id!!, eventId = event.id!!, status = RegistrationStatus.CONFIRMED))
+            registrationRepository.save(Registration(userId = user1.id!!, eventId = event.id!!, status = RegistrationStatus.CONFIRMED))
+            registrationRepository.save(Registration(userId = user2.id!!, eventId = event.id!!, status = RegistrationStatus.WAITLISTED))
+
+            mvc
+                .perform(
+                    get("/api/events/${event.publicId}"),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.event.confirmedCount").value(2))
+        }
+
+        @Test
+        fun `waitlistCount는 대기자 수를 반영한다`() {
+            val (creator, _) = dataGenerator.generateUser()
+            val (user1, _) = dataGenerator.generateUser()
+            val (user2, _) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = creator.id!!, capacity = 2, waitlistEnabled = true)
+
+            registrationRepository.save(Registration(userId = creator.id!!, eventId = event.id!!, status = RegistrationStatus.CONFIRMED))
+            registrationRepository.save(Registration(userId = user1.id!!, eventId = event.id!!, status = RegistrationStatus.CONFIRMED))
+            registrationRepository.save(Registration(userId = user2.id!!, eventId = event.id!!, status = RegistrationStatus.WAITLISTED))
+
+            mvc
+                .perform(
+                    get("/api/events/${event.publicId}"),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.event.waitlistCount").value(1))
+        }
+
+        // =================================================================
+        // GET /api/events/me — 내가 만든 이벤트 목록 조회 (무한 스크롤)
+        // =================================================================
+
+        @Test
+        fun `인증 없이 내 이벤트 목록 조회 요청 시 401을 반환한다`() {
+            mvc
+                .perform(
+                    get("/api/events/me"),
+                ).andExpect(status().isUnauthorized)
+                .andExpect(jsonPath("$.code").value("AUTHENTICATION_REQUIRED"))
+        }
+
+        @Test
+        fun `생성한 이벤트가 없을 때 내 이벤트 목록 조회 시 빈 목록을 반환한다`() {
+            val (_, token) = dataGenerator.generateUser()
+
+            mvc
+                .perform(
+                    get("/api/events/me")
+                        .header("Authorization", "Bearer $token"),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.events").isArray)
+                .andExpect(jsonPath("$.events.length()").value(0))
+                .andExpect(jsonPath("$.hasNext").value(false))
+        }
+
+        @Test
+        fun `내 이벤트 목록 조회 시 내가 생성한 이벤트만 반환한다`() {
+            val (user, token) = dataGenerator.generateUser()
+            val (otherUser, _) = dataGenerator.generateUser()
+
+            val myEvent = createEventInDb(createdBy = user.id!!, title = "내 이벤트")
+            createEventInDb(createdBy = otherUser.id!!, title = "다른 사람 이벤트")
+
+            mvc
+                .perform(
+                    get("/api/events/me")
+                        .header("Authorization", "Bearer $token"),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.events.length()").value(1))
+                .andExpect(jsonPath("$.events[0].publicId").value(myEvent.publicId))
+                .andExpect(jsonPath("$.events[0].title").value("내 이벤트"))
+        }
+
+        @Test
+        fun `내 이벤트 목록 조회 시 size 파라미터로 페이지 크기를 제한할 수 있다`() {
+            val (user, token) = dataGenerator.generateUser()
+            repeat(3) { i -> createEventInDb(createdBy = user.id!!, title = "이벤트 $i") }
+
+            mvc
+                .perform(
+                    get("/api/events/me")
+                        .header("Authorization", "Bearer $token")
+                        .param("size", "2"),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.events.length()").value(2))
+                .andExpect(jsonPath("$.hasNext").value(true))
+                .andExpect(jsonPath("$.nextCursor").isNotEmpty)
+        }
+
+        @Test
+        fun `내 이벤트 목록에 이벤트 응답 필드가 올바르게 포함된다`() {
+            val (user, token) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = user.id!!, title = "필드 검증 이벤트", capacity = 20)
+
+            mvc
+                .perform(
+                    get("/api/events/me")
+                        .header("Authorization", "Bearer $token"),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.events[0].publicId").value(event.publicId))
+                .andExpect(jsonPath("$.events[0].title").value("필드 검증 이벤트"))
+                .andExpect(jsonPath("$.events[0].capacity").value(20))
+                .andExpect(jsonPath("$.events[0].confirmedCount").value(0))
+                .andExpect(jsonPath("$.events[0].waitlistCount").value(0))
+        }
+
+        @Test
+        fun `cursor 기반 페이징으로 다음 페이지를 조회할 수 있다`() {
+            val (user, token) = dataGenerator.generateUser()
+            // events[0]=이벤트 0(oldest), events[1]=이벤트 1, events[2]=이벤트 2(newest)
+            val events =
+                (0 until 3).map { i ->
+                    createEventInDb(createdBy = user.id!!, title = "이벤트 $i")
+                        .also { Thread.sleep(10) } // createdAt 순서 보장
+                }
+
+            // 첫 페이지 (size=2) → 최신 2개: 이벤트 2, 이벤트 1
+            val firstResult =
+                mvc
+                    .perform(
+                        get("/api/events/me")
+                            .header("Authorization", "Bearer $token")
+                            .param("size", "2"),
+                    ).andExpect(status().isOk)
+                    .andExpect(jsonPath("$.events.length()").value(2))
+                    .andExpect(jsonPath("$.hasNext").value(true))
+                    .andReturn()
+
+            val firstTree = mapper.readTree(firstResult.response.contentAsString)
+            val nextCursor = firstTree.get("nextCursor").asText()
+            val firstPageIds =
+                (0 until 2).map {
+                    firstTree
+                        .get("events")
+                        .get(it)
+                        .get("publicId")
+                        .asText()
+                }
+
+            // 1페이지는 최신순 (이벤트 2 → 이벤트 1)
+            assertThat(firstPageIds[0]).isEqualTo(events[2].publicId)
+            assertThat(firstPageIds[1]).isEqualTo(events[1].publicId)
+
+            // 두 번째 페이지 (cursor 사용) → 나머지 1개: 이벤트 0
+            val secondResult =
+                mvc
+                    .perform(
+                        get("/api/events/me")
+                            .header("Authorization", "Bearer $token")
+                            .param("size", "2")
+                            .param("cursor", nextCursor),
+                    ).andExpect(status().isOk)
+                    .andExpect(jsonPath("$.events.length()").value(1))
+                    .andExpect(jsonPath("$.hasNext").value(false))
+                    .andReturn()
+
+            val secondTree = mapper.readTree(secondResult.response.contentAsString)
+            val secondPageIds =
+                listOf(
+                    secondTree
+                        .get("events")
+                        .get(0)
+                        .get("publicId")
+                        .asText(),
+                )
+
+            // 2페이지는 가장 오래된 이벤트 0
+            assertThat(secondPageIds[0]).isEqualTo(events[0].publicId)
+
+            // 1페이지와 2페이지 간 publicId 중복 없음
+            assertThat(firstPageIds).doesNotContainAnyElementsOf(secondPageIds)
+        }
+
+        // =================================================================
+        // PUT /api/events/{publicId} — 이벤트 수정
+        // =================================================================
+
+        @Test
+        fun `주최자가 유효한 데이터로 이벤트 수정 시 200과 수정된 정보를 반환한다`() {
+            val (user, token) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = user.id!!)
+
+            mvc
+                .perform(
+                    put("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $token")
+                        .content(mapper.writeValueAsString(UpdateEventRequest(title = "수정된 제목", location = "새 장소")))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.title").value("수정된 제목"))
+                .andExpect(jsonPath("$.location").value("새 장소"))
+        }
+
+        @Test
+        fun `인증 없이 이벤트 수정 요청 시 401을 반환한다`() {
+            val (user, _) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = user.id!!)
+
+            mvc
+                .perform(
+                    put("/api/events/${event.publicId}")
+                        .content(mapper.writeValueAsString(UpdateEventRequest(title = "수정")))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isUnauthorized)
+                .andExpect(jsonPath("$.code").value("AUTHENTICATION_REQUIRED"))
+        }
+
+        @Test
+        fun `존재하지 않는 이벤트 수정 요청 시 404를 반환한다`() {
+            val (_, token) = dataGenerator.generateUser()
+
+            mvc
+                .perform(
+                    put("/api/events/${UUID.randomUUID()}")
+                        .header("Authorization", "Bearer $token")
+                        .content(mapper.writeValueAsString(UpdateEventRequest(title = "수정")))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isNotFound)
+                .andExpect(jsonPath("$.code").value("EVENT_NOT_FOUND"))
+        }
+
+        @Test
+        fun `이벤트 주최자가 아닌 사용자가 수정 요청 시 403을 반환한다`() {
+            val (creator, _) = dataGenerator.generateUser()
+            val (_, otherToken) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = creator.id!!)
+
+            mvc
+                .perform(
+                    put("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $otherToken")
+                        .content(mapper.writeValueAsString(UpdateEventRequest(title = "수정")))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isForbidden)
+                .andExpect(jsonPath("$.code").value("NOT_EVENT_ADMIN"))
+        }
+
+        @Test
+        fun `이벤트 제목을 공백으로 수정 요청 시 400을 반환한다`() {
+            val (user, token) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = user.id!!)
+
+            mvc
+                .perform(
+                    put("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $token")
+                        .content(mapper.writeValueAsString(UpdateEventRequest(title = "   ")))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("EVENT_TITLE_BLANK"))
+        }
+
+        @Test
+        fun `정원을 0으로 수정 요청 시 400을 반환한다`() {
+            val (user, token) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = user.id!!)
+
+            mvc
+                .perform(
+                    put("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $token")
+                        .content(mapper.writeValueAsString(UpdateEventRequest(capacity = 0)))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("EVENT_CAPACITY_INVALID"))
+        }
+
+        @Test
+        fun `정원을 음수로 수정 요청 시 400을 반환한다`() {
+            val (user, token) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = user.id!!)
+
+            mvc
+                .perform(
+                    put("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $token")
+                        .content(mapper.writeValueAsString(UpdateEventRequest(capacity = -1)))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("EVENT_CAPACITY_INVALID"))
+        }
+
+        @Test
+        fun `모임 시작 시간을 신청 마감 시간보다 이전으로 수정하면 400을 반환한다`() {
+            val (user, token) = dataGenerator.generateUser()
+            // 기본 registrationEndsAt=now+5400 → startsAt=now-3600 으로 변경하면 역전
+            val event = createEventInDb(createdBy = user.id!!)
+
+            mvc
+                .perform(
+                    put("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $token")
+                        .content(mapper.writeValueAsString(UpdateEventRequest(startsAt = Instant.now().minusSeconds(3600))))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("REGISTRATION_ENDS_AFTER_EVENT_START"))
+        }
+
+        @Test
+        fun `모임 시작 시간을 앞당겨 기존 신청 마감 시간과 역전되면 400을 반환한다`() {
+            val (user, token) = dataGenerator.generateUser()
+            // startsAt=+7200, registrationEndsAt=+5400 → 유효한 초기 상태
+            val event =
+                createEventInDb(
+                    createdBy = user.id!!,
+                    startsAt = Instant.now().plusSeconds(7200),
+                    endsAt = Instant.now().plusSeconds(10800),
+                    registrationEndsAt = Instant.now().plusSeconds(5400),
+                )
+
+            // startsAt=+3600 으로 앞당기면 registrationEndsAt(+5400) > startsAt(+3600) 이 됨
+            mvc
+                .perform(
+                    put("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $token")
+                        .content(mapper.writeValueAsString(UpdateEventRequest(startsAt = Instant.now().plusSeconds(3600))))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("REGISTRATION_ENDS_AFTER_EVENT_START"))
+        }
+
+        @Test
+        fun `수정 시 null 필드는 기존 값을 유지한다`() {
+            val (user, token) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = user.id!!, title = "원래 제목")
+
+            // title만 수정, description은 null → 기존 description(null) 유지
+            mvc
+                .perform(
+                    put("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $token")
+                        .content(mapper.writeValueAsString(UpdateEventRequest(title = "바뀐 제목")))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.title").value("바뀐 제목"))
+                .andExpect(jsonPath("$.waitlistEnabled").value(false)) // 기존 값 유지
+        }
+
+        @Test
+        fun `확정 참가자 있어도 신청 시작 시간을 늦출 수 있다`() {
+            val (host, token) = dataGenerator.generateUser()
+            val (participant, _) = dataGenerator.generateUser()
+            val event =
+                createEventInDb(
+                    createdBy = host.id!!,
+                    startsAt = Instant.now().plusSeconds(7200),
+                    endsAt = Instant.now().plusSeconds(10800),
+                    registrationStartsAt = Instant.now().plusSeconds(3600),
+                    registrationEndsAt = Instant.now().plusSeconds(5400),
+                )
+
+            registrationRepository.save(
+                Registration(userId = participant.id!!, eventId = event.id!!, status = RegistrationStatus.CONFIRMED),
+            )
+
+            mvc
+                .perform(
+                    put("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $token")
+                        // +3600 → +4500 으로 늦춤 — 기존 신청자 영향 없이 모집 중단
+                        .content(mapper.writeValueAsString(UpdateEventRequest(registrationStartsAt = Instant.now().plusSeconds(4500))))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+        }
+
+        @Test
+        fun `확정 참가자 있어도 신청 마감 시간을 과거로 앞당길 수 있다`() {
+            val (host, token) = dataGenerator.generateUser()
+            val (participant, _) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = host.id!!, registrationEndsAt = Instant.now().plusSeconds(3600))
+
+            registrationRepository.save(
+                Registration(userId = participant.id!!, eventId = event.id!!, status = RegistrationStatus.CONFIRMED),
+            )
+
+            mvc
+                .perform(
+                    put("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $token")
+                        // 모집 마감을 현재 이전으로 앞당김 — 모집 중단, 기존 신청자 영향 없음
+                        .content(mapper.writeValueAsString(UpdateEventRequest(registrationEndsAt = Instant.now().minusSeconds(60))))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+        }
+
+        @Test
+        fun `신청 시작 시간과 신청 마감 시간이 같으면 400을 반환한다`() {
+            val (_, token) = dataGenerator.generateUser()
+            val sameTime = Instant.now().plusSeconds(3600)
+            val request =
+                CreateEventRequest(
+                    title = "정기 모임",
+                    capacity = 10,
+                    waitlistEnabled = false,
+                    registrationStartsAt = sameTime,
+                    registrationEndsAt = sameTime,
+                )
+
+            mvc
+                .perform(
+                    post("/api/events")
+                        .header("Authorization", "Bearer $token")
+                        .content(mapper.writeValueAsString(request))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("REGISTRATION_TIME_RANGE_INVALID"))
+        }
+
+        @Test
+        fun `일정 수정 시 신청 마감 시간을 과거로 앞당길 수 있다`() {
+            val (user, token) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = user.id!!, registrationEndsAt = Instant.now().plusSeconds(3600))
+
+            mvc
+                .perform(
+                    put("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $token")
+                        .content(mapper.writeValueAsString(UpdateEventRequest(registrationEndsAt = Instant.now().minusSeconds(60))))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+        }
+
+        @Test
+        fun `정원을 확정 참가자 수보다 줄이면 초과 참가자가 대기로 강등된다`() {
+            val (host, hostToken) = dataGenerator.generateUser()
+            val (p1, p1Token) = dataGenerator.generateUser()
+            val (p2, p2Token) = dataGenerator.generateUser()
+            val (p3, p3Token) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = host.id!!, capacity = 10, waitlistEnabled = true)
+
+            registrationRepository.save(Registration(userId = p1.id!!, eventId = event.id!!, status = RegistrationStatus.CONFIRMED))
+            Thread.sleep(10)
+            registrationRepository.save(Registration(userId = p2.id!!, eventId = event.id!!, status = RegistrationStatus.CONFIRMED))
+            Thread.sleep(10)
+            registrationRepository.save(Registration(userId = p3.id!!, eventId = event.id!!, status = RegistrationStatus.CONFIRMED))
+
+            // capacity 10 → 2: 확정자 3명 중 가장 최근 확정된 p3 1명이 강등
+            mvc
+                .perform(
+                    put("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $hostToken")
+                        .content(mapper.writeValueAsString(UpdateEventRequest(capacity = 2)))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.capacity").value(2))
+
+            mvc
+                .perform(get("/api/events/${event.publicId}").header("Authorization", "Bearer $p1Token"))
+                .andExpect(status().isOk)
+                .andExpect(jsonPath("$.viewer.status").value("CONFIRMED"))
+
+            mvc
+                .perform(get("/api/events/${event.publicId}").header("Authorization", "Bearer $p2Token"))
+                .andExpect(status().isOk)
+                .andExpect(jsonPath("$.viewer.status").value("CONFIRMED"))
+
+            mvc
+                .perform(get("/api/events/${event.publicId}").header("Authorization", "Bearer $p3Token"))
+                .andExpect(status().isOk)
+                .andExpect(jsonPath("$.viewer.status").value("WAITLISTED"))
+        }
+
+        @Test
+        fun `정원 축소 시 가장 최근 확정된 참가자부터 강등된다`() {
+            val (host, hostToken) = dataGenerator.generateUser()
+            val (early, earlyToken) = dataGenerator.generateUser()
+            val (late, lateToken) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = host.id!!, capacity = 10, waitlistEnabled = true)
+
+            registrationRepository.save(Registration(userId = early.id!!, eventId = event.id!!, status = RegistrationStatus.CONFIRMED))
+            Thread.sleep(20)
+            registrationRepository.save(Registration(userId = late.id!!, eventId = event.id!!, status = RegistrationStatus.CONFIRMED))
+
+            // capacity 10 → 1: 더 늦게 확정된 late만 강등
+            mvc
+                .perform(
+                    put("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $hostToken")
+                        .content(mapper.writeValueAsString(UpdateEventRequest(capacity = 1)))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+
+            mvc
+                .perform(get("/api/events/${event.publicId}").header("Authorization", "Bearer $earlyToken"))
+                .andExpect(status().isOk)
+                .andExpect(jsonPath("$.viewer.status").value("CONFIRMED"))
+
+            mvc
+                .perform(get("/api/events/${event.publicId}").header("Authorization", "Bearer $lateToken"))
+                .andExpect(status().isOk)
+                .andExpect(jsonPath("$.viewer.status").value("WAITLISTED"))
+        }
+
+        @Test
+        fun `정원 축소로 강등 시 기존 대기자는 영향 없다`() {
+            val (host, hostToken) = dataGenerator.generateUser()
+            val (confirmed, _) = dataGenerator.generateUser()
+            val (waiter, waiterToken) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = host.id!!, capacity = 5, waitlistEnabled = true)
+
+            registrationRepository.save(Registration(userId = confirmed.id!!, eventId = event.id!!, status = RegistrationStatus.CONFIRMED))
+            registrationRepository.save(Registration(userId = waiter.id!!, eventId = event.id!!, status = RegistrationStatus.WAITLISTED))
+
+            // confirmed=1 == newCapacity=1 → 강등 없음, 기존 대기자도 그대로
+            mvc
+                .perform(
+                    put("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $hostToken")
+                        .content(mapper.writeValueAsString(UpdateEventRequest(capacity = 1)))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+
+            mvc
+                .perform(get("/api/events/${event.publicId}").header("Authorization", "Bearer $waiterToken"))
+                .andExpect(status().isOk)
+                .andExpect(jsonPath("$.viewer.status").value("WAITLISTED"))
+        }
+
+        @Test
+        fun `정원 축소로 강등된 참가자에게 이메일이 발송된다`() {
+            val (host, hostToken) = dataGenerator.generateUser()
+            val (p1, _) = dataGenerator.generateUser()
+            val (p2, _) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = host.id!!, capacity = 10, waitlistEnabled = true)
+
+            registrationRepository.save(Registration(userId = p1.id!!, eventId = event.id!!, status = RegistrationStatus.CONFIRMED))
+            registrationRepository.save(Registration(userId = p2.id!!, eventId = event.id!!, status = RegistrationStatus.CONFIRMED))
+
+            // capacity 10 → 1: 1명 강등 → sendDemotionEmail 1회 호출
+            mvc
+                .perform(
+                    put("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $hostToken")
+                        .content(mapper.writeValueAsString(UpdateEventRequest(capacity = 1)))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+
+            verify(emailService, times(1)).sendDemotionEmail(any())
+        }
+
+        @Test
+        fun `정원을 확정 참가자 수와 동일하게 줄일 수 있다`() {
+            val (host, hostToken) = dataGenerator.generateUser()
+            val (confirmed, _) = dataGenerator.generateUser()
+            val (waiter, waiterToken) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = host.id!!, capacity = 5, waitlistEnabled = true)
+
+            registrationRepository.save(Registration(userId = confirmed.id!!, eventId = event.id!!, status = RegistrationStatus.CONFIRMED))
+            registrationRepository.save(Registration(userId = waiter.id!!, eventId = event.id!!, status = RegistrationStatus.WAITLISTED))
+
+            // capacity 5 → 1 (확정자 수와 동일) — 허용됨
+            mvc
+                .perform(
+                    put("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $hostToken")
+                        .content(mapper.writeValueAsString(UpdateEventRequest(capacity = 1)))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.capacity").value(1))
+
+            // 대기자는 여전히 WAITLISTED — 정원이 늘지 않았으므로 전환 없음
+            mvc
+                .perform(
+                    get("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $waiterToken"),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.viewer.status").value("WAITLISTED"))
+        }
+
+        @Test
+        fun `정원을 늘리면 대기자가 확정 참가자로 전환된다`() {
+            val (host, hostToken) = dataGenerator.generateUser()
+            val (waiter, waiterToken) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = host.id!!, capacity = 1, waitlistEnabled = true)
+
+            registrationRepository.save(Registration(userId = host.id!!, eventId = event.id!!, status = RegistrationStatus.CONFIRMED))
+            registrationRepository.save(Registration(userId = waiter.id!!, eventId = event.id!!, status = RegistrationStatus.WAITLISTED))
+
+            mvc
+                .perform(
+                    put("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $hostToken")
+                        .content(mapper.writeValueAsString(UpdateEventRequest(capacity = 2)))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+
+            mvc
+                .perform(
+                    get("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $waiterToken"),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.viewer.status").value("CONFIRMED"))
+        }
+
+        @Test
+        fun `확정 참가자 없을 때 신청 시작 시간과 정원을 함께 변경할 수 있다`() {
+            val (host, token) = dataGenerator.generateUser()
+            val event =
+                createEventInDb(
+                    createdBy = host.id!!,
+                    capacity = 10,
+                    startsAt = Instant.now().plusSeconds(7200),
+                    endsAt = Instant.now().plusSeconds(10800),
+                    registrationStartsAt = Instant.now().plusSeconds(3600),
+                    registrationEndsAt = Instant.now().plusSeconds(5400),
+                )
+
+            val newRegistrationStartsAt = Instant.now().plusSeconds(3900)
+
+            mvc
+                .perform(
+                    put("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $token")
+                        .content(
+                            mapper.writeValueAsString(
+                                UpdateEventRequest(
+                                    capacity = 5,
+                                    registrationStartsAt = newRegistrationStartsAt,
+                                ),
+                            ),
+                        ).contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.capacity").value(5))
+        }
+
+        // =================================================================
+        // DELETE /api/events/{publicId} — 이벤트 삭제
+        // =================================================================
+
+        @Test
+        fun `확정된 참가자가 없는 이벤트를 주최자가 삭제 시 204를 반환한다`() {
+            val (user, token) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = user.id!!)
+
+            mvc
+                .perform(
+                    delete("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $token"),
+                ).andExpect(status().isNoContent)
+        }
+
+        @Test
+        fun `이벤트 삭제 후 해당 이벤트 조회 시 404를 반환한다`() {
+            val (user, token) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = user.id!!)
+
+            mvc
+                .perform(
+                    delete("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $token"),
+                ).andExpect(status().isNoContent)
+
+            mvc
+                .perform(
+                    get("/api/events/${event.publicId}"),
+                ).andExpect(status().isNotFound)
+                .andExpect(jsonPath("$.code").value("EVENT_NOT_FOUND"))
+        }
+
+        @Test
+        fun `인증 없이 이벤트 삭제 요청 시 401을 반환한다`() {
+            val (user, _) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = user.id!!)
+
+            mvc
+                .perform(
+                    delete("/api/events/${event.publicId}"),
+                ).andExpect(status().isUnauthorized)
+                .andExpect(jsonPath("$.code").value("AUTHENTICATION_REQUIRED"))
+        }
+
+        @Test
+        fun `존재하지 않는 이벤트 삭제 요청 시 404를 반환한다`() {
+            val (_, token) = dataGenerator.generateUser()
+
+            mvc
+                .perform(
+                    delete("/api/events/${UUID.randomUUID()}")
+                        .header("Authorization", "Bearer $token"),
+                ).andExpect(status().isNotFound)
+                .andExpect(jsonPath("$.code").value("EVENT_NOT_FOUND"))
+        }
+
+        @Test
+        fun `이벤트 주최자가 아닌 사용자가 삭제 요청 시 403을 반환한다`() {
+            val (creator, _) = dataGenerator.generateUser()
+            val (_, otherToken) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = creator.id!!)
+
+            mvc
+                .perform(
+                    delete("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $otherToken"),
+                ).andExpect(status().isForbidden)
+                .andExpect(jsonPath("$.code").value("NOT_EVENT_ADMIN"))
+        }
+
+        @Test
+        fun `확정된 참가자가 있는 이벤트도 주최자가 삭제 시 204를 반환한다`() {
+            val (user, token) = dataGenerator.generateUser()
+            val (participant, _) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = user.id!!)
+
+            registrationRepository.save(
+                Registration(
+                    userId = participant.id!!,
+                    eventId = event.id!!,
+                    status = RegistrationStatus.CONFIRMED,
+                ),
+            )
+
+            mvc
+                .perform(
+                    delete("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $token"),
+                ).andExpect(status().isNoContent)
+        }
+
+        @Test
+        fun `이벤트 삭제 시 CONFIRMED와 WAITLISTED 신청자에게 이메일이 발송되고 BANNED에게는 발송되지 않는다`() {
+            val (host, token) = dataGenerator.generateUser()
+            val (confirmed, _) = dataGenerator.generateUser()
+            val (waitlisted, _) = dataGenerator.generateUser()
+            val (banned, _) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = host.id!!, capacity = 2)
+
+            registrationRepository.save(Registration(userId = confirmed.id!!, eventId = event.id!!, status = RegistrationStatus.CONFIRMED))
+            registrationRepository.save(
+                Registration(userId = waitlisted.id!!, eventId = event.id!!, status = RegistrationStatus.WAITLISTED),
+            )
+            registrationRepository.save(Registration(userId = banned.id!!, eventId = event.id!!, status = RegistrationStatus.BANNED))
+
+            mvc
+                .perform(
+                    delete("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $token"),
+                ).andExpect(status().isNoContent)
+
+            verify(emailService, times(2)).sendEventCancellationEmail(any())
+        }
+
+        @Test
+        fun `이벤트 삭제 시 관련 registration도 모두 삭제된다`() {
+            val (host, token) = dataGenerator.generateUser()
+            val (p1, _) = dataGenerator.generateUser()
+            val (p2, _) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = host.id!!, capacity = 1)
+
+            registrationRepository.save(Registration(userId = p1.id!!, eventId = event.id!!, status = RegistrationStatus.CONFIRMED))
+            registrationRepository.save(Registration(userId = p2.id!!, eventId = event.id!!, status = RegistrationStatus.WAITLISTED))
+
+            mvc
+                .perform(
+                    delete("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $token"),
+                ).andExpect(status().isNoContent)
+
+            assertThat(registrationRepository.findByEventId(event.id!!)).isEmpty()
+        }
+
+        @Test
+        fun `신청자가 없는 이벤트 삭제 시 이메일이 발송되지 않는다`() {
+            val (user, token) = dataGenerator.generateUser()
+            val event = createEventInDb(createdBy = user.id!!)
+
+            mvc
+                .perform(
+                    delete("/api/events/${event.publicId}")
+                        .header("Authorization", "Bearer $token"),
+                ).andExpect(status().isNoContent)
+
+            verify(emailService, never()).sendEventCancellationEmail(any())
+        }
+    }
diff --git a/src/test/kotlin/com/wafflestudio/spring2025/RegistrationIntegrationTest.kt b/src/test/kotlin/com/wafflestudio/spring2025/RegistrationIntegrationTest.kt
index 77734df8..f2b1564a 100644
--- a/src/test/kotlin/com/wafflestudio/spring2025/RegistrationIntegrationTest.kt
+++ b/src/test/kotlin/com/wafflestudio/spring2025/RegistrationIntegrationTest.kt
@@ -1,38 +1,48 @@
 package com.wafflestudio.spring2025
 
+import com.fasterxml.jackson.databind.JsonNode
 import com.fasterxml.jackson.databind.ObjectMapper
-import com.wafflestudio.spring2025.domain.auth.LoggedInUser
+import com.wafflestudio.spring2025.common.email.service.EmailService
 import com.wafflestudio.spring2025.domain.event.model.Event
 import com.wafflestudio.spring2025.domain.event.repository.EventRepository
+import com.wafflestudio.spring2025.domain.registration.dto.request.CreateRegistrationRequest
+import com.wafflestudio.spring2025.domain.registration.dto.request.UpdateRegistrationStatusRequest
+import com.wafflestudio.spring2025.domain.registration.model.Registration
+import com.wafflestudio.spring2025.domain.registration.model.RegistrationStatus
 import com.wafflestudio.spring2025.domain.registration.repository.RegistrationRepository
-import com.wafflestudio.spring2025.domain.user.repository.UserRepository
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertNotNull
+import org.junit.jupiter.api.Assertions.assertNull
+import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.Test
 import org.springframework.beans.factory.annotation.Autowired
 import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc
 import org.springframework.boot.test.context.SpringBootTest
-import org.springframework.boot.test.context.TestConfiguration
-import org.springframework.core.MethodParameter
-import org.springframework.core.annotation.Order
+import org.springframework.context.annotation.Import
 import org.springframework.http.MediaType
 import org.springframework.test.context.ActiveProfiles
+import org.springframework.test.context.bean.override.mockito.MockitoBean
 import org.springframework.test.web.servlet.MockMvc
+import org.springframework.test.web.servlet.MvcResult
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete
 import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.patch
 import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post
 import org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath
 import org.springframework.test.web.servlet.result.MockMvcResultMatchers.status
-import org.springframework.web.bind.support.WebDataBinderFactory
-import org.springframework.web.context.request.NativeWebRequest
-import org.springframework.web.method.support.HandlerMethodArgumentResolver
-import org.springframework.web.method.support.ModelAndViewContainer
-import org.springframework.web.servlet.config.annotation.WebMvcConfigurer
 import org.testcontainers.junit.jupiter.Testcontainers
 import java.time.Instant
 import java.util.UUID
+import java.util.concurrent.CopyOnWriteArrayList
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.Executors
+import java.util.concurrent.TimeUnit
 
 @SpringBootTest
 @ActiveProfiles("test")
 @Testcontainers
-@AutoConfigureMockMvc(addFilters = false)
+@AutoConfigureMockMvc
+@Import(TestContainerConfig::class)
 class RegistrationIntegrationTest
     @Autowired
     constructor(
@@ -42,41 +52,745 @@ class RegistrationIntegrationTest
         private val eventRepository: EventRepository,
         private val registrationRepository: RegistrationRepository,
     ) {
+        @MockitoBean
+        private lateinit var emailService: EmailService
+
+        @Test
+        fun `로그인 사용자가 등록하면 CONFIRMED 상태로 저장된다`() {
+            val (host, _) = dataGenerator.generateUser()
+            val (participant, participantToken) = dataGenerator.generateUser()
+            val event = createEvent(createdBy = host.id!!, title = "Backend Study", capacity = 10, waitlistEnabled = false)
+
+            val result =
+                mvc
+                    .perform(
+                        post("/api/events/${event.publicId}/registrations")
+                            .header("Authorization", "Bearer $participantToken")
+                            .content(mapper.writeValueAsString(CreateRegistrationRequest()))
+                            .contentType(MediaType.APPLICATION_JSON),
+                    ).andExpect(status().isOk)
+                    .andExpect(jsonPath("$.registrationPublicId").isNotEmpty)
+                    .andReturn()
+
+            val registrationId = extractRegistrationPublicId(result)
+            val saved = findRegistration(registrationId)
+
+            assertEquals(participant.id, saved.userId)
+            assertNull(saved.guestName)
+            assertNull(saved.guestEmail)
+            assertEquals(RegistrationStatus.CONFIRMED, saved.status)
+        }
+
+        @Test
+        fun `비로그인 사용자도 guestName과 guestEmail로 등록할 수 있다`() {
+            val (host, _) = dataGenerator.generateUser()
+            val event = createEvent(createdBy = host.id!!, title = "Guest Registration")
+
+            val registrationId = registerAsGuest(event.publicId, "Guest User", "guest-1@example.com")
+            val saved = findRegistration(registrationId)
+
+            assertNull(saved.userId)
+            assertEquals("Guest User", saved.guestName)
+            assertEquals("guest-1@example.com", saved.guestEmail)
+            assertEquals(RegistrationStatus.CONFIRMED, saved.status)
+        }
+
+        @Test
+        fun `주최자는 자신의 이벤트에 등록할 수 없다`() {
+            val (host, hostToken) = dataGenerator.generateUser()
+            val event = createEvent(createdBy = host.id!!, title = "Host Event")
+
+            mvc
+                .perform(
+                    post("/api/events/${event.publicId}/registrations")
+                        .header("Authorization", "Bearer $hostToken")
+                        .content(mapper.writeValueAsString(CreateRegistrationRequest()))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isConflict)
+                .andExpect(jsonPath("$.code").value("REGISTRATION_BLOCKED_HOST"))
+        }
+
+        @Test
+        fun `정원이 가득 찼고 대기열이 비활성화면 등록을 할 수 없다`() {
+            val (host, _) = dataGenerator.generateUser()
+            val (_, firstRegistrantToken) = dataGenerator.generateUser()
+            val (_, secondRegistrantToken) = dataGenerator.generateUser()
+            val event = createEvent(createdBy = host.id!!, title = "No Waitlist", capacity = 1, waitlistEnabled = false)
+
+            registerAsUser(event.publicId, firstRegistrantToken)
+
+            mvc
+                .perform(
+                    post("/api/events/${event.publicId}/registrations")
+                        .header("Authorization", "Bearer $secondRegistrantToken")
+                        .content(mapper.writeValueAsString(CreateRegistrationRequest()))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isConflict)
+                .andExpect(jsonPath("$.code").value("EVENT_FULL"))
+        }
+
+        @Test
+        fun `정원이 가득 찼고 대기열이 활성화면 WAITLISTED로 등록된다`() {
+            val (host, _) = dataGenerator.generateUser()
+            val (_, confirmedUserToken) = dataGenerator.generateUser()
+            val (_, waitlistedUserToken) = dataGenerator.generateUser()
+            val event = createEvent(createdBy = host.id!!, title = "Waitlist Enabled", capacity = 1, waitlistEnabled = true)
+
+            val confirmedRegistrationId = registerAsUser(event.publicId, confirmedUserToken)
+            val waitlistedRegistrationId = registerAsUser(event.publicId, waitlistedUserToken)
+
+            assertEquals(RegistrationStatus.CONFIRMED, findRegistration(confirmedRegistrationId).status)
+            assertEquals(RegistrationStatus.WAITLISTED, findRegistration(waitlistedRegistrationId).status)
+        }
+
+        @Test
+        fun `이벤트 신청 시작 시간 이전에는 신청할 수 없다`() {
+            val (host, _) = dataGenerator.generateUser()
+            val (_, participantToken) = dataGenerator.generateUser()
+            val now = Instant.now()
+            val event =
+                createEvent(
+                    createdBy = host.id!!,
+                    title = "Registration Not Open Yet",
+                    registrationStartsAt = now.plusSeconds(1800),
+                    registrationEndsAt = now.plusSeconds(7200),
+                )
+
+            mvc
+                .perform(
+                    post("/api/events/${event.publicId}/registrations")
+                        .header("Authorization", "Bearer $participantToken")
+                        .content(mapper.writeValueAsString(CreateRegistrationRequest()))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("NOT_WITHIN_REGISTRATION_WINDOW"))
+        }
+
+        @Test
+        fun `이벤트 신청 마감 시간 이후에는 신청할 수 없다`() {
+            val (host, _) = dataGenerator.generateUser()
+            val (_, participantToken) = dataGenerator.generateUser()
+            val now = Instant.now()
+            val event =
+                createEvent(
+                    createdBy = host.id!!,
+                    title = "Registration Closed",
+                    registrationStartsAt = now.minusSeconds(7200),
+                    registrationEndsAt = now.minusSeconds(60),
+                )
+
+            mvc
+                .perform(
+                    post("/api/events/${event.publicId}/registrations")
+                        .header("Authorization", "Bearer $participantToken")
+                        .content(mapper.writeValueAsString(CreateRegistrationRequest()))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("NOT_WITHIN_REGISTRATION_WINDOW"))
+        }
+
+        @Test
+        fun `게스트 등록 시 이메일 형식이 잘못되면 400을 반환한다`() {
+            val (host, _) = dataGenerator.generateUser()
+            val event = createEvent(createdBy = host.id!!, title = "Invalid Guest Email")
+
+            mvc
+                .perform(
+                    post("/api/events/${event.publicId}/registrations")
+                        .content(
+                            mapper.writeValueAsString(
+                                CreateRegistrationRequest(
+                                    guestName = "Guest User",
+                                    guestEmail = "invalid-email-format",
+                                ),
+                            ),
+                        ).contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("REGISTRATION_WRONG_EMAIL"))
+        }
+
+        @Test
+        fun `같은 이벤트에 동일한 게스트 이메일로 중복 등록할 수 없다`() {
+            val (host, _) = dataGenerator.generateUser()
+            val event = createEvent(createdBy = host.id!!, title = "Duplicate Guest Email")
+
+            registerAsGuest(event.publicId, "Guest One", "guest-duplicate@example.com")
+
+            mvc
+                .perform(
+                    post("/api/events/${event.publicId}/registrations")
+                        .content(
+                            mapper.writeValueAsString(
+                                CreateRegistrationRequest(
+                                    guestName = "Guest Two",
+                                    guestEmail = "guest-duplicate@example.com",
+                                ),
+                            ),
+                        ).contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isConflict)
+                .andExpect(jsonPath("$.code").value("REGISTRATION_ALREADY_EXISTS"))
+        }
+
+        @Test
+        fun `본인의 참가 신청은 본인만 취소할 수 있다`() {
+            val (host, hostToken) = dataGenerator.generateUser()
+            val (_, participantToken) = dataGenerator.generateUser()
+            val event = createEvent(createdBy = host.id!!, title = "Host Delete Permission")
+            val participantRegistrationId = registerAsUser(event.publicId, participantToken)
+
+            mvc
+                .perform(
+                    delete("/api/registrations/$participantRegistrationId")
+                        .header("Authorization", "Bearer $hostToken")
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isForbidden)
+                .andExpect(jsonPath("$.code").value("REGISTRATION_DELETE_UNAUTHORIZED"))
+
+            mvc
+                .perform(
+                    delete("/api/registrations/$participantRegistrationId")
+                        .header("Authorization", "Bearer $participantToken")
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+
+            assertNull(registrationRepository.findByRegistrationPublicId(participantRegistrationId))
+        }
+
+        @Test
+        fun `CONFIRMED 등록을 삭제하면 대기자가 승격된다`() {
+            val (host, _) = dataGenerator.generateUser()
+            val (_, confirmedUserToken) = dataGenerator.generateUser()
+            val (_, waitlistedUserToken) = dataGenerator.generateUser()
+            val event = createEvent(createdBy = host.id!!, title = "Delete Promotion", capacity = 1, waitlistEnabled = true)
+
+            val confirmedRegistrationId = registerAsUser(event.publicId, confirmedUserToken)
+            val waitlistedRegistrationId = registerAsUser(event.publicId, waitlistedUserToken)
+
+            assertEquals(RegistrationStatus.CONFIRMED, findRegistration(confirmedRegistrationId).status)
+            assertEquals(RegistrationStatus.WAITLISTED, findRegistration(waitlistedRegistrationId).status)
+
+            mvc
+                .perform(
+                    delete("/api/registrations/$confirmedRegistrationId")
+                        .header("Authorization", "Bearer $confirmedUserToken")
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+
+            assertNull(registrationRepository.findByRegistrationPublicId(confirmedRegistrationId))
+            assertEquals(RegistrationStatus.CONFIRMED, findRegistration(waitlistedRegistrationId).status)
+        }
+
+        @Test
+        fun `주최자만 강퇴할 수 있고 CONFIRMED 강퇴 시 대기자가 승격된다`() {
+            val (host, hostToken) = dataGenerator.generateUser()
+            val (confirmedUser, confirmedUserToken) = dataGenerator.generateUser()
+            val (_, waitlistedUserToken) = dataGenerator.generateUser()
+            val event = createEvent(createdBy = host.id!!, title = "Ban Scenario", capacity = 1, waitlistEnabled = true)
+
+            val confirmedRegistrationId = registerAsUser(event.publicId, confirmedUserToken)
+            val waitlistedRegistrationId = registerAsUser(event.publicId, waitlistedUserToken)
+
+            mvc
+                .perform(
+                    patch("/api/registrations/$confirmedRegistrationId")
+                        .header("Authorization", "Bearer $confirmedUserToken")
+                        .content(
+                            mapper.writeValueAsString(
+                                UpdateRegistrationStatusRequest(status = RegistrationStatus.BANNED),
+                            ),
+                        ).contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isForbidden)
+                .andExpect(jsonPath("$.code").value("REGISTRATION_PATCH_UNAUTHORIZED"))
+
+            mvc
+                .perform(
+                    patch("/api/registrations/$confirmedRegistrationId")
+                        .header("Authorization", "Bearer $hostToken")
+                        .content(
+                            mapper.writeValueAsString(
+                                UpdateRegistrationStatusRequest(status = RegistrationStatus.BANNED),
+                            ),
+                        ).contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.patchEmail").value(confirmedUser.email))
+
+            assertEquals(RegistrationStatus.BANNED, findRegistration(confirmedRegistrationId).status)
+            assertEquals(RegistrationStatus.CONFIRMED, findRegistration(waitlistedRegistrationId).status)
+        }
+
+        @Test
+        fun `모집 시작 전에는 자발적 취소를 할 수 없다`() {
+            val (host, _) = dataGenerator.generateUser()
+            val (participant, participantToken) = dataGenerator.generateUser()
+            val now = Instant.now()
+            val event =
+                createEvent(
+                    createdBy = host.id!!,
+                    title = "Before Registration Opens - Cancel",
+                    registrationStartsAt = now.plusSeconds(3600),
+                    registrationEndsAt = now.plusSeconds(7200),
+                )
+            val registration =
+                registrationRepository.save(
+                    Registration(
+                        userId = participant.id!!,
+                        eventId = event.id!!,
+                        status = RegistrationStatus.CONFIRMED,
+                    ),
+                )
+
+            mvc
+                .perform(
+                    delete("/api/registrations/${registration.registrationPublicId}")
+                        .header("Authorization", "Bearer $participantToken")
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("NOT_WITHIN_REGISTRATION_WINDOW"))
+        }
+
         @Test
-        fun `내 신청 목록을 최신순과 페이징으로 조회한다`() {
-            val (user, _) = dataGenerator.generateUser()
-            val event1 = createEvent(createdBy = user.id!!, title = "Event 1")
-            val event2 = createEvent(createdBy = user.id!!, title = "Event 2")
+        fun `모집 마감 후에는 자발적 취소를 할 수 없다`() {
+            val (host, _) = dataGenerator.generateUser()
+            val (participant, participantToken) = dataGenerator.generateUser()
+            val now = Instant.now()
+            val event =
+                createEvent(
+                    createdBy = host.id!!,
+                    title = "After Registration Closed - Cancel",
+                    registrationStartsAt = now.minusSeconds(7200),
+                    registrationEndsAt = now.minusSeconds(60),
+                )
+            val registration =
+                registrationRepository.save(
+                    Registration(
+                        userId = participant.id!!,
+                        eventId = event.id!!,
+                        status = RegistrationStatus.CONFIRMED,
+                    ),
+                )
 
             mvc
                 .perform(
-                    post("/api/v1/events/${event1.id}/registrations")
-                        .content("{}")
-                        .header("X-Test-User-Id", user.id.toString())
+                    delete("/api/registrations/${registration.registrationPublicId}")
+                        .header("Authorization", "Bearer $participantToken")
                         .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("NOT_WITHIN_REGISTRATION_WINDOW"))
+        }
+
+        @Test
+        fun `모집 시작 전에도 주최자는 BANNED 처리를 할 수 있다`() {
+            val (host, hostToken) = dataGenerator.generateUser()
+            val (participant, _) = dataGenerator.generateUser()
+            val now = Instant.now()
+            val event =
+                createEvent(
+                    createdBy = host.id!!,
+                    title = "Ban Before Registration Opens",
+                    registrationStartsAt = now.plusSeconds(3600),
+                    registrationEndsAt = now.plusSeconds(7200),
+                )
+            val registration =
+                registrationRepository.save(
+                    Registration(
+                        userId = participant.id!!,
+                        eventId = event.id!!,
+                        status = RegistrationStatus.CONFIRMED,
+                    ),
+                )
+
+            mvc
+                .perform(
+                    patch("/api/registrations/${registration.registrationPublicId}")
+                        .header("Authorization", "Bearer $hostToken")
+                        .content(
+                            mapper.writeValueAsString(
+                                UpdateRegistrationStatusRequest(status = RegistrationStatus.BANNED),
+                            ),
+                        ).contentType(MediaType.APPLICATION_JSON),
                 ).andExpect(status().isOk)
 
-            Thread.sleep(5)
+            assertEquals(RegistrationStatus.BANNED, findRegistration(registration.registrationPublicId).status)
+        }
+
+        @Test
+        fun `모집 마감 후에도 주최자는 BANNED 처리를 할 수 있다`() {
+            val (host, hostToken) = dataGenerator.generateUser()
+            val (participant, _) = dataGenerator.generateUser()
+            val now = Instant.now()
+            val event =
+                createEvent(
+                    createdBy = host.id!!,
+                    title = "Ban After Registration Closed",
+                    registrationStartsAt = now.minusSeconds(7200),
+                    registrationEndsAt = now.minusSeconds(60),
+                )
+            val registration =
+                registrationRepository.save(
+                    Registration(
+                        userId = participant.id!!,
+                        eventId = event.id!!,
+                        status = RegistrationStatus.CONFIRMED,
+                    ),
+                )
+
+            mvc
+                .perform(
+                    patch("/api/registrations/${registration.registrationPublicId}")
+                        .header("Authorization", "Bearer $hostToken")
+                        .content(
+                            mapper.writeValueAsString(
+                                UpdateRegistrationStatusRequest(status = RegistrationStatus.BANNED),
+                            ),
+                        ).contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+
+            assertEquals(RegistrationStatus.BANNED, findRegistration(registration.registrationPublicId).status)
+        }
+
+        @Test
+        fun `모집 마감 후 BANNED 처리 시 대기자는 승격되지 않는다`() {
+            val (host, hostToken) = dataGenerator.generateUser()
+            val (confirmedUser, _) = dataGenerator.generateUser()
+            val (waitlistedUser, _) = dataGenerator.generateUser()
+            val now = Instant.now()
+            val event =
+                createEvent(
+                    createdBy = host.id!!,
+                    title = "Ban After Closed - No Promotion",
+                    capacity = 1,
+                    waitlistEnabled = true,
+                    registrationStartsAt = now.minusSeconds(7200),
+                    registrationEndsAt = now.minusSeconds(60),
+                )
+            val confirmedReg =
+                registrationRepository.save(
+                    Registration(
+                        userId = confirmedUser.id!!,
+                        eventId = event.id!!,
+                        status = RegistrationStatus.CONFIRMED,
+                    ),
+                )
+            val waitlistedReg =
+                registrationRepository.save(
+                    Registration(
+                        userId = waitlistedUser.id!!,
+                        eventId = event.id!!,
+                        status = RegistrationStatus.WAITLISTED,
+                    ),
+                )
 
             mvc
                 .perform(
-                    post("/api/v1/events/${event2.id}/registrations")
-                        .content("{}")
-                        .header("X-Test-User-Id", user.id.toString())
+                    patch("/api/registrations/${confirmedReg.registrationPublicId}")
+                        .header("Authorization", "Bearer $hostToken")
+                        .content(
+                            mapper.writeValueAsString(
+                                UpdateRegistrationStatusRequest(status = RegistrationStatus.BANNED),
+                            ),
+                        ).contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+
+            assertEquals(RegistrationStatus.BANNED, findRegistration(confirmedReg.registrationPublicId).status)
+            assertEquals(RegistrationStatus.WAITLISTED, findRegistration(waitlistedReg.registrationPublicId).status)
+        }
+
+        // ─────────────────────────────────────────────────────────────────────────
+
+        @Test
+        fun `주최자만 참여자 이메일을 볼 수 있고 참여자는 볼 수 없다`() {
+            val (host, hostToken) = dataGenerator.generateUser()
+            val (participant, participantToken) = dataGenerator.generateUser()
+            val event = createEvent(createdBy = host.id!!, title = "Email Visibility", capacity = 10, waitlistEnabled = false)
+
+            registerAsUser(event.publicId, participantToken)
+            registerAsGuest(event.publicId, "Guest User", "guest@example.com")
+
+            val nonHostResponse =
+                mvc
+                    .perform(
+                        get("/api/events/${event.publicId}/registrations")
+                            .contentType(MediaType.APPLICATION_JSON),
+                    ).andExpect(status().isOk)
+                    .andReturn()
+
+            val nonHostParticipants = extractParticipants(nonHostResponse)
+            assertTrue(nonHostParticipants.all { it.path("email").isNull })
+
+            val hostResponse =
+                mvc
+                    .perform(
+                        get("/api/events/${event.publicId}/registrations")
+                            .header("Authorization", "Bearer $hostToken")
+                            .contentType(MediaType.APPLICATION_JSON),
+                    ).andExpect(status().isOk)
+                    .andReturn()
+
+            val hostParticipants = extractParticipants(hostResponse)
+            assertTrue(hostParticipants.any { it.path("email").asText() == participant.email })
+            assertTrue(hostParticipants.any { it.path("email").asText() == "guest@example.com" })
+        }
+
+        @Test
+        fun `동시에 여러 사용자가 신청해도 정원을 초과하지 않는다`() {
+            val capacity = 4
+            val totalUsers = 15
+
+            val (host, _) = dataGenerator.generateUser()
+            val event =
+                createEvent(
+                    createdBy = host.id!!,
+                    title = "동시성 테스트 이벤트",
+                    capacity = capacity,
+                    waitlistEnabled = true,
+                )
+
+            val tokens = (1..totalUsers).map { dataGenerator.generateUser().second }
+
+            val executor = Executors.newFixedThreadPool(totalUsers)
+            val startLatch = CountDownLatch(1)
+            val doneLatch = CountDownLatch(totalUsers)
+            val statusCodes = CopyOnWriteArrayList<Int>()
+
+            tokens.forEach { token ->
+                executor.submit {
+                    try {
+                        startLatch.await()
+                        val result =
+                            mvc
+                                .perform(
+                                    post("/api/events/${event.publicId}/registrations")
+                                        .header("Authorization", "Bearer $token")
+                                        .content(mapper.writeValueAsString(CreateRegistrationRequest()))
+                                        .contentType(MediaType.APPLICATION_JSON),
+                                ).andReturn()
+                        statusCodes.add(result.response.status)
+                    } finally {
+                        doneLatch.countDown()
+                    }
+                }
+            }
+
+            startLatch.countDown()
+            val completed = doneLatch.await(10, TimeUnit.SECONDS)
+            executor.shutdown()
+
+            assertTrue(completed, "모든 요청이 타임아웃(10초) 내에 완료되어야 합니다")
+            assertTrue(statusCodes.all { it == 200 }, "모든 요청이 HTTP 200으로 성공해야 합니다: $statusCodes")
+
+            val confirmed = registrationRepository.countByEventIdAndStatus(event.id!!, RegistrationStatus.CONFIRMED)
+            val waitlisted = registrationRepository.countByEventIdAndStatus(event.id!!, RegistrationStatus.WAITLISTED)
+
+            assertEquals(capacity.toLong(), confirmed, "CONFIRMED 수가 정원과 일치해야 합니다")
+            assertEquals((totalUsers - capacity).toLong(), waitlisted, "WAITLISTED 수가 정확해야 합니다")
+        }
+
+        @Test
+        fun `my registrations endpoint paginates without overlap`() {
+            val (_, participantToken) = dataGenerator.generateUser()
+            val registeredEventIds =
+                (1..25).map { index ->
+                    val (host, _) = dataGenerator.generateUser()
+                    val event = createEvent(createdBy = host.id!!, title = "my-registrations-$index")
+                    registerAsUser(event.publicId, participantToken)
+                    event.publicId
+                }
+
+            val page0 =
+                mvc
+                    .perform(
+                        get("/api/registrations/me")
+                            .header("Authorization", "Bearer $participantToken")
+                            .param("page", "0")
+                            .param("size", "10")
+                            .contentType(MediaType.APPLICATION_JSON),
+                    ).andExpect(status().isOk)
+                    .andExpect(jsonPath("$.registrations.length()").value(10))
+                    .andReturn()
+
+            val page1 =
+                mvc
+                    .perform(
+                        get("/api/registrations/me")
+                            .header("Authorization", "Bearer $participantToken")
+                            .param("page", "1")
+                            .param("size", "10")
+                            .contentType(MediaType.APPLICATION_JSON),
+                    ).andExpect(status().isOk)
+                    .andExpect(jsonPath("$.registrations.length()").value(10))
+                    .andReturn()
+
+            val page2 =
+                mvc
+                    .perform(
+                        get("/api/registrations/me")
+                            .header("Authorization", "Bearer $participantToken")
+                            .param("page", "2")
+                            .param("size", "10")
+                            .contentType(MediaType.APPLICATION_JSON),
+                    ).andExpect(status().isOk)
+                    .andExpect(jsonPath("$.registrations.length()").value(5))
+                    .andReturn()
+
+            val page3 =
+                mvc
+                    .perform(
+                        get("/api/registrations/me")
+                            .header("Authorization", "Bearer $participantToken")
+                            .param("page", "3")
+                            .param("size", "10")
+                            .contentType(MediaType.APPLICATION_JSON),
+                    ).andExpect(status().isOk)
+                    .andExpect(jsonPath("$.registrations.length()").value(0))
+                    .andReturn()
+
+            val page0Ids = extractMyRegistrationEventPublicIds(page0)
+            val page1Ids = extractMyRegistrationEventPublicIds(page1)
+            val page2Ids = extractMyRegistrationEventPublicIds(page2)
+            val page3Ids = extractMyRegistrationEventPublicIds(page3)
+
+            assertTrue(page0Ids.intersect(page1Ids.toSet()).isEmpty())
+            assertTrue(page0Ids.intersect(page2Ids.toSet()).isEmpty())
+            assertTrue(page1Ids.intersect(page2Ids.toSet()).isEmpty())
+            assertTrue(page3Ids.isEmpty())
+
+            val merged = (page0Ids + page1Ids + page2Ids).toSet()
+            assertEquals(registeredEventIds.toSet(), merged)
+        }
+
+        @Test
+        fun `my registrations endpoint respects size parameter`() {
+            val (_, participantToken) = dataGenerator.generateUser()
+
+            repeat(7) { index ->
+                val (host, _) = dataGenerator.generateUser()
+                val event = createEvent(createdBy = host.id!!, title = "size-check-$index")
+                registerAsUser(event.publicId, participantToken)
+            }
+
+            mvc
+                .perform(
+                    get("/api/registrations/me")
+                        .header("Authorization", "Bearer $participantToken")
+                        .param("page", "0")
+                        .param("size", "3")
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.registrations.length()").value(3))
+
+            mvc
+                .perform(
+                    get("/api/registrations/me")
+                        .header("Authorization", "Bearer $participantToken")
+                        .param("page", "1")
+                        .param("size", "3")
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.registrations.length()").value(3))
+
+            mvc
+                .perform(
+                    get("/api/registrations/me")
+                        .header("Authorization", "Bearer $participantToken")
+                        .param("page", "2")
+                        .param("size", "3")
                         .contentType(MediaType.APPLICATION_JSON),
                 ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.registrations.length()").value(1))
+        }
+
+        @Test
+        fun `my registrations endpoint includes confirmed and waitlist counts`() {
+            val (host, _) = dataGenerator.generateUser()
+            val (_, participantToken) = dataGenerator.generateUser()
+            val (_, anotherParticipantToken) = dataGenerator.generateUser()
+
+            val event =
+                createEvent(
+                    createdBy = host.id!!,
+                    title = "count-check",
+                    capacity = 1,
+                    waitlistEnabled = true,
+                )
+
+            registerAsUser(event.publicId, participantToken)
+            registerAsUser(event.publicId, anotherParticipantToken)
 
             mvc
                 .perform(
-                    get("/api/v1/registrations/me")
-                        .header("X-Test-User-Id", user.id.toString())
-                        .queryParam("page", "0")
-                        .queryParam("size", "1")
+                    get("/api/registrations/me")
+                        .header("Authorization", "Bearer $participantToken")
+                        .param("page", "0")
+                        .param("size", "10")
                         .contentType(MediaType.APPLICATION_JSON),
                 ).andExpect(status().isOk)
                 .andExpect(jsonPath("$.registrations.length()").value(1))
-                .andExpect(jsonPath("$.registrations[0].title").value(event2.title))
-                .andExpect(jsonPath("$.registrations[0].publicId").value(event2.publicId))
+                .andExpect(jsonPath("$.registrations[0].confirmedCount").value(1))
+                .andExpect(jsonPath("$.registrations[0].waitlistCount").value(1))
+                .andExpect(jsonPath("$.registrations[0].registrationCnt").doesNotExist())
+        }
+
+        private fun registerAsUser(
+            eventPublicId: String,
+            token: String,
+        ): String {
+            val result =
+                mvc
+                    .perform(
+                        post("/api/events/$eventPublicId/registrations")
+                            .header("Authorization", "Bearer $token")
+                            .content(mapper.writeValueAsString(CreateRegistrationRequest()))
+                            .contentType(MediaType.APPLICATION_JSON),
+                    ).andExpect(status().isOk)
+                    .andExpect(jsonPath("$.registrationPublicId").isNotEmpty)
+                    .andReturn()
+
+            return extractRegistrationPublicId(result)
+        }
+
+        private fun registerAsGuest(
+            eventPublicId: String,
+            guestName: String,
+            guestEmail: String,
+        ): String {
+            val result =
+                mvc
+                    .perform(
+                        post("/api/events/$eventPublicId/registrations")
+                            .content(
+                                mapper.writeValueAsString(
+                                    CreateRegistrationRequest(
+                                        guestName = guestName,
+                                        guestEmail = guestEmail,
+                                    ),
+                                ),
+                            ).contentType(MediaType.APPLICATION_JSON),
+                    ).andExpect(status().isOk)
+                    .andExpect(jsonPath("$.registrationPublicId").isNotEmpty)
+                    .andReturn()
+
+            return extractRegistrationPublicId(result)
+        }
+
+        private fun extractRegistrationPublicId(result: MvcResult): String =
+            mapper.readTree(result.response.contentAsString).path("registrationPublicId").asText()
+
+        private fun extractParticipants(result: MvcResult): List<JsonNode> =
+            mapper
+                .readTree(result.response.contentAsString)
+                .path("participants")
+                .toList()
+
+        private fun extractMyRegistrationEventPublicIds(result: MvcResult): List<String> =
+            mapper
+                .readTree(result.response.contentAsString)
+                .path("registrations")
+                .map { it.path("publicId").asText() }
+
+        private fun findRegistration(registrationPublicId: String): Registration {
+            val registration = registrationRepository.findByRegistrationPublicId(registrationPublicId)
+            assertNotNull(registration)
+            return registration!!
         }
 
         private fun createEvent(
@@ -84,6 +798,8 @@ class RegistrationIntegrationTest
             title: String,
             capacity: Int = 10,
             waitlistEnabled: Boolean = false,
+            registrationStartsAt: Instant? = null,
+            registrationEndsAt: Instant = Instant.now().plusSeconds(5400),
         ): Event =
             eventRepository.save(
                 Event(
@@ -95,35 +811,9 @@ class RegistrationIntegrationTest
                     endsAt = Instant.now().plusSeconds(7200),
                     capacity = capacity,
                     waitlistEnabled = waitlistEnabled,
-                    registrationEndsAt = null,
+                    registrationStartsAt = registrationStartsAt,
+                    registrationEndsAt = registrationEndsAt,
                     createdBy = createdBy,
                 ),
             )
-
-        @TestConfiguration
-        @Order(0)
-        class TestWebConfig(
-            private val userRepository: UserRepository,
-        ) : WebMvcConfigurer {
-            override fun addArgumentResolvers(resolvers: MutableList<HandlerMethodArgumentResolver>) {
-                resolvers.add(0, TestLoggedInUserArgumentResolver(userRepository))
-            }
-        }
-
-        private class TestLoggedInUserArgumentResolver(
-            private val userRepository: UserRepository,
-        ) : HandlerMethodArgumentResolver {
-            override fun supportsParameter(parameter: MethodParameter): Boolean = parameter.hasParameterAnnotation(LoggedInUser::class.java)
-
-            override fun resolveArgument(
-                parameter: MethodParameter,
-                mavContainer: ModelAndViewContainer?,
-                webRequest: NativeWebRequest,
-                binderFactory: WebDataBinderFactory?,
-            ): Any? {
-                val userIdHeader = webRequest.getHeader("X-Test-User-Id") ?: return null
-                val userId = userIdHeader.toLongOrNull() ?: return null
-                return userRepository.findById(userId).orElse(null)
-            }
-        }
     }
diff --git a/src/test/kotlin/com/wafflestudio/spring2025/TestContainerConfig.kt b/src/test/kotlin/com/wafflestudio/spring2025/TestContainerConfig.kt
new file mode 100644
index 00000000..8b03c934
--- /dev/null
+++ b/src/test/kotlin/com/wafflestudio/spring2025/TestContainerConfig.kt
@@ -0,0 +1,16 @@
+package com.wafflestudio.spring2025
+
+import org.springframework.boot.test.context.TestConfiguration
+import org.springframework.boot.testcontainers.service.connection.ServiceConnection
+import org.springframework.context.annotation.Bean
+import org.testcontainers.containers.GenericContainer
+import org.testcontainers.utility.DockerImageName
+
+@TestConfiguration
+class TestContainerConfig {
+    @Bean
+    @ServiceConnection(name = "redis")
+    fun redisContainer(): GenericContainer<*> =
+        GenericContainer(DockerImageName.parse("redis:7-alpine"))
+            .withExposedPorts(6379)
+}
diff --git a/src/test/kotlin/com/wafflestudio/spring2025/UserIntegrationTest.kt b/src/test/kotlin/com/wafflestudio/spring2025/UserIntegrationTest.kt
new file mode 100644
index 00000000..dbe38e39
--- /dev/null
+++ b/src/test/kotlin/com/wafflestudio/spring2025/UserIntegrationTest.kt
@@ -0,0 +1,339 @@
+package com.wafflestudio.spring2025
+
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.wafflestudio.spring2025.common.image.service.ImageService
+import com.wafflestudio.spring2025.domain.auth.dto.LoginRequest
+import com.wafflestudio.spring2025.domain.user.dto.PatchMeRequest
+import org.junit.jupiter.api.Test
+import org.mockito.ArgumentMatchers.any
+import org.mockito.BDDMockito.given
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc
+import org.springframework.boot.test.context.SpringBootTest
+import org.springframework.context.annotation.Import
+import org.springframework.http.MediaType
+import org.springframework.test.context.ActiveProfiles
+import org.springframework.test.context.bean.override.mockito.MockitoBean
+import org.springframework.test.web.servlet.MockMvc
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.patch
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post
+import org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath
+import org.springframework.test.web.servlet.result.MockMvcResultMatchers.status
+import org.testcontainers.junit.jupiter.Testcontainers
+import software.amazon.awssdk.services.s3.S3Client
+import software.amazon.awssdk.services.s3.model.HeadObjectRequest
+import software.amazon.awssdk.services.s3.model.NoSuchKeyException
+
+@SpringBootTest
+@ActiveProfiles("test")
+@Testcontainers
+@AutoConfigureMockMvc
+@Import(TestContainerConfig::class)
+class UserIntegrationTest
+    @Autowired
+    constructor(
+        private val mvc: MockMvc,
+        private val mapper: ObjectMapper,
+        private val dataGenerator: DataGenerator,
+    ) {
+        // UserService.validateProfileImage 에서 직접 호출하는 S3Client 모킹
+        @MockitoBean
+        private lateinit var s3Client: S3Client
+
+        // UserService.me 에서 presignedGetUrl 호출 시 실제 AWS 호출 방지
+        @MockitoBean
+        private lateinit var imageService: ImageService
+
+        // =================================================================
+        // GET /api/users/me — 내 정보 조회
+        // =================================================================
+
+        @Test
+        fun `유효한 토큰으로 내 정보 조회 시 200과 사용자 정보를 반환한다`() {
+            val (user, token) = dataGenerator.generateUser()
+
+            mvc
+                .perform(
+                    get("/api/users/me")
+                        .header("Authorization", "Bearer $token")
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.id").value(user.id))
+                .andExpect(jsonPath("$.email").value(user.email))
+                .andExpect(jsonPath("$.name").value(user.name))
+                .andExpect(jsonPath("$.profileImage").value(null as Any?))
+        }
+
+        @Test
+        fun `Authorization 헤더 없이 내 정보 조회 시 401을 반환한다`() {
+            mvc
+                .perform(
+                    get("/api/users/me")
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isUnauthorized)
+                .andExpect(jsonPath("$.code").value("AUTHENTICATION_REQUIRED"))
+        }
+
+        @Test
+        fun `유효하지 않은 토큰으로 내 정보 조회 시 401을 반환한다`() {
+            mvc
+                .perform(
+                    get("/api/users/me")
+                        .header("Authorization", "Bearer invalid.token.value")
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isUnauthorized)
+                .andExpect(jsonPath("$.code").value("AUTHENTICATION_REQUIRED"))
+        }
+
+        @Test
+        fun `프로필 이미지가 있는 사용자의 내 정보 조회 시 presigned URL을 반환한다`() {
+            val s3Key = "profile-images/1/photo.jpg"
+            val presignedUrl = "https://s3.example.com/presigned/photo.jpg"
+
+            // profileImage가 설정된 User를 DB에 직접 생성
+            val (user, token) = dataGenerator.generateUserWithProfileImage(s3Key)
+
+            given(imageService.presignedGetUrl(s3Key)).willReturn(presignedUrl)
+
+            mvc
+                .perform(
+                    get("/api/users/me")
+                        .header("Authorization", "Bearer $token")
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.id").value(user.id))
+                .andExpect(jsonPath("$.profileImage").value(presignedUrl))
+        }
+
+        // =================================================================
+        // PATCH /api/users/me — 내 정보 수정
+        // =================================================================
+
+        @Test
+        fun `이름을 변경하면 200과 변경된 이름을 반환한다`() {
+            val (_, token) = dataGenerator.generateUser()
+            val newName = "변경된이름"
+
+            mvc
+                .perform(
+                    patch("/api/users/me")
+                        .header("Authorization", "Bearer $token")
+                        .content(
+                            mapper.writeValueAsString(PatchMeRequest(name = newName, email = null, password = null, profileImage = null)),
+                        ).contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.name").value(newName))
+        }
+
+        @Test
+        fun `변경 필드 없이 PATCH 시 기존 정보 그대로 200을 반환한다`() {
+            val (user, token) = dataGenerator.generateUser()
+
+            mvc
+                .perform(
+                    patch("/api/users/me")
+                        .header("Authorization", "Bearer $token")
+                        .content(mapper.writeValueAsString(PatchMeRequest(name = null, email = null, password = null, profileImage = null)))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.name").value(user.name))
+                .andExpect(jsonPath("$.email").value(user.email))
+        }
+
+        @Test
+        fun `비밀번호를 변경하면 이전 비밀번호는 무효화되고 새 비밀번호로 로그인할 수 있다`() {
+            val oldPassword = "oldPassword1"
+            val newPassword = "newPassword2"
+            val (user, token) = dataGenerator.generateUserWithPassword(oldPassword)
+
+            // 비밀번호 변경
+            mvc
+                .perform(
+                    patch("/api/users/me")
+                        .header("Authorization", "Bearer $token")
+                        .content(
+                            mapper.writeValueAsString(
+                                PatchMeRequest(name = null, email = null, password = newPassword, profileImage = null),
+                            ),
+                        ).contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+
+            // 이전 비밀번호로 로그인 → 실패
+            mvc
+                .perform(
+                    post("/api/auth/login")
+                        .content(mapper.writeValueAsString(LoginRequest(email = user.email, password = oldPassword)))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isUnauthorized)
+
+            // 새 비밀번호로 로그인 → 성공
+            mvc
+                .perform(
+                    post("/api/auth/login")
+                        .content(mapper.writeValueAsString(LoginRequest(email = user.email, password = newPassword)))
+                        .contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.token").isNotEmpty)
+        }
+
+        @Test
+        fun `S3에 존재하는 키로 프로필 이미지를 변경하면 200을 반환한다`() {
+            val (_, token) = dataGenerator.generateUser()
+            val validKey = "profile-images/test/valid.jpg"
+            val presignedUrl = "https://s3.example.com/presigned/valid.jpg"
+
+            // headObject 는 기본적으로 예외 없이 반환 (mock 기본값) → 유효한 키로 간주
+            given(imageService.presignedGetUrl(validKey)).willReturn(presignedUrl)
+
+            mvc
+                .perform(
+                    patch("/api/users/me")
+                        .header("Authorization", "Bearer $token")
+                        .content(
+                            mapper.writeValueAsString(PatchMeRequest(name = null, email = null, password = null, profileImage = validKey)),
+                        ).contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.profileImage").value(presignedUrl))
+        }
+
+        @Test
+        fun `이름과 비밀번호를 동시에 변경하면 200과 변경된 정보를 반환한다`() {
+            val oldPassword = "oldPassword1"
+            val newPassword = "newPassword2"
+            val newName = "새이름"
+            val (user, token) = dataGenerator.generateUserWithPassword(oldPassword)
+
+            mvc
+                .perform(
+                    patch("/api/users/me")
+                        .header("Authorization", "Bearer $token")
+                        .content(
+                            mapper.writeValueAsString(
+                                PatchMeRequest(name = newName, email = null, password = newPassword, profileImage = null),
+                            ),
+                        ).contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isOk)
+                .andExpect(jsonPath("$.name").value(newName))
+                .andExpect(jsonPath("$.email").value(user.email))
+        }
+
+        @Test
+        fun `이메일 변경 시도 시 403을 반환한다`() {
+            val (_, token) = dataGenerator.generateUser()
+
+            mvc
+                .perform(
+                    patch("/api/users/me")
+                        .header("Authorization", "Bearer $token")
+                        .content(
+                            mapper.writeValueAsString(
+                                PatchMeRequest(name = null, email = "newemail@example.com", password = null, profileImage = null),
+                            ),
+                        ).contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isForbidden)
+                .andExpect(jsonPath("$.code").value("EMAIL_CHANGE_FORBIDDEN"))
+        }
+
+        @Test
+        fun `이름을 공백 문자열로 변경 시도 시 400을 반환한다`() {
+            val (_, token) = dataGenerator.generateUser()
+
+            mvc
+                .perform(
+                    patch("/api/users/me")
+                        .header("Authorization", "Bearer $token")
+                        .content(
+                            mapper.writeValueAsString(PatchMeRequest(name = "   ", email = null, password = null, profileImage = null)),
+                        ).contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("BAD_NAME"))
+        }
+
+        @Test
+        fun `비밀번호를 8자 미만으로 변경 시도 시 400을 반환한다`() {
+            val (_, token) = dataGenerator.generateUser()
+
+            mvc
+                .perform(
+                    patch("/api/users/me")
+                        .header("Authorization", "Bearer $token")
+                        .content(
+                            mapper.writeValueAsString(PatchMeRequest(name = null, email = null, password = "abc1", profileImage = null)),
+                        ).contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("BAD_PASSWORD"))
+        }
+
+        @Test
+        fun `비밀번호에 숫자가 없으면 변경 시도 시 400을 반환한다`() {
+            val (_, token) = dataGenerator.generateUser()
+
+            mvc
+                .perform(
+                    patch("/api/users/me")
+                        .header("Authorization", "Bearer $token")
+                        .content(
+                            mapper.writeValueAsString(
+                                PatchMeRequest(name = null, email = null, password = "onlyletters", profileImage = null),
+                            ),
+                        ).contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("BAD_PASSWORD"))
+        }
+
+        @Test
+        fun `비밀번호에 문자가 없으면 변경 시도 시 400을 반환한다`() {
+            val (_, token) = dataGenerator.generateUser()
+
+            mvc
+                .perform(
+                    patch("/api/users/me")
+                        .header("Authorization", "Bearer $token")
+                        .content(
+                            mapper.writeValueAsString(
+                                PatchMeRequest(name = null, email = null, password = "12345678", profileImage = null),
+                            ),
+                        ).contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("BAD_PASSWORD"))
+        }
+
+        @Test
+        fun `S3에 존재하지 않는 키로 프로필 이미지 변경 시도 시 400을 반환한다`() {
+            val (_, token) = dataGenerator.generateUser()
+
+            given(s3Client.headObject(any(HeadObjectRequest::class.java)))
+                .willThrow(
+                    NoSuchKeyException
+                        .builder()
+                        .message("Not found")
+                        .statusCode(404)
+                        .build(),
+                )
+
+            mvc
+                .perform(
+                    patch("/api/users/me")
+                        .header("Authorization", "Bearer $token")
+                        .content(
+                            mapper.writeValueAsString(
+                                PatchMeRequest(name = null, email = null, password = null, profileImage = "nonexistent/image.jpg"),
+                            ),
+                        ).contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isBadRequest)
+                .andExpect(jsonPath("$.code").value("PROFILE_IMAGE_NOT_FOUND"))
+        }
+
+        @Test
+        fun `토큰 없이 내 정보 수정 시도 시 401을 반환한다`() {
+            mvc
+                .perform(
+                    patch("/api/users/me")
+                        .content(
+                            mapper.writeValueAsString(PatchMeRequest(name = "새이름", email = null, password = null, profileImage = null)),
+                        ).contentType(MediaType.APPLICATION_JSON),
+                ).andExpect(status().isUnauthorized)
+                .andExpect(jsonPath("$.code").value("AUTHENTICATION_REQUIRED"))
+        }
+    }
diff --git a/src/test/resources/application-test.properties b/src/test/resources/application-test.properties
index f5effe00..fcec3309 100644
--- a/src/test/resources/application-test.properties
+++ b/src/test/resources/application-test.properties
@@ -8,3 +8,10 @@ spring.data.redis.port=6379
 
 jwt.secret=test-secret-key-for-jwt-token-generation-minimum-32-chars
 jwt.expiration-in-ms=86400000
+
+oauth.providers.google.client-id=test-google-client-id
+oauth.providers.google.client-secret=test-google-client-secret
+oauth.providers.google.redirect-uri=http://localhost:8080/auth/google/callback
+
+aws.s3.bucket=test-bucket
+aws.s3.region=ap-northeast-2