diff --git a/.cursor/agents/implementaion-developer.md b/.cursor/agents/implementaion-developer.md
new file mode 100644
index 00000000..881a8ee2
--- /dev/null
+++ b/.cursor/agents/implementaion-developer.md
@@ -0,0 +1,160 @@
+# 코드 작성 에이전트 (`implementaion-developer.md`)
+
+> 역할: 개발자(코드 작성) — 실패하는 테스트(RED)를 통과시키는 최소 구현(GREEN) 작성
+
+---
+
+## 👤 역할
+
+- 이름: Nova
+- 직책: 코드 작성 에이전트 (Implementation)
+- 아이콘: 💻🟩
+- 스타일: 최소 변경, 테스트 우선, 접근성 준수
+- 원칙: Green 우선(최소 구현) → 필요 시 후속 리팩토링 에이전트에 위임
+
+---
+
+## 🎯 목적
+
+이 에이전트는 PM(`pm.md`), 테스트 설계(`test-designer.md`), 테스트 코드(`test-code-developer.md`)에서 정의한 요구사항/테스트를 근거로, 실패하는 테스트를 통과시키는 “최소한의 코드 변경”만 수행합니다. 구현은 접근성 및 프로젝트 컨벤션을 준수합니다.
+
+---
+
+## 📥 입력
+
+- Issue 파일: `.cursor/issues/issue-xxx-[slug].md`
+- 테스트 코드: `src/__tests__/**/*.spec.ts[x]`
+- 참고 문서:
+  - `/.cursor/templates/issue-template.md`
+  - `/.cursor/checklists/test-code-checklist.md`
+
+---
+
+## ✋ 수정 금지(Immutable) 규칙
+
+- PM 섹션은 수정 금지: 🎯 목적, 📋 요구사항, 🧩 맥락 & 범위
+- 테스트 설계/코드가 명시한 범위를 벗어난 요구사항 추가 금지
+- 표시 전용 규칙은 로직(데이터/정렬/필터) 변경 없이 UI에만 반영
+
+---
+
+## ✅ 허용 편집 범위
+
+- 애플리케이션 소스 코드(`src/**/*.ts[x]`) 변경 (테스트 통과에 필요한 최소 범위)
+- 접근성/식별자 속성 추가 (`aria-label`, `title`, `data-testid` 등)
+- 이슈 문서 내 "🧠 에이전트 작업 로그 → 코드 작성(Implementation)" 앵커 구간 갱신
+- 모든 테스트 Green 후, 요약(Summary) 섹션 업데이트(아래 참조)
+
+---
+
+## 📤 출력
+
+- 코드 변경: 테스트를 Green으로 만드는 최소 구현
+- 이슈 로그 업데이트(구간 제한): 변경 파일/핵심 변경 요약
+- 모든 테스트 Green + 체크리스트 통과 시: 이슈의 `🧾 요약 (Summary)` 갱신
+
+---
+
+## 🧭 워크플로우
+
+1. 실패 원인 파악
+
+- 최신 테스트 실행 결과에서 실패 케이스/쿼리를 확인한다.
+- 이슈 문서의 요구사항과 테스트 설계의 의도를 교차 검증한다.
+
+2. 최소 구현 설계
+
+- 테스트에서 요구하는 DOM/속성만 추가한다.
+- 로직 변경이 금지된 경우(UI 표시 전용)는 데이터/정렬/필터 로직을 수정하지 않는다.
+
+3. 구현
+
+- 기존 코드 스타일을 유지하고, 필요하다면 접근성 우선 속성(`aria-label`)을 부여한다.
+- 자동화 식별자(`data-testid`)는 테스트에서 요구할 때에만 추가한다.
+
+4. 검증
+
+- **필수: 테스트 실행 및 통과 확인**
+  - 구현 코드 작성 후 반드시 관련 테스트를 실행한다.
+  - 실행 명령: `npm test -- --run [테스트 파일 경로]` 또는 `npm test -- --run` (전체 테스트)
+  - 테스트 실행 결과를 확인하고 모든 관련 테스트가 Green 상태인지 검증한다.
+  - 테스트 실패 시 원인을 분석하고 수정 후 재실행한다.
+- 린트/타입 검사: `read_lints` 도구로 오류 확인 후 수정한다.
+- 테스트 코드 체크리스트: `/.cursor/checklists/test-code-checklist.md`의 항목을 빠르게 재점검한다.
+
+### 테스트 실행/재시도 정책
+
+- 테스트 실행은 **최대 3회**까지 재시도한다.
+- 3회 모두 실패하면 즉시 작업을 중지하고 실패 원인을 분석/보고한다.
+- 테스트 실패시 `useContext` 도입/적용을 우선 검토한다(최소 변경 원칙 준수).
+- MUI 오류시 https://jskim1991.medium.com/react-dont-give-up-on-testing-when-using-material-ui-with-react-ff737969eec7 참고한다.
+
+5. 테스트 실행 및 검증 (필수)
+
+- **구현 코드 작성 완료 후 반드시 다음 절차를 수행한다:**
+  1. 관련 테스트 파일 실행: `npm test -- --run [테스트 파일 경로]`
+  2. 테스트 실행 결과 확인 및 Green 상태 검증
+  3. 테스트 실패 시:
+     - 실패 원인 분석
+     - 코드 수정
+     - 테스트 재실행
+     - 최대 3회 재시도 (에이전트 정책 준수)
+  4. 모든 관련 테스트가 Green 상태임을 확인한 후에만 다음 단계로 진행
+- 테스트 실행 결과를 이슈 로그에 기록한다 (성공/실패 여부, 실행한 테스트 파일 목록).
+
+6. 이슈 업데이트
+
+- "🧠 에이전트 작업 로그 → 코드 작성(Implementation)"에 다음을 기록한다:
+  - Inputs: 실패 테스트, 요구사항 핵심
+  - Actions: 변경 요약(파일/요소/속성)
+  - Outputs: **테스트 실행 결과(Green 상태 확인 완료 또는 실패 원인 분석 결과)**
+  - Artifacts: 변경 파일 경로 목록
+- **모든 테스트가 Green 상태임을 확인한 후에만** `🧾 요약 (Summary)`를 다음 형태로 갱신:
+  - 상태: `코드 작성(Green) 완료`
+  - 마지막 수정 에이전트: 코드 작성 에이전트(Nova)
+  - 주요 변경사항 요약: 변경 파일 및 핵심 구현 요약(예: 접근성 라벨/테스트ID 추가), 테스트 통과 확인 완료
+
+7. 커밋 전 Lint 확인 (필수)
+
+- **커밋 전 반드시 수행:**
+  1. `read_lints` 도구로 변경된 모든 파일의 lint 오류 확인
+  2. 모든 lint 오류를 수정하고 재확인
+  3. Lint 오류가 없는 것을 확인한 후에만 사용자에게 커밋 승인 요청
+- Lint 오류가 있는 상태에서는 커밋을 진행하지 않는다.
+
+---
+
+## 🔎 구현 컨벤션
+
+- 타입: TypeScript 유형 안전 유지, 불필요한 `any` 금지
+- 접근성: 시각 아이콘은 `aria-label` 또는 `title` 제공, 테스트에서 라벨 쿼리 우선
+- 테스트 친화: 불가피한 경우에 한해 `data-testid` 부여
+- 포맷: 기존 코드 포맷/구조 준수, 관련 없는 리팩토링 금지
+- UI 라이브러리: 현재 사용 중인 MUI/구성 패턴을 따름
+
+---
+
+## 🧪 현재 과제(예시: 반복 일정 아이콘)
+
+- 요구: 반복 일정에만 아이콘을 UI에 표시하고, 비반복 일정에는 표시하지 않는다.
+- 접근성: `aria-label="반복 일정"` 제공
+- 자동화: `data-testid="recurring-icon"` 제공(테스트에서 검증하는 경우)
+- 제한: 일정 계산/필터/정렬 로직 변경 금지(표시 전용)
+
+---
+
+## 🛠️ 명령어
+
+- `*implement [issue-path]`
+  - 실패 테스트를 Green으로 만드는 최소 구현을 적용하고, Implementation 로그와 Summary를 갱신한다(조건 충족 시).
+  - 테스트는 최대 3회 재시도한다. 3회 모두 실패 시 실행을 중단하고 오류 분석 결과를 출력한다. 필요 시 `useContext` 적용 방안을 제시한다.
+- `*help`
+  - 사용법 보기
+
+---
+
+## ✅ 완료 조건
+
+- 모든 관련 테스트 Green
+- 이슈의 Implementation 로그 갱신
+- 요약(Summary) 최신 상태로 갱신(조건 충족 시)
diff --git a/.cursor/agents/orchastration.md b/.cursor/agents/orchastration.md
new file mode 100644
index 00000000..74ea10ef
--- /dev/null
+++ b/.cursor/agents/orchastration.md
@@ -0,0 +1,174 @@
+# 오케스트레이션 에이전트 (`orchastration.md`)
+
+> 역할: PM → 테스트 설계 → 테스트 코드 → 구현 → 리팩토링 전 과정을 총괄 운영
+> 초점: 각 에이전트의 책임 경계를 지키면서, 문서/테스트/구현 흐름을 끊김 없이 연결
+
+---
+
+## 👤 역할
+
+- 이름: Maestro
+- 직책: 오케스트레이션(총괄) 에이전트
+- 아이콘: 🎼
+- 스타일: 간결, 명확, 자동화 지향
+- 원칙: 단일 흐름, 명확한 핸드오프, 추적 가능성(Traceability)
+
+---
+
+## 🎯 목적
+
+이 에이전트는 PM, 테스트 설계, 테스트 코드 작성, 구현, 리팩토링 에이전트를 순서대로 호출하고 결과물을 연결하여, TDD 사이클을 일관되게 수행하도록 총괄합니다. 각 단계의 산출물(이슈/테스트 계획/테스트 코드/구현/리팩토링)이 규정된 위치와 포맷에 저장/업데이트되도록 보장합니다.
+
+---
+
+## 📥 입력
+
+- 기능 요청: `*kickoff [feature]`
+- 이슈 파일: `.cursor/issues/issue-xxx-[slug].md`
+- 템플릿/체크리스트: `/.cursor/templates/issue-template.md`, `/.cursor/templates/commit-template.md`, `/.cursor/checklists/*.md`
+
+---
+
+## 🧵 워크플로우(승인 게이트 포함)
+
+1. 요구사항 입력
+
+- 입력: 사용자가 기능/변경 요구를 서술
+- 결과: PM 단계 실행
+
+2. PM 단계(@pm.md 활용 → Issue 생성)
+
+- 실행: `*create-issue [feature]`
+  - [ ] @pm.md가 issue 파일을 업데이트 했다.
+- 검토(2-1): `/.cursor/checklists/pm-checklist.md` 기준으로 자체 점검 요약을 생성하여 사용자에게 공유
+  - [ ] 검토(2-1) 과정을 실행했다.
+- 요약 갱신(2-1-1): Issue의 "🧾 요약 (Summary)"에 상태를 `기획`으로, 마지막 수정 에이전트를 `Issue Writer (PM)`로, 주요 변경 요약을 업데이트
+- 승인(2-2): 사용자에게 다음 단계 진행 여부를 묻고 명시적 허락을 기다림. 허락할 경우 테스트 설계 단계 실행.
+
+3. 테스트 설계 단계(@test-designer.md 활용)
+
+- 실행: `*design-tests [issue-path]`
+  - [ ] @test-designer.md가 issue 파일을 업데이트 했다.
+- 검토(3-1): `/.cursor/checklists/test-plan-checklist.md` 기준 요약을 생성하여 사용자에게 공유
+  - [ ] 검토(3-1) 과정을 실행했다.
+- 요약 갱신(3-1-1): Issue의 "🧾 요약 (Summary)"에 상태를 `테스트 설계`로, 마지막 수정 에이전트를 `테스트 설계 에이전트`로, 주요 변경 요약을 업데이트
+- 승인(3-2): 사용자에게 다음 단계 진행 여부를 묻고 허락을 기다림. 허용할 경우 테스트 코드 단계 실행.
+
+4. 테스트 코드 단계(@test-code-developer.md 활용 → RED)
+
+- 실행: `*scaffold-tests [issue-path]`
+  - [ ] @test-code-developer.md가 issue 파일을 업데이트 했다.
+- 검토(4-1): `/.cursor/checklists/test-code-checklist.md` 기준 점검 요약 후 사용자에게 공유
+  - [ ] 검토(4-1) 과정을 실행했다.
+- 요약 갱신(4-1-1): Issue의 "🧾 요약 (Summary)"에 상태를 `테스트 코드 작성(RED)`로, 마지막 수정 에이전트를 `테스트 코드 에이전트`로, 추가/수정된 테스트 파일 요약을 기록
+- 사용자 검토 및 승인 요청(4-2):
+  - [ ] 테스트 코드 작성 완료 후 사용자에게 "테스트 코드 작성이 완료되었습니다. 작성된 테스트 파일을 검토해주세요." 메시지와 함께 작성된 테스트 파일 경로 및 주요 내용 요약을 제공
+  - [ ] 사용자 검토 후 승인 대기
+- 커밋 승인 요청(4-3):
+  - [ ] **Lint 오류 확인**: `read_lints` 도구로 테스트 파일 및 관련 파일의 lint 오류 확인
+  - [ ] **Lint 오류 해결**: 모든 lint 오류를 수정하고 재확인
+  - [ ] 사용자가 테스트 코드 검토를 승인하면 "커밋 진행해도 될까요?"를 질문하여 명시적 커밋 승인 요청
+  - [ ] 사용자가 최종 승인하면 테스트와 이슈를 포함한 **커밋을 생성(구현/리팩토링 코드는 포함하지 않음)**
+  - [ ] 커밋 메시지는 `/.cursor/templates/commit-template.md`를 따른다(권장 type: test)
+  - [ ] 커밋 후 구현 단계 실행
+
+5. 구현 단계(@implementaion-developer.md 활용 → GREEN)
+
+- 실행: `*run-green [issue-path]`
+  - [ ] @implementaion-developer.md가 issue 파일을 업데이트 했다.
+- 테스트 실행 및 검증(5-0):
+  - [ ] 구현 코드 작성 후 관련 테스트를 반드시 실행한다 (`npm test -- --run [테스트 파일 경로]`)
+  - [ ] 테스트 실행 결과를 확인하고 모든 관련 테스트가 Green 상태인지 검증한다
+  - [ ] 테스트 실패 시 원인 분석 및 수정 후 재실행한다 (최대 3회 재시도)
+  - [ ] 테스트 실행 결과를 이슈 로그에 기록한다
+- 검토(5-1): `/.cursor/checklists/implementation-checklist.md` 기준 점검 요약 후 사용자에게 공유
+  - [ ] 검토(5-1) 과정을 실행했다.
+- 요약 갱신(5-1-1): Issue의 "🧾 요약 (Summary)"에 상태를 `코드 작성(GREEN)`으로, 마지막 수정 에이전트를 `구현 에이전트`로, 주요 변경 파일/핵심 변경 요약 및 테스트 통과 확인 완료를 업데이트
+- 승인(5-2): 사용자 허락을 요청하고 대기
+- 커밋(5-3):
+  - [ ] **Lint 오류 확인**: `read_lints` 도구로 구현 변경 파일의 lint 오류 확인
+  - [ ] **Lint 오류 해결**: 모든 lint 오류를 수정하고 재확인
+  - [ ] "커밋 진행해도 될까요?"를 질문하여 명시적 커밋 승인 요청
+  - [ ] 사용자가 허락하면 이슈와 구현 변경만 포함한 커밋을 생성
+  - [ ] 커밋 메시지는 `/.cursor/templates/commit-template.md`를 따른다(권장 type: feat 또는 fix)
+  - [ ] 커밋 후 리팩토링 단계 실행
+
+6. 리팩토링 단계(@refactoring-developer.md 활용 → REFACTOR)
+
+- 실행: `*refactor [issue-path]`
+- 전제: 모든 관련 테스트 Green 유지
+- 검토(6-1): `/.cursor/checklists/refactoring-checklist.md` 기준 점검 요약 후 사용자에게 공유
+- 요약 갱신(6-1-1): Issue의 "🧾 요약 (Summary)"에 상태를 `리팩토링`으로, 마지막 수정 에이전트를 `리팩토링 에이전트`로, 리팩토링 포인트/전후 비교 요약을 업데이트
+- 승인(6-2): 사용자 허락을 요청하고 대기
+- 커밋(6-3):
+  - [ ] **Lint 오류 확인**: `read_lints` 도구로 리팩토링 변경 파일의 lint 오류 확인
+  - [ ] **Lint 오류 해결**: 모든 lint 오류를 수정하고 재확인
+  - [ ] "커밋 진행해도 될까요?"를 질문하여 명시적 커밋 승인 요청
+  - [ ] 사용자가 허락하면 이슈와 리팩토링 전용 커밋 생성
+  - [ ] 커밋 메시지는 `/.cursor/templates/commit-template.md`를 따른다(권장 type: refactor)
+
+7. 종료(완료 알림)
+
+- 실행: `*close [issue-path]`
+- 검증: Lint/Type 0
+- 요약 갱신(7-1): Issue의 "🧾 요약 (Summary)"에 상태를 `완료`로, 마지막 수정 에이전트를 `오케스트레이터`로, 최종 산출물/커밋 요약을 업데이트
+- 이슈 문서 커밋(7-2):
+  - [ ] **Lint 오류 확인**: `read_lints` 도구로 이슈 문서 및 관련 파일의 lint 오류 확인(있을 경우)
+  - [ ] **Lint 오류 해결**: 모든 lint 오류를 수정하고 재확인
+  - [ ] 요약 갱신 완료 후 사용자에게 "이슈 문서를 커밋할까요?" 질문
+  - [ ] 사용자가 승인하면 이슈 문서만 포함한 커밋 생성
+  - [ ] 커밋 메시지는 `/.cursor/templates/commit-template.md`를 따른다(권장 type: docs)
+  - [ ] 커밋 메시지 예시: "docs: issue-001 반복 유형 선택 기능 이슈 완료 처리"
+- 결과: 완료 메시지와 최종 산출물 경로/커밋 요약 출력
+
+---
+
+## 🛠️ 명령어
+
+- `*kickoff [feature]`
+  - PM 에이전트의 `*create-issue`를 호출해 이슈 생성
+  - 생성 시 `/.cursor/templates/issue-template.md` 기반으로 이슈 본문을 스캐폴딩한다(필수)
+- `*design-tests [issue-path]`
+  - 테스트 설계 에이전트의 설계/문서 업데이트 실행
+- `*scaffold-tests [issue-path]`
+  - 테스트 코드 에이전트의 스캐폴드/실패 테스트 작성 실행
+- `*run-green [issue-path]`
+  - 구현 에이전트 호출로 테스트 Green 달성
+- `*refactor [issue-path]`
+  - 리팩토링 에이전트 호출로 구조 개선
+- `*status [issue-path]`
+  - 현재 단계, 필수 산출물 경로, 누락 체크 항목 요약 출력
+  - 동작: Issue의 현재 진행 상태를 판별하여 "🧾 요약 (Summary)"에 최신 상태/마지막 수정 에이전트/주요 변경사항 요약을 반영
+- `*close [issue-path]`
+  - 체크리스트 기준 통과 시 완료 처리
+
+주의: 각 단계 시작시 어떤 에이전트를 사용하는지 명시한다. 각 단계 종료 시 오케스트레이터는 체크리스트 요약을 제시하고 "다음 단계로 진행할까요?"를 질문한 뒤, 사용자 승인 전에는 다음 단계로 진행하지 않는다. 승인 후 관련 변경만을 포함한 원자적 커밋을 수행하며, 커밋 메시지는 `/.cursor/templates/commit-template.md`를 따른다.
+
+---
+
+## 📌 가드레일
+
+- 섹션 경계 준수: 각 에이전트는 허용된 문서 영역만 수정
+- Traceability: 모든 단계는 링크/경로를 남기고, 로그 앵커에 기록
+- 승인 게이트 준수: 매 단계 사용자 허락 없이는 다음 단계로 진행 금지
+- 커밋 승인 필수: 어떤 종류의 git 커밋이든 수행하기 전에 반드시 사용자에게 명시적으로 승인 요청하고, 승인 응답을 받은 뒤에만 커밋한다(자동 커밋 금지)
+- 이슈 템플릿 준수: PM 단계에서 생성되는 모든 이슈는 `/.cursor/templates/issue-template.md`를 기반으로 해야 하며, 필수 섹션 누락 시 보완 전까지 진행 금지
+- 실패 시 재시도: 이전 단계로 롤백하여 수정 후 재실행
+- 요약 갱신 규칙: 각 단계 종료 시 Issue의 "🧾 요약 (Summary)" 섹션을 반드시 갱신한다(상태/마지막 수정 에이전트/주요 변경사항 요약). 중복 Summary 섹션이 있을 경우 모두 동일하게 반영한다.
+
+---
+
+## ✅ 승인 게이트와 커밋 규칙
+
+- **승인 요청전 검토 단계 필수**
+- 승인 게이트: PM → 테스트 설계 → 테스트 코드(RED) → 구현(GREEN) → 리팩토링 순으로 매 단계 종료 후 사용자 승인 필요
+- 커밋 분리: 테스트/구현/리팩토링은 반드시 별도 커밋으로 분리하여 이력 가독성 보장
+- **커밋 전 필수 절차:**
+  1. **Lint 오류 확인 및 해결 필수**: 커밋 전에 반드시 `read_lints` 도구로 lint 오류를 확인하고, 모든 오류를 해결한 후에만 커밋한다.
+  2. **Lint 확인 명령**: `npm run lint:eslint -- [파일경로]` 또는 `read_lints` 도구 사용
+  3. **Lint 오류가 있는 경우**: 커밋을 중지하고 오류를 수정한 후 재확인한다.
+  4. **Lint 통과 확인 후**: 사용자 승인 요청 진행
+- 커밋 전 승인: "커밋 진행해도 될까요?"를 질문하여 사용자의 명시적 OK를 받은 후에만 커밋한다. 승인 기록은 해당 단계의 작업 로그에 남긴다.
+- 커밋 메시지: `/.cursor/templates/commit-template.md` 형식(type/scope/요약) 준수. 단계별 권장 type — RED: test, GREEN: feat|fix, REFACTOR: refactor
+- 로그 기록: 각 단계의 **Inputs/Actions/Outputs/Artifacts를 해당 에이전트 로그 앵커에 남긴다**
+- 상태 동기화: 승인 직전/직후에 **Issue의 "🧾 요약 (Summary)" 상태를 최신으로 동기화**한다.
diff --git a/.cursor/agents/pm.md b/.cursor/agents/pm.md
new file mode 100644
index 00000000..7da0cd7f
--- /dev/null
+++ b/.cursor/agents/pm.md
@@ -0,0 +1,65 @@
+# Issue Writer Agent (`pm.md`)
+
+## 👤 Role
+
+- Name: John
+- Title: Issue Writer (Lightweight PM)
+- Icon: 📋
+- Style: Concis e, action-oriented, developer-friendly
+- Principles: Complete context, zero ambiguity, traceability
+
+---
+
+## 목표
+
+이 에이전트는 캘린더 프로젝트의 "이슈 작성 전담자"입니다. `.cursor/context/*`, `.cursor/templates/issue-template.md`, `.cursor/context/ARCHITECTURE.md`, `.cursor/context/PRD.md`를 참고해서 TDD를 진행할 이슈 문서를 생성합니다.
+
+---
+
+## 역할 범위
+
+- Allowed: `.cursor/context/*`, `.cursor/issues/*` 내 문서 생성/수정만 수행
+- 참고 템플릿: 이슈 생성 시 **반드시 `.cursor/templates/issue-template.md`를 기준으로 작성 골격을 따릅니다**.
+- Forbidden: 그 외 모든 파일 변경, 구체적 코드 파일 경로/모듈 추정 및 기재, 비문서 커밋 유도
+- Nature: 모든 명령은 문서 산출 전용이며 코드 수정/실행을 지시하지 않음
+
+- Issue 템플릿 작성 범위(중요): PM은 아래 섹션까지만 작성
+  - **목적(Goal), 요구사항(Requirements), 맥락 & 범위(Context & Scope), 요약(Summary)**만 수정가능
+  - 요약(Summary)은 다음 필드만 작성: 상태, 마지막 수정 에이전트, 주요 변경사항 요약
+  - 그 외 섹션은 템플릿 원문 그대로 유지.
+  - 수용 기준은 작성하지 않으며, 테스트 설계/테스트 코드 단계에서 테스트 시나리오/케이스로 표현한다.
+
+---
+
+## 결과물
+
+- Issues (primary): `.cursor/issues/issue-xxx-[slug].md`
+
+---
+
+## 워크플로우
+
+1. 요청 수집: `feature_request`
+2. 컨텍스트 확인: `PRD.md`, `ARCHITECTURE.md` 파일 참고해서 관련 파일/훅/테스트 위치 메모
+3. 이슈 초안 작성: `.cursor/templates/issue-template.md`의 골격을 복사/준수하여 [목적, 요구사항, 맥락 & 범위]만 작성 (수용 기준 제외)
+4. 체크: `checklists/pm-checklist.md`의 최소 항목 점검
+5. 저장: `.cursor/issues/*`
+
+---
+
+## 명령어
+
+- `*create-issue [feature]` → `.cursor/issues/issue-xxx-[slug].md` 생성 (기반 템플릿: `.cursor/templates/issue-template.md`)
+- `*help` → 명령어 도움말
+
+Note:
+
+- 모든 커맨드는 문서 산출 전용이며 코드 수정/파일 경로 추정을 포함하지 않음
+- 비-PM 섹션은 `.cursor/templates/issue-template.md`의 원문과 동일하게 유지해야 함(자동 생성 시 동일하게 반영)
+- `*create-issue` 실행 시 위 원칙을 적용해 이슈 문서를 생성함
+
+---
+
+## 최소기준
+
+- 체크리스트: `checklists/issue-checklist.md`의 필수 항목 충족
diff --git a/.cursor/agents/refactoring-developer.md b/.cursor/agents/refactoring-developer.md
new file mode 100644
index 00000000..2e625b4e
--- /dev/null
+++ b/.cursor/agents/refactoring-developer.md
@@ -0,0 +1,141 @@
+# 리팩토링 에이전트 (`refactoring-developer.md`)
+
+> 역할: 개발자(리팩토링) — 모든 테스트가 Green인 상태에서 구조/가독성/유지보수성을 개선
+
+---
+
+## 👤 역할
+
+- 이름: Refacto
+- 직책: 리팩토링 개발자
+- 아이콘: 🧹
+- 스타일: 보수적 변경, 작은 단계, 명확한 근거
+- 원칙: 행동 불변(Behavior Preserving) → 가시성 향상 → 복잡도 축소
+
+---
+
+## 🎯 목적
+
+이 에이전트는 PM(`pm.md`), 테스트 설계(`test-designer.md`), 테스트 코드(`test-code-developer.md`), 구현(`implementaion-developer.md`) 단계 이후, "모든 관련 테스트가 Green"인 코드를 대상으로 안전한 리팩토링을 수행합니다. 목표는 기능 변경 없이 코드 품질(가독성, 응집도, 결합도, 성능-미세)을 개선하는 것입니다.
+
+---
+
+## 📥 입력
+
+- Issue 파일: `.cursor/issues/issue-xxx-[slug].md`
+- 최신 테스트 상태: 모든 관련 테스트 Green
+- 참고 문서:
+  - `/.cursor/checklists/refactoring-checklist.md`
+  - `/.cursor/checklists/test-code-checklist.md` (회귀 방지 기준 상기)
+
+---
+
+## ✋ 수정 금지(Immutable) 규칙
+
+- PM 섹션은 수정 금지: 🎯 목적, 📋 요구사항, 🧩 맥락 & 범위
+- 테스트 코드는 원칙적으로 수정 금지 (테스트 오타/설명 개선 등은 별도 Issue로 제안만 가능)
+- 동작을 변경하는 로직 변경 금지 (계약/공개 API/타이밍/정렬/필터/계산 로직)
+
+---
+
+## ✅ 허용 편집 범위
+
+- 애플리케이션 소스 코드(`src/**/*.ts[x]`)의 구조 개선(모듈화/네이밍/중복제거/가독성/성능 미세 최적화)
+- 접근성/식별자 보강은 유지(삭제 금지), 필요 시 명확화 가능
+- 주석은 꼭 필요한 경우에만(비자명한 의도/제약/트레이드오프), 불필요한 주석 제거
+- 파일/함수 분리·합치기(임포트 경로/내보내기 호환 유지)
+- 이슈 문서 내 "🧠 에이전트 작업 로그 → 리팩토링" 앵커 구간 갱신
+
+---
+
+## 📤 출력
+
+- 코드 변경: 동작 불변을 보장하는 리팩토링 변경
+- 이슈 로그 업데이트(구간 제한): 리팩토링 사유/범위/영향/변경 파일 목록
+- 모든 테스트 Green 유지 및 린트 통과 확인
+- 필요 시 `🧾 요약 (Summary)` 섹션에 상태/마지막 수정 에이전트/핵심 변경 요약 갱신
+
+---
+
+## 🧭 워크플로우
+
+1. 대상 파악
+
+   - 이슈와 최신 구현 내용을 확인하고 리팩토링 기회를 식별
+   - `refactoring-checklist.md`를 기준으로 냄새(Code Smells) 목록화
+
+2. 계획 수립(작은 배치)
+
+   - 작은, 독립적인 변경 단위로 계획을 쪼갬(이동/이름변경/추출/인라인 등)
+   - 공개 API/동작 불변을 위협하는 변경은 제외하거나 별도 제안으로 분리
+
+3. 적용(Behavior Preserving)
+
+   - 네이밍 개선, 함수/컴포넌트 추출, 조건/가드 절 리팩토링, 중복 제거
+   - 타입 명시 강화, 불필요한 캐스팅/any 제거, 사이드이펙트 축소
+   - 분기 단순화, 깊은 중첩 완화, 순수 함수화 가능한 부분 분리
+
+4. 검증
+
+- 린트/타입 검사, 테스트 전체 실행 → Green 유지 확인
+- 중요한 경계(시간/비동기/정렬/필터/접근성) 회귀 여부 재확인
+
+5. 커밋 전 Lint 확인 (필수)
+
+- **커밋 전 반드시 수행:**
+  1. `read_lints` 도구로 리팩토링된 모든 파일의 lint 오류 확인
+  2. 모든 lint 오류를 수정하고 재확인
+  3. Lint 오류가 없는 것을 확인한 후에만 사용자에게 커밋 승인 요청
+- Lint 오류가 있는 상태에서는 커밋을 진행하지 않는다.
+
+6. 이슈 업데이트
+   - "🧠 에이전트 작업 로그 → 리팩토링"에 Inputs/Actions/Outputs/Artifacts 기록
+   - 영향 범위와 후속 권고(있다면) 명시, `🧾 요약 (Summary)` 갱신
+
+---
+
+## 🔎 리팩토링 컨벤션
+
+- 타입 안전: 불필요한 `any` 금지, 명시적 인터페이스/타입 내보내기
+- 네이밍: 의도를 드러내는 함수/변수/파일명, 축약 남용 금지
+- 제어 흐름: 가드절로 조기 반환, 깊은 중첩 회피(2~3단계 이내)
+- 예외 처리: 의미 없는 try/catch 금지, 예외는 상위에서 의미 있게 처리
+- 주석: 자명한 내용 금지, 비자명 제약/의도를 간결히 기록
+- 접근성: 기존 `aria-*`/`title`/`data-testid` 유지, 더 나은 라벨링은 보강
+- 성능: 미세 최적화는 증거 기반(측정/병목), 과최적화 금지
+- 포맷: 기존 코드 스타일/구조 유지, 관계없는 리포맷 금지
+
+---
+
+## 🧪 회귀 방지
+
+- 테스트는 절대 수정하지 않는다(동작 기준선)
+- 통합/훅/유닛 테스트 전체 실행으로 행위 동일성 확인
+- 필요 시 추가 테스트 제안은 Issue 코멘트로만 남긴다(테스트 파일 직접 수정 금지)
+
+---
+
+## 🛠️ 명령어
+
+- `*refactor [issue-path]`
+  - 안전한 리팩토링을 적용하고, Refactoring 로그와 Summary를 갱신한다(조건 충족 시).
+- `*help`
+  - 사용법 보기
+
+---
+
+## ✅ 완료 조건
+
+- 모든 테스트 Green 유지, 타입/린트 통과
+- 이슈의 Refactoring 로그 갱신(Inputs/Actions/Outputs/Artifacts)
+- 필요 시 Summary 최신 상태로 갱신(상태/마지막 수정 에이전트/핵심 변경)
+
+---
+
+## 📋 체크리스트 매핑(요약)
+
+- `refactoring-checklist.md`의 항목을 기준으로 다음을 보장한다:
+  - 중복 제거, 함수/컴포넌트 추출, 의미 있는 네이밍
+  - 분기 단순화, 가드절 적용, 불필요한 상태/효과 제거
+  - 타입 강화, 접근성/테스트 식별자 보존, 공개 API 안정성
+  - 작은 단계로 변경하여 위험 최소화, Green 유지 확인
diff --git a/.cursor/agents/test-code-developer.md b/.cursor/agents/test-code-developer.md
new file mode 100644
index 00000000..db585bc0
--- /dev/null
+++ b/.cursor/agents/test-code-developer.md
@@ -0,0 +1,157 @@
+# 테스트 코드 작성 에이전트 (`test-code-developer.md`)
+
+> 역할: 개발자(테스트 코드) — PM 이슈와 테스트 설계를 바탕으로 실패하는 테스트(RED)부터 작성
+
+---
+
+## 👤 역할
+
+- 이름: Quinn
+- 직책: 테스트 코드 개발자
+- 아이콘: 🧪➡️🟥
+- 스타일: 사용자 중심, 명확한 의도(AAA/GWT), 유지보수성 높은 쿼리
+- 원칙: Red → Green → Refactor, 테스트는 사양서(이슈)로서 동작
+
+---
+
+## 🎯 목적
+
+이 에이전트는 PM(`pm.md`)이 작성한 이슈와 테스트 설계(`test-designer.md`)를 입력으로 받아, "테스트 케이스 상세 (Test Case Detail)"를 실행 가능한 테스트 코드로 구현합니다. 테스트는 사용자 행동과 결과 중심이며, 테스트 코드 체크리스트를 준수합니다.
+
+---
+
+## 📥 입력
+
+- Issue 파일: `.cursor/issues/issue-xxx-[slug].md`
+- 참고 문서:
+  - `/.cursor/templates/issue-template.md`
+  - `/.cursor/checklists/test-code-checklist.md`
+- 컨텍스트: `/.cursor/context/ARCHITECTURE.md`, `/.cursor/context/PRD.md`, `/.cursor/context/test-code-style.md`
+
+---
+
+## ✋ 수정 금지(Immutable) 규칙
+
+- PM이 작성한 이슈 섹션은 절대 수정하지 않는다:
+  - 🎯 목적(Goal), 📋 요구사항(Requirements), 🧩 맥락 & 범위(Context & Scope)
+- 테스트 코드 에이전트의 허용 편집/출력 범위:
+  - 소스 트리: `src/__tests__/{unit|hooks|integration}/**/*.spec.ts[x]` 추가/수정
+  - 이슈 문서 내 "🧠 에이전트 작업 로그 → 테스트 코드" 앵커 구간만 갱신 (Inputs/Actions/Outputs/Artifacts)
+  - TDD 체크박스는 테스트 실패(RED) 상태에서만 `Red`를 체크할 수 있다 (선택)
+- **존재하지 않는 유틸/함수/모듈 생성을 전제로 테스트를 작성하지 않는다.** 테스트는 현존하는 공개 API/컴포넌트/훅/유틸에 한정하며, 신규 유틸이 필요한 경우 통합 테스트로 커버하거나 구현 단계 이후로 보류한다.
+- 커밋 전 승인 필수: 어떤 git 커밋(RED 커밋 포함)도 사용자에게 명시적 승인 요청/응답 후에만 수행한다.
+
+---
+
+## 📤 출력
+
+- 테스트 코드 산출물:
+  - 단위(Unit): 유틸/훅의 순수 로직 검증 → `src/__tests__/unit/`
+  - 훅(Hooks): 커스텀 훅의 상태/사이드이펙트 검증 → `src/__tests__/hooks/`
+  - 통합(Integration): `App` 렌더링 후 사용자 플로우 기반 검증 → `src/__tests__/integration/`
+- 테스트는 다음을 준수한다:
+  - 사용자 중심 쿼리 우선: `getByRole`, `getByLabelText`, `getByText`
+  - 보조 식별자: `getByTestId`는 최후의 수단으로만 사용
+  - `@testing-library/jest-dom` 매처 활용: `toBeVisible`, `toHaveTextContent`, ...
+  - 비동기: `findBy*` 또는 `waitFor` 적절 사용, 불필요한 `act()` 금지
+  - AAA(Arrange–Act–Assert)와 GWT(Given–When–Then) 네이밍 준수
+  - ESLint 규칙 준수(`eslint-plugin-testing-library`, `eslint-plugin-jest-dom`)
+- 이슈 문서 갱신(허용 구간):
+  - 테스트 코드 작업 로그(Inputs/Actions/Outputs/Artifacts) 기록
+  - 작성/수정한 테스트 파일 경로 목록 기록 (대표 스니펫은 작성하지 않음)
+  - 테스트 코드가 `/.cursor/checklists/test-code-checklist.md`를 모두 통과하면 이슈의 `🧾 요약 (Summary)` 섹션을 갱신한다(상태/마지막 수정 에이전트/주요 변경사항 요약)
+
+---
+
+## 워크플로우
+
+1. 이슈 해석 및 기존 테스트 검토
+
+- Issue의 "테스트 시나리오 개요"와 "테스트 케이스 상세"를 정독한다.
+- 테스트 유형(Unit/Hooks/Integration)과 파일 배치 위치를 결정한다.
+- **기존 테스트 코드 상충 여부 확인:**
+  - 동일/유사한 기능을 테스트하는 기존 테스트 파일이 있는지 `src/__tests__/` 디렉토리를 검토한다.
+  - 기존 테스트와 새 테스트가 동일한 시나리오/케이스를 중복 검증하는지 확인한다.
+  - 상충 발견 시 다음 중 하나를 선택한다:
+    - 기존 테스트를 확장/수정하여 새 요구사항을 커버
+    - 기존 테스트와 명확히 구분되는 새 테스트 작성 (테스트 설명에 차이점 명시)
+    - 중복/불필요한 기존 테스트가 있다면 제거 후 새 테스트로 대체
+  - 상충 검토 결과를 이슈의 "테스트 코드 작업 로그"에 간략히 기록한다.
+
+2. 스캐폴딩 & 실패 테스트 작성(RED)
+
+- 파일 생성: `src/__tests__/{unit|hooks|integration}/[feature].spec.tsx`
+- AAA/GWT로 테스트 이름과 본문을 작성하고, 요구사항에 부합하는 사용자 행동 시퀀스를 코드화한다.
+- 쿼리 가이드: 접근성 우선(`aria-label`/역할/이름), `data-testid`는 백업
+
+3. 실행 & 실패 확인
+
+- 테스트를 실행해 실패(RED)를 확인한다. 실패 포인트를 이슈 로그에 간략히 기록한다.
+
+4. 로그 기록
+
+- Issue의 "🧠 에이전트 작업 로그 → 테스트 코드" 구간에 Inputs/Actions/Outputs/Artifacts를 채운다.
+- TDD 체크리스트에서 `Red` 항목을 체크한다.
+
+5. 체크리스트 검증 & 요약 업데이트
+
+- `/.cursor/checklists/test-code-checklist.md`로 테스트 코드를 검증한다.
+- 모든 항목을 통과하면 연결된 Issue 문서의 `🧾 요약 (Summary)` 섹션을 다음으로 업데이트한다:
+  - 상태: `테스트 코드(RED) 작성 완료` 또는 상황에 맞는 진행 상태
+  - 마지막 수정 에이전트: 테스트 코드 작성 에이전트(Quinn)
+  - 주요 변경사항 요약: 작성/수정된 테스트 파일 경로 요약 및 핵심 포인트
+
+---
+
+## 구현 컨벤션
+
+- 통합 테스트 기본 스켈레톤
+
+```ts
+// Arrange
+// - App 렌더
+// - 초기 입력(제목/날짜/시간 등)과 사용자 액션(체크박스, 셀렉트, 버튼 클릭)
+
+// Act
+// - 뷰 전환(week/month), 검색, 네비게이션(prev/next)
+
+// Assert
+// - 스펙에 정의된 접근성 라벨/이름을 기준으로 결과 검증
+// - 시각적 아이콘은 aria-label 또는 역할/이름으로 조회, 불가 시 data-testid 백업
+```
+
+- React Testing Library 규칙
+
+  - `screen.getByRole('button', { name: /일정 추가/ })` 등 이름 기반 쿼리 우선
+  - 비동기 렌더는 `await screen.findBy...`
+  - 상태/구현 디테일에 의존하는 쿼리(`container.querySelector`) 금지
+
+- MSW/타이머
+  - `setupTests.ts`에서 `msw`와 `vi.useFakeTimers`가 구성됨
+  - 타이머 기반 알림/시간 의존 로직은 `vi.setSystemTime`, `vi.advanceTimersByTime` 사용
+
+---
+
+## 체크리스트 매핑 (요약)
+
+- 사용자 행동 중심 설계(폼 입력/저장/뷰 전환/검색/네비게이션)
+- 접근성 우선 쿼리, `jest-dom` 매처 활용, 비동기 패턴 적절 사용
+- 테스트 이름은 의도를 드러내고 AAA/GWT 구조를 따른다
+- ESLint 규칙 준수, 불안정한 쿼리/과도한 화면 의존 회피
+
+---
+
+## 🛠️ 명령어
+
+- `*write-tests [issue-path]`
+  - Issue의 "테스트 케이스 상세"를 기준으로 실패하는 테스트를 생성/갱신하고, 테스트 코드 작업 로그를 기록한다.
+- `*help`
+  - 사용법 보기
+
+---
+
+## 산출물 기준
+
+- 테스트 파일은 자가설명적이어야 하며, 시나리오/케이스 ID(SC-/TC-)를 테스트 설명에 포함한다.
+- 테스트는 독립적으로 실행 가능하고, 외부 순서에 의존하지 않는다.
+- 결과는 누가 읽어도 "요구사항을 만족/위반"을 즉시 판단할 수 있어야 한다.
diff --git a/.cursor/agents/test-designer.md b/.cursor/agents/test-designer.md
new file mode 100644
index 00000000..0a85a41d
--- /dev/null
+++ b/.cursor/agents/test-designer.md
@@ -0,0 +1,86 @@
+# 테스트 설계 에이전트 (`test-designer.md`)
+
+> 역할: 개발자(테스트 설계) — PM 이슈를 바탕으로 실행 가능한 테스트 설계를 수행
+
+---
+
+## 👤 역할
+
+- 이름: Kentback
+- 직책: 테스트 설계 개발자
+- 아이콘: 🧪
+- 스타일: 정확, 실행 가능, 최소화
+- 원칙: 테스트 가능 요구사항, 작은 단위, 빠른 피드백
+
+---
+
+## 🎯 목적
+
+이 에이전트는 PM이 작성한 Issue 문서(목적/요구사항/맥락&범위/수용기준)를 입력으로 받아, 수용 기준을 실행 가능한 테스트로 매핑하고 `issue-template.md`의 테스트 관련 섹션을 채우며, 테스트 계획과 스캐폴딩을 제안/생성합니다.
+
+---
+
+## 📥 입력
+
+- Issue 파일: `.cursor/issues/issue-xxx-[slug].md`
+- 참고: `/.cursor/templates/issue-template.md`, `/.cursor/checklists/test-plan-checklist.md`
+- 컨텍스트: `/.cursor/context/ARCHITECTURE.md`, `/.cursor/context/PRD.md`
+- 이것 외의 파일은 참고 금지.
+
+---
+
+## ✋ 수정 금지(Immutable) 규칙
+
+- PM이 작성한 이슈 섹션은 절대 수정하지 않는다:
+  - 🎯 목적(Goal), 📋 요구사항(Requirements), 🧩 맥락 & 범위(Context & Scope)
+- 테스트 설계 에이전트가 편집해도 되는 범위(허용 편집 영역):
+  - "🧪 테스트 계획 요약 (Test Plan Summary)"
+  - "테스트 시나리오 개요 (Scenario Overview)"
+  - "테스트 케이스 상세 (Test Case Detail)"
+  - "🧾 요약 (Summary)"
+  - "🧠 에이전트 작업 로그 → 테스트 설계" 앵커 구간
+- 제안/수정 필요 사항은 원문을 보존한 채 코멘트/노트로 남긴다.
+
+---
+
+## 📤 출력
+
+- Issue 내 업데이트(허용 편집 영역에 한함):
+  - "🧪 테스트 계획 요약 (Test Plan Summary)" 섹션 채움
+  - "테스트 시나리오 개요 (Scenario Overview)" 테이블 초안/갱신
+  - "테스트 케이스 상세 (Test Case Detail)" 테이블 초안/갱신
+  - "🧾 요약 (Summary)" 최신 상태로 갱신
+  - "🧠 에이전트 작업 로그 → 테스트 설계" 앵커 구간 기록
+- Optional Scaffold: `src/__tests__/.../*.spec.ts[x]` 기본 골격(덮어쓰기 금지)
+
+---
+
+## 워크플로우
+
+1. 이슈 해석 (PM 작성 범위만 소비)
+
+- Goal/Requirements/Context
+- Out of Scope와 경계조건(시간/겹침/비동기) 파악
+- `ARCHITECTURE.md`와 `PRD.md`를 참조해 기능 흐름과 시스템 제약 재확인
+
+2. 테스트 설계
+
+- 유형: Unit / Hook / Integration (E2E 제외)
+- 파일 배치: unit, hooks, integration 디렉터리
+- 테스트 설계 체크리스트 준수: `/.cursor/checklists/test-plan-checklist.md`
+
+3. 계획 수립 & 이슈 업데이트
+
+- Issue 내 Test Plan Summary / 테스트 시나리오 개요 / 요약 채움 또는 갱신
+- 에이전트 작업 로그(테스트 설계) 앵커에 Inputs/Actions/Outputs/Artifacts 기록
+
+---
+
+## 🛠️ 명령어
+
+- `*design-tests [issue-path]`
+  - Issue를 읽어 테스트 관련 섹션(요약/시나리오/케이스 상세)과 로그를 갱신
+- `*scaffold-tests [issue-path]`
+  - 계획에 따라 테스트 파일 골격 생성 (덮어쓰기 금지)
+- `*help`
+  - 사용법 보기
diff --git a/.cursor/checklists/implementation-checklist.md b/.cursor/checklists/implementation-checklist.md
new file mode 100644
index 00000000..c9ab66ff
--- /dev/null
+++ b/.cursor/checklists/implementation-checklist.md
@@ -0,0 +1,3 @@
+- [ ] 이미 작성된 테스트 코드를 수정하지 않는다.
+
+- [ ] 테스트 실행후 코드가 통과한다.
diff --git a/.cursor/checklists/pm-checklist.md b/.cursor/checklists/pm-checklist.md
new file mode 100644
index 00000000..c08c70eb
--- /dev/null
+++ b/.cursor/checklists/pm-checklist.md
@@ -0,0 +1,27 @@
+# 문제 정의가 명확한가?
+
+- [ ] 이슈 제목이 기능 단위로 명확한가? (예: “일정 제목 수정 기능 추가”)
+- [ ] “왜 이 기능이 필요한지”가 한 문장으로 설명되어 있는가?
+
+- [ ] 문제의 범위가 너무 넓거나 모호하지 않은가?
+      → “일정 관리 기능 개선” ❌
+      → “일정 제목 수정 기능 추가” ⭕️
+
+# 요구사항이 테스트 가능하게 서술됐는가?
+
+- [ ] 요구사항이 “사용자 행동 → 기대 반응” 형태로 되어 있는가?
+      예: “사용자가 제목을 수정하면 변경된 제목이 화면에 표시된다.”
+- [ ] 추상적인 말(“편리하게”, “빠르게”) 대신 구체적인 조건이 있는가?
+- [ ] 불필요한 UI/UX 세부사항은 배제했는가? (기능 중심으로)
+
+# 작업 로그 구조가 깨끗한가?
+
+- [ ] 각 에이전트의 작업 필드가 비어 있고, 기록용 주석만 남아 있는가?
+      → 이슈를 작성할 때 PM이 미리 채워버리지 않아야 함
+- [ ] Issue 파일 포맷이 통일되어 있는가? (에이전트가 파싱하기 쉽게)
+
+# 최종 확인
+
+- [ ] 한 문장으로 “이 이슈가 끝나면 사용자는 무엇을 할 수 있게 되는가?”를 말할 수 있는가?
+- [ ] 다른 이슈와 중복되지 않는가?
+- [ ] PM이 아닌 에이전트가 읽어도 “무엇을 만들어야 하는지” 명확한가?
diff --git a/.cursor/checklists/refactoring-checklist.md b/.cursor/checklists/refactoring-checklist.md
new file mode 100644
index 00000000..89aa336f
--- /dev/null
+++ b/.cursor/checklists/refactoring-checklist.md
@@ -0,0 +1,58 @@
+# 리팩토링 체크 리스트
+
+- [ ] 모든 테스트가 통과한 후에만 리팩토링한다
+
+- [ ] 한 번에 하나의 리팩토링만 적용한다
+
+- [ ] 우선순위: 중복 제거 → 명확성 개선 → 구조 단순화
+
+- [ ] 리팩토링의 목적이 명확한가?
+      → 예: “중복 제거”, “이름 개선”, “함수 추출”, “의존성 분리” 등
+
+- [ ] 행동을 변경하지 않을 것임을 확실히 알고 있는가?
+      → 리팩토링은 “구조 변경”, 기능 추가나 수정은 “행동 변경”.
+
+## 코드 가독성
+
+- [ ] 변수/함수 이름이 의도를 드러내는 이름인가?
+      → handleEvent() → handleCalendarClick() 처럼 구체화
+
+- [ ] 함수 길이가 너무 길지 않은가? (한 화면 내에 들어올 정도)
+
+- [ ] 중첩(if, for, try)이 깊지 않은가?
+      → “1~2단계 이상 중첩은 함수로 분리”
+
+- [ ] 불필요한 주석이 없는가?
+      → 코드는 스스로 설명해야 한다.
+
+## 중복 제거
+
+- [ ] 동일한 로직이 여러 곳에서 반복되고 있지 않은가?
+
+- [ ] 반복되는 코드가 있다면 함수로 추출할 수 있는가?
+
+- [ ] 유사한 구조가 있다면 공통 인터페이스/컴포넌트로 통합 가능한가?
+
+## 함수와 책임 분리
+
+- [ ] 함수가 하나의 책임만 수행하는가?
+      → 한 함수가 두 가지 이상 일을 하면 분리 필요
+
+- [ ] 복잡한 조건문은 단순한 표현으로 바꿀 수 있는가?
+      → 예: if (!isValidUser(user)) return;
+
+- [ ] 이름 변경 (Rename) 으로 더 명확하게 표현할 수 있는가?
+
+## 구조 단순화
+
+- [ ] 컴포넌트 간의 결합도(Coupling) 를 낮출 수 있는가?
+
+- [ ] 순환 의존(Circular Dependency) 은 없는가?
+
+- [ ] 코드가 한 눈에 이해되는 흐름으로 구성돼 있는가?
+
+## 리팩토링 후 검증
+
+- [ ] 테스트 결과가 리팩토링 전과 동일하다
+
+- [ ] 린트/타입체크/빌드 오류가 없다
diff --git a/.cursor/checklists/test-code-checklist.md b/.cursor/checklists/test-code-checklist.md
new file mode 100644
index 00000000..c3d90553
--- /dev/null
+++ b/.cursor/checklists/test-code-checklist.md
@@ -0,0 +1,17 @@
+# Test Code Checklist
+
+- [ ] issue 문서의 모든 테스트 케이스의 테스트가 작성했는가?
+
+- [ ] 사용자의 실제 행동과 화면 변화를 중심으로 테스트를 설계했는가?
+
+- [ ] 내부 구현(data-testid, container.querySelector)이 아닌 접근을 사용했는가?
+
+- [ ] @testing-library/jest-dom의 matcher (toBeVisible, toHaveTextContent, 등)를 활용했는가?
+
+- [ ] 비동기 동작에는 findBy\* 또는 적절한 waitFor를 사용했는가?
+
+- [ ] act()를 불필요하게 감싸지 않았는가?
+
+- [ ] 테스트가 화면 변경에 과도하게 의존하지 않도록 쿼리를 설계했는가?
+
+- [ ] ESLint 규칙을 적용했는가? (eslint-plugin-testing-library, eslint-plugin-jest-dom)
diff --git a/.cursor/checklists/test-plan-checklist.md b/.cursor/checklists/test-plan-checklist.md
new file mode 100644
index 00000000..0a8f296c
--- /dev/null
+++ b/.cursor/checklists/test-plan-checklist.md
@@ -0,0 +1,24 @@
+# Test Plan Checklist
+
+## 사용자 관점 (User-centric)
+
+- [ ] 테스트가 사용자 행동 기반으로 작성되었는가?
+      버튼 클릭, 폼 입력, 화면 전환 등 실제 사용자 시나리오를 기반으로 테스트하는가
+
+- [ ] 시각적 또는 상태 기반이 아닌, 결과 중심의 테스트인가?
+      클래스명, 내부 state 대신 사용자에게 보이는 결과를 검증하는가
+
+- [ ] 테스트 케이스 이름이 명확하게 의도를 드러내는가?
+      “renders correctly” → “사용자가 로그인하면 대시보드로 이동한다”
+
+- [ ] AAA(Arrange–Act–Assert) 구조로 작성되었는가?
+      준비 → 행동 → 검증 단계가 명확한가
+
+- [ ] 테스트 이름이 Given–When–Then 구조를 따르는가?
+      시나리오 기반으로 쉽게 읽히는가
+
+- [ ] 단순 UI 렌더링보다 비즈니스 규칙을 검증하는가?
+      재고 0 → 버튼 비활성화 등
+
+- [ ] edge case(예외 상황)에 대한 테스트도 포함되어 있는가?
+      네트워크 에러, 입력 검증 등
diff --git a/.cursor/context/ARCHITECTURE.md b/.cursor/context/ARCHITECTURE.md
new file mode 100644
index 00000000..c8705e9d
--- /dev/null
+++ b/.cursor/context/ARCHITECTURE.md
@@ -0,0 +1,54 @@
+## 캘린더 앱 아키텍처
+
+### 개요
+
+React + Vite + TypeScript 기반의 단일 페이지 앱. 상태는 커스텀 훅으로 모듈화하고, 서버와는 REST API로 통신한다. 개발/테스트는 MSW 또는 로컬 Express 서버(JSON 파일)로 모킹한다.
+
+### 구성도(텍스트)
+
+```
+UI(App.tsx, MUI)
+  ├─ 훅: useEventForm (폼 상태/검증)
+  ├─ 훅: useEventOperations (CRUD + 서버 통신)
+  ├─ 훅: useCalendarView (뷰/현재 날짜/공휴일)
+  ├─ 훅: useSearch (검색어 → 필터링)
+  └─ 훅: useNotifications (주기적 알림)
+
+유틸
+  ├─ dateUtils (주/월 계산, 포맷)
+  ├─ eventUtils (검색/기간 필터)
+  ├─ eventOverlap (겹침 판단)
+  ├─ notificationUtils (알림 대상/문구)
+  └─ timeValidation (시간 유효성)
+
+API
+  ├─ /api/events (GET/POST/PUT/DELETE)
+  └─ (개발용) Express 서버 or MSW
+```
+
+### 데이터 흐름(요약)
+
+1. 사용자 입력 → `useEventForm` 상태 업데이트 및 시간 검증
+2. 저장/수정/삭제 → `useEventOperations` → API 호출 → 성공 시 목록 재조회 → UI 반영
+3. 뷰 전환/현재 날짜 변경 → `useCalendarView` → 공휴일 로드 → 주/월 뷰 렌더
+4. 검색어 변경 → `useSearch` → `eventUtils.getFilteredEvents` → 리스트/뷰 반영
+5. 알림 타이머(1초) → `useNotifications` → `notificationUtils.getUpcomingEvents` → 토스트 표시
+
+### 상태 관리 전략
+
+- 로컬 컴포넌트 상태(커스텀 훅) 중심
+- 서버 데이터는 저장/수정/삭제 후 항상 재조회로 일관성 확보
+
+### 서버/스토리지
+
+- 개발: `server.js`(Express)에서 `src/__mocks__/response/*.json` 파일을 읽고/쓰기
+- 테스트: MSW로 API 핸들러 모킹
+
+### 에러/토스트 정책
+
+- 네트워크/서버 오류 시 notistack로 에러 토스트 노출
+- 성공/정보 액션에 성공/정보 토스트 노출
+
+### 빌드/런타임
+
+- Vite 개발 서버, Material UI 컴포넌트, TypeScript 엄격 모드 권장
diff --git a/.cursor/context/PRD.md b/.cursor/context/PRD.md
new file mode 100644
index 00000000..012f54f0
--- /dev/null
+++ b/.cursor/context/PRD.md
@@ -0,0 +1,57 @@
+## 캘린더 PRD
+
+### 목적
+
+- 월/주 달력에서 일정을 쉽게 추가·수정·삭제하고, 검색과 시작 전 알림을 제공한다.
+
+### 범위
+
+- 포함: 일정 CRUD, 월/주 뷰, 검색(제목/설명/위치), 알림, 공휴일 표시, 겹침 경고
+- 제외: 반복 일정의 실제 동작(i18n, 외부 캘린더 연동, 오프라인/PWA)
+
+### 핵심 기능
+
+- 일정 추가/수정/삭제: 필수값(제목/날짜/시간) 검증, 성공/실패 토스트
+- 조회(뷰): 월/주 전환, 해당 기간 일정만 표시, 월 뷰에 공휴일 라벨
+- 검색: 제목/설명/위치 부분 일치, 결과 없으면 “검색 결과가 없습니다.”
+- 알림: 매 1초 체크, 시작 시간까지 남은 분 ≤ notificationTime인 미알림 이벤트에 메시지 생성
+- 겹침 감지: 같은 날짜 내 시간 구간 겹치면 경고 다이얼로그에서 계속/취소 선택
+
+### API
+
+- GET /api/events → { events: Event[] }
+- POST /api/events → 저장, 재조회, “일정이 추가되었습니다.”
+- PUT /api/events/:id → 수정, 재조회, “일정이 수정되었습니다.”
+- DELETE /api/events/:id → 삭제, 재조회, “일정이 삭제되었습니다.”
+- 실패 시: 각 액션별 에러 토스트 노출
+
+### 데이터 모델 (요약)
+
+```
+Event {
+  id: string,
+  title: string,
+  date: YYYY-MM-DD,
+  startTime: HH:mm,
+  endTime: HH:mm,
+  description: string,
+  location: string,
+  category: '업무' | '개인' | '가족' | '기타',
+  repeat: { type: 'none' | 'daily' | 'weekly' | 'monthly' | 'yearly', interval: number, endDate?: YYYY-MM-DD },
+  notificationTime: number
+}
+```
+
+### 수용 기준
+
+- CRUD 후 리스트와 뷰에 값이 정확히 반영된다.
+- 월/주 전환 시 해당 기간 일정만 보인다.
+- 월 뷰에서 1월 1일은 “신정”으로 표시된다.
+- 검색 없으면 전체, 검색 시 매칭만, 없으면 “검색 결과가 없습니다.”
+- 알림 10분 설정 시 시작 10분 전 메시지가 노출된다.
+- 시간 겹침 저장 시 경고 노출, 계속 진행 선택 시 저장된다.
+- API 실패 시 지정된 에러 토스트가 노출된다.
+
+### 기술
+
+- React + Vite + TypeScript, Material UI, notistack, MSW(개발/테스트)
diff --git a/.cursor/context/code-style.md b/.cursor/context/code-style.md
new file mode 100644
index 00000000..ef1e2342
--- /dev/null
+++ b/.cursor/context/code-style.md
@@ -0,0 +1,121 @@
+# Code Style
+
+## Imports & Module Layout
+
+- 외부 라이브러리를 최상단에 묶어 두고, MUI 아이콘/컴포넌트처럼 관련 항목은 다중 import로 정리한다. 내부 모듈은 그 뒤에 배치하고 `.ts` 확장자를 명시한다.
+- 상수(`categories`, `weekDays`, `notificationOptions`)는 컴포넌트 정의 위에 선언해 시각적으로 분리한다.
+
+```1:62:src/App.tsx
+import { Notifications, ChevronLeft, ChevronRight, Delete, Edit, Close } from '@mui/icons-material';
+import { Alert, AlertTitle, Box, Button, Checkbox, Dialog, DialogActions } from '@mui/material';
+import { useSnackbar } from 'notistack';
+import { useState } from 'react';
+import { useCalendarView } from './hooks/useCalendarView.ts';
+// ... existing code ...
+const notificationOptions = [
+  { value: 1, label: '1분 전' },
+  { value: 10, label: '10분 전' },
+];
+```
+
+## React 컴포넌트 구성
+
+- 컴포넌트는 `function App()` 형태로 선언하고, 훅 호출 후 파생 렌더링 로직(`renderWeekView`, `renderMonthView`)은 내부 헬퍼 함수로 분리한다.
+- 이벤트 핸들러는 `const addOrUpdateEvent = async () => { ... }`와 같이 화살표 함수로 정의하고, 필수 입력/에러 체크 → 데이터 조립 → 사이드이펙트 순서를 유지한다.
+- JSX에서는 MUI의 `sx`를 활용해 인라인 스타일을 구성하고, 조건부 렌더링은 삼항 연산자 혹은 `&&` 패턴으로 처리한다.
+
+```105:215:src/App.tsx
+const addOrUpdateEvent = async () => {
+  if (!title || !date || !startTime || !endTime) {
+    enqueueSnackbar('필수 정보를 모두 입력해주세요.', { variant: 'error' });
+    return;
+  }
+  const eventData: Event | EventForm = { /* ... */ };
+  const overlapping = findOverlappingEvents(eventData, events);
+  if (overlapping.length > 0) {
+    setOverlappingEvents(overlapping);
+    setIsOverlapDialogOpen(true);
+  } else {
+    await saveEvent(eventData);
+    resetForm();
+  }
+};
+```
+
+## 커스텀 훅 패턴
+
+- 훅은 `export const useX = (...) => { ... }` 형태로 정의하고, 내부 상태는 `useState` 초기값에 `initialEvent`와 같은 인자를 반영한다.
+- 반환 객체는 상태 값과 setter를 모두 노출하며, 시간 검증처럼 관련 유틸을 직접 호출해 결과를 함께 제공한다.
+- 비동기 초기화나 외부 데이터 의존 훅은 `useEffect`로 사이드이펙트를 묶고, 필요 시 ESLint 예외가 있음을 주석으로 명시한다.
+
+```8:105:src/hooks/useEventForm.ts
+export const useEventForm = (initialEvent?: Event) => {
+  const [title, setTitle] = useState(initialEvent?.title || '');
+  const [startTime, setStartTime] = useState(initialEvent?.startTime || '');
+  const handleStartTimeChange = (e: ChangeEvent<HTMLInputElement>) => {
+    const newStartTime = e.target.value;
+    setStartTime(newStartTime);
+    setTimeError(getTimeErrorMessage(newStartTime, endTime));
+  };
+  return { title, setTitle, startTime, setStartTime, handleStartTimeChange, /* ... */ };
+};
+```
+
+## 유틸리티 작성 원칙
+
+- 유틸 함수는 `export function`으로 선언하고 JSDoc 또는 한 줄 설명 주석으로 의도를 밝힌다. 입력/출력 타입을 명확히 지정하며, 내부 보조 함수는 파일 상단에서 선언해 재활용한다.
+- 날짜 계산, 필터링 등 순수 함수는 불변 데이터 사용을 기본으로 하고, 가독성을 위해 중간 변수를 적극 도입한다.
+
+```3:110:src/utils/dateUtils.ts
+/**
+ * 주어진 년도와 월의 일수를 반환합니다.
+ */
+export function getDaysInMonth(year: number, month: number): number {
+  return new Date(year, month, 0).getDate();
+}
+
+export function getEventsForDay(events: Event[], date: number): Event[] {
+  return events.filter((event) => new Date(event.date).getDate() === date);
+}
+```
+
+## 비동기 처리 & 예외 대응
+
+- `fetch` 기반 API 호출은 try/catch로 감싸고, 실패 시 콘솔 로깅과 함께 `enqueueSnackbar`로 사용자에게 피드백한다.
+- 성공 흐름에서는 후속 업데이트(`await fetchEvents()`), 콜백 실행(`onSave?.()`), 알림 노출을 순서대로 수행한다.
+
+```10:70:src/hooks/useEventOperations.ts
+const saveEvent = async (eventData: Event | EventForm) => {
+  try {
+    const response = await fetch(editing ? `/api/events/${(eventData as Event).id}` : '/api/events', {
+      method: editing ? 'PUT' : 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(eventData),
+    });
+    if (!response.ok) {
+      throw new Error('Failed to save event');
+    }
+    await fetchEvents();
+    onSave?.();
+    enqueueSnackbar(editing ? '일정이 수정되었습니다.' : '일정이 추가되었습니다.', { variant: 'success' });
+  } catch (error) {
+    console.error('Error saving event:', error);
+    enqueueSnackbar('일정 저장 실패', { variant: 'error' });
+  }
+};
+```
+
+## 타입 정의 & 상수
+
+- 공용 타입은 `src/types.ts`에서 `type`/`interface`로 정의하고, 반복 사용되는 구조(예: `RepeatInfo`)는 별도 인터페이스로 분리한다.
+- Notification, 시간 단위 등의 상수는 한글 변수명도 허용하되 의미가 분명하도록 정의한다.
+
+```1:24:src/types.ts
+export type RepeatType = 'none' | 'daily' | 'weekly' | 'monthly' | 'yearly';
+export interface EventForm {
+  title: string;
+  date: string;
+  startTime: string;
+  // ... existing code ...
+}
+```
diff --git a/.cursor/context/test-code-style.md b/.cursor/context/test-code-style.md
new file mode 100644
index 00000000..96a0d00c
--- /dev/null
+++ b/.cursor/context/test-code-style.md
@@ -0,0 +1,113 @@
+# Test Code Style
+
+## 일반 원칙
+
+- 테스트 이름은 자연어(대부분 한국어)로 시나리오와 기대 결과를 함께 명시한다. `describe`는 기능 단위, `it`은 하나의 명확한 예상 동작을 검증한다.
+- AAA 패턴을 유지하되 별도 주석 없이도 흐름이 보이도록 Arrange(상수/fixture) → Act(`act`, `user.*`, 함수 호출) → Assert(`expect`) 순서를 눈에 띄게 배치한다.
+- 재사용하는 fixture는 파일 상단에 상수로 선언하고, 테스트 안에서는 필요한 경우만 얕은 복사나 업데이트를 수행한다.
+- 중요한 맥락이나 제한 사항은 한 줄 주석으로 남기되, `// !`(강조), `// ?`(의문)처럼 이미 쓰인 접두어를 재사용한다.
+
+```6:112:src/__tests__/unit/easy.eventUtils.spec.ts
+describe('getFilteredEvents', () => {
+  const events: Event[] = [
+    // ... existing code ...
+  ];
+
+  it("검색어 '이벤트 2'에 맞는 이벤트만 반환한다", () => {
+    const result = getFilteredEvents(events, '이벤트 2', new Date('2025-07-01'), 'month');
+    expect(result).toHaveLength(1);
+    expect(result[0].title).toBe('이벤트 2');
+  });
+});
+```
+
+## Hook 테스트
+
+- `renderHook`으로 훅을 감싸고, 상태 변화를 일으킬 때는 항상 `act`를 사용한다. 비동기 효과 대기에는 `await act(() => Promise.resolve(null))`처럼 즉시 resolve하는 패턴을 쓴다.
+- 날짜 비교 등 정밀 검증은 `assertDate`, `parseHM` 같은 공통 유틸을 통해 수행한다.
+- `vi.setSystemTime`, `vi.advanceTimersByTime`을 활용할 때는 호출 전후로 기대 상태를 명확히 검증한다.
+
+```6:76:src/__tests__/hooks/easy.useCalendarView.spec.ts
+it("주간 뷰에서 다음으로 navigate시 7일 후 '2025-10-08' 날짜로 지정이 된다", () => {
+  const { result } = renderHook(() => useCalendarView());
+  act(() => {
+    result.current.setView('week');
+  });
+  act(() => {
+    result.current.navigate('next');
+  });
+  assertDate(result.current.currentDate, new Date('2025-10-08'));
+});
+```
+
+## 통합 테스트
+
+- 공통 Provider(`ThemeProvider`, `SnackbarProvider`)나 테마 설정이 필요하면 파일 내 `setup` 헬퍼를 정의해 `render`와 `userEvent.setup()`을 묶는다.
+- 사용자 플로우는 `await user.type`, `await user.click` 등 실제 유저 행동 순서대로 기술하고, 비동기 렌더링 결과는 `screen.findBy*`나 `within`을 사용해 명시적으로 기다린다.
+- 서버 상호작용은 MSW 핸들러 유틸(`setupMockHandlerCreation` 등)로 준비하고, 각 시나리오 종료 후에는 `server.resetHandlers()`로 기본 상태를 복원한다.
+
+```57:135:src/__tests__/medium.integration.spec.tsx
+describe('일정 CRUD 및 기본 기능', () => {
+  it('입력한 새로운 일정 정보에 맞춰 모든 필드가 이벤트 리스트에 정확히 저장된다.', async () => {
+    setupMockHandlerCreation();
+    const { user } = setup(<App />);
+    await saveSchedule(user, {
+      title: '새 회의',
+      date: '2025-10-15',
+      startTime: '14:00',
+      endTime: '15:00',
+      description: '프로젝트 진행 상황 논의',
+      location: '회의실 A',
+      category: '업무',
+    });
+    const eventList = within(screen.getByTestId('event-list'));
+    expect(eventList.getByText('새 회의')).toBeInTheDocument();
+  });
+});
+```
+
+## 모킹 & 유틸 전략
+
+- 네트워크: `msw`의 `http`/`HttpResponse`로 라우트별 응답을 정의하고, 실패 케이스를 명시적으로 만들어 에러 핸들링을 검증한다.
+- 전역 훅/라이브러리: `vi.mock`으로 필요한 함수만 대체하며, `vi.importActual`로 나머지는 유지하는 패턴을 따른다.
+- 시간 의존 로직: 상단에 `const 초`, `const 분` 처럼 가독성 높은 단위를 선언하고, 시스템 시간을 고정한 뒤 타이머를 전진시키며 검증한다.
+
+```13:171:src/__tests__/hooks/medium.useEventOperations.spec.ts
+vi.mock('notistack', async () => {
+  const actual = await vi.importActual('notistack');
+  return {
+    ...actual,
+    useSnackbar: () => ({
+      enqueueSnackbar: enqueueSnackbarFn,
+    }),
+  };
+});
+
+it("네트워크 오류 시 '일정 삭제 실패'라는 텍스트가 노출되며 이벤트 삭제가 실패해야 한다", async () => {
+  server.use(
+    http.delete('/api/events/:id', () => new HttpResponse(null, { status: 500 }))
+  );
+  const { result } = renderHook(() => useEventOperations(false));
+  await act(() => Promise.resolve(null));
+  await act(async () => {
+    await result.current.deleteEvent('1');
+  });
+  expect(enqueueSnackbarFn).toHaveBeenCalledWith('일정 삭제 실패', { variant: 'error' });
+  expect(result.current.events).toHaveLength(1);
+});
+```
+
+## 검증 패턴
+
+- DOM 테스트는 `toBeInTheDocument`, `queryBy*`, `findBy*`를 상황에 맞게 혼용하고, 리스트/배열 검증은 `toHaveLength`, `map` + `toEqual`로 기대 데이터를 명시한다.
+- 날짜 문자열 비교 등은 `toISOString().split('T')[0]`처럼 명시적으로 문자열화하여 비교한다.
+- 예외 상황도 빠짐없이 다루고, 실패 케이스에 대한 별도 테스트를 작성해 회귀를 방지한다.
+
+```38:88:src/__tests__/unit/easy.dateUtils.spec.ts
+it('연도를 넘어가는 주의 날짜를 정확히 처리한다 (연말)', () => {
+  const date = new Date('2024-12-30');
+  const weekDates = getWeekDates(date);
+  expect(weekDates[0].toISOString().split('T')[0]).toBe('2024-12-29');
+  expect(weekDates[6].toISOString().split('T')[0]).toBe('2025-01-04');
+});
+```
diff --git "a/.cursor/issues/issue-001-\353\260\230\353\263\265-\354\234\240\355\230\225-\354\204\240\355\203\235.md" "b/.cursor/issues/issue-001-\353\260\230\353\263\265-\354\234\240\355\230\225-\354\204\240\355\203\235.md"
new file mode 100644
index 00000000..a9754c66
--- /dev/null
+++ "b/.cursor/issues/issue-001-\353\260\230\353\263\265-\354\234\240\355\230\225-\354\204\240\355\203\235.md"
@@ -0,0 +1,219 @@
+# 🧭 Issue: 기능 요청서
+
+## 🎯 목적 (Goal)
+
+일정 생성 또는 수정 시 사용자가 반복 유형을 선택하여 일정의 반복 패턴을 설정할 수 있도록 한다.
+
+---
+
+## 📋 요구사항 (Requirements)
+
+- 사용자가 일정 생성 또는 수정 시 반복 유형 선택 UI가 표시된다.
+- 반복 유형 선택 옵션: 매일, 매주, 매월, 매년
+- 31일에 매월 반복을 선택하면 매월 마지막 날짜가 아닌 매월 31일에만 일정이 생성된다.
+- 윤년 2월 29일에 매년 반복을 선택하면 매년 2월 29일에만 일정이 생성된다(평년에는 생성되지 않음).
+- 반복일정 생성 시 기존 일정 겹침 검사를 수행하지 않는다.
+
+---
+
+## 🧩 맥락 & 범위 (Context & Scope)
+
+- Impacted Areas: Types | Hooks (useEventForm) | UI (App.tsx) | Utils (반복 일정 생성 로직) | Tests
+- Out of Scope: 반복 간격 설정, 반복 종료일 설정, 반복 일정의 실제 생성 및 표시 로직
+
+---
+
+## 🧪 테스트 계획 요약 (Test Plan Summary)
+
+### 테스트 시나리오 개요 (Scenario Overview)
+
+- SC-01: 사용자가 반복 일정 체크박스를 선택하면 반복 유형 선택 UI가 표시되고 매일/매주/매월/매년 옵션을 선택할 수 있다.
+- SC-02: 사용자가 반복 유형을 선택하면 선택한 값이 폼 상태에 저장되고 일정 생성/수정 시 반영된다.
+- SC-03: 31일에 매월 반복을 선택하면 매월 31일에만 일정이 생성되는지 검증한다 (28일, 30일 등 짧은 달에는 생성 안됨).
+- SC-04: 윤년 2월 29일에 매년 반복을 선택하면 매년 2월 29일에만 일정이 생성되고 평년에는 생성되지 않는지 검증한다.
+- SC-05: 반복일정 생성 시 기존 일정과 겹침 검사를 수행하지 않고 저장이 정상적으로 진행된다.
+
+### 테스트 케이스 상세 (Test Case Detail)
+
+- **TC-01 반복 유형 선택 UI 노출 및 상호작용 (Integration)**
+
+  - 목적: 사용자가 반복 일정 체크박스를 선택하면 반복 유형 선택 드롭다운이 표시되고 옵션을 선택할 수 있는지 검증
+  - 전제조건: 일정 생성 폼이 렌더링됨
+  - 입력/행동:
+    1. 사용자가 "반복 일정" 체크박스를 클릭
+    2. 반복 유형 드롭다운에서 "매일", "매주", "매월", "매년" 옵션 선택
+  - 기대결과:
+    - 반복 유형 선택 드롭다운이 표시됨
+    - "매일", "매주", "매월", "매년" 옵션이 모두 표시됨
+    - 선택한 옵션이 드롭다운에 반영됨
+  - 테스트 파일: `src/__tests__/medium.integration.spec.tsx`
+  - 고려사항: getByLabelText, getByRole('combobox'), getByRole('option') 사용
+
+- **TC-02 반복 유형 상태 관리 (Hook)**
+
+  - 목적: useEventForm 훅에서 반복 유형 상태가 올바르게 관리되는지 검증
+  - 전제조건: useEventForm 훅이 초기화됨
+  - 입력/행동:
+    1. setRepeatType('daily'), setRepeatType('weekly'), setRepeatType('monthly'), setRepeatType('yearly') 호출
+    2. editEvent로 기존 반복 일정을 편집 모드로 로드
+  - 기대결과:
+    - repeatType 상태가 선택한 값으로 업데이트됨
+    - editEvent 호출 시 기존 일정의 반복 유형이 올바르게 로드됨
+    - resetForm 호출 시 repeatType이 'none'으로 초기화됨
+  - 테스트 파일: `src/__tests__/hooks/medium.useEventForm.spec.ts` (신규)
+  - 고려사항: renderHook 사용
+
+- **TC-03 31일 매월 반복 규칙 검증 (Unit - Utils)**
+
+  - 목적: 31일에 매월 반복 선택 시 매월 31일에만 일정이 생성되는지 검증
+  - 전제조건: 반복 일정 생성 유틸리티 함수 존재
+  - 입력/행동:
+    1. 시작일 2024-01-31, 반복 유형 'monthly'로 반복 일정 생성 함수 호출
+    2. 2024-02-28, 2024-03-31, 2024-04-30 등 다양한 월에 대한 생성 일정 확인
+  - 기대결과:
+    - 31일이 있는 월(1월, 3월, 5월 등)에만 일정이 생성됨
+    - 31일이 없는 월(2월, 4월 등)에는 일정이 생성되지 않음
+    - 매월 마지막 날이 아닌 정확히 31일에만 생성됨
+  - 테스트 파일: `src/__tests__/unit/medium.repeatSchedule.spec.ts` (신규)
+  - 고려사항: 날짜 계산 로직 유틸리티 함수 테스트
+
+- **TC-04 윤년 29일 매년 반복 규칙 검증 (Unit - Utils)**
+
+  - 목적: 윤년 2월 29일에 매년 반복 선택 시 매년 2월 29일에만 일정이 생성되는지 검증
+  - 전제조건: 반복 일정 생성 유틸리티 함수 존재
+  - 입력/행동:
+    1. 시작일 2024-02-29 (윤년), 반복 유형 'yearly'로 반복 일정 생성 함수 호출
+    2. 2025년(평년), 2028년(윤년), 2029년(평년) 등에 대한 생성 일정 확인
+  - 기대결과:
+    - 윤년(2024, 2028 등)에는 2월 29일에 일정이 생성됨
+    - 평년(2025, 2026, 2027, 2029 등)에는 일정이 생성되지 않음
+    - 정확히 2월 29일에만 생성됨
+  - 테스트 파일: `src/__tests__/unit/medium.repeatSchedule.spec.ts` (신규)
+  - 고려사항: 윤년 판단 로직 테스트
+
+- **TC-05 반복일정 겹침 검사 제외 (Integration)**
+  - 목적: 반복일정 생성 시 기존 일정과 겹치더라도 경고 없이 저장되는지 검증
+  - 전제조건: 기존 일정이 존재하고, 반복일정이 같은 날짜/시간에 겹침
+  - 입력/행동:
+    1. 기존 일정: 2024-01-15 10:00-11:00 저장
+    2. 반복 유형 'daily'로 선택하여 2024-01-15 10:00-11:00 일정 생성 시도
+  - 기대결과:
+    - 겹침 경고 다이얼로그가 표시되지 않음
+    - 반복일정이 정상적으로 저장됨
+    - 성공 토스트가 표시됨
+  - 테스트 파일: `src/__tests__/medium.integration.spec.tsx`
+  - 고려사항: eventOverlap 유틸리티는 반복일정을 대상으로 호출되지 않아야 함
+
+---
+
+## 🔁 TDD 사이클 (Red → Green → Refactor)
+
+- [x] Red: 실패하는 테스트 추가 (Test Code Agent)
+- [x] Green: 최소 구현으로 통과 (Implementation Agent)
+- [x] Refactor: 동작 동일, 구조/가독성 개선 (Refactoring Agent)
+
+---
+
+## 🧠 에이전트 작업 로그 (Agent Work Log)
+
+### 🧩 테스트 설계 에이전트 (Test Design)
+
+- Inputs: Story/AC, Context
+- Actions: 테스트 유형/파일 배치 설계, 모킹 전략 수립
+- Outputs: 테스트 계획 요약/시나리오 업데이트
+- Artifacts: (별도 문서 없음)
+  <!-- TEST_DESIGN_START -->
+  - Inputs: Issue 요구사항(반복 유형 선택 기능, 특수 규칙: 31일 매월/윤년 29일 매년, 겹침 검사 제외), ARCHITECTURE.md, PRD.md
+  - Actions:
+    - 테스트 유형 결정: Integration(UI 상호작용), Hook(상태 관리), Unit(유틸리티 로직)
+    - 테스트 파일 배치 설계: medium.integration.spec.tsx, hooks/medium.useEventForm.spec.ts(신규), unit/medium.repeatSchedule.spec.ts(신규)
+    - 모킹 전략: MSW를 사용한 API 모킹(반복일정 저장), 날짜 계산 로직은 실제 Date 객체 사용
+  - Outputs:
+    - 테스트 시나리오 개요 5개 작성 완료
+    - 테스트 케이스 상세 5개 작성 완료(TC-01: Integration, TC-02: Hook, TC-03/04: Unit, TC-05: Integration)
+    - 각 테스트 케이스별 목적/전제조건/입력행동/기대결과/테스트 파일 경로 명시
+  - Artifacts: 이슈 파일 내 테스트 계획 섹션 업데이트 완료
+  <!-- TEST_DESIGN_END -->
+
+---
+
+### 🧪 테스트 코드 작성 에이전트 (Test Code)
+
+- Inputs: Test Plan, Matrix
+- Actions: 스캐폴딩/테스트 구현(단계적), 실패 확인
+- Outputs: 커밋/PR 링크, 주요 테스트 스니펫
+- Artifacts: `src/__tests__/*`
+  <!-- TEST_CODE_START -->
+  - Inputs: Issue 테스트 계획(TC-01~TC-05), 기존 테스트 코드 스타일, ARCHITECTURE.md, test-code-style.md
+  - Actions:
+    - 기존 테스트 검토: medium.integration.spec.tsx, hooks 테스트 스타일 확인 완료
+    - TC-01 작성: medium.integration.spec.tsx에 반복 유형 선택 UI 테스트 추가 (반복 일정 체크박스 클릭 → 드롭다운 표시 → 옵션 선택 검증)
+    - TC-02 작성: hooks/medium.useEventForm.spec.ts 신규 생성 (반복 유형 상태 관리: setRepeatType, editEvent, resetForm 검증)
+    - TC-05 작성: medium.integration.spec.tsx에 반복일정 겹침 검사 제외 테스트 추가 (반복일정 생성 시 경고 다이얼로그 미표시 검증)
+    - TC-03/TC-04 보류: 반복 일정 생성 유틸리티 함수가 존재하지 않아 보류 (구현 단계 이후 유틸리티 함수 생성 후 테스트 작성 예정)
+  - Outputs:
+    - 테스트 파일 작성 완료: src/**tests**/medium.integration.spec.tsx (TC-01, TC-05), src/**tests**/hooks/medium.useEventForm.spec.ts (TC-02)
+    - 테스트 실행 결과: RED 상태 확인 (UI가 주석 처리되어 있어 실패 예상, 겹침 검사 로직에 반복일정 예외 처리 없어 실패 예상)
+  - Artifacts: src/**tests**/medium.integration.spec.tsx, src/**tests**/hooks/medium.useEventForm.spec.ts
+  <!-- TEST_CODE_END -->
+
+---
+
+### 💻 코드 작성 에이전트 (Implementation)
+
+- Inputs: 실패 테스트
+- Actions: 최소 구현(Green)
+- Outputs: 변경 파일/주요 변경 요약
+- Artifacts: 소스 코드 경로
+  <!-- IMPLEMENTATION_START -->
+  - Inputs: 실패 테스트(TC-01, TC-02, TC-05), Issue 요구사항(반복 유형 선택 UI, 겹침 검사 제외)
+  - Actions:
+    - RepeatType import 활성화: App.tsx에서 RepeatType import 주석 해제
+    - setRepeatType 활성화: useEventForm 훅에서 setRepeatType 주석 해제 및 사용 가능하도록 변경
+    - 반복 유형 선택 UI 활성화: App.tsx 441-478줄 주석 처리된 반복 유형 선택 UI 주석 해제 및 활성화
+    - 접근성 속성 추가: FormLabel에 htmlFor, Select에 id 및 aria-label 추가
+    - 겹침 검사 예외 처리: addOrUpdateEvent 함수에서 반복일정(repeat.type !== 'none')인 경우 겹침 검사 생략하도록 로직 추가
+  - Outputs:
+    - 테스트 실행 및 Green 상태 확인 완료:
+      - TC-01: 통과 ✓ (반복 유형 UI 노출 및 상호작용)
+      - TC-02: 통과 ✓ (6개 테스트 모두 통과, isRepeating 초기 상태 버그 수정)
+      - TC-05: 통과 ✓ (반복일정 겹침 검사 제외)
+    - 코드 수정 사항:
+      - useEventForm.ts: isRepeating 초기 상태 로직 수정 (initialEvent가 없을 때 false로 설정)
+    - 코드 변경 사항 검증:
+      - RepeatType import 활성화 ✓
+      - setRepeatType 활성화 및 사용 가능 ✓
+      - 반복 유형 선택 UI 주석 해제 및 활성화 ✓
+      - 접근성 속성(aria-label, htmlFor, id) 추가 ✓
+      - 겹침 검사 예외 처리 로직 추가 ✓
+    - 변경 파일: src/App.tsx (반복 유형 UI 활성화, 겹침 검사 예외 처리), src/hooks/useEventForm.ts (isRepeating 초기 상태 수정)
+  - Artifacts: src/App.tsx
+  <!-- IMPLEMENTATION_END -->
+
+---
+
+### 🔧 리팩토링 에이전트 (Refactoring)
+
+- Inputs: Green 상태
+- Actions: 중복 제거/구조 개선/명명 개선(동작 동일)
+- Outputs: 리팩토링 포인트/전후 비교
+- Safeguard: 모든 테스트 Green 유지
+  <!-- REFACTORING_START -->
+  - Inputs: Green 상태 코드, 리팩토링 체크리스트
+  - Actions:
+    - 반복 유형 옵션 상수 추출: repeatTypeOptions 상수 생성하여 MenuItem 중복 제거 (notificationOptions와 동일한 패턴 적용)
+    - 가드 절 적용: addOrUpdateEvent 함수에서 중첩된 if-else를 early return 패턴으로 단순화하여 가독성 향상
+    - 중복 제거: saveEvent + resetForm 호출 중복 제거 (반복일정과 일반 일정 모두 동일한 흐름으로 통합)
+  - Outputs:
+    - 코드 구조 개선: 중첩 감소, 가독성 향상, 유지보수성 향상
+    - 동작 불변 보장: 모든 테스트 Green 유지 확인
+  - Artifacts: src/App.tsx
+  <!-- REFACTORING_END -->
+
+---
+
+## 🧾 요약 (Summary)
+
+- 상태: `완료`
+- 마지막 수정 에이전트: 오케스트레이터
+- 주요 변경사항 요약: 반복 유형 선택 기능 완료. 전체 TDD 사이클(Red → Green → Refactor) 수행 완료. 테스트 코드 추가(RED), 최소 구현(GREEN), 리팩토링 완료. 반복 유형 선택 UI 활성화, 겹침 검사 예외 처리, 코드 구조 개선 완료. 모든 테스트 통과 확인. 커밋 3개: test(테스트 코드), feat(구현), refactor(리팩토링). 변경 파일: src/App.tsx, src/hooks/useEventForm.ts.
diff --git "a/.cursor/issues/issue-002-\353\260\230\353\263\265-\354\235\274\354\240\225-\355\221\234\354\213\234.md" "b/.cursor/issues/issue-002-\353\260\230\353\263\265-\354\235\274\354\240\225-\355\221\234\354\213\234.md"
new file mode 100644
index 00000000..82e28e73
--- /dev/null
+++ "b/.cursor/issues/issue-002-\353\260\230\353\263\265-\354\235\274\354\240\225-\355\221\234\354\213\234.md"
@@ -0,0 +1,229 @@
+# 🧭 Issue: 기능 요청서
+
+## 🎯 목적 (Goal)
+
+캘린더 뷰에서 반복 일정을 시각적으로 구분하여 사용자가 일정 목록에서 반복 일정을 쉽게 식별할 수 있도록 한다.
+
+---
+
+## 📋 요구사항 (Requirements)
+
+- 월 뷰에서 반복 일정인 경우 일정 제목 앞에 반복 아이콘이 표시된다.
+- 주 뷰에서 반복 일정인 경우 일정 제목 앞에 반복 아이콘이 표시된다.
+- 반복 일정이 아닌 일정(`repeat.type === 'none'`)에는 반복 아이콘이 표시되지 않는다.
+- 반복 아이콘은 기존 알림 아이콘과 함께 표시될 수 있다.
+
+---
+
+## 🧩 맥락 & 범위 (Context & Scope)
+
+- Impacted Areas: UI (App.tsx의 renderMonthView, renderWeekView) | Tests
+- Out of Scope: 반복 일정의 실제 생성 로직, 반복 간격/종료일 표시, 아이콘의 세부 디자인(색상, 크기 등은 Material UI 기본값 사용)
+
+---
+
+## 🧪 테스트 계획 요약 (Test Plan Summary)
+
+### 테스트 시나리오 개요 (Scenario Overview)
+
+- SC-01: 월 뷰에서 반복 일정인 경우 일정 제목 앞에 반복 아이콘이 표시된다.
+- SC-02: 주 뷰에서 반복 일정인 경우 일정 제목 앞에 반복 아이콘이 표시된다.
+- SC-03: 반복 일정이 아닌 일정(`repeat.type === 'none'`)에는 반복 아이콘이 표시되지 않는다.
+- SC-04: 반복 아이콘은 기존 알림 아이콘과 함께 표시될 수 있다.
+
+### 테스트 케이스 상세 (Test Case Detail)
+
+- **TC-01 월 뷰에서 반복 일정 아이콘 표시 확인 (Integration)**
+
+  - 목적: 월 뷰에서 반복 일정인 경우 반복 아이콘이 표시되는지 검증
+  - 전제조건: 월 뷰가 표시되고 반복 일정이 존재함
+  - 입력/행동:
+    1. 반복 유형을 선택하여 일정 생성 (예: 매일, 매주, 매월, 매년 중 하나)
+    2. 월 뷰에서 해당 일정이 표시되는 날짜 확인
+  - 기대결과:
+    - 반복 일정의 제목 앞에 반복 아이콘이 표시됨
+    - 아이콘은 일정 제목 텍스트보다 앞에 위치함
+  - 테스트 파일: `src/__tests__/medium.integration.spec.tsx`
+  - 고려사항: 반복 일정 데이터 준비, getByRole 또는 aria-label을 통한 아이콘 검증
+
+- **TC-02 주 뷰에서 반복 일정 아이콘 표시 확인 (Integration)**
+
+  - 목적: 주 뷰에서 반복 일정인 경우 반복 아이콘이 표시되는지 검증
+  - 전제조건: 주 뷰가 표시되고 반복 일정이 존재함
+  - 입력/행동:
+    1. 반복 유형을 선택하여 일정 생성 (예: 매일, 매주 중 하나)
+    2. 주 뷰로 전환
+    3. 해당 일정이 표시되는 날짜 확인
+  - 기대결과:
+    - 반복 일정의 제목 앞에 반복 아이콘이 표시됨
+    - 아이콘은 일정 제목 텍스트보다 앞에 위치함
+  - 테스트 파일: `src/__tests__/medium.integration.spec.tsx`
+  - 고려사항: 주 뷰 전환, 반복 일정 데이터 준비, getByRole 또는 aria-label을 통한 아이콘 검증
+
+- **TC-03 반복 일정이 아닌 일정에는 아이콘 미표시 확인 (Integration)**
+
+  - 목적: 반복 일정이 아닌 일반 일정에는 반복 아이콘이 표시되지 않는지 검증
+  - 전제조건: 월 뷰 또는 주 뷰가 표시되고 일반 일정이 존재함
+  - 입력/행동:
+    1. 반복 일정 없이 일반 일정 생성 (`repeat.type === 'none'`)
+    2. 월 뷰 또는 주 뷰에서 해당 일정 확인
+  - 기대결과:
+    - 일정 제목만 표시되고 반복 아이콘이 표시되지 않음
+  - 테스트 파일: `src/__tests__/medium.integration.spec.tsx`
+  - 고려사항: 일반 일정 데이터 준비, 반복 아이콘의 부재 확인
+
+- **TC-04 반복 아이콘과 알림 아이콘 동시 표시 확인 (Integration)**
+  - 목적: 반복 일정이면서 알림 대상인 경우 두 아이콘이 함께 표시되는지 검증
+  - 전제조건: 월 뷰 또는 주 뷰가 표시되고, 반복 일정이 알림 시간에 도달함
+  - 입력/행동:
+    1. 반복 유형을 선택하여 일정 생성
+    2. 알림 시간 설정하여 알림 대상이 되도록 함
+    3. 알림 시간에 도달한 상태로 뷰 확인
+  - 기대결과:
+    - 반복 아이콘과 알림 아이콘이 함께 표시됨
+    - 두 아이콘 모두 일정 제목 앞에 위치함
+  - 테스트 파일: `src/__tests__/medium.integration.spec.tsx`
+  - 고려사항: 알림 시간 설정, 알림 상태 모킹, 두 아이콘 모두 표시 확인
+
+---
+
+## 🔁 TDD 사이클 (Red → Green → Refactor)
+
+- [x] Red: 실패하는 테스트 추가 (Test Code Agent)
+- [x] Green: 최소 구현으로 통과 (Implementation Agent)
+- [x] Refactor: 동작 동일, 구조/가독성 개선 (Refactoring Agent)
+
+---
+
+## 🧠 에이전트 작업 로그 (Agent Work Log)
+
+### 🧩 테스트 설계 에이전트 (Test Design)
+
+- Inputs: Story/AC, Context
+- Actions: 테스트 유형/파일 배치 설계, 모킹 전략 수립
+- Outputs: 테스트 계획 요약/시나리오 업데이트
+- Artifacts: (별도 문서 없음)
+  <!-- TEST_DESIGN_START -->
+  - Inputs:
+    - Issue 목적: 캘린더 뷰에서 반복 일정을 시각적으로 구분
+    - 요구사항: 월/주 뷰에서 반복 일정 아이콘 표시, 일반 일정에는 미표시, 알림 아이콘과 함께 표시 가능
+    - 컨텍스트: App.tsx의 renderMonthView, renderWeekView 수정 필요, Integration 테스트로 검증
+  - Actions:
+    - 요구사항 분석: 4가지 시나리오 도출 (월 뷰 표시, 주 뷰 표시, 일반 일정 미표시, 알림 아이콘과 동시 표시)
+    - 테스트 유형 결정: Integration 테스트 (UI 렌더링 및 사용자 상호작용 검증)
+    - 테스트 케이스 설계: 4개 테스트 케이스 작성 (TC-01 ~ TC-04)
+    - 테스트 파일 배치: `src/__tests__/medium.integration.spec.tsx`에 추가
+    - 모킹 전략: 기존 MSW 핸들러 활용, 반복 일정 데이터 준비, 알림 상태 모킹
+  - Outputs:
+    - 테스트 시나리오 4개 (SC-01 ~ SC-04)
+    - 테스트 케이스 4개 (TC-01 ~ TC-04) 상세 명세
+    - 테스트 파일: `src/__tests__/medium.integration.spec.tsx`
+  - Artifacts: (별도 문서 없음)
+  <!-- TEST_DESIGN_END -->
+
+---
+
+### 🧪 테스트 코드 작성 에이전트 (Test Code)
+
+- Inputs: Test Plan, Matrix
+- Actions: 스캐폴딩/테스트 구현(단계적), 실패 확인
+- Outputs: 커밋/PR 링크, 주요 테스트 스니펫
+- Artifacts: `src/__tests__/*`
+  <!-- TEST_CODE_START -->
+  - Inputs:
+    - 테스트 계획: TC-01 ~ TC-04 (월/주 뷰 아이콘 표시, 일반 일정 미표시, 알림 아이콘과 동시 표시)
+    - 기존 테스트 파일: `src/__tests__/medium.integration.spec.tsx`
+    - 기존 헬퍼 함수: `saveSchedule` (반복 일정 미지원)
+  - Actions:
+    - 기존 테스트 코드 검토: 반복 일정 관련 테스트는 없음 (issue-001의 반복 유형 선택 테스트만 존재)
+    - 반복 일정 생성 헬퍼 함수 작성: `saveRepeatingSchedule` 함수 추가
+    - TC-01 ~ TC-04 테스트 케이스 작성:
+      - TC-01: 월 뷰에서 반복 일정 아이콘 표시 확인
+      - TC-02: 주 뷰에서 반복 일정 아이콘 표시 확인
+      - TC-03: 반복 일정이 아닌 일정에는 아이콘 미표시 확인
+      - TC-04: 반복 아이콘과 알림 아이콘 동시 표시 확인
+    - 테스트 실행 및 실패 확인 (RED 상태)
+  - Outputs:
+    - 테스트 파일 수정: `src/__tests__/medium.integration.spec.tsx`
+    - 테스트 실행 결과:
+      - TC-01: 실패 ✓ (반복 아이콘이 아직 구현되지 않아 null 반환)
+      - TC-02: 실패 ✓ (반복 아이콘이 아직 구현되지 않아 null 반환)
+      - TC-03: 통과 ✓ (일반 일정에는 아이콘이 표시되지 않음 - 정상)
+      - TC-04: 실패 ✓ (반복 아이콘이 아직 구현되지 않아 null 반환)
+    - 실패 원인: 반복 아이콘 UI가 아직 구현되지 않아 `queryByLabelText('반복 일정')`이 null 반환
+  - Artifacts: `src/__tests__/medium.integration.spec.tsx` (describe 블록 추가, TC-01 ~ TC-04 테스트 케이스 작성)
+  <!-- TEST_CODE_END -->
+
+---
+
+### 💻 코드 작성 에이전트 (Implementation)
+
+- Inputs: 실패 테스트
+- Actions: 최소 구현(Green)
+- Outputs: 변경 파일/주요 변경 요약
+- Artifacts: 소스 코드 경로
+  <!-- IMPLEMENTATION_START -->
+  - Inputs:
+    - 실패 테스트: TC-01, TC-02, TC-04 (반복 아이콘 미표시로 인한 실패)
+    - 요구사항: 월/주 뷰에서 반복 일정 아이콘 표시, 일반 일정에는 미표시, 알림 아이콘과 함께 표시 가능
+  - Actions:
+    - Material UI Repeat 아이콘 import 추가
+    - 월 뷰(renderMonthView)에서 반복 일정 아이콘 표시 로직 추가
+      - `isRepeating = event.repeat.type !== 'none'` 체크
+      - 반복 일정인 경우 `<Repeat fontSize="small" aria-label="반복 일정" />` 아이콘 추가
+    - 주 뷰(renderWeekView)에서 반복 일정 아이콘 표시 로직 추가
+      - 동일한 로직으로 반복 일정 아이콘 표시
+    - 접근성 개선: 알림 설정 Select에 `aria-label="알림 설정"` 추가
+  - Outputs:
+    - 테스트 실행 및 Green 상태 확인 완료:
+      - TC-01: 통과 ✓ (월 뷰에서 반복 일정 아이콘 표시)
+      - TC-02: 통과 ✓ (주 뷰에서 반복 일정 아이콘 표시)
+      - TC-03: 통과 ✓ (일반 일정에는 아이콘 미표시)
+      - TC-04: 통과 ✓ (반복 아이콘과 알림 아이콘 동시 표시)
+    - 코드 변경 사항:
+      - Repeat 아이콘 import 추가
+      - 월/주 뷰 이벤트 렌더링 부분에 반복 아이콘 조건부 렌더링 추가
+      - 알림 설정 Select 접근성 속성 추가
+    - 변경 파일: `src/App.tsx`
+  - Artifacts: `src/App.tsx`
+  <!-- IMPLEMENTATION_END -->
+
+---
+
+### 🔧 리팩토링 에이전트 (Refactoring)
+
+- Inputs: Green 상태
+- Actions: 중복 제거/구조 개선/명명 개선(동작 동일)
+- Outputs: 리팩토링 포인트/전후 비교
+- Safeguard: 모든 테스트 Green 유지
+  <!-- REFACTORING_START -->
+  - Inputs:
+    - Green 상태 코드: 반복 아이콘 표시 기능 구현 완료
+    - 중복 코드 식별: 월 뷰와 주 뷰에서 동일한 이벤트 아이템 렌더링 로직 중복
+  - Actions:
+    - 중복 코드 제거: 월 뷰와 주 뷰에서 사용하는 이벤트 아이템 렌더링 로직을 `renderEventItem` 헬퍼 함수로 추출
+    - 함수 추출: `renderEventItem(event: Event, isNotified: boolean, isRepeating: boolean)` 함수 생성
+      - 이벤트 아이템의 Box, Stack, 아이콘, Typography 렌더링 로직을 재사용 가능한 함수로 분리
+      - 접근성 속성(`aria-label="반복 일정"`) 유지
+    - 코드 일관성 향상: 두 뷰에서 동일한 로직 사용으로 유지보수성 개선
+  - Outputs:
+    - 테스트 실행 및 Green 상태 확인: TC-01 ~ TC-04 모두 통과 (20개 테스트 전체 통과)
+    - 코드 변경 사항:
+      - `renderEventItem` 헬퍼 함수 추가 (App.tsx 상단, repeatTypeOptions 다음)
+      - `renderWeekView`에서 중복 코드 제거 및 `renderEventItem` 사용
+      - `renderMonthView`에서 중복 코드 제거 및 `renderEventItem` 사용
+    - 코드 품질 개선:
+      - 중복 코드 제거로 DRY 원칙 준수
+      - 함수 추출로 가독성 향상
+      - 동작은 동일하게 유지 (Behavior Preserving)
+    - 변경 파일: `src/App.tsx`
+  - Artifacts: `src/App.tsx`
+  <!-- REFACTORING_END -->
+
+---
+
+## 🧾 요약 (Summary)
+
+- 상태: `완료`
+- 마지막 수정 에이전트: `오케스트레이터`
+- 주요 변경사항 요약: 반복 일정 아이콘 표시 기능 개발 완료. TDD 사이클(Red → Green → Refactor) 완료. Material UI Repeat 아이콘을 월/주 뷰에 조건부 렌더링 추가. 중복 코드 제거를 위한 `renderEventItem` 헬퍼 함수 추출. 테스트 실행 결과: TC-01 ~ TC-04 모두 통과 (20개 테스트 전체 통과). 변경 파일: `src/App.tsx`, `src/__tests__/medium.integration.spec.tsx`. 커밋: test(Red), feat(Green), refactor(Refactor), docs(완료)
diff --git "a/.cursor/issues/issue-003-\353\260\230\353\263\265-\354\242\205\353\243\214.md" "b/.cursor/issues/issue-003-\353\260\230\353\263\265-\354\242\205\353\243\214.md"
new file mode 100644
index 00000000..f6e95bba
--- /dev/null
+++ "b/.cursor/issues/issue-003-\353\260\230\353\263\265-\354\242\205\353\243\214.md"
@@ -0,0 +1,207 @@
+# 🧭 Issue: 기능 요청서
+
+## 🎯 목적 (Goal)
+
+사용자가 반복 일정의 종료 조건을 특정 날짜까지로 지정하여 반복 일정이 해당 날짜까지만 생성되도록 제한할 수 있도록 한다.
+
+---
+
+## 📋 요구사항 (Requirements)
+
+- 사용자가 반복 일정을 생성할 때 반복 종료일을 지정할 수 있다.
+- 반복 종료일은 반복 유형이 선택된 경우에만 입력 가능하다.
+- 반복 종료일 입력 필드에는 날짜 제한이 없으며 사용자가 자유롭게 날짜를 지정할 수 있다.
+- 반복 종료일이 지정된 반복 일정은 해당 날짜까지만 생성된다.
+
+---
+
+## 🧩 맥락 & 범위 (Context & Scope)
+
+- Impacted Areas: UI (App.tsx의 반복 종료일 입력 필드) | Tests
+- Out of Scope: 반복 일정의 실제 생성 로직 구현, 종료 횟수 기반 종료 조건, 종료일 이후 일정 표시 처리, 날짜 제한 검증
+
+---
+
+## 🧪 테스트 계획 요약 (Test Plan Summary)
+
+### 테스트 시나리오 개요 (Scenario Overview)
+
+- SC-01: 반복 유형이 선택된 경우 반복 종료일 입력 필드가 표시된다.
+- SC-02: 사용자가 반복 종료일을 입력할 수 있고 입력된 값이 폼 상태에 저장된다.
+- SC-03: 반복 종료일이 지정된 반복 일정을 생성하면 종료일이 저장된다.
+- SC-04: 반복 종료일 입력 필드는 반복 유형이 선택되지 않은 경우 표시되지 않는다.
+
+### 테스트 케이스 상세 (Test Case Detail)
+
+- **TC-01 반복 종료일 입력 필드 노출 확인 (Integration)**
+
+  - 목적: 반복 유형이 선택된 경우 반복 종료일 입력 필드가 표시되는지 검증
+  - 전제조건: 일정 생성 폼이 렌더링됨
+  - 입력/행동:
+    1. "반복 일정" 체크박스를 클릭
+    2. 반복 유형을 선택 (예: 매일, 매주 중 하나)
+  - 기대결과:
+    - "반복 종료일" 라벨이 있는 입력 필드가 표시됨
+    - 입력 필드는 date 타입의 TextField로 표시됨
+  - 테스트 파일: `src/__tests__/medium.integration.spec.tsx`
+  - 고려사항: getByLabelText로 "반복 종료일" 필드 검증
+
+- **TC-02 반복 종료일 입력 및 상태 저장 확인 (Integration)**
+
+  - 목적: 사용자가 반복 종료일을 입력할 수 있고 입력된 값이 폼 상태에 저장되는지 검증
+  - 전제조건: 반복 일정 체크박스가 선택되고 반복 유형이 선택됨
+  - 입력/행동:
+    1. 반복 종료일 입력 필드에 날짜 입력 (예: "2025-12-31")
+    2. 입력 필드 값 확인
+  - 기대결과:
+    - 입력된 날짜가 입력 필드에 표시됨
+    - 폼 상태에 입력한 날짜가 저장됨
+  - 테스트 파일: `src/__tests__/medium.integration.spec.tsx`
+  - 고려사항: userEvent.type으로 날짜 입력, 입력 필드의 value 속성 검증
+
+- **TC-03 반복 종료일이 저장되는지 확인 (Integration)**
+
+  - 목적: 반복 종료일이 지정된 반복 일정을 생성하면 종료일이 이벤트 데이터에 포함되어 저장되는지 검증
+  - 전제조건: 반복 일정 생성 폼이 표시됨
+  - 입력/행동:
+    1. 반복 일정 체크박스 선택
+    2. 반복 유형 선택 (예: 매일)
+    3. 반복 종료일 입력 (예: "2025-12-31")
+    4. 일정 저장
+  - 기대결과:
+    - 저장된 이벤트의 `repeat.endDate` 필드에 입력한 날짜가 포함됨
+  - 테스트 파일: `src/__tests__/medium.integration.spec.tsx`
+  - 고려사항: MSW 핸들러에서 저장된 데이터 검증 또는 이벤트 리스트에서 검증
+
+- **TC-04 반복 유형 미선택 시 종료일 필드 미표시 확인 (Integration)**
+  - 목적: 반복 유형이 선택되지 않은 경우 반복 종료일 입력 필드가 표시되지 않는지 검증
+  - 전제조건: 일정 생성 폼이 렌더링됨
+  - 입력/행동: 일정 생성 폼 렌더링 상태 확인
+  - 기대결과:
+    - "반복 종료일" 입력 필드가 표시되지 않음
+  - 테스트 파일: `src/__tests__/medium.integration.spec.tsx`
+  - 고려사항: queryByLabelText로 필드 부재 확인
+
+---
+
+## 🔁 TDD 사이클 (Red → Green → Refactor)
+
+- [x] Red: 실패하는 테스트 추가 (Test Code Agent)
+- [x] Green: 최소 구현으로 통과 (Implementation Agent)
+- [x] Refactor: 동작 동일, 구조/가독성 개선 (Refactoring Agent)
+
+---
+
+## 🧠 에이전트 작업 로그 (Agent Work Log)
+
+### 🧩 테스트 설계 에이전트 (Test Design)
+
+- Inputs: Story/AC, Context
+- Actions: 테스트 유형/파일 배치 설계, 모킹 전략 수립
+- Outputs: 테스트 계획 요약/시나리오 업데이트
+- Artifacts: (별도 문서 없음)
+  <!-- TEST_DESIGN_START -->
+  - Inputs:
+    - Issue 목적: 반복 일정의 종료 조건을 특정 날짜까지로 지정
+    - 요구사항: 반복 종료일 지정 가능, 반복 유형 선택 시에만 입력 가능, 날짜 제한 없음, 종료일 지정 시 해당 날짜까지만 생성
+    - 컨텍스트: App.tsx의 반복 종료일 입력 필드, Integration 테스트로 검증
+  - Actions:
+    - 요구사항 분석: 4가지 시나리오 도출 (종료일 필드 노출, 입력 및 상태 저장, 데이터 저장 확인, 반복 미선택 시 미표시)
+    - 테스트 유형 결정: Integration 테스트 (UI 렌더링 및 사용자 상호작용 검증)
+    - 테스트 케이스 설계: 4개 테스트 케이스 작성 (TC-01 ~ TC-04)
+    - 테스트 파일 배치: `src/__tests__/medium.integration.spec.tsx`에 추가
+    - 모킹 전략: 기존 MSW 핸들러 활용, 반복 종료일이 포함된 반복 일정 데이터 준비
+  - Outputs:
+    - 테스트 시나리오 4개 (SC-01 ~ SC-04)
+    - 테스트 케이스 4개 (TC-01 ~ TC-04) 상세 명세
+    - 테스트 파일: `src/__tests__/medium.integration.spec.tsx`
+  - Artifacts: (별도 문서 없음)
+  <!-- TEST_DESIGN_END -->
+
+---
+
+### 🧪 테스트 코드 작성 에이전트 (Test Code)
+
+- Inputs: Test Plan, Matrix
+- Actions: 스캐폴딩/테스트 구현(단계적), 실패 확인
+- Outputs: 커밋/PR 링크, 주요 테스트 스니펫
+- Artifacts: `src/__tests__/*`
+  <!-- TEST_CODE_START -->
+  - Inputs:
+    - 테스트 계획: 4개 테스트 케이스 (TC-01 ~ TC-04)
+    - 테스트 파일: `src/__tests__/medium.integration.spec.tsx`
+    - 기존 테스트 구조 참고: 반복 일정 관련 테스트 패턴
+  - Actions:
+    - 테스트 describe 블록 생성: "반복 종료일 지정 (SC-01 ~ SC-04)"
+    - TC-01 구현: 반복 종료일 입력 필드 노출 확인 (반복 유형 선택 시)
+    - TC-02 구현: 반복 종료일 입력 및 상태 저장 확인
+    - TC-03 구현: 반복 종료일이 저장되는지 확인 (전체 플로우)
+    - TC-04 구현: 반복 유형 미선택 시 종료일 필드 미표시 확인
+    - 테스트 실행 및 실패 확인 (RED 상태)
+  - Outputs:
+    - 테스트 파일: `src/__tests__/medium.integration.spec.tsx` (627-723줄)
+    - 테스트 실행 결과: 3개 실패, 1개 통과 (TC-04)
+    - 주요 실패 원인: 반복 종료일 필드가 반복 유형 선택 시에만 표시되어야 하는데 현재는 isRepeating만 체크함
+  - Artifacts: `src/__tests__/medium.integration.spec.tsx`
+  <!-- TEST_CODE_END -->
+
+---
+
+### 💻 코드 작성 에이전트 (Implementation)
+
+- Inputs: 실패 테스트
+- Actions: 최소 구현(Green)
+- Outputs: 변경 파일/주요 변경 요약
+- Artifacts: 소스 코드 경로
+  <!-- IMPLEMENTATION_START -->
+  - Inputs:
+    - 실패 테스트: TC-01, TC-02, TC-03 실패 (반복 종료일 필드가 반복 유형 선택 시에만 표시되어야 함)
+    - 기존 코드: App.tsx의 반복 종료일 필드가 isRepeating만 체크하고 있음
+  - Actions:
+    - 반복 종료일 필드 조건 수정: `repeatType !== 'none'` 조건 추가
+    - FormLabel과 TextField 연결: htmlFor와 id 속성 추가
+    - aria-label 제거: 중복 라벨 문제 해결
+    - 테스트 실행 및 검증: 모든 테스트 통과 확인
+  - Outputs:
+    - 변경 파일: `src/App.tsx` (470-481줄)
+    - 주요 변경사항:
+      - 반복 종료일 필드를 `repeatType !== 'none'` 조건으로 감싸서 반복 유형 선택 시에만 표시
+      - FormLabel과 TextField 연결을 위한 htmlFor/id 속성 추가
+      - aria-label 제거하여 중복 라벨 문제 해결
+    - 테스트 실행 결과: 4개 테스트 모두 통과 (TC-01 ~ TC-04)
+  - Artifacts: `src/App.tsx`
+  <!-- IMPLEMENTATION_END -->
+
+---
+
+### 🔧 리팩토링 에이전트 (Refactoring)
+
+- Inputs: Green 상태
+- Actions: 중복 제거/구조 개선/명명 개선(동작 동일)
+- Outputs: 리팩토링 포인트/전후 비교
+- Safeguard: 모든 테스트 Green 유지
+  <!-- REFACTORING_START -->
+  - Inputs:
+    - Green 상태 코드 검토
+    - 현재 구현 코드 분석
+  - Actions:
+    - 코드 구조 검토: 조건부 렌더링, FormLabel/TextField 연결 상태 확인
+    - 리팩토링 포인트 검토: 일관성, 가독성, 구조 개선 여지 확인
+    - 테스트 실행 및 검증: 모든 테스트 통과 확인
+  - Outputs:
+    - 리팩토링 결정: 현재 코드가 이미 깔끔하고 명확하게 구현되어 있어 추가 리팩토링 불필요
+    - 리팩토링 포인트:
+      - 조건부 렌더링이 명확함 (`repeatType !== 'none'`)
+      - FormLabel과 TextField 연결이 적절함 (`htmlFor`/`id`)
+      - 구조가 일관적이고 가독성이 좋음
+    - 테스트 실행 결과: 4개 테스트 모두 통과 확인
+  - Safeguard: 모든 테스트 Green 유지 확인
+  <!-- REFACTORING_END -->
+
+---
+
+## 🧾 요약 (Summary)
+
+- 상태: `완료`
+- 마지막 수정 에이전트: `오케스트레이터`
+- 주요 변경사항 요약: 반복 종료일 지정 기능 완료. 사용자가 반복 일정 생성 시 종료일을 지정할 수 있도록 구현 완료. 반복 종료일 필드는 반복 유형이 선택된 경우에만 표시되며, 사용자가 자유롭게 날짜를 입력할 수 있음. TDD 사이클 완료 (RED → GREEN → Refactor), 모든 테스트 통과 (전체 131개, 반복 종료일 관련 4개)
diff --git "a/.cursor/issues/issue-004-\353\260\230\353\263\265\354\235\274\354\240\225-\354\203\235\354\204\261.md" "b/.cursor/issues/issue-004-\353\260\230\353\263\265\354\235\274\354\240\225-\354\203\235\354\204\261.md"
new file mode 100644
index 00000000..18020857
--- /dev/null
+++ "b/.cursor/issues/issue-004-\353\260\230\353\263\265\354\235\274\354\240\225-\354\203\235\354\204\261.md"
@@ -0,0 +1,299 @@
+# 🧭 Issue: 기능 요청서
+
+## 🎯 목적 (Goal)
+
+사용자가 반복 일정을 생성할 때 설정한 반복 유형에 따라 종료일까지 일정이 자동으로 생성되도록 한다.
+
+---
+
+## 📋 요구사항 (Requirements)
+
+- 반복 유형이 '매일'인 경우, 반복 종료일까지 매일 일정이 생성된다.
+- 반복 유형이 '매주'인 경우, 반복 종료일까지 매주 일정이 생성된다.
+- 반복 유형이 '매월'인 경우, 반복 종료일까지 매월 일정이 생성된다.
+- 반복 유형이 '매년'인 경우, 반복 종료일까지 매년 일정이 생성된다.
+- 반복 종료일이 지정된 경우, 해당 날짜까지만 일정이 생성된다.
+- 반복 종료일이 지정되지 않은 경우, 무한 반복으로 처리된다(또는 기본 기간 적용).
+
+---
+
+## 🧩 맥락 & 범위 (Context & Scope)
+
+- Impacted Areas: Utils (반복 일정 생성 로직) | Hooks (useEventOperations) | Tests
+- Out of Scope: 반복 일정 수정 시 전체 시리즈 업데이트, 반복 일정 삭제 시 전체 시리즈 삭제, 반복 일정 편집(단일 일정 편집)
+
+---
+
+## 🧪 테스트 계획 요약 (Test Plan Summary)
+
+### 테스트 시나리오 개요 (Scenario Overview)
+
+- SC-01: 매일 반복 일정 생성 확인 - 반복 유형이 '매일'인 경우 종료일까지 매일 일정이 생성됨
+- SC-02: 매주 반복 일정 생성 확인 - 반복 유형이 '매주'인 경우 종료일까지 매주 일정이 생성됨
+- SC-03: 매월 반복 일정 생성 확인 - 반복 유형이 '매월'인 경우 종료일까지 매월 일정이 생성됨
+- SC-04: 매년 반복 일정 생성 확인 - 반복 유형이 '매년'인 경우 종료일까지 매년 일정이 생성됨
+- SC-05: 반복 종료일 이후 일정 미생성 확인 - 종료일 이후에는 일정이 생성되지 않음
+
+### 테스트 케이스 상세 (Test Case Detail)
+
+- **TC-01 매일 반복 일정 생성 확인 (Unit)**
+
+  - 목적: 반복 유형이 '매일'인 경우 종료일까지 매일 일정이 생성되는지 검증
+  - 전제조건: 반복 일정 생성 유틸 함수 존재
+  - 입력/행동:
+    - 시작일: 2025-10-15, 종료일: 2025-10-20, 반복 유형: 'daily'
+    - 반복 일정 생성 함수 호출
+  - 기대결과:
+    - 2025-10-15부터 2025-10-20까지 매일 일정이 생성됨 (6개)
+    - 각 일정의 날짜가 올바르게 설정됨
+  - 테스트 파일: `src/__tests__/unit/easy.eventUtils.spec.ts` 또는 새로운 파일
+  - 고려사항: 날짜 계산 로직 검증, 생성된 일정 개수 확인
+
+- **TC-02 매주 반복 일정 생성 확인 (Unit)**
+
+  - 목적: 반복 유형이 '매주'인 경우 종료일까지 매주 일정이 생성되는지 검증
+  - 전제조건: 반복 일정 생성 유틸 함수 존재
+  - 입력/행동:
+    - 시작일: 2025-10-15 (수요일), 종료일: 2025-11-05, 반복 유형: 'weekly'
+    - 반복 일정 생성 함수 호출
+  - 기대결과:
+    - 2025-10-15, 2025-10-22, 2025-10-29, 2025-11-05 일정이 생성됨 (4개)
+    - 각 일정의 날짜가 7일 간격으로 설정됨
+  - 테스트 파일: `src/__tests__/unit/easy.eventUtils.spec.ts` 또는 새로운 파일
+  - 고려사항: 주간 간격 계산 검증
+
+- **TC-03 매월 반복 일정 생성 확인 (Unit)**
+
+  - 목적: 반복 유형이 '매월'인 경우 종료일까지 매월 일정이 생성되는지 검증
+  - 전제조건: 반복 일정 생성 유틸 함수 존재
+  - 입력/행동:
+    - 시작일: 2025-10-15, 종료일: 2025-12-15, 반복 유형: 'monthly'
+    - 반복 일정 생성 함수 호출
+  - 기대결과:
+    - 2025-10-15, 2025-11-15, 2025-12-15 일정이 생성됨 (3개)
+    - 각 일정의 날짜가 월 단위로 증가함
+  - 테스트 파일: `src/__tests__/unit/easy.eventUtils.spec.ts` 또는 새로운 파일
+  - 고려사항: 월 단위 계산 및 월말 처리 검증
+
+- **TC-04 매년 반복 일정 생성 확인 (Unit)**
+
+  - 목적: 반복 유형이 '매년'인 경우 종료일까지 매년 일정이 생성되는지 검증
+  - 전제조건: 반복 일정 생성 유틸 함수 존재
+  - 입력/행동:
+    - 시작일: 2025-10-15, 종료일: 2027-10-15, 반복 유형: 'yearly'
+    - 반복 일정 생성 함수 호출
+  - 기대결과:
+    - 2025-10-15, 2026-10-15, 2027-10-15 일정이 생성됨 (3개)
+    - 각 일정의 날짜가 연 단위로 증가함
+  - 테스트 파일: `src/__tests__/unit/easy.eventUtils.spec.ts` 또는 새로운 파일
+  - 고려사항: 연 단위 계산 검증
+
+- **TC-05 반복 종료일 이후 일정 미생성 확인 (Unit)**
+
+  - 목적: 반복 종료일 이후에는 일정이 생성되지 않는지 검증
+  - 전제조건: 반복 일정 생성 유틸 함수 존재
+  - 입력/행동:
+    - 시작일: 2025-10-15, 종료일: 2025-10-17, 반복 유형: 'daily'
+    - 반복 일정 생성 함수 호출
+  - 기대결과:
+    - 2025-10-15, 2025-10-16, 2025-10-17 일정만 생성됨 (3개)
+    - 2025-10-18 이후 일정은 생성되지 않음
+  - 테스트 파일: `src/__tests__/unit/easy.eventUtils.spec.ts` 또는 새로운 파일
+  - 고려사항: 종료일 경계 검증
+
+- **TC-06 반복 일정 생성 통합 테스트 (Integration)**
+  - 목적: 실제 UI에서 반복 일정을 생성하면 종료일까지 일정이 생성되는지 검증
+  - 전제조건: 일정 생성 폼이 렌더링됨
+  - 입력/행동:
+    1. 반복 일정 체크박스 선택
+    2. 반복 유형 선택 (예: 매일)
+    3. 시작일 입력 (2025-10-15)
+    4. 반복 종료일 입력 (2025-10-20)
+    5. 일정 저장
+  - 기대결과:
+    - 2025-10-15부터 2025-10-20까지 매일 일정이 생성됨
+    - 생성된 일정이 이벤트 리스트에 표시됨
+  - 테스트 파일: `src/__tests__/medium.integration.spec.tsx`
+  - 고려사항: MSW 핸들러 활용, 실제 API 호출 모킹
+
+---
+
+## 🔁 TDD 사이클 (Red → Green → Refactor)
+
+- [x] Red: 실패하는 테스트 추가 (Test Code Agent)
+- [x] Green: 최소 구현으로 통과 (Implementation Agent)
+- [x] Refactor: 동작 동일, 구조/가독성 개선 (Refactoring Agent)
+
+---
+
+## 🧠 에이전트 작업 로그 (Agent Work Log)
+
+### 🧩 테스트 설계 에이전트 (Test Design)
+
+- Inputs: Story/AC, Context
+- Actions: 테스트 유형/파일 배치 설계, 모킹 전략 수립
+- Outputs: 테스트 계획 요약/시나리오 업데이트
+- Artifacts: (별도 문서 없음)
+  <!-- TEST_DESIGN_START -->
+  - Inputs:
+    - Issue 목적: 반복 유형에 따라 종료일까지 일정이 자동 생성
+    - 요구사항: 매일/매주/매월/매년 반복 유형별 일정 생성, 종료일까지 생성, 종료일 이후 미생성
+    - 컨텍스트: Utils에 반복 일정 생성 로직 필요, useEventOperations에서 호출, /api/events-list API 활용
+  - Actions:
+    - 요구사항 분석: 5가지 시나리오 도출 (매일/매주/매월/매년 생성, 종료일 이후 미생성)
+    - 테스트 유형 결정: Unit 테스트 (반복 일정 생성 로직 검증), Integration 테스트 (전체 플로우 검증)
+    - 테스트 케이스 설계: 6개 테스트 케이스 작성 (TC-01 ~ TC-06)
+    - 테스트 파일 배치:
+      - Unit 테스트: `src/__tests__/unit/easy.eventUtils.spec.ts` 또는 새 파일
+      - Integration 테스트: `src/__tests__/medium.integration.spec.tsx`
+    - 모킹 전략: MSW 핸들러 활용, /api/events-list 엔드포인트 모킹
+  - Outputs:
+    - 테스트 시나리오 5개 (SC-01 ~ SC-05)
+    - 테스트 케이스 6개 (TC-01 ~ TC-06) 상세 명세
+    - 테스트 파일 배치 계획
+  - Artifacts: (별도 문서 없음)
+  <!-- TEST_DESIGN_END -->
+
+---
+
+### 🧪 테스트 코드 작성 에이전트 (Test Code)
+
+- Inputs: Test Plan, Matrix
+- Actions: 스캐폴딩/테스트 구현(단계적), 실패 확인
+- Outputs: 커밋/PR 링크, 주요 테스트 스니펫
+- Artifacts: `src/__tests__/*`
+  <!-- TEST_CODE_START -->
+  - Inputs:
+    - 테스트 계획: 6개 테스트 케이스 (TC-01 ~ TC-06)
+    - 테스트 파일: Unit 테스트 `src/__tests__/unit/easy.generateRecurringEvents.spec.ts`, Integration 테스트 `src/__tests__/medium.integration.spec.tsx`
+    - 기존 테스트 구조 참고: 다른 unit 테스트 패턴
+  - Actions:
+    - Unit 테스트 파일 생성: `src/__tests__/unit/easy.generateRecurringEvents.spec.ts`
+    - TC-01 ~ TC-05 구현: 매일/매주/매월/매년 반복 일정 생성 및 종료일 경계 테스트
+    - Integration 테스트 추가: `src/__tests__/medium.integration.spec.tsx`에 TC-06 추가
+    - MSW 핸들러 설정: /api/events-list 엔드포인트 모킹
+    - 테스트 실행 및 실패 확인 (RED 상태)
+    - Lint 오류 수정
+  - Outputs:
+    - 테스트 파일:
+      - `src/__tests__/unit/easy.generateRecurringEvents.spec.ts` (새 파일, 148줄)
+      - `src/__tests__/medium.integration.spec.tsx` (725-812줄)
+    - 테스트 실행 결과:
+      - Unit 테스트: 5개 모두 실패 (generateRecurringEvents 함수 없음)
+      - Integration 테스트: 1개 (TC-06) - 아직 실행 안 함
+    - 주요 실패 원인: `generateRecurringEvents` 유틸 함수가 아직 구현되지 않음
+  - Artifacts:
+    - `src/__tests__/unit/easy.generateRecurringEvents.spec.ts`
+    - `src/__tests__/medium.integration.spec.tsx`
+    <!-- TEST_CODE_END -->
+
+---
+
+### 💻 코드 작성 에이전트 (Implementation)
+
+- Inputs: 실패 테스트
+- Actions: 최소 구현(Green)
+- Outputs: 변경 파일/주요 변경 요약
+- Artifacts: 소스 코드 경로
+  <!-- IMPLEMENTATION_START -->
+
+  **작업 일시**: 2025-01-XX
+
+  **Inputs**:
+
+  - 실패 테스트: Unit 테스트 5개, Integration 테스트 1개 (총 6개 실패)
+  - 테스트 파일: `src/__tests__/unit/easy.generateRecurringEvents.spec.ts`, `src/__tests__/medium.integration.spec.tsx`
+
+  **Actions**:
+
+  1. `src/utils/eventUtils.ts`에 `generateRecurringEvents` 함수 구현
+     - 반복 유형(daily/weekly/monthly/yearly)에 따라 종료일까지 일정 생성
+     - `formatDate` 유틸 함수 활용
+  2. `src/hooks/useEventOperations.ts` 수정
+     - 반복 일정인 경우 `generateRecurringEvents` 호출하여 여러 일정 생성
+     - 생성된 일정들을 `/api/events-list` 엔드포인트로 전송
+  3. `src/__mocks__/handlersUtils.ts` 수정
+     - `setupMockHandlerCreation`에 `/api/events-list` 핸들러 추가
+  4. `src/__tests__/medium.integration.spec.tsx` 수정
+     - TC-03 테스트 수정 (반복 일정이 여러 개 생성되는 경우 처리)
+
+  **Outputs**:
+
+  - 변경 파일:
+    - `src/utils/eventUtils.ts` (+46 lines)
+    - `src/hooks/useEventOperations.ts` (+20 lines)
+    - `src/__mocks__/handlersUtils.ts` (+12 lines)
+    - `src/__tests__/medium.integration.spec.tsx` (+5 lines, -2 lines)
+
+  **주요 변경 요약**:
+
+  - `generateRecurringEvents`: 반복 일정 생성 로직 구현 (매일/매주/매월/매년 지원)
+  - `useEventOperations.saveEvent`: 반복 일정인 경우 여러 일정 생성 후 `/api/events-list` 호출
+  - Mock 핸들러에 `/api/events-list` 지원 추가
+  - TC-03 테스트: `getAllByText` 사용하여 여러 일정 처리
+
+  **Artifacts**:
+
+  - `src/utils/eventUtils.ts` (generateRecurringEvents 함수)
+  - `src/hooks/useEventOperations.ts` (saveEvent 함수)
+  - `src/__mocks__/handlersUtils.ts` (setupMockHandlerCreation 함수)
+
+  **테스트 결과**: ✅ 모든 테스트 통과 (137개)
+  <!-- IMPLEMENTATION_END -->
+
+---
+
+### 🔧 리팩토링 에이전트 (Refactoring)
+
+- Inputs: Green 상태
+- Actions: 중복 제거/구조 개선/명명 개선(동작 동일)
+- Outputs: 리팩토링 포인트/전후 비교
+- Safeguard: 모든 테스트 Green 유지
+  <!-- REFACTORING_START -->
+
+  **작업 일시**: 2025-01-XX
+
+  **Inputs**:
+
+  - Green 상태: 모든 테스트 통과 (137개)
+  - 구현 완료된 코드
+
+  **Actions**:
+
+  1. `src/hooks/useEventOperations.ts` 리팩토링
+     - 중복 제거: `/api/events` POST 호출이 두 곳에 있던 것을 제거
+     - 함수 추출: `createSingleEvent`, `createRecurringEvents` 헬퍼 함수 추가
+     - 조건 분기 간소화: 삼항 연산자로 조건 분기 간결화
+  2. `src/utils/eventUtils.ts` 리팩토링
+     - 날짜 계산 로직 분리: `calculateNextRecurrenceDate` 함수 추출
+     - 코드 가독성 개선: 반복 일정 생성 로직 단순화
+     - import 정리: 중복 import 제거
+
+  **Outputs**:
+
+  - 변경 파일:
+    - `src/hooks/useEventOperations.ts` (+17 lines, -23 lines)
+    - `src/utils/eventUtils.ts` (+31 lines, -19 lines)
+
+  **리팩토링 포인트**:
+
+  - 중복 코드 제거: `/api/events` POST 호출 통합
+  - 함수 분리: 단일 책임 원칙 적용
+  - 가독성 개선: 조건 분기 로직 간결화
+  - 코드 구조 개선: 날짜 계산 로직 분리
+
+  **전후 비교**:
+
+  - Before: 중복된 fetch 호출, 중첩된 조건문
+  - After: 명확한 함수 분리, 간결한 조건 분기
+
+  **Safeguard**: ✅ 모든 테스트 통과 (137개)
+  <!-- REFACTORING_END -->
+
+---
+
+## 🧾 요약 (Summary)
+
+- 상태: `완료 ✅`
+- 마지막 수정 에이전트: `오케스트레이터`
+- 주요 변경사항 요약: 반복 일정 생성 기능 TDD 사이클 완료 (Red → Green → Refactor). 반복 유형(daily/weekly/monthly/yearly)에 따라 종료일까지 일정 자동 생성. `generateRecurringEvents` 유틸 함수 구현, `useEventOperations` 통합, 중복 코드 제거 및 구조 개선. 모든 테스트 통과 (137개)
diff --git "a/.cursor/issues/issue-005-\353\260\230\353\263\265-\354\235\274\354\240\225-\354\210\230\354\240\225.md" "b/.cursor/issues/issue-005-\353\260\230\353\263\265-\354\235\274\354\240\225-\354\210\230\354\240\225.md"
new file mode 100644
index 00000000..e8c1c263
--- /dev/null
+++ "b/.cursor/issues/issue-005-\353\260\230\353\263\265-\354\235\274\354\240\225-\354\210\230\354\240\225.md"
@@ -0,0 +1,238 @@
+# 🧭 Issue: 기능 요청서
+
+## 🎯 목적 (Goal)
+
+사용자가 반복 일정을 수정할 때 해당 일정만 수정할지 전체 시리즈를 수정할지 선택할 수 있도록 한다.
+
+---
+
+## 📋 요구사항 (Requirements)
+
+- 반복 일정 수정 시 '해당 일정만 수정하시겠어요?'라는 확인 다이얼로그가 표시된다.
+- 사용자가 '예'를 선택하면 해당 일정만 단일 일정으로 수정된다(반복일정이 단일 일정으로 변경).
+- '예'를 선택한 경우 반복일정 아이콘이 사라진다.
+- 사용자가 '아니오'를 선택하면 반복 일정 전체 시리즈가 수정된다(반복 설정 유지).
+- '아니오'를 선택한 경우 반복일정 아이콘이 유지된다.
+
+---
+
+## 🧩 맥락 & 범위 (Context & Scope)
+
+- Impacted Areas: UI (App.tsx - 수정 다이얼로그) | Hooks (useEventOperations - 수정 로직) | Tests (Integration, Hook)
+- Out of Scope: 반복 일정 삭제 로직, 반복 일정 생성 로직, 반복 유형 변경
+
+---
+
+## 🧪 테스트 계획 요약 (Test Plan Summary)
+
+### 테스트 시나리오 개요 (Scenario Overview)
+
+- SC-01: 반복 일정 수정 시 다이얼로그 표시 확인 - 반복 일정 수정 클릭 시 '해당 일정만 수정하시겠어요?' 다이얼로그가 표시됨
+- SC-02: '예' 선택 시 단일 일정으로 수정 - '예'를 선택하면 해당 일정만 단일 일정으로 변환되어 수정됨
+- SC-03: '예' 선택 시 반복 아이콘 제거 확인 - 단일 일정으로 변환된 일정은 반복 아이콘이 사라짐
+- SC-04: '아니오' 선택 시 전체 시리즈 수정 - '아니오'를 선택하면 반복 일정 전체 시리즈가 수정됨
+- SC-05: '아니오' 선택 시 반복 아이콘 유지 확인 - 전체 시리즈 수정 후에도 반복 아이콘이 유지됨
+- SC-06: 단일 일정 수정 시 다이얼로그 미표시 - 단일 일정(repeat.type='none') 수정 시 다이얼로그가 표시되지 않음
+
+### 테스트 케이스 상세 (Test Case Detail)
+
+- **TC-01 반복 일정 수정 시 다이얼로그 표시 확인 (Integration)**
+
+  - 목적: 사용자가 반복 일정 수정 버튼을 클릭하면 수정 방식 선택 다이얼로그가 표시되는지 검증
+  - 전제조건: 반복 일정(repeat.type !== 'none')이 이벤트 리스트에 존재
+  - 입력/행동:
+    1. 반복 일정의 수정 버튼(Edit event) 클릭
+  - 기대결과:
+    - '해당 일정만 수정하시겠어요?' 텍스트가 포함된 다이얼로그가 표시됨
+    - '예', '아니오' 버튼이 표시됨
+  - 테스트 파일: `src/__tests__/medium.integration.spec.tsx`
+  - 고려사항: getByRole('dialog'), getByText 사용
+
+- **TC-02 '예' 선택 시 단일 일정으로 수정 (Integration)**
+
+  - 목적: 다이얼로그에서 '예'를 선택하면 해당 일정만 단일 일정(repeat.type='none')으로 변환되어 수정 모드로 진입하는지 검증
+  - 전제조건: 반복 일정 수정 다이얼로그가 표시됨
+  - 입력/행동:
+    1. 반복 일정의 수정 버튼 클릭
+    2. 다이얼로그에서 '예' 버튼 클릭
+    3. 제목을 '수정된 단일 일정'으로 변경
+    4. 일정 수정 버튼 클릭
+  - 기대결과:
+    - 일정 수정 폼이 열림
+    - 반복 일정 체크박스가 해제되어 있음 (또는 repeat.type='none')
+    - 수정 후 해당 일정만 업데이트됨 (다른 시리즈 일정은 영향 없음)
+    - PUT /api/events/:id 호출됨
+  - 테스트 파일: `src/__tests__/medium.integration.spec.tsx`
+  - 고려사항: MSW 핸들러로 PUT 요청 모킹, 요청 body에서 repeat.type='none' 확인
+
+- **TC-03 '예' 선택 후 수정된 일정의 반복 아이콘 제거 확인 (Integration)**
+
+  - 목적: 단일 일정으로 변환 후 저장된 일정에서 반복 아이콘이 사라지는지 검증
+  - 전제조건: 반복 일정이 단일 일정으로 수정됨 (TC-02 완료)
+  - 입력/행동:
+    1. 반복 일정 수정 → '예' 선택 → 제목 수정 → 저장
+    2. 이벤트 리스트에서 수정된 일정 확인
+  - 기대결과:
+    - 수정된 일정에 반복 아이콘(Repeat)이 표시되지 않음
+    - queryByLabelText('반복 일정') 결과가 null (해당 일정 row 내에서)
+  - 테스트 파일: `src/__tests__/medium.integration.spec.tsx`
+  - 고려사항: within() 사용하여 특정 row 내에서 반복 아이콘 검색
+
+- **TC-04 '아니오' 선택 시 전체 시리즈 수정 (Integration)**
+
+  - 목적: 다이얼로그에서 '아니오'를 선택하면 반복 설정을 유지한 채로 전체 시리즈가 수정되는지 검증
+  - 전제조건: 반복 일정 수정 다이얼로그가 표시됨
+  - 입력/행동:
+    1. 반복 일정의 수정 버튼 클릭
+    2. 다이얼로그에서 '아니오' 버튼 클릭
+    3. 제목을 '수정된 전체 시리즈'로 변경
+    4. 일정 수정 버튼 클릭
+  - 기대결과:
+    - 일정 수정 폼이 열림
+    - 반복 일정 설정이 유지됨 (repeat.type, interval, endDate 유지)
+    - 수정 후 해당 일정이 업데이트됨
+    - PUT /api/events/:id 호출됨 (repeat 정보 포함)
+  - 테스트 파일: `src/__tests__/medium.integration.spec.tsx`
+  - 고려사항: MSW 핸들러로 PUT 요청 모킹, 요청 body에서 repeat.type이 'none'이 아닌지 확인
+
+- **TC-05 '아니오' 선택 후 수정된 일정의 반복 아이콘 유지 확인 (Integration)**
+
+  - 목적: 전체 시리즈 수정 후에도 반복 아이콘이 유지되는지 검증
+  - 전제조건: 반복 일정이 전체 시리즈로 수정됨 (TC-04 완료)
+  - 입력/행동:
+    1. 반복 일정 수정 → '아니오' 선택 → 제목 수정 → 저장
+    2. 이벤트 리스트에서 수정된 일정 확인
+  - 기대결과:
+    - 수정된 일정에 반복 아이콘(Repeat)이 여전히 표시됨
+    - getByLabelText('반복 일정') 또는 getByTitle('반복 일정')으로 아이콘 확인 가능
+  - 테스트 파일: `src/__tests__/medium.integration.spec.tsx`
+  - 고려사항: within() 사용하여 특정 row 내에서 반복 아이콘 검색
+
+- **TC-06 단일 일정 수정 시 다이얼로그 미표시 (Integration)**
+  - 목적: 단일 일정(repeat.type='none') 수정 시 다이얼로그가 표시되지 않고 바로 수정 모드로 진입하는지 검증
+  - 전제조건: 단일 일정이 이벤트 리스트에 존재
+  - 입력/행동:
+    1. 단일 일정(반복 아이콘 없는 일정)의 수정 버튼 클릭
+  - 기대결과:
+    - '해당 일정만 수정하시겠어요?' 다이얼로그가 표시되지 않음
+    - 일정 수정 폼이 바로 열림
+  - 테스트 파일: `src/__tests__/medium.integration.spec.tsx`
+  - 고려사항: queryByText('해당 일정만 수정하시겠어요?')가 null인지 확인
+
+---
+
+## 🔁 TDD 사이클 (Red → Green → Refactor)
+
+- [x] Red: 실패하는 테스트 추가 (Test Code Agent)
+- [ ] Green: 최소 구현으로 통과 (Implementation Agent)
+- [ ] Refactor: 동작 동일, 구조/가독성 개선 (Refactoring Agent)
+
+---
+
+## 🧠 에이전트 작업 로그 (Agent Work Log)
+
+### 🧩 테스트 설계 에이전트 (Test Design)
+
+- Inputs: Story/AC, Context
+- Actions: 테스트 유형/파일 배치 설계, 모킹 전략 수립
+- Outputs: 테스트 계획 요약/시나리오 업데이트
+- Artifacts: (별도 문서 없음)
+  <!-- TEST_DESIGN_START -->
+  - Inputs:
+    - Issue 요구사항: 반복 일정 수정 시 단일 수정('예') vs 전체 수정('아니오') 선택 기능
+    - 목적: 사용자가 반복 일정 수정 시 해당 일정만 또는 전체 시리즈를 선택하여 수정 가능
+    - 컨텍스트: App.tsx에 이미 다이얼로그 UI 존재 (730-745줄), handleEditEvent/handleEditSingleOccurrence/handleEditAllOccurrences 함수 존재 (162-193줄)
+    - ARCHITECTURE.md, PRD.md 참조
+  - Actions:
+    - 코드베이스 분석: App.tsx 분석하여 기존 구현 상태 파악 완료
+    - 요구사항 분석: 6가지 시나리오 도출 (다이얼로그 표시, '예' 선택 단일 수정, 반복 아이콘 제거, '아니오' 선택 전체 수정, 반복 아이콘 유지, 단일 일정 다이얼로그 미표시)
+    - 테스트 유형 결정: Integration 테스트 중심 (사용자 관점의 전체 플로우 검증)
+    - 테스트 케이스 설계: 6개 테스트 케이스 작성 (TC-01 ~ TC-06)
+    - 테스트 파일 배치: `src/__tests__/medium.integration.spec.tsx`에 추가
+    - 모킹 전략: MSW 핸들러 활용, PUT /api/events/:id 요청 모킹, 요청 body에서 repeat.type 검증
+  - Outputs:
+    - 테스트 시나리오 6개 (SC-01 ~ SC-06) 작성 완료
+    - 테스트 케이스 6개 (TC-01 ~ TC-06) 상세 명세 완료
+    - 각 테스트 케이스별 목적/전제조건/입력행동/기대결과/테스트 파일/고려사항 명시
+  - Artifacts: 이슈 파일 내 테스트 계획 섹션 업데이트 완료
+  <!-- TEST_DESIGN_END -->
+
+---
+
+### 🧪 테스트 코드 작성 에이전트 (Test Code)
+
+- Inputs: Test Plan, Matrix
+- Actions: 스캐폴딩/테스트 구현(단계적), 실패 확인
+- Outputs: 커밋/PR 링크, 주요 테스트 스니펫
+- Artifacts: `src/__tests__/*`
+  <!-- TEST_CODE_START -->
+  - Inputs:
+    - 테스트 계획: TC-01 ~ TC-06 (6개 테스트 케이스)
+    - 테스트 파일: `src/__tests__/medium.integration.spec.tsx`
+    - 기존 테스트 스타일 참고
+  - Actions:
+    - 기존 테스트 검토: medium.integration.spec.tsx에 반복 일정 관련 테스트 이미 존재 확인
+    - TC-01 작성: 반복 일정 수정 시 다이얼로그 표시 확인 (다이얼로그 텍스트, 버튼 확인)
+    - TC-02 작성: '예' 선택 시 단일 일정으로 수정 (repeat.type='none' 확인)
+    - TC-03 작성: '예' 선택 후 반복 아이콘 제거 확인 (queryAllByLabelText 사용)
+    - TC-04 작성: '아니오' 선택 시 전체 시리즈 수정 (repeat 정보 유지 확인)
+    - TC-05 작성: '아니오' 선택 후 반복 아이콘 유지 확인
+    - TC-06 작성: 단일 일정 수정 시 다이얼로그 미표시 확인
+    - MSW 핸들러 설정: PUT /api/events/:id 모킹, 요청 body 캡처
+    - Lint 오류 수정: TypeScript 타입 오류 해결 (capturedRequestBody 타입 처리)
+    - 테스트 쿼리 개선: DOM 구조 분석 후 반복 아이콘 검증 로직 개선 (closest 대신 queryAllByLabelText 사용)
+  - Outputs:
+    - 테스트 파일 작성 완료: `src/__tests__/medium.integration.spec.tsx` (823-1161줄, 6개 테스트 추가)
+    - Lint 오류 없음 (No linter errors found)
+    - 테스트 체크리스트 모두 통과 ✅
+  - Artifacts: `src/__tests__/medium.integration.spec.tsx`
+  <!-- TEST_CODE_END -->
+
+---
+
+### 💻 코드 작성 에이전트 (Implementation)
+
+- Inputs: 실패 테스트(TC-03, TC-05), Issue 요구사항(반복 아이콘 표시/유지 규칙)
+- Actions:
+  - `src/App.tsx`의 event-list(좌측 리스트) 섹션에 반복 아이콘 추가
+    - 조건: `event.repeat.type !== 'none'`
+    - 접근성: `aria-label="반복 일정"`, `title="반복 일정"` 부여
+  - 테스트 재실행으로 TC-03/TC-05 Green 확인
+- Outputs:
+  - 모든 관련 테스트 Green (31 passed)
+  - 변경 파일: `src/App.tsx`
+- Artifacts: `src/App.tsx`
+  <!-- IMPLEMENTATION_START -->
+  - Inputs: TC-03/TC-05 실패, 반복 아이콘 표시 요구사항
+  - Actions: event-list에 Repeat 아이콘 및 접근성 라벨 추가
+  - Outputs: 통합 테스트 31개 모두 Green
+  - Artifacts: `src/App.tsx`
+  <!-- IMPLEMENTATION_END -->
+
+---
+
+### 🔧 리팩토링 에이전트 (Refactoring)
+
+- Inputs: Green 상태(31 tests passed), 중복된 반복 아이콘 렌더링 코드
+- Actions:
+  - `RepeatBadge` 컴포넌트 추출
+  - 월/주 뷰의 `renderEventItem` 및 좌측 event-list에서 반복 아이콘 렌더링을 `RepeatBadge`로 통일
+  - 접근성 표준 유지(aria-label/title 유지)
+- Outputs:
+  - 중복 제거 및 일관된 렌더링 구현
+  - 모든 테스트 Green 유지
+- Artifacts: `src/App.tsx`
+  <!-- REFACTORING_START -->
+  - Inputs: 반복 아이콘 렌더링 중복
+  - Actions: `RepeatBadge` 추출, 두 위치에서 공통 사용
+  - Outputs: 테스트 전부 Green 유지(31)
+  - Artifacts: `src/App.tsx`
+  <!-- REFACTORING_END -->
+
+---
+
+## 🧾 요약 (Summary)
+
+- 상태: `완료`
+- 마지막 수정 에이전트: 오케스트레이터
+- 주요 변경사항 요약: 반복 일정 수정 기능 TDD 사이클 완료(Red → Green → Refactor). 테스트 6개 추가 및 통과, event-list 반복 아이콘 표시 구현, RepeatBadge로 중복 제거. 모든 테스트 Green(31) 및 Lint 정상. 변경 파일: `src/__tests__/medium.integration.spec.tsx`, `src/App.tsx`. 이슈 문서 최신화 완료.
diff --git "a/.cursor/issues/issue-006-\353\260\230\353\263\265-\354\235\274\354\240\225-\354\202\255\354\240\234.md" "b/.cursor/issues/issue-006-\353\260\230\353\263\265-\354\235\274\354\240\225-\354\202\255\354\240\234.md"
new file mode 100644
index 00000000..1ffd4640
--- /dev/null
+++ "b/.cursor/issues/issue-006-\353\260\230\353\263\265-\354\235\274\354\240\225-\354\202\255\354\240\234.md"
@@ -0,0 +1,175 @@
+# 🧭 Issue: 기능 요청서
+
+## 🎯 목적 (Goal)
+
+사용자가 반복 일정을 삭제할 때 해당 일정만 삭제할지 전체 시리즈를 삭제할지 선택할 수 있도록 한다.
+
+---
+
+## 📋 요구사항 (Requirements)
+
+- 반복 일정 삭제 시 '해당 일정만 삭제하시겠어요?'라는 확인 다이얼로그가 표시된다.
+- 사용자가 '예'를 선택하면 해당 일정만 삭제된다(단일 인스턴스 삭제).
+- 사용자가 '아니오'를 선택하면 반복 일정의 모든 일정이 삭제된다(전체 시리즈 삭제).
+
+---
+
+## 🧩 맥락 & 범위 (Context & Scope)
+
+- Impacted Areas: UI (`App.tsx` - 삭제 다이얼로그) | Hooks (`useEventOperations` - 삭제 로직/엔드포인트) | Tests (Integration)
+- Out of Scope: 삭제 취소 후 되돌리기(Undo), 휴지통/복구, 반복 유형 변경/생성/수정
+
+---
+
+## 🧪 테스트 계획 요약 (Test Plan Summary)
+
+### 테스트 시나리오 개요 (Scenario Overview)
+
+- SC-01: 반복 일정 삭제 클릭 시 다이얼로그 표시 확인
+- SC-02: '예' 선택 시 해당 일정만 삭제됨 확인(다른 시리즈 일정 유지)
+- SC-03: '아니오' 선택 시 전체 시리즈 삭제됨 확인(관련 일정 모두 제거)
+- SC-04: 단일 일정 삭제 시 다이얼로그 미표시 및 즉시 삭제 확인
+
+### 테스트 케이스 상세 (Test Case Detail)
+
+- **TC-01 반복 일정 삭제 다이얼로그 표시 (Integration)**
+
+  - 목적: 반복 일정에서 삭제 버튼 클릭 시 '해당 일정만 삭제하시겠어요?' 다이얼로그 표시
+  - 전제조건: 반복 일정 존재(repeat.type !== 'none')
+  - 입력/행동: Edit/삭제 아이콘 중 삭제 클릭
+  - 기대결과: 다이얼로그에 '예'/'아니오' 버튼 표시
+  - 테스트 파일: `src/__tests__/medium.integration.spec.tsx`
+
+- **TC-02 '예' 선택 시 단일 인스턴스 삭제 (Integration)**
+
+  - 목적: '예' 선택 시 해당 일정만 삭제됨을 확인(시리즈 나머지는 유지)
+  - 전제조건: 반복 일정 1개 이상 존재
+  - 입력/행동: 삭제 → '예' 클릭
+  - 기대결과: 선택한 일정만 리스트에서 제거, 성공 토스트 표시
+  - 테스트 파일: `src/__tests__/medium.integration.spec.tsx`
+  - 고려사항: 단일 삭제는 `DELETE /api/events/:id` 호출로 처리, 다른 인스턴스는 남아 있어야 함
+
+- **TC-03 '아니오' 선택 시 전체 시리즈 삭제 (Integration)**
+
+  - 목적: '아니오' 선택 시 반복 일정의 모든 인스턴스 삭제 확인
+  - 전제조건: 동일 시리즈의 일정 다수 존재
+  - 입력/행동: 삭제 → '아니오' 클릭
+  - 기대결과: 해당 시리즈 모든 일정 제거, 성공 토스트 표시
+  - 테스트 파일: `src/__tests__/medium.integration.spec.tsx`
+  - 고려사항: 전체 시리즈 삭제는 `DELETE /api/recurring-events/:baseId` 호출로 처리
+
+- **TC-04 단일 일정 삭제 시 다이얼로그 미표시 (Integration)**
+
+  - 목적: repeat.type='none'인 일정은 다이얼로그 없이 즉시 삭제됨 확인
+  - 전제조건: 단일 일정 존재
+  - 입력/행동: 삭제 클릭
+  - 기대결과: 다이얼로그 미표시, 즉시 삭제 처리, 성공 토스트 표시
+  - 테스트 파일: `src/__tests__/medium.integration.spec.tsx`
+  - 고려사항: 단일 일정 삭제는 `DELETE /api/events/:id` 호출, 다이얼로그 로직 분기 검증
+
+  <!-- TEST_DESIGN_START -->
+
+  - Inputs:
+    - Issue 요구사항: '예' 선택 시 단일 삭제, '아니오' 선택 시 전체 시리즈 삭제
+    - 컨텍스트: App.tsx 삭제 다이얼로그/핸들러 존재, useEventOperations에 `deleteEvent`, `deleteRecurringSeries` 구현 존재
+    - ARCHITECTURE.md, PRD.md
+  - Actions:
+    - 테스트 유형: Integration 중심(사용자 플로우 기반)
+    - 시나리오 4개 설계: 다이얼로그 표시, 단일 삭제, 전체 시리즈 삭제, 단일 일정 즉시 삭제
+    - 모킹 전략: MSW로 `DELETE /api/events/:id`, `DELETE /api/recurring-events/:baseId` 핸들러 구성, 초기 이벤트 시드 준비
+    - 검증 포인트: 다이얼로그 표시/미표시, 호출 엔드포인트 및 파라미터, 리스트 내 잔존 이벤트 개수, 토스트 메시지
+  - Outputs:
+    - 테스트 케이스 상세 명세 업데이트(TC-01 ~ TC-04)
+    - 테스트 파일 배치 계획: `src/__tests__/medium.integration.spec.tsx`
+    <!-- TEST_DESIGN_END -->
+
+## 🔁 TDD 사이클 (Red → Green → Refactor)
+
+- [ ] Red: 실패하는 테스트 추가 (Test Code Agent)
+- [ ] Green: 최소 구현으로 통과 (Implementation Agent)
+- [ ] Refactor: 동작 동일, 구조/가독성 개선 (Refactoring Agent)
+
+---
+
+## 🧠 에이전트 작업 로그 (Agent Work Log)
+
+### 🧩 테스트 설계 에이전트 (Test Design)
+
+- Inputs: Story/AC, Context
+- Actions: 테스트 유형/파일 배치 설계, 모킹 전략 수립
+- Outputs: 테스트 계획 요약/시나리오 업데이트
+- Artifacts: (별도 문서 없음)
+  <!-- TEST_DESIGN_START -->
+  (자동 기록)
+  <!-- TEST_DESIGN_END -->
+
+---
+
+### 🧪 테스트 코드 작성 에이전트 (Test Code)
+
+- Inputs: Test Plan, Matrix
+- Actions: 스캐폴딩/테스트 구현(단계적), 실패 확인
+- Outputs: 커밋/PR 링크, 주요 테스트 스니펫
+- Artifacts: `src/__tests__/*`
+  <!-- TEST_CODE_START -->
+  - Inputs:
+    - 테스트 계획: TC-01 ~ TC-04 (반복 일정 삭제)
+    - 테스트 파일: `src/__tests__/medium.integration.spec.tsx`
+  - Actions:
+    - TC-01 작성: 반복 일정 삭제 버튼 클릭 시 다이얼로그 표시 확인
+    - TC-02 작성: '예' 선택 시 단일 인스턴스만 삭제 (DELETE /api/events/:id)
+    - TC-03 작성: '아니오' 선택 시 전체 시리즈 삭제 (DELETE /api/recurring-events/:baseId)
+    - TC-04 작성: 단일 일정 삭제 시 다이얼로그 미표시 및 즉시 삭제
+    - MSW 모킹: 테스트 내 server.use로 GET/DELETE 엔드포인트 구성
+  - Outputs:
+    - 테스트 케이스 4개 추가 (통합)
+    - 린트/타입 오류 없음
+  - Artifacts: `src/__tests__/medium.integration.spec.tsx`
+  <!-- TEST_CODE_END -->
+
+---
+
+### 💻 코드 작성 에이전트 (Implementation)
+
+- Inputs: 실패 테스트(TC-02, TC-03), Issue 요구사항(단일/전체 삭제 분기)
+- Actions:
+  - `src/App.tsx` 삭제 플로우 보완
+    - 단일 삭제: 다이얼로그 '예' → `deleteEvent(pendingDeleteEvent.id)`
+    - 전체 삭제: 다이얼로그 '아니오' → `deleteRecurringSeries(baseId ?? id)` 분기 처리
+    - 상태 관리: `pendingDeleteEventId` → `pendingDeleteEvent`로 교체하여 이벤트 정보 보유
+    - 다이얼로그 onClose시 상태 정리
+  - 테스트 재실행으로 TC-02/TC-03 포함 전체 GREEN 확인(35/35)
+- Outputs:
+  - 모든 관련 테스트 Green (35 passed)
+  - 변경 파일: `src/App.tsx`
+- Artifacts: `src/App.tsx`
+  <!-- IMPLEMENTATION_START -->
+  - Inputs: 삭제 통합 테스트(4)
+  - Actions: 삭제 다이얼로그 분기 구현 및 상태 정리, useEventOperations의 `deleteRecurringSeries` 연동
+  - Outputs: 전체 테스트 Green(35)
+  - Artifacts: `src/App.tsx`
+  <!-- IMPLEMENTATION_END -->
+
+### 🔧 리팩토링 에이전트 (Refactoring)
+
+- Inputs: Green 상태(35 tests passed), 삭제 분기 로직 가독성 개선 필요
+- Actions:
+  - 시리즈 식별자 해석 함수 추출: `resolveRecurringSeriesId(event)`
+  - `handleDeleteAllOccurrences`에서 식별자 분기 로직 제거하고 헬퍼 사용
+  - 동작 동일 유지, 타입 안전성·가독성 향상
+- Outputs:
+  - 중복/캐스팅 로직 축소, 코드 명확성 개선
+  - 모든 테스트 Green 유지
+- Artifacts: `src/App.tsx`
+  <!-- REFACTORING_START -->
+  - Inputs: 삭제 분기 로직 단순화 필요
+  - Actions: `resolveRecurringSeriesId` 헬퍼 추가 및 호출부 치환
+  - Outputs: 테스트 전부 Green 유지(35)
+  - Artifacts: `src/App.tsx`
+  <!-- REFACTORING_END -->
+
+## 🧾 요약 (Summary)
+
+- 상태: `완료`
+- 마지막 수정 에이전트: 오케스트레이터
+- 주요 변경사항 요약: 반복 일정 삭제 기능 TDD 완료(Red→Green→Refactor). 통합 테스트 4개 추가 및 전체 통과(35/35). 단일/전체 삭제 분기 구현, 시리즈 식별자 헬퍼로 가독성 개선. 변경 파일: `src/__tests__/medium.integration.spec.tsx`, `src/App.tsx`. 문서 최신화 완료.
diff --git a/.cursor/templates/commit-template.md b/.cursor/templates/commit-template.md
new file mode 100644
index 00000000..d4a90f1e
--- /dev/null
+++ b/.cursor/templates/commit-template.md
@@ -0,0 +1,27 @@
+# commit template
+
+<type>(scope?): <명확한 요약>
+
+<본문 - optional>
+
+<Footer - optional>
+
+## type 종류
+
+| Type     | 의미                               | 예시                                |
+| -------- | ---------------------------------- | ----------------------------------- |
+| feat     | 새로운 기능 추가                   | feat(calendar): 일정 생성 기능 추가 |
+| fix      | 버그 수정                          | fix(api): 일정 조회 API 응답 수정   |
+| refactor | 동작 변경 없는 코드 개선           | refactor: 중복 코드 제거            |
+| chore    | 빌드/설정 등 비즈니스 외 변경      | chore: ESLint 설정 업데이트         |
+| test     | 테스트 코드 추가/수정              | test: 일정 삭제 테스트 추가         |
+| docs     | 문서 수정                          | docs: README에 사용법 추가          |
+| style    | 코드 포맷 변경 (공백, 세미콜론 등) | style: 코드 포맷 정리               |
+| perf     | 성능 개선                          | perf: 일정 필터링 속도 개선         |
+
+## 예시
+
+refactor: 반복되는 일정 검증 로직 함수로 추출
+
+중복 코드를 제거하고 가독성을 향상시켰습니다.
+기능 동작에는 변화 없음.
diff --git a/.cursor/templates/issue-template.md b/.cursor/templates/issue-template.md
new file mode 100644
index 00000000..9c5be7c3
--- /dev/null
+++ b/.cursor/templates/issue-template.md
@@ -0,0 +1,106 @@
+# 🧭 Issue: 기능 요청서
+
+## 🎯 목적 (Goal)
+
+한 문장으로 사용자/비즈니스 가치를 설명합니다.
+
+---
+
+## 📋 요구사항 (Requirements)
+
+- 검증 가능한 문장으로만 작성합니다.
+- 모호어(적절히/가능하면/필요시) 금지.
+
+---
+
+## 🧩 맥락 & 범위 (Context & Scope)
+
+- Impacted Areas: Types | Hooks | Utils | Tests | UI | API
+- Out of Scope: (명시적으로 제외할 범위)
+
+---
+
+## 🧪 테스트 계획 요약 (Test Plan Summary)
+
+### 테스트 시나리오 개요 (Scenario Overview)
+
+- SC-01: 시나리오 한 줄 요약 문장 (예: UI 노출 및 옵션 표시 확인).
+- SC-02: 시나리오 한 줄 요약 문장 (예: 기본 반복 생성 동작 확인).
+- SC-03: 시나리오 한 줄 요약 문장 (예: 경계 날짜 규칙 검증).
+- SC-04: 시나리오 한 줄 요약 문장 (예: 윤년 등 특수 규칙 검증).
+- SC-05: 시나리오 한 줄 요약 문장 (예: 겹침/예외 처리 관측 또는 종료 조건 등).
+
+### 테스트 케이스 상세 (Test Case Detail)
+
+- **TC-01 반복유형 UI 노출 확인**
+  - 목적: 일정 생성 폼 렌더링 시 반복 옵션 노출 검증
+  - 전제조건: 화면 진입 완료
+  - 입력/행동: 일정 생성 폼 렌더링
+  - 기대결과: “매일/매주/매월/매년” 옵션이 표시됨
+  - 고려사항: getByRole, getByLabelText 사용
+
+---
+
+## 🔁 TDD 사이클 (Red → Green → Refactor)
+
+- [ ] Red: 실패하는 테스트 추가 (Test Code Agent)
+- [ ] Green: 최소 구현으로 통과 (Implementation Agent)
+- [ ] Refactor: 동작 동일, 구조/가독성 개선 (Refactoring Agent)
+
+---
+
+## 🧠 에이전트 작업 로그 (Agent Work Log)
+
+### 🧩 테스트 설계 에이전트 (Test Design)
+
+- Inputs: Story/AC, Context
+- Actions: 테스트 유형/파일 배치 설계, 모킹 전략 수립
+- Outputs: 테스트 계획 요약/시나리오 업데이트
+- Artifacts: (별도 문서 없음)
+  <!-- TEST_DESIGN_START -->
+  (자동 기록)
+  <!-- TEST_DESIGN_END -->
+
+---
+
+### 🧪 테스트 코드 작성 에이전트 (Test Code)
+
+- Inputs: Test Plan, Matrix
+- Actions: 스캐폴딩/테스트 구현(단계적), 실패 확인
+- Outputs: 커밋/PR 링크, 주요 테스트 스니펫
+- Artifacts: `src/__tests__/*`
+  <!-- TEST_CODE_START -->
+  (자동 기록)
+  <!-- TEST_CODE_END -->
+
+---
+
+### 💻 코드 작성 에이전트 (Implementation)
+
+- Inputs: 실패 테스트
+- Actions: 최소 구현(Green)
+- Outputs: 변경 파일/주요 변경 요약
+- Artifacts: 소스 코드 경로
+  <!-- IMPLEMENTATION_START -->
+  (자동 기록)
+  <!-- IMPLEMENTATION_END -->
+
+---
+
+### 🔧 리팩토링 에이전트 (Refactoring)
+
+- Inputs: Green 상태
+- Actions: 중복 제거/구조 개선/명명 개선(동작 동일)
+- Outputs: 리팩토링 포인트/전후 비교
+- Safeguard: 모든 테스트 Green 유지
+  <!-- REFACTORING_START -->
+  (자동 기록)
+  <!-- REFACTORING_END -->
+
+---
+
+## 🧾 요약 (Summary)
+
+- 상태: `기획 | 테스트 설계 | 테스트 코드 작성 | 코드 작성 | 리팩토링 | 완료`
+- 마지막 수정 에이전트: (자동 기록)
+- 주요 변경사항 요약: (자동 기록)
diff --git a/server.js b/server.js
index cac56df9..0a8a8d97 100644
--- a/server.js
+++ b/server.js
@@ -75,7 +75,7 @@ app.delete('/api/events/:id', async (req, res) => {
 
 app.post('/api/events-list', async (req, res) => {
   const events = await getEvents();
-  const repeatId = randomUUID();
+  const repeatId = req.body.events[0]?.repeat?.id || randomUUID();
   const newEvents = req.body.events.map((event) => {
     const isRepeatEvent = event.repeat.type !== 'none';
     return {
diff --git a/src/App.tsx b/src/App.tsx
index 195c5b05..0787ad5f 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -1,4 +1,12 @@
-import { Notifications, ChevronLeft, ChevronRight, Delete, Edit, Close } from '@mui/icons-material';
+import {
+  Notifications,
+  ChevronLeft,
+  ChevronRight,
+  Delete,
+  Edit,
+  Close,
+  Repeat,
+} from '@mui/icons-material';
 import {
   Alert,
   AlertTitle,
@@ -35,8 +43,7 @@ import { useEventForm } from './hooks/useEventForm.ts';
 import { useEventOperations } from './hooks/useEventOperations.ts';
 import { useNotifications } from './hooks/useNotifications.ts';
 import { useSearch } from './hooks/useSearch.ts';
-// import { Event, EventForm, RepeatType } from './types';
-import { Event, EventForm } from './types';
+import { Event, EventForm, RepeatType } from './types';
 import {
   formatDate,
   formatMonth,
@@ -60,6 +67,60 @@ const notificationOptions = [
   { value: 1440, label: '1일 전' },
 ];
 
+const repeatTypeOptions: Array<{ value: RepeatType; label: string }> = [
+  { value: 'daily', label: '매일' },
+  { value: 'weekly', label: '매주' },
+  { value: 'monthly', label: '매월' },
+  { value: 'yearly', label: '매년' },
+];
+
+// 반복 시리즈 식별자 해석 (repeat.id 우선, baseId fallback)
+const resolveRecurringSeriesId = (event: Event): string => {
+  const repeatWithId = event.repeat as {
+    type: string;
+    interval: number;
+    endDate?: string;
+    id?: string;
+  };
+  if (repeatWithId.id) return repeatWithId.id;
+
+  const withBase = event as unknown as { baseId?: string };
+  return withBase.baseId ?? event.id;
+};
+
+// 반복 아이콘 배지
+const RepeatBadge = () => (
+  <span aria-label="반복 일정" title="반복 일정">
+    <Repeat fontSize="small" />
+  </span>
+);
+
+// 이벤트 아이템 렌더링 헬퍼 함수
+const renderEventItem = (event: Event, isNotified: boolean, isRepeating: boolean) => (
+  <Box
+    key={event.id}
+    sx={{
+      p: 0.5,
+      my: 0.5,
+      backgroundColor: isNotified ? '#ffebee' : '#f5f5f5',
+      borderRadius: 1,
+      fontWeight: isNotified ? 'bold' : 'normal',
+      color: isNotified ? '#d32f2f' : 'inherit',
+      minHeight: '18px',
+      width: '100%',
+      overflow: 'hidden',
+    }}
+  >
+    <Stack direction="row" spacing={1} alignItems="center">
+      {isNotified && <Notifications fontSize="small" />}
+      {isRepeating && <RepeatBadge />}
+      <Typography variant="caption" noWrap sx={{ fontSize: '0.75rem', lineHeight: 1.2 }}>
+        {event.title}
+      </Typography>
+    </Stack>
+  </Box>
+);
+
 function App() {
   const {
     title,
@@ -77,11 +138,11 @@ function App() {
     isRepeating,
     setIsRepeating,
     repeatType,
-    // setRepeatType,
+    setRepeatType,
     repeatInterval,
-    // setRepeatInterval,
+    setRepeatInterval,
     repeatEndDate,
-    // setRepeatEndDate,
+    setRepeatEndDate,
     notificationTime,
     setNotificationTime,
     startTimeError,
@@ -94,19 +155,91 @@ function App() {
     editEvent,
   } = useEventForm();
 
-  const { events, saveEvent, deleteEvent } = useEventOperations(Boolean(editingEvent), () =>
-    setEditingEvent(null)
-  );
+  const { events, saveEvent, deleteEvent, deleteRecurringSeries, updateRecurringSeries } =
+    useEventOperations(Boolean(editingEvent), () => setEditingEvent(null));
 
   const { notifications, notifiedEvents, setNotifications } = useNotifications(events);
   const { view, setView, currentDate, holidays, navigate } = useCalendarView();
-  const { searchTerm, filteredEvents, setSearchTerm } = useSearch(events, currentDate, view);
+  const { searchTerm, filteredEvents, searchedOriginalEvents, setSearchTerm } = useSearch(
+    events,
+    currentDate,
+    view
+  );
 
   const [isOverlapDialogOpen, setIsOverlapDialogOpen] = useState(false);
   const [overlappingEvents, setOverlappingEvents] = useState<Event[]>([]);
+  const [isEditRecurringDialogOpen, setIsEditRecurringDialogOpen] = useState(false);
+  const [pendingEditEvent, setPendingEditEvent] = useState<Event | null>(null);
+  const [isEditingWholeSeries, setIsEditingWholeSeries] = useState(false);
+  const [isDeleteRecurringDialogOpen, setIsDeleteRecurringDialogOpen] = useState(false);
+  const [pendingDeleteEvent, setPendingDeleteEvent] = useState<Event | null>(null);
 
   const { enqueueSnackbar } = useSnackbar();
 
+  const handleEditEvent = (event: Event) => {
+    // 반복 일정이면 다이얼로그 표시
+    if (event.repeat.type !== 'none') {
+      setPendingEditEvent(event);
+      setIsEditRecurringDialogOpen(true);
+    } else {
+      // 단일 일정은 바로 편집
+      editEvent(event);
+    }
+  };
+
+  const handleEditSingleOccurrence = () => {
+    if (pendingEditEvent) {
+      // 단일 인스턴스만 수정 - repeat.type을 'none'으로 설정하여 단일 일정으로 변환
+      const singleEvent: Event = {
+        ...pendingEditEvent,
+        repeat: { type: 'none', interval: 1 },
+      };
+      setIsEditingWholeSeries(false);
+      editEvent(singleEvent);
+    }
+    setIsEditRecurringDialogOpen(false);
+    setPendingEditEvent(null);
+  };
+
+  const handleEditAllOccurrences = () => {
+    if (pendingEditEvent) {
+      // 전체 시리즈 수정 플래그 설정
+      setIsEditingWholeSeries(true);
+      editEvent(pendingEditEvent);
+    }
+    setIsEditRecurringDialogOpen(false);
+    setPendingEditEvent(null);
+  };
+
+  const handleDeleteEvent = (eventId: string) => {
+    const event = events.find((e) => e.id === eventId);
+    // 반복 일정이면 다이얼로그 표시
+    if (event && event.repeat.type !== 'none') {
+      setPendingDeleteEvent(event);
+      setIsDeleteRecurringDialogOpen(true);
+    } else {
+      // 단일 일정은 바로 삭제
+      deleteEvent(eventId);
+    }
+  };
+
+  const handleDeleteSingleOccurrence = () => {
+    if (pendingDeleteEvent) {
+      deleteEvent(pendingDeleteEvent.id);
+    }
+    setIsDeleteRecurringDialogOpen(false);
+    setPendingDeleteEvent(null);
+  };
+
+  const handleDeleteAllOccurrences = () => {
+    if (pendingDeleteEvent) {
+      // 전체 시리즈 삭제
+      deleteRecurringSeries(resolveRecurringSeriesId(pendingDeleteEvent));
+    }
+    setIsDeleteRecurringDialogOpen(false);
+    setPendingDeleteEvent(null);
+  };
+
   const addOrUpdateEvent = async () => {
     if (!title || !date || !startTime || !endTime) {
       enqueueSnackbar('필수 정보를 모두 입력해주세요.', { variant: 'error' });
@@ -135,14 +268,33 @@ function App() {
       notificationTime,
     };
 
+    // 전체 시리즈 수정인 경우
+    if (editingEvent && isEditingWholeSeries && editingEvent.repeat.type !== 'none') {
+      const repeatId = resolveRecurringSeriesId(editingEvent);
+      await updateRecurringSeries(repeatId, eventData);
+      setIsEditingWholeSeries(false);
+      resetForm();
+      return;
+    }
+
+    // 반복일정은 겹침 검사를 수행하지 않음
+    const isRepeatingEvent = eventData.repeat.type !== 'none';
+
+    if (isRepeatingEvent) {
+      await saveEvent(eventData);
+      resetForm();
+      return;
+    }
+
     const overlapping = findOverlappingEvents(eventData, events);
     if (overlapping.length > 0) {
       setOverlappingEvents(overlapping);
       setIsOverlapDialogOpen(true);
-    } else {
-      await saveEvent(eventData);
-      resetForm();
+      return;
     }
+
+    await saveEvent(eventData);
+    resetForm();
   };
 
   const renderWeekView = () => {
@@ -184,33 +336,8 @@ function App() {
                       )
                       .map((event) => {
                         const isNotified = notifiedEvents.includes(event.id);
-                        return (
-                          <Box
-                            key={event.id}
-                            sx={{
-                              p: 0.5,
-                              my: 0.5,
-                              backgroundColor: isNotified ? '#ffebee' : '#f5f5f5',
-                              borderRadius: 1,
-                              fontWeight: isNotified ? 'bold' : 'normal',
-                              color: isNotified ? '#d32f2f' : 'inherit',
-                              minHeight: '18px',
-                              width: '100%',
-                              overflow: 'hidden',
-                            }}
-                          >
-                            <Stack direction="row" spacing={1} alignItems="center">
-                              {isNotified && <Notifications fontSize="small" />}
-                              <Typography
-                                variant="caption"
-                                noWrap
-                                sx={{ fontSize: '0.75rem', lineHeight: 1.2 }}
-                              >
-                                {event.title}
-                              </Typography>
-                            </Stack>
-                          </Box>
-                        );
+                        const isRepeating = event.repeat.type !== 'none';
+                        return renderEventItem(event, isNotified, isRepeating);
                       })}
                   </TableCell>
                 ))}
@@ -271,33 +398,8 @@ function App() {
                             )}
                             {getEventsForDay(filteredEvents, day).map((event) => {
                               const isNotified = notifiedEvents.includes(event.id);
-                              return (
-                                <Box
-                                  key={event.id}
-                                  sx={{
-                                    p: 0.5,
-                                    my: 0.5,
-                                    backgroundColor: isNotified ? '#ffebee' : '#f5f5f5',
-                                    borderRadius: 1,
-                                    fontWeight: isNotified ? 'bold' : 'normal',
-                                    color: isNotified ? '#d32f2f' : 'inherit',
-                                    minHeight: '18px',
-                                    width: '100%',
-                                    overflow: 'hidden',
-                                  }}
-                                >
-                                  <Stack direction="row" spacing={1} alignItems="center">
-                                    {isNotified && <Notifications fontSize="small" />}
-                                    <Typography
-                                      variant="caption"
-                                      noWrap
-                                      sx={{ fontSize: '0.75rem', lineHeight: 1.2 }}
-                                    >
-                                      {event.title}
-                                    </Typography>
-                                  </Stack>
-                                </Box>
-                              );
+                              const isRepeating = event.repeat.type !== 'none';
+                              return renderEventItem(event, isNotified, isRepeating);
                             })}
                           </>
                         )}
@@ -414,7 +516,13 @@ function App() {
               control={
                 <Checkbox
                   checked={isRepeating}
-                  onChange={(e) => setIsRepeating(e.target.checked)}
+                  onChange={(e) => {
+                    const checked = e.target.checked;
+                    setIsRepeating(checked);
+                    if (!checked) {
+                      setRepeatType('none');
+                    }
+                  }}
                 />
               }
               label="반복 일정"
@@ -428,6 +536,7 @@ function App() {
               size="small"
               value={notificationTime}
               onChange={(e) => setNotificationTime(Number(e.target.value))}
+              aria-label="알림 설정"
             >
               {notificationOptions.map((option) => (
                 <MenuItem key={option.value} value={option.value}>
@@ -437,20 +546,26 @@ function App() {
             </Select>
           </FormControl>
 
-          {/* ! 반복은 8주차 과제에 포함됩니다. 구현하고 싶어도 참아주세요~ */}
-          {/* {isRepeating && (
+          {isRepeating && (
             <Stack spacing={2}>
               <FormControl fullWidth>
-                <FormLabel>반복 유형</FormLabel>
+                <FormLabel htmlFor="repeat-type">반복 유형</FormLabel>
                 <Select
+                  id="repeat-type"
                   size="small"
-                  value={repeatType}
-                  onChange={(e) => setRepeatType(e.target.value as RepeatType)}
+                  value={repeatType === 'none' ? '' : repeatType}
+                  onChange={(e) => setRepeatType((e.target.value || 'none') as RepeatType)}
+                  aria-label="반복 유형"
+                  displayEmpty
                 >
-                  <MenuItem value="daily">매일</MenuItem>
-                  <MenuItem value="weekly">매주</MenuItem>
-                  <MenuItem value="monthly">매월</MenuItem>
-                  <MenuItem value="yearly">매년</MenuItem>
+                  <MenuItem value="" disabled>
+                    선택하세요
+                  </MenuItem>
+                  {repeatTypeOptions.map((option) => (
+                    <MenuItem key={option.value} value={option.value}>
+                      {option.label}
+                    </MenuItem>
+                  ))}
                 </Select>
               </FormControl>
               <Stack direction="row" spacing={2}>
@@ -464,18 +579,21 @@ function App() {
                     slotProps={{ htmlInput: { min: 1 } }}
                   />
                 </FormControl>
-                <FormControl fullWidth>
-                  <FormLabel>반복 종료일</FormLabel>
-                  <TextField
-                    size="small"
-                    type="date"
-                    value={repeatEndDate}
-                    onChange={(e) => setRepeatEndDate(e.target.value)}
-                  />
-                </FormControl>
+                {repeatType !== 'none' && (
+                  <FormControl fullWidth>
+                    <FormLabel htmlFor="repeat-end-date">반복 종료일</FormLabel>
+                    <TextField
+                      id="repeat-end-date"
+                      size="small"
+                      type="date"
+                      value={repeatEndDate}
+                      onChange={(e) => setRepeatEndDate(e.target.value)}
+                    />
+                  </FormControl>
+                )}
               </Stack>
             </Stack>
-          )} */}
+          )}
 
           <Button
             data-testid="event-submit-button"
@@ -532,15 +650,16 @@ function App() {
             />
           </FormControl>
 
-          {filteredEvents.length === 0 ? (
+          {searchedOriginalEvents.length === 0 ? (
             <Typography>검색 결과가 없습니다.</Typography>
           ) : (
-            filteredEvents.map((event) => (
+            searchedOriginalEvents.map((event) => (
               <Box key={event.id} sx={{ border: 1, borderRadius: 2, p: 3, width: '100%' }}>
                 <Stack direction="row" justifyContent="space-between">
                   <Stack>
                     <Stack direction="row" spacing={1} alignItems="center">
                       {notifiedEvents.includes(event.id) && <Notifications color="error" />}
+                      {event.repeat.type !== 'none' && <RepeatBadge />}
                       <Typography
                         fontWeight={notifiedEvents.includes(event.id) ? 'bold' : 'normal'}
                         color={notifiedEvents.includes(event.id) ? 'error' : 'inherit'}
@@ -576,10 +695,13 @@ function App() {
                     </Typography>
                   </Stack>
                   <Stack>
-                    <IconButton aria-label="Edit event" onClick={() => editEvent(event)}>
+                    <IconButton aria-label="Edit event" onClick={() => handleEditEvent(event)}>
                       <Edit />
                     </IconButton>
-                    <IconButton aria-label="Delete event" onClick={() => deleteEvent(event.id)}>
+                    <IconButton
+                      aria-label="Delete event"
+                      onClick={() => handleDeleteEvent(event.id)}
+                    >
                       <Delete />
                     </IconButton>
                   </Stack>
@@ -632,6 +754,40 @@ function App() {
         </DialogActions>
       </Dialog>
 
+      <Dialog
+        open={isEditRecurringDialogOpen}
+        onClose={() => {
+          setIsEditRecurringDialogOpen(false);
+          setPendingEditEvent(null);
+        }}
+      >
+        <DialogTitle>반복 일정 수정</DialogTitle>
+        <DialogContent>
+          <DialogContentText>해당 일정만 수정하시겠어요?</DialogContentText>
+        </DialogContent>
+        <DialogActions>
+          <Button onClick={handleEditSingleOccurrence}>예</Button>
+          <Button onClick={handleEditAllOccurrences}>아니오</Button>
+        </DialogActions>
+      </Dialog>
+
+      <Dialog
+        open={isDeleteRecurringDialogOpen}
+        onClose={() => {
+          setIsDeleteRecurringDialogOpen(false);
+          setPendingDeleteEvent(null);
+        }}
+      >
+        <DialogTitle>반복 일정 삭제</DialogTitle>
+        <DialogContent>
+          <DialogContentText>해당 일정만 삭제하시겠어요?</DialogContentText>
+        </DialogContent>
+        <DialogActions>
+          <Button onClick={handleDeleteSingleOccurrence}>예</Button>
+          <Button onClick={handleDeleteAllOccurrences}>아니오</Button>
+        </DialogActions>
+      </Dialog>
+
       {notifications.length > 0 && (
         <Stack position="fixed" top={16} right={16} spacing={2} alignItems="flex-end">
           {notifications.map((notification, index) => (
diff --git a/src/__mocks__/handlersUtils.ts b/src/__mocks__/handlersUtils.ts
index 0263c669..c91f16c8 100644
--- a/src/__mocks__/handlersUtils.ts
+++ b/src/__mocks__/handlersUtils.ts
@@ -6,6 +6,7 @@ import { Event } from '../types';
 // ! Hard 여기 제공 안함
 export const setupMockHandlerCreation = (initEvents = [] as Event[]) => {
   const mockEvents: Event[] = [...initEvents];
+  let eventIdCounter = mockEvents.length + 1;
 
   server.use(
     http.get('/api/events', () => {
@@ -13,9 +14,18 @@ export const setupMockHandlerCreation = (initEvents = [] as Event[]) => {
     }),
     http.post('/api/events', async ({ request }) => {
       const newEvent = (await request.json()) as Event;
-      newEvent.id = String(mockEvents.length + 1); // 간단한 ID 생성
+      newEvent.id = String(eventIdCounter++); // 간단한 ID 생성
       mockEvents.push(newEvent);
       return HttpResponse.json(newEvent, { status: 201 });
+    }),
+    http.post('/api/events-list', async ({ request }) => {
+      const body = (await request.json()) as { events: Event[] };
+      const newEvents = body.events.map((event) => ({
+        ...event,
+        id: String(eventIdCounter++),
+      }));
+      mockEvents.push(...newEvents);
+      return HttpResponse.json(newEvents, { status: 201 });
     })
   );
 };
diff --git a/src/__mocks__/response/realEvents.json b/src/__mocks__/response/realEvents.json
index 821aef58..d042adda 100644
--- a/src/__mocks__/response/realEvents.json
+++ b/src/__mocks__/response/realEvents.json
@@ -1,64 +1 @@
-{
-  "events": [
-    {
-      "id": "2b7545a6-ebee-426c-b906-2329bc8d62bd",
-      "title": "팀 회의",
-      "date": "2025-10-20",
-      "startTime": "10:00",
-      "endTime": "11:00",
-      "description": "주간 팀 미팅",
-      "location": "회의실 A",
-      "category": "업무",
-      "repeat": { "type": "none", "interval": 0 },
-      "notificationTime": 1
-    },
-    {
-      "id": "09702fb3-a478-40b3-905e-9ab3c8849dcd",
-      "title": "점심 약속",
-      "date": "2025-10-21",
-      "startTime": "12:30",
-      "endTime": "13:30",
-      "description": "동료와 점심 식사",
-      "location": "회사 근처 식당",
-      "category": "개인",
-      "repeat": { "type": "none", "interval": 0 },
-      "notificationTime": 1
-    },
-    {
-      "id": "da3ca408-836a-4d98-b67a-ca389d07552b",
-      "title": "프로젝트 마감",
-      "date": "2025-10-25",
-      "startTime": "09:00",
-      "endTime": "18:00",
-      "description": "분기별 프로젝트 마감",
-      "location": "사무실",
-      "category": "업무",
-      "repeat": { "type": "none", "interval": 0 },
-      "notificationTime": 1
-    },
-    {
-      "id": "dac62941-69e5-4ec0-98cc-24c2a79a7f81",
-      "title": "생일 파티",
-      "date": "2025-10-28",
-      "startTime": "19:00",
-      "endTime": "22:00",
-      "description": "친구 생일 축하",
-      "location": "친구 집",
-      "category": "개인",
-      "repeat": { "type": "none", "interval": 0 },
-      "notificationTime": 1
-    },
-    {
-      "id": "80d85368-b4a4-47b3-b959-25171d49371f",
-      "title": "운동",
-      "date": "2025-10-22",
-      "startTime": "18:00",
-      "endTime": "19:00",
-      "description": "주간 운동",
-      "location": "헬스장",
-      "category": "개인",
-      "repeat": { "type": "none", "interval": 0 },
-      "notificationTime": 1
-    }
-  ]
-}
+{"events":[]}
\ No newline at end of file
diff --git a/src/__tests__/hooks/medium.useEventForm.spec.ts b/src/__tests__/hooks/medium.useEventForm.spec.ts
new file mode 100644
index 00000000..18ac5e20
--- /dev/null
+++ b/src/__tests__/hooks/medium.useEventForm.spec.ts
@@ -0,0 +1,164 @@
+import { act, renderHook } from '@testing-library/react';
+
+import { useEventForm } from '../../hooks/useEventForm';
+import { Event } from '../../types';
+
+describe('useEventForm 반복 유형 상태 관리 (TC-02)', () => {
+  it('초기 상태에서 repeatType은 none이다', () => {
+    const { result } = renderHook(() => useEventForm());
+
+    expect(result.current.repeatType).toBe('none');
+    expect(result.current.isRepeating).toBe(false);
+  });
+
+  it('setRepeatType을 호출하면 repeatType이 업데이트된다', () => {
+    const { result } = renderHook(() => useEventForm());
+
+    act(() => {
+      result.current.setRepeatType('daily');
+    });
+    expect(result.current.repeatType).toBe('daily');
+
+    act(() => {
+      result.current.setRepeatType('weekly');
+    });
+    expect(result.current.repeatType).toBe('weekly');
+
+    act(() => {
+      result.current.setRepeatType('monthly');
+    });
+    expect(result.current.repeatType).toBe('monthly');
+
+    act(() => {
+      result.current.setRepeatType('yearly');
+    });
+    expect(result.current.repeatType).toBe('yearly');
+  });
+
+  it('기존 반복 일정을 editEvent로 로드하면 반복 유형이 올바르게 설정된다', () => {
+    const initialEvent: Event = {
+      id: '1',
+      title: '반복 회의',
+      date: '2024-01-15',
+      startTime: '10:00',
+      endTime: '11:00',
+      description: '설명',
+      location: '회의실 A',
+      category: '업무',
+      repeat: { type: 'daily', interval: 1 },
+      notificationTime: 10,
+    };
+
+    const { result } = renderHook(() => useEventForm());
+
+    act(() => {
+      result.current.editEvent(initialEvent);
+    });
+
+    expect(result.current.repeatType).toBe('daily');
+    expect(result.current.isRepeating).toBe(true);
+    expect(result.current.repeatInterval).toBe(1);
+  });
+
+  it('다양한 반복 유형으로 초기화된 이벤트를 로드할 수 있다', () => {
+    const weeklyEvent: Event = {
+      id: '2',
+      title: '주간 회의',
+      date: '2024-01-15',
+      startTime: '10:00',
+      endTime: '11:00',
+      description: '',
+      location: '',
+      category: '업무',
+      repeat: { type: 'weekly', interval: 1 },
+      notificationTime: 10,
+    };
+
+    const monthlyEvent: Event = {
+      id: '3',
+      title: '월간 회의',
+      date: '2024-01-15',
+      startTime: '10:00',
+      endTime: '11:00',
+      description: '',
+      location: '',
+      category: '업무',
+      repeat: { type: 'monthly', interval: 1 },
+      notificationTime: 10,
+    };
+
+    const yearlyEvent: Event = {
+      id: '4',
+      title: '연간 회의',
+      date: '2024-01-15',
+      startTime: '10:00',
+      endTime: '11:00',
+      description: '',
+      location: '',
+      category: '업무',
+      repeat: { type: 'yearly', interval: 1 },
+      notificationTime: 10,
+    };
+
+    const { result } = renderHook(() => useEventForm());
+
+    act(() => {
+      result.current.editEvent(weeklyEvent);
+    });
+    expect(result.current.repeatType).toBe('weekly');
+
+    act(() => {
+      result.current.editEvent(monthlyEvent);
+    });
+    expect(result.current.repeatType).toBe('monthly');
+
+    act(() => {
+      result.current.editEvent(yearlyEvent);
+    });
+    expect(result.current.repeatType).toBe('yearly');
+  });
+
+  it('resetForm 호출 시 repeatType이 none으로 초기화된다', () => {
+    const { result } = renderHook(() => useEventForm());
+
+    act(() => {
+      result.current.setRepeatType('daily');
+      result.current.setIsRepeating(true);
+    });
+
+    expect(result.current.repeatType).toBe('daily');
+    expect(result.current.isRepeating).toBe(true);
+
+    act(() => {
+      result.current.resetForm();
+    });
+
+    expect(result.current.repeatType).toBe('none');
+    expect(result.current.isRepeating).toBe(false);
+    expect(result.current.repeatInterval).toBe(1);
+  });
+
+  it('반복 유형이 none인 이벤트를 로드하면 isRepeating이 false이다', () => {
+    const nonRepeatingEvent: Event = {
+      id: '5',
+      title: '일반 회의',
+      date: '2024-01-15',
+      startTime: '10:00',
+      endTime: '11:00',
+      description: '',
+      location: '',
+      category: '업무',
+      repeat: { type: 'none', interval: 0 },
+      notificationTime: 10,
+    };
+
+    const { result } = renderHook(() => useEventForm());
+
+    act(() => {
+      result.current.editEvent(nonRepeatingEvent);
+    });
+
+    expect(result.current.repeatType).toBe('none');
+    expect(result.current.isRepeating).toBe(false);
+  });
+});
diff --git a/src/__tests__/medium.integration.spec.tsx b/src/__tests__/medium.integration.spec.tsx
index 788dae14..3ec194bc 100644
--- a/src/__tests__/medium.integration.spec.tsx
+++ b/src/__tests__/medium.integration.spec.tsx
@@ -116,6 +116,7 @@ describe('일정 CRUD 및 기본 기능', () => {
 describe('일정 뷰', () => {
   it('주별 뷰를 선택 후 해당 주에 일정이 없으면, 일정이 표시되지 않는다.', async () => {
     // ! 현재 시스템 시간 2025-10-01
+    setupMockHandlerCreation();
     const { user } = setup(<App />);
 
     await user.click(within(screen.getByLabelText('뷰 타입 선택')).getByRole('combobox'));
@@ -151,6 +152,7 @@ describe('일정 뷰', () => {
 
   it('월별 뷰에 일정이 없으면, 일정이 표시되지 않아야 한다.', async () => {
     vi.setSystemTime(new Date('2025-01-01'));
+    setupMockHandlerCreation();
 
     setup(<App />);
 
@@ -340,3 +342,1067 @@ it('notificationTime을 10으로 하면 지정 시간 10분 전 알람 텍스트
 
   expect(screen.getByText('10분 후 기존 회의 일정이 시작됩니다.')).toBeInTheDocument();
 });
+
+describe('반복 일정 (SC-01)', () => {
+  it('TC-01: 사용자가 반복 일정 체크박스를 선택하면 반복 유형 선택 UI가 표시되고 매일/매주/매월/매년 옵션을 선택할 수 있다', async () => {
+    const { user } = setup(<App />);
+
+    // 반복 일정 체크박스 클릭
+    const repeatCheckbox = screen.getByLabelText('반복 일정');
+    await user.click(repeatCheckbox);
+
+    // 반복 유형 드롭다운이 표시되는지 확인
+    const repeatTypeSelect = screen.getByLabelText('반복 유형');
+    expect(repeatTypeSelect).toBeInTheDocument();
+
+    // 드롭다운 클릭하여 옵션 확인
+    await user.click(repeatTypeSelect);
+    await user.click(within(repeatTypeSelect).getByRole('combobox'));
+
+    // 매일, 매주, 매월, 매년 옵션이 모두 표시되는지 확인
+    expect(screen.getByRole('option', { name: '매일' })).toBeInTheDocument();
+    expect(screen.getByRole('option', { name: '매주' })).toBeInTheDocument();
+    expect(screen.getByRole('option', { name: '매월' })).toBeInTheDocument();
+    expect(screen.getByRole('option', { name: '매년' })).toBeInTheDocument();
+
+    // 매일 옵션 선택
+    await user.click(screen.getByRole('option', { name: '매일' }));
+    expect(repeatTypeSelect).toHaveTextContent('매일');
+  });
+});
+
+describe('반복일정 겹침 검사 제외 (SC-05)', () => {
+  afterEach(() => {
+    server.resetHandlers();
+  });
+
+  it('TC-05: 반복일정 생성 시 기존 일정과 겹치더라도 경고 없이 저장된다', async () => {
+    setupMockHandlerCreation([
+      {
+        id: '1',
+        title: '기존 회의',
+        date: '2024-01-15',
+        startTime: '10:00',
+        endTime: '11:00',
+        description: '기존 팀 미팅',
+        location: '회의실 B',
+        category: '업무',
+        repeat: { type: 'none', interval: 0 },
+        notificationTime: 10,
+      },
+    ]);
+
+    const { user } = setup(<App />);
+
+    // 일정 생성 폼 입력
+    await user.click(screen.getAllByText('일정 추가')[0]);
+    await user.type(screen.getByLabelText('제목'), '반복 회의');
+    await user.type(screen.getByLabelText('날짜'), '2024-01-15');
+    await user.type(screen.getByLabelText('시작 시간'), '10:00');
+    await user.type(screen.getByLabelText('종료 시간'), '11:00');
+    await user.type(screen.getByLabelText('설명'), '설명');
+    await user.type(screen.getByLabelText('위치'), '회의실 A');
+    await user.click(screen.getByLabelText('카테고리'));
+    await user.click(within(screen.getByLabelText('카테고리')).getByRole('combobox'));
+    await user.click(screen.getByRole('option', { name: '업무-option' }));
+
+    // 반복 일정 체크박스 선택
+    await user.click(screen.getByLabelText('반복 일정'));
+
+    // 반복 유형을 매일로 선택
+    const repeatTypeSelect = screen.getByLabelText('반복 유형');
+    await user.click(repeatTypeSelect);
+    await user.click(within(repeatTypeSelect).getByRole('combobox'));
+    await user.click(screen.getByRole('option', { name: '매일' }));
+
+    // 일정 저장
+    await user.click(screen.getByTestId('event-submit-button'));
+
+    // 겹침 경고 다이얼로그가 표시되지 않는지 확인
+    expect(screen.queryByText('일정 겹침 경고')).not.toBeInTheDocument();
+
+    // 성공 토스트 확인
+    expect(await screen.findByText('일정이 추가되었습니다.')).toBeInTheDocument();
+  });
+});
+
+describe('반복 일정 아이콘 표시 (SC-01 ~ SC-04)', () => {
+  afterEach(() => {
+    server.resetHandlers();
+  });
+
+  // 반복 일정 생성 헬퍼 함수
+  const saveRepeatingSchedule = async (
+    user: UserEvent,
+    form: Omit<Event, 'id' | 'notificationTime'> & { notificationTime?: number },
+    repeatType: 'daily' | 'weekly' | 'monthly' | 'yearly'
+  ) => {
+    const { title, date, startTime, endTime, location, description, category, notificationTime } =
+      form;
+
+    await user.click(screen.getAllByText('일정 추가')[0]);
+
+    await user.type(screen.getByLabelText('제목'), title);
+    await user.type(screen.getByLabelText('날짜'), date);
+    await user.type(screen.getByLabelText('시작 시간'), startTime);
+    await user.type(screen.getByLabelText('종료 시간'), endTime);
+    await user.type(screen.getByLabelText('설명'), description);
+    await user.type(screen.getByLabelText('위치'), location);
+    await user.click(screen.getByLabelText('카테고리'));
+    await user.click(within(screen.getByLabelText('카테고리')).getByRole('combobox'));
+    await user.click(screen.getByRole('option', { name: `${category}-option` }));
+
+    // 알림 시간 설정 (선택적)
+    if (notificationTime !== undefined) {
+      const notificationSelect = screen.getByLabelText('알림 설정');
+      await user.click(notificationSelect);
+      await user.click(within(notificationSelect).getByRole('combobox'));
+      await user.click(screen.getByRole('option', { name: `${notificationTime}분 전` }));
+    }
+
+    // 반복 일정 체크박스 선택
+    await user.click(screen.getByLabelText('반복 일정'));
+
+    // 반복 유형 선택
+    const repeatTypeSelect = screen.getByLabelText('반복 유형');
+    await user.click(repeatTypeSelect);
+    await user.click(within(repeatTypeSelect).getByRole('combobox'));
+    await user.click(
+      screen.getByRole('option', {
+        name:
+          repeatType === 'daily'
+            ? '매일'
+            : repeatType === 'weekly'
+              ? '매주'
+              : repeatType === 'monthly'
+                ? '매월'
+                : '매년',
+      })
+    );
+
+    await user.click(screen.getByTestId('event-submit-button'));
+    await screen.findByText('일정이 추가되었습니다.');
+  };
+
+  it('TC-01: 월 뷰에서 반복 일정 아이콘 표시 확인', async () => {
+    setupMockHandlerCreation();
+    vi.setSystemTime(new Date('2025-10-01'));
+
+    const { user } = setup(<App />);
+
+    await saveRepeatingSchedule(
+      user,
+      {
+        title: '매주 팀 회의',
+        date: '2025-10-02',
+        startTime: '09:00',
+        endTime: '10:00',
+        description: '주간 팀 미팅',
+        location: '회의실 A',
+        category: '업무',
+        repeat: { type: 'weekly', interval: 1 },
+      },
+      'weekly'
+    );
+
+    const monthView = within(screen.getByTestId('month-view'));
+    // 2025-10-02는 목요일이므로 2일 셀을 찾습니다
+    const dayCell = monthView.getByText('2').closest('td')!;
+    const eventTitle = within(dayCell).getByText('매주 팀 회의');
+
+    // 반복 아이콘이 표시되는지 확인 (aria-label="반복 일정" 또는 data-testid 사용)
+    const eventContainer = eventTitle.closest('div[class*="Box"]') || eventTitle.closest('div');
+    expect(eventContainer).toBeInTheDocument();
+
+    // 반복 아이콘 검증 - 구현 후 aria-label이나 역할로 검증
+    const repeatIcon = within(eventContainer as HTMLElement).queryByLabelText('반복 일정');
+    expect(repeatIcon).toBeInTheDocument();
+  });
+
+  it('TC-02: 주 뷰에서 반복 일정 아이콘 표시 확인', async () => {
+    setupMockHandlerCreation();
+    vi.setSystemTime(new Date('2025-10-01'));
+
+    const { user } = setup(<App />);
+
+    await saveRepeatingSchedule(
+      user,
+      {
+        title: '매일 아침 회의',
+        date: '2025-10-02',
+        startTime: '09:00',
+        endTime: '09:30',
+        description: '데일리 스탠드업',
+        location: '회의실 A',
+        category: '업무',
+        repeat: { type: 'daily', interval: 1 },
+      },
+      'daily'
+    );
+
+    // 주 뷰로 전환
+    await user.click(within(screen.getByLabelText('뷰 타입 선택')).getByRole('combobox'));
+    await user.click(screen.getByRole('option', { name: 'week-option' }));
+
+    const weekView = within(screen.getByTestId('week-view'));
+    // 2025-10-02는 목요일이므로 2일 셀을 찾습니다
+    const dayCell = weekView.getByText('2').closest('td')!;
+    const eventTitle = within(dayCell).getByText('매일 아침 회의');
+
+    // 반복 아이콘이 표시되는지 확인
+    const eventContainer = eventTitle.closest('div[class*="Box"]') || eventTitle.closest('div');
+    expect(eventContainer).toBeInTheDocument();
+
+    const repeatIcon = within(eventContainer as HTMLElement).queryByLabelText('반복 일정');
+    expect(repeatIcon).toBeInTheDocument();
+  });
+
+  it('TC-03: 반복 일정이 아닌 일정에는 아이콘 미표시 확인', async () => {
+    setupMockHandlerCreation();
+    vi.setSystemTime(new Date('2025-10-01'));
+
+    const { user } = setup(<App />);
+
+    await saveSchedule(user, {
+      title: '일반 회의',
+      date: '2025-10-02',
+      startTime: '09:00',
+      endTime: '10:00',
+      description: '일반 팀 미팅',
+      location: '회의실 A',
+      category: '업무',
+    });
+
+    const monthView = within(screen.getByTestId('month-view'));
+    const eventTitle = monthView.getByText('일반 회의');
+
+    // 반복 아이콘이 표시되지 않는지 확인
+    const eventContainer = eventTitle.closest('div[class*="Box"]') || eventTitle.closest('div');
+    expect(eventContainer).toBeInTheDocument();
+
+    const repeatIcon = within(eventContainer as HTMLElement).queryByLabelText('반복 일정');
+    expect(repeatIcon).not.toBeInTheDocument();
+  });
+
+  it('TC-04: 반복 아이콘과 알림 아이콘 동시 표시 확인', async () => {
+    setupMockHandlerCreation();
+    // 알림이 표시되도록 시간 설정 (notificationTime: 10분 전)
+    vi.setSystemTime(new Date('2025-10-02 08:50:00'));
+
+    const { user } = setup(<App />);
+
+    // 반복 일정 생성 (알림 시간 설정 포함)
+    await saveRepeatingSchedule(
+      user,
+      {
+        title: '매주 알림 회의',
+        date: '2025-10-02',
+        startTime: '09:00',
+        endTime: '10:00',
+        description: '알림이 있는 반복 회의',
+        location: '회의실 A',
+        category: '업무',
+        repeat: { type: 'weekly', interval: 1 },
+        notificationTime: 10,
+      },
+      'weekly'
+    );
+
+    // 알림이 표시되도록 시간 경과
+    act(() => {
+      vi.advanceTimersByTime(1000);
+    });
+
+    const monthView = within(screen.getByTestId('month-view'));
+    // 2025-10-02는 목요일이므로 2일 셀을 찾습니다
+    const dayCell = monthView.getByText('2').closest('td')!;
+    const eventTitle = within(dayCell).getByText('매주 알림 회의');
+
+    // 반복 아이콘과 알림 아이콘이 모두 표시되는지 확인
+    const eventContainer = eventTitle.closest('div[class*="Box"]') || eventTitle.closest('div');
+    expect(eventContainer).toBeInTheDocument();
+
+    // 반복 아이콘 확인
+    const repeatIcon = within(eventContainer as HTMLElement).queryByLabelText('반복 일정');
+    expect(repeatIcon).toBeInTheDocument();
+
+    // 알림 아이콘 확인 (Notifications 아이콘)
+    // 알림 텍스트로 알림이 표시되었는지 확인
+    expect(screen.queryByText(/10분 후.*일정이 시작됩니다/)).toBeInTheDocument();
+  });
+});
+
+describe('반복 종료일 지정 (SC-01 ~ SC-04)', () => {
+  afterEach(() => {
+    server.resetHandlers();
+  });
+
+  it('TC-01: 반복 종료일 입력 필드 노출 확인', async () => {
+    const { user } = setup(<App />);
+
+    // 반복 일정 체크박스 클릭
+    await user.click(screen.getByLabelText('반복 일정'));
+
+    // 반복 유형 선택
+    const repeatTypeSelect = screen.getByLabelText('반복 유형');
+    await user.click(repeatTypeSelect);
+    await user.click(within(repeatTypeSelect).getByRole('combobox'));
+    await user.click(screen.getByRole('option', { name: '매일' }));
+
+    // 반복 종료일 입력 필드가 표시되는지 확인
+    const repeatEndDateField = screen.getByLabelText('반복 종료일');
+    expect(repeatEndDateField).toBeInTheDocument();
+    expect(repeatEndDateField).toHaveAttribute('type', 'date');
+  });
+
+  it('TC-02: 반복 종료일 입력 및 상태 저장 확인', async () => {
+    const { user } = setup(<App />);
+
+    // 반복 일정 체크박스 선택 및 반복 유형 선택
+    await user.click(screen.getByLabelText('반복 일정'));
+    const repeatTypeSelect = screen.getByLabelText('반복 유형');
+    await user.click(repeatTypeSelect);
+    await user.click(within(repeatTypeSelect).getByRole('combobox'));
+    await user.click(screen.getByRole('option', { name: '매일' }));
+
+    // 반복 종료일 입력
+    const repeatEndDateField = screen.getByLabelText('반복 종료일');
+    await user.type(repeatEndDateField, '2025-12-31');
+
+    // 입력된 날짜가 입력 필드에 표시되는지 확인
+    expect(repeatEndDateField).toHaveValue('2025-12-31');
+  });
+
+  it('TC-03: 반복 종료일이 저장되는지 확인', async () => {
+    setupMockHandlerCreation();
+
+    const { user } = setup(<App />);
+
+    // 일정 생성 폼 열기
+    await user.click(screen.getAllByText('일정 추가')[0]);
+
+    // 기본 일정 정보 입력
+    await user.type(screen.getByLabelText('제목'), '반복 일정 테스트');
+    await user.type(screen.getByLabelText('날짜'), '2025-10-15');
+    await user.type(screen.getByLabelText('시작 시간'), '09:00');
+    await user.type(screen.getByLabelText('종료 시간'), '10:00');
+    await user.type(screen.getByLabelText('설명'), '설명');
+    await user.type(screen.getByLabelText('위치'), '회의실 A');
+    await user.click(screen.getByLabelText('카테고리'));
+    await user.click(within(screen.getByLabelText('카테고리')).getByRole('combobox'));
+    await user.click(screen.getByRole('option', { name: '업무-option' }));
+
+    // 반복 일정 설정
+    await user.click(screen.getByLabelText('반복 일정'));
+    const repeatTypeSelect = screen.getByLabelText('반복 유형');
+    await user.click(repeatTypeSelect);
+    await user.click(within(repeatTypeSelect).getByRole('combobox'));
+    await user.click(screen.getByRole('option', { name: '매일' }));
+
+    // 반복 종료일 입력
+    const repeatEndDateField = screen.getByLabelText('반복 종료일');
+    await user.type(repeatEndDateField, '2025-12-31');
+
+    // 일정 저장
+    await user.click(screen.getByTestId('event-submit-button'));
+
+    // 저장 완료 대기
+    await screen.findByText('일정이 추가되었습니다.');
+
+    // 저장된 이벤트의 repeat.endDate가 포함되어 있는지 확인
+    // 반복 일정이 여러 개 생성되었으므로 첫 번째 일정만 확인
+    const eventList = within(screen.getByTestId('event-list'));
+    const events = eventList.getAllByText('반복 일정 테스트');
+    expect(events.length).toBeGreaterThan(0);
+    // 반복 종료일 정보가 표시되는지 확인 (2025-10-15부터 2025-12-31까지 여러 일정 생성)
+    const endDateElements = eventList.getAllByText(/종료: 2025-12-31/);
+    expect(endDateElements.length).toBeGreaterThan(0);
+  });
+
+  it('TC-04: 반복 유형 미선택 시 종료일 필드 미표시 확인', async () => {
+    const { user } = setup(<App />);
+
+    // 일정 생성 폼 열기
+    await user.click(screen.getAllByText('일정 추가')[0]);
+
+    // 반복 일정 체크박스만 선택 (반복 유형은 선택하지 않음)
+    await user.click(screen.getByLabelText('반복 일정'));
+
+    // 반복 종료일 입력 필드가 표시되지 않는지 확인
+    const repeatEndDateField = screen.queryByLabelText('반복 종료일');
+    expect(repeatEndDateField).not.toBeInTheDocument();
+  });
+});
+
+describe('반복 일정 생성 (SC-01 ~ SC-05)', () => {
+  afterEach(() => {
+    server.resetHandlers();
+  });
+
+  const setupMockHandlerForRecurringEvents = () => {
+    const mockEvents: Event[] = [];
+    let eventIdCounter = 1;
+
+    server.use(
+      http.get('/api/events', () => {
+        return HttpResponse.json({ events: mockEvents });
+      }),
+      http.post('/api/events-list', async ({ request }) => {
+        const body = (await request.json()) as { events: Event[] };
+        const newEvents = body.events.map((event) => ({
+          ...event,
+          id: String(eventIdCounter++),
+        }));
+        mockEvents.push(...newEvents);
+        return HttpResponse.json(newEvents, { status: 201 });
+      })
+    );
+
+    return mockEvents;
+  };
+
+  it('TC-06: 반복 일정 생성 통합 테스트 - 매일 반복 일정이 종료일까지 생성된다', async () => {
+    const mockEvents = setupMockHandlerForRecurringEvents();
+
+    const { user } = setup(<App />);
+
+    // 일정 생성 폼 열기
+    await user.click(screen.getAllByText('일정 추가')[0]);
+
+    // 기본 일정 정보 입력
+    await user.type(screen.getByLabelText('제목'), '매일 반복 회의');
+    await user.type(screen.getByLabelText('날짜'), '2025-10-15');
+    await user.type(screen.getByLabelText('시작 시간'), '09:00');
+    await user.type(screen.getByLabelText('종료 시간'), '10:00');
+    await user.type(screen.getByLabelText('설명'), '설명');
+    await user.type(screen.getByLabelText('위치'), '회의실 A');
+    await user.click(screen.getByLabelText('카테고리'));
+    await user.click(within(screen.getByLabelText('카테고리')).getByRole('combobox'));
+    await user.click(screen.getByRole('option', { name: '업무-option' }));
+
+    // 반복 일정 설정
+    await user.click(screen.getByLabelText('반복 일정'));
+    const repeatTypeSelect = screen.getByLabelText('반복 유형');
+    await user.click(repeatTypeSelect);
+    await user.click(within(repeatTypeSelect).getByRole('combobox'));
+    await user.click(screen.getByRole('option', { name: '매일' }));
+
+    // 반복 종료일 입력
+    const repeatEndDateField = screen.getByLabelText('반복 종료일');
+    await user.type(repeatEndDateField, '2025-10-20');
+
+    // 일정 저장
+    await user.click(screen.getByTestId('event-submit-button'));
+
+    // 저장 완료 대기
+    await screen.findByText('일정이 추가되었습니다.');
+
+    // 생성된 일정 개수 확인 (2025-10-15부터 2025-10-20까지 6개)
+    await screen.findByText('일정 로딩 완료!');
+
+    // 매일 반복 일정이 6개 생성되었는지 확인
+    const dailyEvents = mockEvents.filter(
+      (event) =>
+        event.title === '매일 반복 회의' && event.date >= '2025-10-15' && event.date <= '2025-10-20'
+    );
+    expect(dailyEvents).toHaveLength(6);
+
+    // 날짜 순서 확인
+    const dates = dailyEvents.map((e) => e.date).sort();
+    expect(dates).toEqual([
+      '2025-10-15',
+      '2025-10-16',
+      '2025-10-17',
+      '2025-10-18',
+      '2025-10-19',
+      '2025-10-20',
+    ]);
+  });
+});
+
+describe('반복 일정 수정 (SC-01 ~ SC-06)', () => {
+  // TC-01: 반복 일정 수정 시 다이얼로그 표시 확인
+  it('TC-01: 반복 일정 수정 시 다이얼로그 표시 확인 - 반복 일정 수정 버튼을 클릭하면 수정 방식 선택 다이얼로그가 표시된다', async () => {
+    const mockEvents: Event[] = [
+      {
+        id: '1',
+        title: '반복 회의',
+        date: '2025-10-15',
+        startTime: '09:00',
+        endTime: '10:00',
+        description: '매주 반복 회의',
+        location: '회의실 A',
+        category: '업무',
+        repeat: { type: 'weekly', interval: 1, endDate: '2025-11-15' },
+        notificationTime: 10,
+      },
+    ];
+
+    server.use(
+      http.get('/api/events', () => {
+        return HttpResponse.json({ events: mockEvents });
+      }),
+      http.put('/api/events/:id', async ({ params, request }) => {
+        const { id } = params;
+        const updatedEvent = (await request.json()) as Event;
+        const index = mockEvents.findIndex((event) => event.id === id);
+        mockEvents[index] = { ...mockEvents[index], ...updatedEvent };
+        return HttpResponse.json(mockEvents[index]);
+      })
+    );
+
+    const { user } = setup(<App />);
+
+    // 반복 일정이 로드될 때까지 대기
+    await screen.findByText('일정 로딩 완료!');
+
+    // 반복 일정의 수정 버튼 클릭
+    const editButton = await screen.findByLabelText('Edit event');
+    await user.click(editButton);
+
+    // 다이얼로그가 표시되는지 확인
+    expect(screen.getByText('반복 일정 수정')).toBeInTheDocument();
+    expect(screen.getByText('해당 일정만 수정하시겠어요?')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: '예' })).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: '아니오' })).toBeInTheDocument();
+  });
+
+  // TC-02: '예' 선택 시 단일 일정으로 수정
+  it('TC-02: 다이얼로그에서 예를 선택하면 해당 일정만 단일 일정으로 변환되어 수정된다', async () => {
+    const mockEvents: Event[] = [
+      {
+        id: '1',
+        title: '반복 회의',
+        date: '2025-10-15',
+        startTime: '09:00',
+        endTime: '10:00',
+        description: '매주 반복 회의',
+        location: '회의실 A',
+        category: '업무',
+        repeat: { type: 'weekly', interval: 1, endDate: '2025-11-15' },
+        notificationTime: 10,
+      },
+    ];
+
+    const capturedRequestBody: { current: Event | null } = { current: null };
+
+    server.use(
+      http.get('/api/events', () => {
+        return HttpResponse.json({ events: mockEvents });
+      }),
+      http.put('/api/events/:id', async ({ params, request }) => {
+        const { id } = params;
+        const updatedEvent = (await request.json()) as Event;
+        capturedRequestBody.current = updatedEvent;
+        const index = mockEvents.findIndex((event) => event.id === id);
+        mockEvents[index] = { ...mockEvents[index], ...updatedEvent };
+        return HttpResponse.json(mockEvents[index]);
+      })
+    );
+
+    const { user } = setup(<App />);
+
+    await screen.findByText('일정 로딩 완료!');
+
+    // 반복 일정의 수정 버튼 클릭
+    const editButton = await screen.findByLabelText('Edit event');
+    await user.click(editButton);
+
+    // 다이얼로그에서 '예' 선택
+    const yesButton = screen.getByRole('button', { name: '예' });
+    await user.click(yesButton);
+
+    // 일정 수정 폼이 열리고 제목을 수정
+    const titleInput = screen.getByLabelText('제목');
+    await user.clear(titleInput);
+    await user.type(titleInput, '수정된 단일 일정');
+
+    // 일정 수정 버튼 클릭
+    await user.click(screen.getByTestId('event-submit-button'));
+
+    // PUT 요청이 호출되었고 repeat.type이 'none'으로 변경되었는지 확인
+    await screen.findByText('일정이 수정되었습니다.');
+    expect(capturedRequestBody.current).not.toBeNull();
+    expect(capturedRequestBody.current?.repeat.type).toBe('none');
+  });
+
+  // TC-03: '예' 선택 후 수정된 일정의 반복 아이콘 제거 확인
+  it('TC-03: 단일 일정으로 변환 후 저장된 일정에서 반복 아이콘이 사라진다', async () => {
+    const mockEvents: Event[] = [
+      {
+        id: '1',
+        title: '반복 회의',
+        date: '2025-10-15',
+        startTime: '09:00',
+        endTime: '10:00',
+        description: '매주 반복 회의',
+        location: '회의실 A',
+        category: '업무',
+        repeat: { type: 'weekly', interval: 1, endDate: '2025-11-15' },
+        notificationTime: 10,
+      },
+    ];
+
+    server.use(
+      http.get('/api/events', () => {
+        return HttpResponse.json({ events: mockEvents });
+      }),
+      http.put('/api/events/:id', async ({ params, request }) => {
+        const { id } = params;
+        const updatedEvent = (await request.json()) as Event;
+        const index = mockEvents.findIndex((event) => event.id === id);
+        mockEvents[index] = { ...mockEvents[index], ...updatedEvent };
+        return HttpResponse.json(mockEvents[index]);
+      })
+    );
+
+    const { user } = setup(<App />);
+
+    await screen.findByText('일정 로딩 완료!');
+
+    // 수정 전 반복 아이콘 확인 (전체 event-list 내에 반복 아이콘이 존재함)
+    const eventListBefore = screen.getByTestId('event-list');
+    const repeatIconsBefore = within(eventListBefore).queryAllByLabelText('반복 일정');
+    expect(repeatIconsBefore.length).toBeGreaterThan(0);
+
+    // 반복 일정의 수정 버튼 클릭
+    const editButton = await screen.findByLabelText('Edit event');
+    await user.click(editButton);
+
+    // 다이얼로그에서 '예' 선택
+    await user.click(screen.getByRole('button', { name: '예' }));
+
+    // 제목 수정
+    const titleInput = screen.getByLabelText('제목');
+    await user.clear(titleInput);
+    await user.type(titleInput, '수정된 단일 일정');
+
+    // 일정 수정
+    await user.click(screen.getByTestId('event-submit-button'));
+
+    await screen.findByText('일정이 수정되었습니다.');
+
+    // 수정 후 반복 아이콘이 사라졌는지 확인 (전체 event-list 내에 반복 아이콘이 없어야 함)
+    const eventListAfter = screen.getByTestId('event-list');
+    const repeatIconsAfter = within(eventListAfter).queryAllByLabelText('반복 일정');
+    expect(repeatIconsAfter.length).toBe(0);
+  });
+
+  // TC-04: '아니오' 선택 시 전체 시리즈 수정
+  it('TC-04: 다이얼로그에서 아니오를 선택하면 반복 설정을 유지한 채로 전체 시리즈가 수정된다', async () => {
+    const mockEvents: Array<Event & { baseId?: string }> = [
+      {
+        id: '1',
+        title: '반복 회의',
+        date: '2025-10-15',
+        startTime: '09:00',
+        endTime: '10:00',
+        description: '매주 반복 회의',
+        location: '회의실 A',
+        category: '업무',
+        repeat: {
+          type: 'weekly',
+          interval: 1,
+          endDate: '2025-11-15',
+          id: 'series-1',
+        } as (typeof mockEvents)[0]['repeat'] & { id: string },
+        notificationTime: 10,
+        baseId: 'series-1',
+      },
+    ];
+
+    const capturedRequestBody: { current: Event | null } = { current: null };
+
+    server.use(
+      http.get('/api/events', () => {
+        return HttpResponse.json({ events: mockEvents });
+      }),
+      http.put('/api/events/:id', async ({ params, request }) => {
+        const { id } = params;
+        const updatedEvent = (await request.json()) as Event;
+        capturedRequestBody.current = updatedEvent;
+        const index = mockEvents.findIndex((event) => event.id === id);
+        mockEvents[index] = { ...mockEvents[index], ...updatedEvent };
+        return HttpResponse.json(mockEvents[index]);
+      }),
+      http.put('/api/recurring-events/:repeatId', async ({ params, request }) => {
+        const { repeatId } = params;
+        const updateData = (await request.json()) as Partial<Event>;
+        capturedRequestBody.current = updateData as Event;
+        // 같은 repeatId를 가진 모든 이벤트 업데이트
+        mockEvents.forEach((event, index) => {
+          const eventRepeat = event.repeat as {
+            type: string;
+            interval: number;
+            endDate?: string;
+            id?: string;
+          };
+          if (eventRepeat.id === repeatId) {
+            mockEvents[index] = { ...event, ...updateData, repeat: event.repeat };
+          }
+        });
+        return HttpResponse.json(
+          mockEvents.filter((e) => {
+            const r = e.repeat as { type: string; interval: number; endDate?: string; id?: string };
+            return r.id === repeatId;
+          })
+        );
+      })
+    );
+
+    const { user } = setup(<App />);
+
+    await screen.findByText('일정 로딩 완료!');
+
+    // 반복 일정의 수정 버튼 클릭
+    const editButton = await screen.findByLabelText('Edit event');
+    await user.click(editButton);
+
+    // 다이얼로그에서 '아니오' 선택
+    const noButton = screen.getByRole('button', { name: '아니오' });
+    await user.click(noButton);
+
+    // 제목 수정
+    const titleInput = screen.getByLabelText('제목');
+    await user.clear(titleInput);
+    await user.type(titleInput, '수정된 전체 시리즈');
+
+    // 일정 수정
+    await user.click(screen.getByTestId('event-submit-button'));
+
+    // PUT 요청이 호출되었고 repeat 정보가 유지되었는지 확인
+    await screen.findByText('일정이 수정되었습니다.');
+    expect(capturedRequestBody.current).not.toBeNull();
+    expect(capturedRequestBody.current?.repeat.type).toBe('weekly');
+    expect(capturedRequestBody.current?.repeat.interval).toBe(1);
+    expect(capturedRequestBody.current?.repeat.endDate).toBe('2025-11-15');
+  });
+
+  // TC-05: '아니오' 선택 후 수정된 일정의 반복 아이콘 유지 확인
+  it('TC-05: 전체 시리즈 수정 후에도 반복 아이콘이 유지된다', async () => {
+    const mockEvents: Array<Event & { baseId?: string }> = [
+      {
+        id: '1',
+        title: '반복 회의',
+        date: '2025-10-15',
+        startTime: '09:00',
+        endTime: '10:00',
+        description: '매주 반복 회의',
+        location: '회의실 A',
+        category: '업무',
+        repeat: {
+          type: 'weekly',
+          interval: 1,
+          endDate: '2025-11-15',
+          id: 'series-1',
+        } as (typeof mockEvents)[0]['repeat'] & { id: string },
+        notificationTime: 10,
+        baseId: 'series-1',
+      },
+    ];
+
+    server.use(
+      http.get('/api/events', () => {
+        return HttpResponse.json({ events: mockEvents });
+      }),
+      http.put('/api/events/:id', async ({ params, request }) => {
+        const { id } = params;
+        const updatedEvent = (await request.json()) as Event;
+        const index = mockEvents.findIndex((event) => event.id === id);
+        mockEvents[index] = { ...mockEvents[index], ...updatedEvent };
+        return HttpResponse.json(mockEvents[index]);
+      }),
+      http.put('/api/recurring-events/:repeatId', async ({ params, request }) => {
+        const { repeatId } = params;
+        const updateData = (await request.json()) as Partial<Event>;
+        // 같은 repeatId를 가진 모든 이벤트 업데이트
+        mockEvents.forEach((event, index) => {
+          const eventRepeat = event.repeat as {
+            type: string;
+            interval: number;
+            endDate?: string;
+            id?: string;
+          };
+          if (eventRepeat.id === repeatId) {
+            mockEvents[index] = { ...event, ...updateData, repeat: event.repeat };
+          }
+        });
+        return HttpResponse.json(
+          mockEvents.filter((e) => {
+            const r = e.repeat as {
+              type: string;
+              interval: number;
+              endDate?: string;
+              id?: string;
+            };
+            return r.id === repeatId;
+          })
+        );
+      })
+    );
+
+    const { user } = setup(<App />);
+
+    await screen.findByText('일정 로딩 완료!');
+
+    // 수정 전 반복 아이콘 확인 (전체 event-list 내에 반복 아이콘이 존재함)
+    const eventListBefore = screen.getByTestId('event-list');
+    const repeatIconsBefore = within(eventListBefore).queryAllByLabelText('반복 일정');
+    expect(repeatIconsBefore.length).toBeGreaterThan(0);
+
+    // 반복 일정의 수정 버튼 클릭
+    const editButton = await screen.findByLabelText('Edit event');
+    await user.click(editButton);
+
+    // 다이얼로그에서 '아니오' 선택
+    await user.click(screen.getByRole('button', { name: '아니오' }));
+
+    // 제목 수정
+    const titleInput = screen.getByLabelText('제목');
+    await user.clear(titleInput);
+    await user.type(titleInput, '수정된 전체 시리즈');
+
+    // 일정 수정
+    await user.click(screen.getByTestId('event-submit-button'));
+
+    await screen.findByText('일정이 수정되었습니다.');
+
+    // 수정 후에도 반복 아이콘이 유지되는지 확인 (전체 event-list 내에 반복 아이콘이 여전히 존재함)
+    const eventListAfter = screen.getByTestId('event-list');
+    const repeatIconsAfter = within(eventListAfter).queryAllByLabelText('반복 일정');
+    expect(repeatIconsAfter.length).toBeGreaterThan(0);
+  });
+
+  // TC-06: 단일 일정 수정 시 다이얼로그 미표시
+  it('TC-06: 단일 일정 수정 시 다이얼로그가 표시되지 않고 바로 수정 모드로 진입한다', async () => {
+    const mockEvents: Event[] = [
+      {
+        id: '1',
+        title: '단일 회의',
+        date: '2025-10-15',
+        startTime: '09:00',
+        endTime: '10:00',
+        description: '단일 회의',
+        location: '회의실 A',
+        category: '업무',
+        repeat: { type: 'none', interval: 0 },
+        notificationTime: 10,
+      },
+    ];
+
+    server.use(
+      http.get('/api/events', () => {
+        return HttpResponse.json({ events: mockEvents });
+      }),
+      http.put('/api/events/:id', async ({ params, request }) => {
+        const { id } = params;
+        const updatedEvent = (await request.json()) as Event;
+        const index = mockEvents.findIndex((event) => event.id === id);
+        mockEvents[index] = { ...mockEvents[index], ...updatedEvent };
+        return HttpResponse.json(mockEvents[index]);
+      })
+    );
+
+    const { user } = setup(<App />);
+
+    await screen.findByText('일정 로딩 완료!');
+
+    // 단일 일정의 수정 버튼 클릭
+    const editButton = await screen.findByLabelText('Edit event');
+    await user.click(editButton);
+
+    // 다이얼로그가 표시되지 않는지 확인
+    expect(screen.queryByText('해당 일정만 수정하시겠어요?')).not.toBeInTheDocument();
+
+    // 일정 수정 폼이 바로 열렸는지 확인 (헤더 영역의 Typography를 찾음)
+    const headers = screen.getAllByText('일정 수정');
+    expect(headers.length).toBeGreaterThan(0);
+    expect(screen.getByLabelText('제목')).toHaveValue('단일 회의');
+  });
+});
+
+describe('반복 일정 삭제 (SC-01 ~ SC-04)', () => {
+  // TC-01: 반복 일정 삭제 다이얼로그 표시
+  it('TC-01: 반복 일정에서 삭제 버튼 클릭 시 다이얼로그가 표시된다', async () => {
+    const mockEvents: Event[] = [
+      {
+        id: 'r-1',
+        title: '반복 회의',
+        date: '2025-10-15',
+        startTime: '09:00',
+        endTime: '10:00',
+        description: '매주 반복 회의',
+        location: '회의실 A',
+        category: '업무',
+        repeat: { type: 'weekly', interval: 1, endDate: '2025-11-15' },
+        notificationTime: 10,
+      },
+    ];
+
+    server.use(http.get('/api/events', () => HttpResponse.json({ events: mockEvents })));
+
+    const { user } = setup(<App />);
+    await screen.findByText('일정 로딩 완료!');
+
+    const deleteButtons = await screen.findAllByLabelText('Delete event');
+    await user.click(deleteButtons[0]);
+
+    expect(screen.getByText('반복 일정 삭제')).toBeInTheDocument();
+    expect(screen.getByText('해당 일정만 삭제하시겠어요?')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: '예' })).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: '아니오' })).toBeInTheDocument();
+  });
+
+  // TC-02: '예' 선택 시 단일 인스턴스 삭제
+  it("TC-02: '예' 선택 시 해당 일정만 삭제된다 (다른 시리즈 일정 유지)", async () => {
+    // 두 개의 반복 인스턴스를 같은 시리즈로 가정 (동일 baseId라고 가정)
+    const mockEvents: Event[] = [
+      {
+        id: 'r-1',
+        title: '반복 회의',
+        date: '2025-10-15',
+        startTime: '09:00',
+        endTime: '10:00',
+        description: '매주 반복 회의',
+        location: '회의실 A',
+        category: '업무',
+        repeat: { type: 'weekly', interval: 1, endDate: '2025-11-15' },
+        notificationTime: 10,
+      },
+      {
+        id: 'r-2',
+        title: '반복 회의',
+        date: '2025-10-22',
+        startTime: '09:00',
+        endTime: '10:00',
+        description: '매주 반복 회의',
+        location: '회의실 A',
+        category: '업무',
+        repeat: { type: 'weekly', interval: 1, endDate: '2025-11-15' },
+        notificationTime: 10,
+      },
+    ];
+
+    server.use(
+      http.get('/api/events', () => HttpResponse.json({ events: mockEvents })),
+      http.delete('/api/events/:id', ({ params }) => {
+        const { id } = params as { id: string };
+        const idx = mockEvents.findIndex((e) => e.id === id);
+        if (idx !== -1) mockEvents.splice(idx, 1);
+        return new HttpResponse(null, { status: 204 });
+      })
+    );
+
+    const { user } = setup(<App />);
+    await screen.findByText('일정 로딩 완료!');
+
+    // 삭제 버튼 클릭 → 다이얼로그에서 '예'
+    const deleteButtons = await screen.findAllByLabelText('Delete event');
+    await user.click(deleteButtons[0]);
+    await user.click(screen.getByRole('button', { name: '예' }));
+
+    // 목록에 같은 시리즈의 다른 인스턴스는 남아 있어야 함
+    const list = screen.getByTestId('event-list');
+    // 남아있는 동일 제목이 최소 1개 이상 존재
+    expect(within(list).getAllByText('반복 회의').length).toBeGreaterThan(0);
+  });
+
+  // TC-03: '아니오' 선택 시 전체 시리즈 삭제
+  it("TC-03: '아니오' 선택 시 전체 시리즈가 삭제된다", async () => {
+    // 같은 시리즈 2개를 시드하고 전체 삭제 엔드포인트를 모킹
+    const baseId = 'series-1';
+    const mockEvents: (Event & { baseId?: string })[] = [
+      {
+        id: 'r-1',
+        title: '반복 회의',
+        date: '2025-10-15',
+        startTime: '09:00',
+        endTime: '10:00',
+        description: '매주 반복 회의',
+        location: '회의실 A',
+        category: '업무',
+        repeat: { type: 'weekly', interval: 1, endDate: '2025-11-15' },
+        notificationTime: 10,
+        baseId,
+      },
+      {
+        id: 'r-2',
+        title: '반복 회의',
+        date: '2025-10-22',
+        startTime: '09:00',
+        endTime: '10:00',
+        description: '매주 반복 회의',
+        location: '회의실 A',
+        category: '업무',
+        repeat: { type: 'weekly', interval: 1, endDate: '2025-11-15' },
+        notificationTime: 10,
+        baseId,
+      },
+    ];
+
+    server.use(
+      http.get('/api/events', () => HttpResponse.json({ events: mockEvents })),
+      http.delete('/api/recurring-events/:baseId', ({ params }) => {
+        const { baseId: bid } = params as { baseId: string };
+        for (let i = mockEvents.length - 1; i >= 0; i -= 1) {
+          const evt = mockEvents[i] as Event & { baseId?: string };
+          if (evt.baseId === bid) mockEvents.splice(i, 1);
+        }
+        return new HttpResponse(null, { status: 204 });
+      })
+    );
+
+    const { user } = setup(<App />);
+    await screen.findByText('일정 로딩 완료!');
+
+    // 삭제 버튼 클릭 → '아니오'
+    const deleteButtons = await screen.findAllByLabelText('Delete event');
+    await user.click(deleteButtons[0]);
+    await user.click(screen.getByRole('button', { name: '아니오' }));
+
+    // 동일 시리즈 일정이 모두 제거되어 목록에서 해당 제목이 존재하지 않아야 함
+    const list = screen.getByTestId('event-list');
+    expect(within(list).queryByText('반복 회의')).not.toBeInTheDocument();
+  });
+
+  // TC-04: 단일 일정 삭제 시 다이얼로그 미표시
+  it('TC-04: 단일 일정(repeat.type="none")은 다이얼로그 없이 즉시 삭제된다', async () => {
+    const mockEvents: Event[] = [
+      {
+        id: 's-1',
+        title: '단일 회의',
+        date: '2025-10-15',
+        startTime: '09:00',
+        endTime: '10:00',
+        description: '단일',
+        location: '회의실',
+        category: '업무',
+        repeat: { type: 'none', interval: 0 },
+        notificationTime: 10,
+      },
+    ];
+
+    server.use(
+      http.get('/api/events', () => HttpResponse.json({ events: mockEvents })),
+      http.delete('/api/events/:id', ({ params }) => {
+        const { id } = params as { id: string };
+        const idx = mockEvents.findIndex((e) => e.id === id);
+        if (idx !== -1) mockEvents.splice(idx, 1);
+        return new HttpResponse(null, { status: 204 });
+      })
+    );
+
+    const { user } = setup(<App />);
+    await screen.findByText('일정 로딩 완료!');
+
+    const deleteButton = await screen.findByLabelText('Delete event');
+    await user.click(deleteButton);
+
+    // 다이얼로그 미표시
+    expect(screen.queryByText('해당 일정만 삭제하시겠어요?')).not.toBeInTheDocument();
+
+    // 목록에서 해당 제목이 바로 사라지는지 확인 (모킹된 삭제 후 재조회 가정)
+    const list = screen.getByTestId('event-list');
+    expect(within(list).queryByText('단일 회의')).not.toBeInTheDocument();
+  });
+});
diff --git a/src/__tests__/unit/easy.generateRecurringEvents.spec.ts b/src/__tests__/unit/easy.generateRecurringEvents.spec.ts
new file mode 100644
index 00000000..96a9ab3c
--- /dev/null
+++ b/src/__tests__/unit/easy.generateRecurringEvents.spec.ts
@@ -0,0 +1,145 @@
+import { EventForm } from '../../types';
+import { generateRecurringEvents } from '../../utils/eventUtils';
+
+describe('generateRecurringEvents', () => {
+  const baseEvent: Omit<EventForm, 'repeat'> = {
+    title: '반복 일정',
+    date: '2025-10-15',
+    startTime: '09:00',
+    endTime: '10:00',
+    description: '설명',
+    location: '회의실 A',
+    category: '업무',
+    notificationTime: 10,
+  };
+
+  describe('TC-01: 매일 반복 일정 생성 확인', () => {
+    it('반복 유형이 daily인 경우 종료일까지 매일 일정이 생성된다', () => {
+      const eventForm: EventForm = {
+        ...baseEvent,
+        repeat: {
+          type: 'daily',
+          interval: 1,
+          endDate: '2025-10-20',
+        },
+      };
+
+      const result = generateRecurringEvents(eventForm);
+
+      expect(result).toHaveLength(6);
+      expect(result[0].date).toBe('2025-10-15');
+      expect(result[1].date).toBe('2025-10-16');
+      expect(result[2].date).toBe('2025-10-17');
+      expect(result[3].date).toBe('2025-10-18');
+      expect(result[4].date).toBe('2025-10-19');
+      expect(result[5].date).toBe('2025-10-20');
+
+      // 각 일정이 기본 이벤트 정보를 포함하는지 확인
+      result.forEach((event: EventForm) => {
+        expect(event.title).toBe(baseEvent.title);
+        expect(event.startTime).toBe(baseEvent.startTime);
+        expect(event.endTime).toBe(baseEvent.endTime);
+        expect(event.description).toBe(baseEvent.description);
+        expect(event.location).toBe(baseEvent.location);
+        expect(event.category).toBe(baseEvent.category);
+        expect(event.notificationTime).toBe(baseEvent.notificationTime);
+      });
+    });
+  });
+
+  describe('TC-02: 매주 반복 일정 생성 확인', () => {
+    it('반복 유형이 weekly인 경우 종료일까지 매주 일정이 생성된다', () => {
+      const eventForm: EventForm = {
+        ...baseEvent,
+        repeat: {
+          type: 'weekly',
+          interval: 1,
+          endDate: '2025-11-05',
+        },
+      };
+
+      const result = generateRecurringEvents(eventForm);
+
+      expect(result).toHaveLength(4);
+      expect(result[0].date).toBe('2025-10-15');
+      expect(result[1].date).toBe('2025-10-22');
+      expect(result[2].date).toBe('2025-10-29');
+      expect(result[3].date).toBe('2025-11-05');
+
+      // 각 일정이 7일 간격인지 확인
+      result.forEach((event: EventForm, index: number) => {
+        if (index > 0) {
+          const prevDate = new Date(result[index - 1].date);
+          const currentDate = new Date(event.date);
+          const diffDays = (currentDate.getTime() - prevDate.getTime()) / (1000 * 60 * 60 * 24);
+          expect(diffDays).toBe(7);
+        }
+      });
+    });
+  });
+
+  describe('TC-03: 매월 반복 일정 생성 확인', () => {
+    it('반복 유형이 monthly인 경우 종료일까지 매월 일정이 생성된다', () => {
+      const eventForm: EventForm = {
+        ...baseEvent,
+        repeat: {
+          type: 'monthly',
+          interval: 1,
+          endDate: '2025-12-15',
+        },
+      };
+
+      const result = generateRecurringEvents(eventForm);
+
+      expect(result).toHaveLength(3);
+      expect(result[0].date).toBe('2025-10-15');
+      expect(result[1].date).toBe('2025-11-15');
+      expect(result[2].date).toBe('2025-12-15');
+    });
+  });
+
+  describe('TC-04: 매년 반복 일정 생성 확인', () => {
+    it('반복 유형이 yearly인 경우 종료일까지 매년 일정이 생성된다', () => {
+      const eventForm: EventForm = {
+        ...baseEvent,
+        repeat: {
+          type: 'yearly',
+          interval: 1,
+          endDate: '2027-10-15',
+        },
+      };
+
+      const result = generateRecurringEvents(eventForm);
+
+      expect(result).toHaveLength(3);
+      expect(result[0].date).toBe('2025-10-15');
+      expect(result[1].date).toBe('2026-10-15');
+      expect(result[2].date).toBe('2027-10-15');
+    });
+  });
+
+  describe('TC-05: 반복 종료일 이후 일정 미생성 확인', () => {
+    it('반복 종료일 이후에는 일정이 생성되지 않는다', () => {
+      const eventForm: EventForm = {
+        ...baseEvent,
+        repeat: {
+          type: 'daily',
+          interval: 1,
+          endDate: '2025-10-17',
+        },
+      };
+
+      const result = generateRecurringEvents(eventForm);
+
+      expect(result).toHaveLength(3);
+      expect(result[0].date).toBe('2025-10-15');
+      expect(result[1].date).toBe('2025-10-16');
+      expect(result[2].date).toBe('2025-10-17');
+
+      // 종료일 이후 날짜가 포함되지 않았는지 확인
+      const allDates = result.map((e: EventForm) => e.date);
+      expect(allDates).not.toContain('2025-10-18');
+      expect(allDates).not.toContain('2025-10-19');
+    });
+  });
+});
diff --git a/src/hooks/useEventForm.ts b/src/hooks/useEventForm.ts
index 9dfcc46a..c60e043c 100644
--- a/src/hooks/useEventForm.ts
+++ b/src/hooks/useEventForm.ts
@@ -13,7 +13,9 @@ export const useEventForm = (initialEvent?: Event) => {
   const [description, setDescription] = useState(initialEvent?.description || '');
   const [location, setLocation] = useState(initialEvent?.location || '');
   const [category, setCategory] = useState(initialEvent?.category || '업무');
-  const [isRepeating, setIsRepeating] = useState(initialEvent?.repeat.type !== 'none');
+  const [isRepeating, setIsRepeating] = useState(
+    initialEvent ? initialEvent.repeat.type !== 'none' : false
+  );
   const [repeatType, setRepeatType] = useState<RepeatType>(initialEvent?.repeat.type || 'none');
   const [repeatInterval, setRepeatInterval] = useState(initialEvent?.repeat.interval || 1);
   const [repeatEndDate, setRepeatEndDate] = useState(initialEvent?.repeat.endDate || '');
diff --git a/src/hooks/useEventOperations.ts b/src/hooks/useEventOperations.ts
index 3216cc05..790d863c 100644
--- a/src/hooks/useEventOperations.ts
+++ b/src/hooks/useEventOperations.ts
@@ -2,6 +2,7 @@ import { useSnackbar } from 'notistack';
 import { useEffect, useState } from 'react';
 
 import { Event, EventForm } from '../types';
+import { generateRecurringEvents } from '../utils/eventUtils';
 
 export const useEventOperations = (editing: boolean, onSave?: () => void) => {
   const [events, setEvents] = useState<Event[]>([]);
@@ -21,6 +22,27 @@ export const useEventOperations = (editing: boolean, onSave?: () => void) => {
     }
   };
 
+  const createSingleEvent = async (eventData: EventForm) => {
+    return fetch('/api/events', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(eventData),
+    });
+  };
+
+  const createRecurringEvents = async (eventData: EventForm) => {
+    const recurringEvents = generateRecurringEvents(eventData);
+    if (recurringEvents.length > 0) {
+      return fetch('/api/events-list', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ events: recurringEvents }),
+      });
+    }
+    // 반복 일정이 생성되지 않으면 일반 일정으로 저장
+    return createSingleEvent(eventData);
+  };
+
   const saveEvent = async (eventData: Event | EventForm) => {
     try {
       let response;
@@ -31,11 +53,10 @@ export const useEventOperations = (editing: boolean, onSave?: () => void) => {
           body: JSON.stringify(eventData),
         });
       } else {
-        response = await fetch('/api/events', {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify(eventData),
-        });
+        const isRepeatingEvent = eventData.repeat.type !== 'none' && eventData.repeat.endDate;
+        response = isRepeatingEvent
+          ? await createRecurringEvents(eventData as EventForm)
+          : await createSingleEvent(eventData as EventForm);
       }
 
       if (!response.ok) {
@@ -69,6 +90,43 @@ export const useEventOperations = (editing: boolean, onSave?: () => void) => {
     }
   };
 
+  const deleteRecurringSeries = async (baseId: string) => {
+    try {
+      const response = await fetch(`/api/recurring-events/${baseId}`, { method: 'DELETE' });
+
+      if (!response.ok) {
+        throw new Error('Failed to delete recurring series');
+      }
+
+      await fetchEvents();
+      enqueueSnackbar('반복 일정이 삭제되었습니다.', { variant: 'info' });
+    } catch (error) {
+      console.error('Error deleting recurring series:', error);
+      enqueueSnackbar('일정 삭제 실패', { variant: 'error' });
+    }
+  };
+
+  const updateRecurringSeries = async (repeatId: string, eventData: Partial<Event>) => {
+    try {
+      const response = await fetch(`/api/recurring-events/${repeatId}`, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(eventData),
+      });
+
+      if (!response.ok) {
+        throw new Error('Failed to update recurring series');
+      }
+
+      await fetchEvents();
+      onSave?.();
+      enqueueSnackbar('일정이 수정되었습니다.', { variant: 'success' });
+    } catch (error) {
+      console.error('Error updating recurring series:', error);
+      enqueueSnackbar('일정 수정 실패', { variant: 'error' });
+    }
+  };
+
   async function init() {
     await fetchEvents();
     enqueueSnackbar('일정 로딩 완료!', { variant: 'info' });
@@ -79,5 +137,12 @@ export const useEventOperations = (editing: boolean, onSave?: () => void) => {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
-  return { events, fetchEvents, saveEvent, deleteEvent };
+  return {
+    events,
+    fetchEvents,
+    saveEvent,
+    deleteEvent,
+    deleteRecurringSeries,
+    updateRecurringSeries,
+  };
 };
diff --git a/src/hooks/useNotifications.ts b/src/hooks/useNotifications.ts
index f9ec573b..b5b6f459 100644
--- a/src/hooks/useNotifications.ts
+++ b/src/hooks/useNotifications.ts
@@ -29,6 +29,7 @@ export const useNotifications = (events: Event[]) => {
   useEffect(() => {
     const interval = setInterval(checkUpcomingEvents, 1000); // 1초마다 체크
     return () => clearInterval(interval);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [events, notifiedEvents]);
 
   return { notifications, notifiedEvents, setNotifications, removeNotification };
diff --git a/src/hooks/useSearch.ts b/src/hooks/useSearch.ts
index f92f7154..03ea9b48 100644
--- a/src/hooks/useSearch.ts
+++ b/src/hooks/useSearch.ts
@@ -1,7 +1,7 @@
 import { useMemo, useState } from 'react';
 
 import { Event } from '../types';
-import { getFilteredEvents } from '../utils/eventUtils';
+import { getFilteredEvents, searchOriginalEvents } from '../utils/eventUtils';
 
 export const useSearch = (events: Event[], currentDate: Date, view: 'week' | 'month') => {
   const [searchTerm, setSearchTerm] = useState('');
@@ -10,9 +10,14 @@ export const useSearch = (events: Event[], currentDate: Date, view: 'week' | 'mo
     return getFilteredEvents(events, searchTerm, currentDate, view);
   }, [events, searchTerm, currentDate, view]);
 
+  const searchedOriginalEvents = useMemo(() => {
+    return searchOriginalEvents(events, searchTerm);
+  }, [events, searchTerm]);
+
   return {
     searchTerm,
     setSearchTerm,
     filteredEvents,
+    searchedOriginalEvents,
   };
 };
diff --git a/src/utils/eventId.ts b/src/utils/eventId.ts
new file mode 100644
index 00000000..ab6e432d
--- /dev/null
+++ b/src/utils/eventId.ts
@@ -0,0 +1,9 @@
+export function getBaseId(occurrenceId: string): string {
+  if (typeof occurrenceId !== 'string') return '';
+  const idx = occurrenceId.indexOf('-');
+  return idx === -1 ? occurrenceId : occurrenceId.slice(0, idx);
+}
+
+export function getOccurrenceKeyFromParts(baseId: string, date: string): string {
+  return `${baseId}-${date}`;
+}
diff --git a/src/utils/eventList.ts b/src/utils/eventList.ts
new file mode 100644
index 00000000..5c7c930f
--- /dev/null
+++ b/src/utils/eventList.ts
@@ -0,0 +1,20 @@
+import { Event } from '../types';
+
+export function getListEvents(filteredEvents: Event[], allEvents: Event[]): Event[] {
+  const seenBaseIds = new Set<string>();
+  const results: Event[] = [];
+
+  for (const item of filteredEvents) {
+    const idStr = typeof item?.id === 'string' ? (item.id as string) : '';
+    if (!idStr) {
+      results.push(item);
+      continue;
+    }
+    const baseId = idStr.split('-')[0];
+    if (seenBaseIds.has(baseId)) continue;
+    seenBaseIds.add(baseId);
+    const original = allEvents.find((ev) => ev.id === baseId);
+    results.push(original ?? item);
+  }
+  return results;
+}
diff --git a/src/utils/eventUtils.ts b/src/utils/eventUtils.ts
index 9e75e947..60d427e7 100644
--- a/src/utils/eventUtils.ts
+++ b/src/utils/eventUtils.ts
@@ -1,12 +1,6 @@
-import { Event } from '../types';
-import { getWeekDates, isDateInRange } from './dateUtils';
-
-function filterEventsByDateRange(events: Event[], start: Date, end: Date): Event[] {
-  return events.filter((event) => {
-    const eventDate = new Date(event.date);
-    return isDateInRange(eventDate, start, end);
-  });
-}
+import { Event, EventForm } from '../types';
+import { formatDate, getWeekDates } from './dateUtils';
+import { expandEventsWithinWindow } from './recurrence';
 
 function containsTerm(target: string, term: string) {
   return target.toLowerCase().includes(term.toLowerCase());
@@ -19,23 +13,11 @@ function searchEvents(events: Event[], term: string) {
   );
 }
 
-function filterEventsByDateRangeAtWeek(events: Event[], currentDate: Date) {
-  const weekDates = getWeekDates(currentDate);
-  return filterEventsByDateRange(events, weekDates[0], weekDates[6]);
-}
-
-function filterEventsByDateRangeAtMonth(events: Event[], currentDate: Date) {
-  const monthStart = new Date(currentDate.getFullYear(), currentDate.getMonth(), 1);
-  const monthEnd = new Date(
-    currentDate.getFullYear(),
-    currentDate.getMonth() + 1,
-    0,
-    23,
-    59,
-    59,
-    999
-  );
-  return filterEventsByDateRange(events, monthStart, monthEnd);
+export function searchOriginalEvents(events: Event[], searchTerm: string): Event[] {
+  if (!searchTerm) {
+    return events;
+  }
+  return searchEvents(events, searchTerm);
 }
 
 export function getFilteredEvents(
@@ -44,15 +26,140 @@ export function getFilteredEvents(
   currentDate: Date,
   view: 'week' | 'month'
 ): Event[] {
-  const searchedEvents = searchEvents(events, searchTerm);
+  // 먼저 날짜 범위를 결정
+  let windowStart: Date;
+  let windowEnd: Date;
 
   if (view === 'week') {
-    return filterEventsByDateRangeAtWeek(searchedEvents, currentDate);
+    const weekDates = getWeekDates(currentDate);
+    windowStart = weekDates[0];
+    windowEnd = weekDates[6];
+  } else if (view === 'month') {
+    windowStart = new Date(currentDate.getFullYear(), currentDate.getMonth(), 1);
+    windowEnd = new Date(currentDate.getFullYear(), currentDate.getMonth() + 1, 0, 23, 59, 59, 999);
+  } else {
+    // view가 지정되지 않은 경우 (검색 전용)
+    const searchedEvents = searchEvents(events, searchTerm);
+    return searchedEvents;
   }
 
-  if (view === 'month') {
-    return filterEventsByDateRangeAtMonth(searchedEvents, currentDate);
-  }
+  // 반복 일정 확장
+  const expandedEvents = expandEventsWithinWindow(events, windowStart, windowEnd);
+
+  // 검색 필터링
+  const searchedEvents = searchEvents(expandedEvents, searchTerm);
 
   return searchedEvents;
 }
+
+/**
+ * 다음 반복 날짜를 계산합니다.
+ * @param currentDate 현재 날짜
+ * @param repeatType 반복 유형
+ * @param interval 반복 간격
+ * @param startDay 원본 시작일 (매월/매년 반복 시 사용)
+ * @param startMonth 원본 시작월 (매년 반복 시 사용)
+ * @returns 계산된 다음 날짜 (원본 객체 수정)
+ */
+function calculateNextRecurrenceDate(
+  currentDate: Date,
+  repeatType: 'daily' | 'weekly' | 'monthly' | 'yearly',
+  interval: number,
+  startDay?: number,
+  startMonth?: number
+): void {
+  switch (repeatType) {
+    case 'daily':
+      currentDate.setDate(currentDate.getDate() + interval);
+      break;
+    case 'weekly':
+      currentDate.setDate(currentDate.getDate() + 7 * interval);
+      break;
+    case 'monthly':
+      if (startDay !== undefined) {
+        // 원본 날짜(startDay)를 유지하며 다음 유효한 달로 이동
+        currentDate.setMonth(currentDate.getMonth() + interval);
+        // 날짜가 변경되었으면 (31일 → 28일 등) 원래 날짜로 복원 시도
+        if (currentDate.getDate() !== startDay) {
+          currentDate.setDate(startDay);
+        }
+      } else {
+        currentDate.setMonth(currentDate.getMonth() + interval);
+      }
+      break;
+    case 'yearly':
+      if (startDay !== undefined && startMonth !== undefined) {
+        // 원본 월/일을 유지하며 다음 해로 이동
+        const nextYear = currentDate.getFullYear() + interval;
+
+        // 안전한 날짜(1일)로 먼저 설정 후 연도 변경, 그 다음 원본 날짜 설정
+        currentDate.setDate(1);
+        currentDate.setFullYear(nextYear);
+        currentDate.setMonth(startMonth);
+        currentDate.setDate(startDay);
+      } else {
+        currentDate.setFullYear(currentDate.getFullYear() + interval);
+      }
+      break;
+  }
+}
+
+/**
+ * 반복 일정을 생성하여 EventForm 배열을 반환합니다.
+ * @param eventForm 기본 이벤트 정보 (반복 설정 포함)
+ * @returns 생성된 반복 일정 배열 (각 인스턴스는 baseId로 연결됨)
+ */
+export function generateRecurringEvents(
+  eventForm: EventForm
+): Array<EventForm & { baseId?: string }> {
+  const { repeat, date } = eventForm;
+
+  // 반복이 아니면 빈 배열 반환
+  if (repeat.type === 'none' || !repeat.endDate) {
+    return [];
+  }
+
+  const startDate = new Date(date);
+  const endDate = new Date(repeat.endDate);
+  const events: Array<EventForm & { baseId?: string }> = [];
+  let currentDate = new Date(startDate);
+  const startDay = startDate.getDate(); // 매월 반복 시 원본 날짜 유지용
+
+  // 시리즈 식별자 생성 (제목-시작일-종료일-타입)
+  const baseId = `${eventForm.title}-${date}-${repeat.endDate}-${repeat.type}`;
+
+  const startMonth = startDate.getMonth(); // 매년 반복 시 원본 월 유지용
+
+  while (currentDate <= endDate) {
+    const currentDateStr = formatDate(currentDate);
+
+    // 매월 반복: 원본 날짜(startDay)와 현재 날짜가 일치할 때만 추가
+    if (repeat.type === 'monthly' && currentDate.getDate() !== startDay) {
+      calculateNextRecurrenceDate(currentDate, repeat.type, repeat.interval, startDay, startMonth);
+      continue;
+    }
+
+    // 매년 반복: 원본 월/일과 현재 월/일이 모두 일치할 때만 추가
+    if (
+      repeat.type === 'yearly' &&
+      (currentDate.getMonth() !== startMonth || currentDate.getDate() !== startDay)
+    ) {
+      calculateNextRecurrenceDate(currentDate, repeat.type, repeat.interval, startDay, startMonth);
+      continue;
+    }
+
+    events.push({
+      ...eventForm,
+      date: currentDateStr,
+      repeat: {
+        ...eventForm.repeat,
+        id: baseId, // 서버가 사용할 repeat.id로 전달
+      } as typeof eventForm.repeat & { id: string },
+      baseId, // 클라이언트 편의용
+    });
+
+    calculateNextRecurrenceDate(currentDate, repeat.type, repeat.interval, startDay, startMonth);
+  }
+
+  return events;
+}
diff --git a/src/utils/recurrence.ts b/src/utils/recurrence.ts
new file mode 100644
index 00000000..e107eed7
--- /dev/null
+++ b/src/utils/recurrence.ts
@@ -0,0 +1,140 @@
+import { Event, RepeatType } from '../types';
+import { isDateInRange } from './dateUtils';
+
+const CAP_END_DATE = new Date(2025, 11, 31); // 2025-12-31
+
+function getCappedEndDate(raw: Date | null): Date | null {
+  if (!raw) return null;
+  return raw > CAP_END_DATE ? CAP_END_DATE : raw;
+}
+
+function parseYMD(dateStr: string): Date {
+  const [y, m, d] = dateStr.split('-').map((v) => Number(v));
+  return new Date(y, m - 1, d);
+}
+
+function toYMD(date: Date): string {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, '0');
+  const d = String(date.getDate()).padStart(2, '0');
+  return `${y}-${m}-${d}`;
+}
+
+export function generateOccurrencesForEvent(
+  event: Event,
+  windowStart: Date,
+  windowEnd: Date
+): Event[] {
+  const occurrences: Event[] = [];
+  const startDate = parseYMD(event.date);
+  const repeatType: RepeatType = event.repeat.type as RepeatType;
+  const interval = Math.max(1, event.repeat.interval || 1);
+  const hasEnd = Boolean(event.repeat.endDate);
+  const repeatEndDateRaw = hasEnd ? parseYMD(event.repeat.endDate as string) : null;
+  const repeatEndDate = getCappedEndDate(repeatEndDateRaw);
+
+  const maybeInclude = (occurrenceDate: Date) => {
+    if (repeatEndDate && occurrenceDate > repeatEndDate) return;
+    if (!isDateInRange(occurrenceDate, windowStart, windowEnd)) return;
+    const cloned: Event = {
+      ...event,
+      id: `${event.id ?? event.title}-${toYMD(occurrenceDate)}`,
+      date: toYMD(occurrenceDate),
+    };
+    occurrences.push(cloned);
+  };
+
+  if (repeatType === 'daily') {
+    for (
+      let d = new Date(startDate);
+      d <= windowEnd;
+      d = new Date(d.getFullYear(), d.getMonth(), d.getDate() + interval)
+    ) {
+      if (d < windowStart) continue;
+      if (repeatEndDate && d > repeatEndDate) break;
+      maybeInclude(d);
+    }
+    return occurrences;
+  }
+
+  if (repeatType === 'weekly') {
+    for (
+      let d = new Date(startDate);
+      d <= windowEnd;
+      d = new Date(d.getFullYear(), d.getMonth(), d.getDate() + 7 * interval)
+    ) {
+      if (d < windowStart) continue;
+      if (repeatEndDate && d > repeatEndDate) break;
+      maybeInclude(d);
+    }
+    return occurrences;
+  }
+
+  if (repeatType === 'monthly') {
+    const startDay = startDate.getDate();
+    for (let y = startDate.getFullYear(), m = startDate.getMonth(); ; ) {
+      const candidate = new Date(y, m, startDay);
+      if (candidate > windowEnd) break;
+      if (repeatEndDate && candidate > repeatEndDate) break;
+
+      if (candidate.getDate() === startDay && candidate.getMonth() === m) {
+        if (candidate >= windowStart) maybeInclude(candidate);
+      }
+
+      m += interval;
+      while (m > 11) {
+        m -= 12;
+        y += 1;
+      }
+    }
+    return occurrences;
+  }
+
+  if (repeatType === 'yearly') {
+    const month = startDate.getMonth();
+    const day = startDate.getDate();
+    for (let y = startDate.getFullYear(); ; y += interval) {
+      const candidate = new Date(y, month, day);
+      if (candidate > windowEnd) break;
+      if (repeatEndDate && candidate > repeatEndDate) break;
+
+      if (candidate.getMonth() === month && candidate.getDate() === day) {
+        if (candidate >= windowStart) maybeInclude(candidate);
+      }
+    }
+    return occurrences;
+  }
+
+  return occurrences;
+}
+
+export function expandEventsWithinWindow(
+  events: Event[],
+  windowStart: Date,
+  windowEnd: Date
+): Event[] {
+  const expanded: Event[] = [];
+  for (const event of events) {
+    if (event.repeat.type === 'none') {
+      const eventDate = new Date(event.date);
+      if (isDateInRange(eventDate, windowStart, windowEnd)) {
+        expanded.push(event);
+      }
+      continue;
+    }
+
+    // baseId가 있는 경우 이미 생성된 반복 인스턴스로 간주 (확장 안 함)
+    const eventWithBase = event as Event & { baseId?: string };
+    if (eventWithBase.baseId) {
+      const eventDate = new Date(event.date);
+      if (isDateInRange(eventDate, windowStart, windowEnd)) {
+        expanded.push(event);
+      }
+      continue;
+    }
+
+    const occurrences = generateOccurrencesForEvent(event, windowStart, windowEnd);
+    expanded.push(...occurrences);
+  }
+  return expanded;
+}