diff --git a/server.js b/server.js
index ec83fbad..8b191b13 100644
--- a/server.js
+++ b/server.js
@@ -38,7 +38,7 @@ app.post('/api/events', async (req, res) => {
 
 app.put('/api/events/:id', async (req, res) => {
   const events = await getEvents();
-  const { id } = req.params;
+  const id = req.params.id;
   const eventIndex = events.events.findIndex((event) => event.id === id);
   if (eventIndex > -1) {
     const newEvents = [...events.events];
@@ -59,7 +59,7 @@ app.put('/api/events/:id', async (req, res) => {
 
 app.delete('/api/events/:id', async (req, res) => {
   const events = await getEvents();
-  const { id } = req.params;
+  const id = req.params.id;
 
   fs.writeFileSync(
     `${__dirname}/src/__mocks__/response/realEvents.json`,
@@ -71,6 +71,72 @@ app.delete('/api/events/:id', async (req, res) => {
   res.status(204).send();
 });
 
+app.post('/api/events-list', async (req, res) => {
+  const events = await getEvents();
+  const repeatId = randomUUID();
+  const newEvents = req.body.events.map((event) => {
+    const isRepeatEvent = event.repeat.type !== 'none';
+    return {
+      id: randomUUID(),
+      ...event,
+      repeat: {
+        ...event.repeat,
+        id: isRepeatEvent ? repeatId : undefined,
+      },
+    };
+  });
+
+  fs.writeFileSync(
+    `${__dirname}/src/__mocks__/response/realEvents.json`,
+    JSON.stringify({
+      events: [...events.events, ...newEvents],
+    })
+  );
+
+  res.status(201).json(newEvents);
+});
+
+app.put('/api/events-list', async (req, res) => {
+  const events = await getEvents();
+  let isUpdated = false;
+
+  const newEvents = [...events.events];
+  req.body.events.forEach((event) => {
+    const eventIndex = events.events.findIndex((target) => target.id === event.id);
+    if (eventIndex > -1) {
+      isUpdated = true;
+      newEvents[eventIndex] = { ...events.events[eventIndex], ...event };
+    }
+  });
+
+  if (isUpdated) {
+    fs.writeFileSync(
+      `${__dirname}/src/__mocks__/response/realEvents.json`,
+      JSON.stringify({
+        events: newEvents,
+      })
+    );
+
+    res.json(events.events);
+  } else {
+    res.status(404).send('Event not found');
+  }
+});
+
+app.delete('/api/events-list', async (req, res) => {
+  const events = await getEvents();
+  const newEvents = events.events.filter((event) => !req.body.eventIds.includes(event.id)); // ? ids를 전달하면 해당 아이디를 기준으로 events에서 제거
+
+  fs.writeFileSync(
+    `${__dirname}/src/__mocks__/response/realEvents.json`,
+    JSON.stringify({
+      events: newEvents,
+    })
+  );
+
+  res.status(204).send();
+});
+
 app.listen(port, () => {
   console.log(`Server running at http://localhost:${port}`);
 });
diff --git a/src/App.tsx b/src/App.tsx
index 195c5b05..a9ec8294 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -30,13 +30,13 @@ import {
 import { useSnackbar } from 'notistack';
 import { useState } from 'react';
 
+import { RepeatEventIcon } from './components/RepeatEventIcon';
 import { useCalendarView } from './hooks/useCalendarView.ts';
 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,
@@ -46,6 +46,7 @@ import {
   getWeeksAtMonth,
 } from './utils/dateUtils';
 import { findOverlappingEvents } from './utils/eventOverlap';
+import { getRepeatDisplayInfo } from './utils/eventStateUtils';
 import { getTimeErrorMessage } from './utils/timeValidation';
 
 const categories = ['업무', '개인', '가족', '기타'];
@@ -77,11 +78,11 @@ function App() {
     isRepeating,
     setIsRepeating,
     repeatType,
-    // setRepeatType,
+    setRepeatType,
     repeatInterval,
-    // setRepeatInterval,
+    setRepeatInterval,
     repeatEndDate,
-    // setRepeatEndDate,
+    setRepeatEndDate,
     notificationTime,
     setNotificationTime,
     startTimeError,
@@ -201,6 +202,11 @@ function App() {
                           >
                             <Stack direction="row" spacing={1} alignItems="center">
                               {isNotified && <Notifications fontSize="small" />}
+                              <RepeatEventIcon
+                                repeatType={event.repeat.type}
+                                interval={event.repeat.interval}
+                                endDate={event.repeat.endDate}
+                              />
                               <Typography
                                 variant="caption"
                                 noWrap
@@ -288,6 +294,11 @@ function App() {
                                 >
                                   <Stack direction="row" spacing={1} alignItems="center">
                                     {isNotified && <Notifications fontSize="small" />}
+                                    <RepeatEventIcon
+                                      repeatType={event.repeat.type}
+                                      interval={event.repeat.interval}
+                                      endDate={event.repeat.endDate}
+                                    />
                                     <Typography
                                       variant="caption"
                                       noWrap
@@ -437,12 +448,12 @@ 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)}
@@ -455,8 +466,9 @@ function App() {
               </FormControl>
               <Stack direction="row" spacing={2}>
                 <FormControl fullWidth>
-                  <FormLabel>반복 간격</FormLabel>
+                  <FormLabel htmlFor="repeat-interval">반복 간격</FormLabel>
                   <TextField
+                    id="repeat-interval"
                     size="small"
                     type="number"
                     value={repeatInterval}
@@ -465,8 +477,9 @@ function App() {
                   />
                 </FormControl>
                 <FormControl fullWidth>
-                  <FormLabel>반복 종료일</FormLabel>
+                  <FormLabel htmlFor="repeat-end-date">반복 종료일</FormLabel>
                   <TextField
+                    id="repeat-end-date"
                     size="small"
                     type="date"
                     value={repeatEndDate}
@@ -475,7 +488,7 @@ function App() {
                 </FormControl>
               </Stack>
             </Stack>
-          )} */}
+          )}
 
           <Button
             data-testid="event-submit-button"
@@ -557,12 +570,7 @@ function App() {
                     <Typography>카테고리: {event.category}</Typography>
                     {event.repeat.type !== 'none' && (
                       <Typography>
-                        반복: {event.repeat.interval}
-                        {event.repeat.type === 'daily' && '일'}
-                        {event.repeat.type === 'weekly' && '주'}
-                        {event.repeat.type === 'monthly' && '월'}
-                        {event.repeat.type === 'yearly' && '년'}
-                        마다
+                        반복: {getRepeatDisplayInfo(event).repeatText}
                         {event.repeat.endDate && ` (종료: ${event.repeat.endDate})`}
                       </Typography>
                     )}
diff --git a/src/__tests__/medium.integration.spec.tsx b/src/__tests__/medium.integration.spec.tsx
index 788dae14..8154475b 100644
--- a/src/__tests__/medium.integration.spec.tsx
+++ b/src/__tests__/medium.integration.spec.tsx
@@ -340,3 +340,108 @@ it('notificationTime을 10으로 하면 지정 시간 10분 전 알람 텍스트
 
   expect(screen.getByText('10분 후 기존 회의 일정이 시작됩니다.')).toBeInTheDocument();
 });
+
+describe('반복 일정 통합 기능', () => {
+  it('반복 일정 체크박스가 존재한다', async () => {
+    setup(<App />);
+
+    // 반복 일정 체크박스가 존재해야 함
+    expect(screen.getByLabelText('반복 일정')).toBeInTheDocument();
+  });
+
+  it('반복 일정 체크박스 클릭 후 상태를 확인한다', async () => {
+    const { user } = setup(<App />);
+
+    // 반복 일정 체크박스 클릭
+    const repeatCheckbox = screen.getByLabelText('반복 일정');
+    expect(repeatCheckbox).toBeInTheDocument();
+
+    // 클릭 전 상태 확인
+    expect(repeatCheckbox).not.toBeChecked();
+
+    // 클릭
+    await user.click(repeatCheckbox);
+
+    // 클릭 후 상태 확인
+    expect(repeatCheckbox).toBeChecked();
+
+    // 현재 DOM 상태 출력 (디버깅용)
+    console.log('Current DOM after checkbox click:', document.body.innerHTML);
+  });
+
+  it('반복 일정 체크박스를 클릭하면 반복 설정 UI가 표시된다', async () => {
+    const { user } = setup(<App />);
+
+    // 반복 일정 체크박스 클릭
+    await user.click(screen.getByLabelText('반복 일정'));
+
+    // 반복 유형 선택 UI가 표시되어야 함
+    expect(screen.getByText('반복 유형')).toBeInTheDocument();
+    expect(screen.getByText('반복 간격')).toBeInTheDocument();
+    expect(screen.getByText('반복 종료일')).toBeInTheDocument();
+  });
+
+  it('매일 반복 일정을 생성할 수 있다', async () => {
+    server.resetHandlers();
+
+    // 기존 이벤트가 있는 상태에서 시작 (현재 시스템 시간과 일치하는 날짜 사용)
+    const initialEvents = [
+      {
+        id: '1',
+        title: '기존 일정',
+        date: '2025-10-01', // 현재 시스템 시간과 일치
+        startTime: '09:00',
+        endTime: '10:00',
+        description: '기존 일정입니다',
+        location: '회의실',
+        category: '업무',
+        repeat: { type: 'none' as const, interval: 0 },
+        notificationTime: 10,
+      },
+    ];
+
+    setupMockHandlerCreation(initialEvents);
+
+    const { user } = setup(<App />);
+
+    // 기존 이벤트가 표시되는지 확인 (이벤트 리스트에서)
+    const eventListContainer = within(screen.getByTestId('event-list'));
+    await eventListContainer.findByText('기존 일정');
+    // 반복 일정 생성
+    await user.click(screen.getAllByText('일정 추가')[0]);
+
+    await user.type(screen.getByLabelText('제목'), '매일 운동');
+    await user.type(screen.getByLabelText('날짜'), '2025-10-01'); // 현재 시스템 시간과 일치
+    await user.type(screen.getByLabelText('시작 시간'), '06:00');
+    await user.type(screen.getByLabelText('종료 시간'), '07:00');
+    await user.type(screen.getByLabelText('설명'), '매일 아침 운동');
+    await user.type(screen.getByLabelText('위치'), '집');
+    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('반복 일정'));
+
+    // 반복 유형 선택: Select 클릭 후 옵션 선택
+    const repeatTypeSelect = screen
+      .getByText('반복 유형')
+      .closest('.MuiFormControl-root')
+      ?.querySelector('[role="combobox"]');
+    if (repeatTypeSelect) {
+      await user.click(repeatTypeSelect);
+      // 옵션이 나타날 때까지 대기
+      await screen.findByRole('option', { name: '매일' });
+      await user.click(screen.getByRole('option', { name: '매일' }));
+    }
+
+    await user.type(screen.getByLabelText('반복 종료일'), '2025-10-05'); // 현재 시스템 시간과 일치
+    await user.click(screen.getByTestId('event-submit-button'));
+
+    // 이벤트 리스트에서 반복 정보 확인
+    const eventList = within(screen.getByTestId('event-list'));
+    expect(eventList.getByText('매일 운동')).toBeInTheDocument();
+    expect(eventList.getByText(/반복: 1일마다/)).toBeInTheDocument();
+    expect(eventList.getByText(/종료: 2025-10-05/)).toBeInTheDocument();
+  });
+});
diff --git a/src/__tests__/unit/eventStateUtils.spec.ts b/src/__tests__/unit/eventStateUtils.spec.ts
new file mode 100644
index 00000000..07e200a9
--- /dev/null
+++ b/src/__tests__/unit/eventStateUtils.spec.ts
@@ -0,0 +1,60 @@
+import {
+  getRepeatingEvents,
+  groupEventsByRepeatType,
+  isRepeatingEvent,
+  getRepeatDisplayInfo,
+} from '../../utils/eventStateUtils';
+import { createEvent } from '../../utils/eventUtils';
+
+describe('반복 일정 판별 함수 테스트', () => {
+  it('반복 일정을 올바르게 판별한다', () => {
+    const repeatingEvent = createEvent('repeating', 'weekly', 1);
+    const singleEvent = createEvent('single', 'none', 1);
+
+    expect(isRepeatingEvent(repeatingEvent)).toBe(true);
+    expect(isRepeatingEvent(singleEvent)).toBe(false);
+  });
+
+  it('반복 일정 표시 정보를 올바르게 생성한다', () => {
+    const weeklyEvent = createEvent('repeating', 'weekly', 2);
+    const result = getRepeatDisplayInfo(weeklyEvent);
+
+    expect(result.isRepeating).toBe(true);
+    expect(result.repeatText).toBe('2주마다');
+    expect(result.shouldShowIcon).toBe(true);
+  });
+
+  it('단일 일정의 경우 아이콘을 표시하지 않는다', () => {
+    const singleEvent = createEvent('single', 'none', 1);
+    const result = getRepeatDisplayInfo(singleEvent);
+
+    expect(result.isRepeating).toBe(false);
+    expect(result.repeatText).toBe('');
+    expect(result.shouldShowIcon).toBe(false);
+  });
+});
+
+describe('반복 일정 필터링 함수 테스트', () => {
+  it('반복 일정만 필터링한다', () => {
+    const events = [
+      createEvent('repeating', 'weekly', 1),
+      createEvent('single', 'none', 1),
+      createEvent('repeating', 'monthly', 1),
+    ];
+
+    const repeatingEvents = getRepeatingEvents(events);
+    expect(repeatingEvents).toHaveLength(2);
+  });
+
+  it('반복 유형별로 일정을 그룹화한다', () => {
+    const events = [
+      createEvent('repeating', 'weekly', 1),
+      createEvent('repeating', 'monthly', 1),
+      createEvent('repeating', 'weekly', 2),
+    ];
+
+    const groups = groupEventsByRepeatType(events);
+    expect(groups.weekly).toHaveLength(2);
+    expect(groups.monthly).toHaveLength(1);
+  });
+});
diff --git a/src/__tests__/unit/eventUpdateUtils.spec.ts b/src/__tests__/unit/eventUpdateUtils.spec.ts
new file mode 100644
index 00000000..e352e561
--- /dev/null
+++ b/src/__tests__/unit/eventUpdateUtils.spec.ts
@@ -0,0 +1,77 @@
+import { updateEventRepeat } from '../../utils/eventUpdateUtils';
+import { createEvent } from '../../utils/eventUtils';
+
+describe('이벤트 반복 설정 업데이트 유틸리티 테스트', () => {
+  describe('핵심 기능', () => {
+    it('반복 일정을 단일 일정으로 변환한다', () => {
+      const weeklyEvent = createEvent('repeating', 'weekly', 1);
+      const updatedEvent = updateEventRepeat(weeklyEvent, { type: 'none', interval: 1 });
+
+      expect(updatedEvent.repeat.type).toBe('none');
+      expect(updatedEvent.repeat.interval).toBe(1);
+      expect(updatedEvent.repeat.endDate).toBeUndefined();
+    });
+
+    it('단일 일정을 반복 일정으로 변환한다', () => {
+      const singleEvent = createEvent('single', 'none', 1);
+      const updatedEvent = updateEventRepeat(singleEvent, { type: 'weekly', interval: 2 });
+
+      expect(updatedEvent.repeat.type).toBe('weekly');
+      expect(updatedEvent.repeat.interval).toBe(2);
+    });
+
+    it('다양한 반복 유형으로 변환한다', () => {
+      const singleEvent = createEvent('single', 'none', 1);
+      const types = ['daily', 'weekly', 'monthly', 'yearly'] as const;
+
+      types.forEach((type) => {
+        const updatedEvent = updateEventRepeat(singleEvent, { type, interval: 1 });
+        expect(updatedEvent.repeat.type).toBe(type);
+        expect(updatedEvent.repeat.interval).toBe(1);
+      });
+    });
+  });
+
+  describe('데이터 무결성', () => {
+    it('원본 객체를 변경하지 않는다 (불변성)', () => {
+      const originalEvent = createEvent('repeating', 'weekly', 1);
+      const originalRepeat = { ...originalEvent.repeat };
+
+      updateEventRepeat(originalEvent, { type: 'none', interval: 1 });
+
+      expect(originalEvent.repeat).toEqual(originalRepeat);
+    });
+
+    it('다른 필드들이 보존된다', () => {
+      const event = createEvent('repeating', 'weekly', 2);
+      const updatedEvent = updateEventRepeat(event, { type: 'none', interval: 1 });
+
+      expect(updatedEvent.title).toBe('Repeating Event weekly 2');
+      expect(updatedEvent.date).toBe('2025-01-01');
+      expect(updatedEvent.startTime).toBe('09:00');
+      expect(updatedEvent.endTime).toBe('10:00');
+      expect(updatedEvent.description).toBe('');
+      expect(updatedEvent.location).toBe('');
+      expect(updatedEvent.category).toBe('업무');
+      expect(updatedEvent.notificationTime).toBe(0);
+    });
+  });
+
+  describe('엣지 케이스', () => {
+    it('이미 단일 일정인 경우에도 안전하게 처리한다', () => {
+      const singleEvent = createEvent('single', 'none', 1);
+      const updatedEvent = updateEventRepeat(singleEvent, { type: 'none', interval: 1 });
+
+      expect(updatedEvent.repeat.type).toBe('none');
+      expect(updatedEvent.repeat.interval).toBe(1);
+    });
+
+    it('동일한 반복 설정으로 업데이트해도 안전하게 처리한다', () => {
+      const weeklyEvent = createEvent('repeating', 'weekly', 1);
+      const updatedEvent = updateEventRepeat(weeklyEvent, { type: 'weekly', interval: 1 });
+
+      expect(updatedEvent.repeat.type).toBe('weekly');
+      expect(updatedEvent.repeat.interval).toBe(1);
+    });
+  });
+});
diff --git a/src/__tests__/unit/repeatEndCondition.spec.ts b/src/__tests__/unit/repeatEndCondition.spec.ts
new file mode 100644
index 00000000..8c912645
--- /dev/null
+++ b/src/__tests__/unit/repeatEndCondition.spec.ts
@@ -0,0 +1,69 @@
+import { generateRepeatDates } from '../../utils/repeatEventUtils';
+
+describe('반복 종료 테스트', () => {
+  it('반복 종료 조건을 지정할 수 있다', () => {
+    // Given: 반복 종료 조건을 지정하는 경우
+    const event = {
+      date: '2025-01-01',
+      repeatType: 'weekly' as const,
+      interval: 1,
+      endDate: '2025-02-26',
+    };
+
+    // When: 반복 종료 조건을 지정할 때
+    const repeatDates = generateRepeatDates(event);
+
+    // Then: 반복 종료 조건이 적용되어야 한다
+    expect(repeatDates).toEqual([
+      '2025-01-01',
+      '2025-01-08',
+      '2025-01-15',
+      '2025-01-22',
+      '2025-01-29',
+      '2025-02-05',
+      '2025-02-12',
+      '2025-02-19',
+      '2025-02-26',
+    ]);
+  });
+
+  it('특정 날짜까지 반복 일정을 생성한다', () => {
+    // Given: 특정 날짜까지 반복 일정을 생성하는 경우
+    const event = {
+      date: '2025-01-31',
+      repeatType: 'monthly' as const,
+      interval: 1,
+      endDate: '2025-08-31',
+    };
+
+    // When: 특정 날짜까지 반복 일정을 생성할 때
+    const repeatDates = generateRepeatDates(event);
+
+    // Then: 특정 날짜까지 반복 일정이 생성되어야 한다
+    expect(repeatDates).toEqual([
+      '2025-01-31',
+      '2025-03-31',
+      '2025-05-31',
+      '2025-07-31',
+      '2025-08-31',
+    ]);
+  });
+
+  it('2025-10-30까지 최대 일자를 생성한다', () => {
+    // Given: 2025-10-30까지 최대 일자를 생성하는 경우
+    const event = {
+      date: '2025-01-01',
+      repeatType: 'daily' as const,
+      interval: 1,
+      endDate: '2025-10-30',
+    };
+
+    // When: 2025-10-30까지 최대 일자를 생성할 때
+    const repeatDates = generateRepeatDates(event);
+
+    // Then: 2025-10-30까지 최대 일자가 생성되어야 한다
+    expect(repeatDates.length).toBe(303); // 1월 1일부터 10월 30일까지 총 303일
+    expect(repeatDates[0]).toBe('2025-01-01'); // 시작일
+    expect(repeatDates[repeatDates.length - 1]).toBe('2025-10-30'); // 종료일
+  });
+});
diff --git a/src/__tests__/unit/repeatEventGeneration.spec.ts b/src/__tests__/unit/repeatEventGeneration.spec.ts
new file mode 100644
index 00000000..db261702
--- /dev/null
+++ b/src/__tests__/unit/repeatEventGeneration.spec.ts
@@ -0,0 +1,228 @@
+import { describe, it, expect } from 'vitest';
+
+import { Event } from '../../types';
+import { generateRepeatDates } from '../../utils/repeatEventUtils';
+
+describe('반복 일정 생성 및 관리 기능', () => {
+  describe('반복 일정 실제 생성', () => {
+    it('매일 반복 일정을 생성할 수 있다', () => {
+      // Given: 매일 반복하는 일정 설정
+      const eventData = {
+        date: '2025-01-01',
+        repeatType: 'daily' as const,
+        interval: 1,
+        endDate: '2025-01-05',
+      };
+
+      // When: 반복 날짜 생성
+      const repeatDates = generateRepeatDates(eventData);
+
+      // Then: 5일간의 반복 날짜가 생성되어야 함
+      expect(repeatDates).toHaveLength(5);
+      expect(repeatDates).toEqual([
+        '2025-01-01',
+        '2025-01-02',
+        '2025-01-03',
+        '2025-01-04',
+        '2025-01-05',
+      ]);
+    });
+
+    it('매주 반복 일정을 생성할 수 있다', () => {
+      // Given: 매주 반복하는 일정 설정
+      const eventData = {
+        date: '2025-01-01',
+        repeatType: 'weekly' as const,
+        interval: 1,
+        endDate: '2025-01-29',
+      };
+
+      // When: 반복 날짜 생성
+      const repeatDates = generateRepeatDates(eventData);
+
+      // Then: 5주간의 반복 날짜가 생성되어야 함
+      expect(repeatDates).toHaveLength(5);
+      expect(repeatDates[0]).toBe('2025-01-01');
+      expect(repeatDates[1]).toBe('2025-01-08');
+      expect(repeatDates[2]).toBe('2025-01-15');
+      expect(repeatDates[3]).toBe('2025-01-22');
+      expect(repeatDates[4]).toBe('2025-01-29');
+    });
+
+    it('매월 반복 일정을 생성할 수 있다', () => {
+      // Given: 매월 반복하는 일정 설정 (1월 31일)
+      const eventData = {
+        date: '2025-01-31',
+        repeatType: 'monthly' as const,
+        interval: 1,
+        endDate: '2025-08-31',
+      };
+
+      // When: 반복 날짜 생성
+      const repeatDates = generateRepeatDates(eventData);
+
+      // Then: 31일이 있는 달에만 생성되어야 함 (2월, 4월, 6월은 건너뛰기)
+      expect(repeatDates).toHaveLength(5);
+      expect(repeatDates[0]).toBe('2025-01-31');
+      expect(repeatDates[1]).toBe('2025-03-31'); // 2월 건너뛰기
+      expect(repeatDates[2]).toBe('2025-05-31'); // 4월 건너뛰기
+      expect(repeatDates[3]).toBe('2025-07-31'); // 6월 건너뛰기
+      expect(repeatDates[4]).toBe('2025-08-31');
+    });
+
+    it('매년 반복 일정을 생성할 수 있다', () => {
+      // Given: 매년 반복하는 일정 설정 (2월 29일)
+      const eventData = {
+        date: '2024-02-29', // 윤년
+        repeatType: 'yearly' as const,
+        interval: 1,
+        endDate: '2028-02-29',
+      };
+
+      // When: 반복 날짜 생성
+      const repeatDates = generateRepeatDates(eventData);
+
+      // Then: 2월 29일이 있는 해(윤년)에만 생성되어야 함
+      expect(repeatDates).toHaveLength(2);
+      expect(repeatDates[0]).toBe('2024-02-29'); // 2024년 (윤년)
+      expect(repeatDates[1]).toBe('2028-02-29'); // 2028년 (윤년)
+      // 2025, 2026, 2027년은 2월 29일이 없으므로 건너뛰기
+    });
+  });
+
+  describe('반복 일정 저장 및 관리', () => {
+    it('생성된 반복 일정들을 저장할 수 있다', () => {
+      // Given: 반복 일정 생성 데이터
+      const baseEvent: Event = {
+        id: '1',
+        title: '팀 미팅',
+        date: '2025-01-01',
+        startTime: '09:00',
+        endTime: '10:00',
+        description: '주간 팀 미팅',
+        location: '회의실 A',
+        category: '업무',
+        repeat: { type: 'weekly', interval: 1, endDate: '2025-01-29' },
+        notificationTime: 10,
+      };
+
+      // When: 반복 일정들을 생성하여 저장
+      const repeatDates = generateRepeatDates({
+        date: baseEvent.date,
+        repeatType: baseEvent.repeat.type,
+        interval: baseEvent.repeat.interval,
+        endDate: baseEvent.repeat.endDate!,
+      });
+
+      const repeatEvents = repeatDates.map((date, index) => ({
+        ...baseEvent,
+        id: `${baseEvent.id}-${index + 1}`,
+        date,
+      }));
+
+      // Then: 모든 반복 일정이 생성되어야 함
+      expect(repeatEvents).toHaveLength(5);
+      expect(repeatEvents[0].date).toBe('2025-01-01');
+      expect(repeatEvents[1].date).toBe('2025-01-08');
+      expect(repeatEvents[2].date).toBe('2025-01-15');
+      expect(repeatEvents[3].date).toBe('2025-01-22');
+      expect(repeatEvents[4].date).toBe('2025-01-29');
+    });
+
+    it('반복 일정 중 특정 일정만 수정할 수 있다', () => {
+      // Given: 반복 일정들
+      const repeatEvents: Event[] = [
+        {
+          id: '1-1',
+          title: '팀 미팅',
+          date: '2025-01-01',
+          startTime: '09:00',
+          endTime: '10:00',
+          description: '주간 팀 미팅',
+          location: '회의실 A',
+          category: '업무',
+          repeat: { type: 'weekly', interval: 1, endDate: '2025-01-29' },
+          notificationTime: 10,
+        },
+        {
+          id: '1-2',
+          title: '팀 미팅',
+          date: '2025-01-08',
+          startTime: '09:00',
+          endTime: '10:00',
+          description: '주간 팀 미팅',
+          location: '회의실 A',
+          category: '업무',
+          repeat: { type: 'weekly', interval: 1, endDate: '2025-01-29' },
+          notificationTime: 10,
+        },
+      ];
+
+      // When: 두 번째 일정만 수정
+      const editedEvent: Event = {
+        ...repeatEvents[1],
+        title: '팀 미팅 (수정됨)',
+        startTime: '10:00',
+        endTime: '11:00',
+        repeat: { type: 'none', interval: 1, endDate: undefined },
+      };
+
+      // Then: 수정된 일정은 단일 일정이 되어야 함
+      expect(editedEvent.repeat.type).toBe('none');
+      expect(editedEvent.title).toBe('팀 미팅 (수정됨)');
+      expect(editedEvent.startTime).toBe('10:00');
+      expect(editedEvent.endTime).toBe('11:00');
+    });
+
+    it('반복 일정 중 특정 일정만 삭제할 수 있다', () => {
+      // Given: 반복 일정들
+      const repeatEvents: Event[] = [
+        {
+          id: '1-1',
+          title: '팀 미팅',
+          date: '2025-01-01',
+          startTime: '09:00',
+          endTime: '10:00',
+          description: '주간 팀 미팅',
+          location: '회의실 A',
+          category: '업무',
+          repeat: { type: 'weekly', interval: 1, endDate: '2025-01-29' },
+          notificationTime: 10,
+        },
+        {
+          id: '1-2',
+          title: '팀 미팅',
+          date: '2025-01-08',
+          startTime: '09:00',
+          endTime: '10:00',
+          description: '주간 팀 미팅',
+          location: '회의실 A',
+          category: '업무',
+          repeat: { type: 'weekly', interval: 1, endDate: '2025-01-29' },
+          notificationTime: 10,
+        },
+        {
+          id: '1-3',
+          title: '팀 미팅',
+          date: '2025-01-15',
+          startTime: '09:00',
+          endTime: '10:00',
+          description: '주간 팀 미팅',
+          location: '회의실 A',
+          category: '업무',
+          repeat: { type: 'weekly', interval: 1, endDate: '2025-01-29' },
+          notificationTime: 10,
+        },
+      ];
+
+      // When: 두 번째 일정만 삭제
+      const remainingEvents = repeatEvents.filter((event) => event.id !== '1-2');
+
+      // Then: 삭제된 일정을 제외한 나머지만 남아야 함
+      expect(remainingEvents).toHaveLength(2);
+      expect(remainingEvents[0].id).toBe('1-1');
+      expect(remainingEvents[1].id).toBe('1-3');
+      expect(remainingEvents.find((event) => event.id === '1-2')).toBeUndefined();
+    });
+  });
+});
diff --git a/src/__tests__/unit/repeatEventSelection.spec.ts b/src/__tests__/unit/repeatEventSelection.spec.ts
new file mode 100644
index 00000000..875006d8
--- /dev/null
+++ b/src/__tests__/unit/repeatEventSelection.spec.ts
@@ -0,0 +1,111 @@
+import { describe, it, expect } from 'vitest';
+
+import { RepeatType } from '../../types';
+
+describe('반복 유형 선택 기능', () => {
+  describe('반복 유형 옵션', () => {
+    it('매일 반복을 선택할 수 있다', () => {
+      // Given: 반복 일정 체크박스가 체크된 상태
+      const isRepeating = true;
+
+      // When: 매일 반복을 선택
+      const selectedRepeatType: RepeatType = 'daily';
+
+      // Then: 매일 반복이 선택되어야 함
+      expect(selectedRepeatType).toBe('daily');
+      expect(isRepeating).toBe(true);
+    });
+
+    it('매주 반복을 선택할 수 있다', () => {
+      // Given: 반복 일정 체크박스가 체크된 상태
+      const isRepeating = true;
+
+      // When: 매주 반복을 선택
+      const selectedRepeatType: RepeatType = 'weekly';
+
+      // Then: 매주 반복이 선택되어야 함
+      expect(selectedRepeatType).toBe('weekly');
+      expect(isRepeating).toBe(true);
+    });
+
+    it('매월 반복을 선택할 수 있다', () => {
+      // Given: 반복 일정 체크박스가 체크된 상태
+      const isRepeating = true;
+
+      // When: 매월 반복을 선택
+      const selectedRepeatType: RepeatType = 'monthly';
+
+      // Then: 매월 반복이 선택되어야 함
+      expect(selectedRepeatType).toBe('monthly');
+      expect(isRepeating).toBe(true);
+    });
+
+    it('매년 반복을 선택할 수 있다', () => {
+      // Given: 반복 일정 체크박스가 체크된 상태
+      const isRepeating = true;
+
+      // When: 매년 반복을 선택
+      const selectedRepeatType: RepeatType = 'yearly';
+
+      // Then: 매년 반복이 선택되어야 함
+      expect(selectedRepeatType).toBe('yearly');
+      expect(isRepeating).toBe(true);
+    });
+  });
+
+  describe('반복 간격 설정', () => {
+    it('반복 간격을 설정할 수 있다', () => {
+      // Given: 반복 일정이 활성화된 상태
+      const isRepeating = true;
+      const repeatType: RepeatType = 'weekly';
+
+      // When: 반복 간격을 2로 설정
+      const repeatInterval = 2;
+
+      // Then: 반복 간격이 2로 설정되어야 함
+      expect(repeatInterval).toBe(2);
+      expect(isRepeating).toBe(true);
+      expect(repeatType).toBe('weekly');
+    });
+
+    it('반복 간격은 최소 1 이상이어야 한다', () => {
+      // Given: 반복 일정이 활성화된 상태
+      const isRepeating = true;
+
+      // When: 반복 간격을 1로 설정
+      const repeatInterval = 1;
+
+      // Then: 반복 간격이 1 이상이어야 함
+      expect(repeatInterval).toBeGreaterThanOrEqual(1);
+      expect(isRepeating).toBe(true);
+    });
+  });
+
+  describe('반복 종료일 설정', () => {
+    it('반복 종료일을 설정할 수 있다', () => {
+      // Given: 반복 일정이 활성화된 상태
+      const isRepeating = true;
+      const repeatType: RepeatType = 'monthly';
+
+      // When: 반복 종료일을 2025-10-30으로 설정
+      const repeatEndDate = '2025-10-30';
+
+      // Then: 반복 종료일이 설정되어야 함
+      expect(repeatEndDate).toBe('2025-10-30');
+      expect(isRepeating).toBe(true);
+      expect(repeatType).toBe('monthly');
+    });
+
+    it('반복 종료일이 없을 수도 있다', () => {
+      // Given: 반복 일정이 활성화된 상태
+      const isRepeating = true;
+
+      // When: 반복 종료일을 설정하지 않음
+      const repeatEndDate = undefined;
+
+      // Then: 반복 종료일이 undefined일 수 있어야 함
+      expect(repeatEndDate).toBeUndefined();
+      expect(isRepeating).toBe(true);
+    });
+  });
+});
diff --git a/src/__tests__/unit/repeatEventSingleDelete.spec.ts b/src/__tests__/unit/repeatEventSingleDelete.spec.ts
new file mode 100644
index 00000000..17fbfd87
--- /dev/null
+++ b/src/__tests__/unit/repeatEventSingleDelete.spec.ts
@@ -0,0 +1,292 @@
+import { describe, it, expect } from 'vitest';
+
+import { Event } from '../../types';
+import { deleteSingleRepeatEvent, isRepeatEvent } from '../../utils/repeatEventUtils';
+
+describe('반복 일정 단일 삭제 기능', () => {
+  describe('단일 삭제 시 특정 일정만 삭제', () => {
+    it('반복 일정 중 특정 일정만 삭제할 수 있다', () => {
+      // Given: 매주 반복하는 일정들
+      const repeatEvents: Event[] = [
+        {
+          id: '1-1',
+          title: '팀 미팅',
+          date: '2025-01-06',
+          startTime: '09:00',
+          endTime: '10:00',
+          description: '주간 팀 미팅',
+          location: '회의실 A',
+          category: '업무',
+          repeat: { type: 'weekly', interval: 1, endDate: '2025-01-29' },
+          notificationTime: 10,
+        },
+        {
+          id: '1-2',
+          title: '팀 미팅',
+          date: '2025-01-13',
+          startTime: '09:00',
+          endTime: '10:00',
+          description: '주간 팀 미팅',
+          location: '회의실 A',
+          category: '업무',
+          repeat: { type: 'weekly', interval: 1, endDate: '2025-01-29' },
+          notificationTime: 10,
+        },
+        {
+          id: '1-3',
+          title: '팀 미팅',
+          date: '2025-01-20',
+          startTime: '09:00',
+          endTime: '10:00',
+          description: '주간 팀 미팅',
+          location: '회의실 A',
+          category: '업무',
+          repeat: { type: 'weekly', interval: 1, endDate: '2025-01-29' },
+          notificationTime: 10,
+        },
+      ];
+
+      // When: 두 번째 일정만 삭제
+      const remainingEvents = deleteSingleRepeatEvent(repeatEvents, '1-2');
+
+      // Then: 삭제된 일정을 제외한 나머지만 남아야 함
+      expect(remainingEvents).toHaveLength(2);
+      expect(remainingEvents[0].id).toBe('1-1');
+      expect(remainingEvents[1].id).toBe('1-3');
+      expect(remainingEvents.find((event) => event.id === '1-2')).toBeUndefined();
+    });
+
+    it('삭제된 일정은 반복 일정 목록에서 완전히 제거된다', () => {
+      // Given: 반복 일정들
+      const repeatEvents: Event[] = [
+        {
+          id: 'daily-1',
+          title: '아침 운동',
+          date: '2025-01-01',
+          startTime: '06:00',
+          endTime: '07:00',
+          description: '매일 아침 운동',
+          location: '집',
+          category: '개인',
+          repeat: { type: 'daily', interval: 1, endDate: '2025-01-31' },
+          notificationTime: 5,
+        },
+        {
+          id: 'daily-2',
+          title: '아침 운동',
+          date: '2025-01-02',
+          startTime: '06:00',
+          endTime: '07:00',
+          description: '매일 아침 운동',
+          location: '집',
+          category: '개인',
+          repeat: { type: 'daily', interval: 1, endDate: '2025-01-31' },
+          notificationTime: 5,
+        },
+      ];
+
+      // When: 첫 번째 일정 삭제
+      const remainingEvents = deleteSingleRepeatEvent(repeatEvents, 'daily-1');
+
+      // Then: 첫 번째 일정이 완전히 제거되어야 함
+      expect(remainingEvents).toHaveLength(1);
+      expect(remainingEvents[0].id).toBe('daily-2');
+      expect(remainingEvents.find((event) => event.id === 'daily-1')).toBeUndefined();
+    });
+
+    it('존재하지 않는 ID로 삭제 시도하면 원본 목록이 그대로 반환된다', () => {
+      // Given: 반복 일정들
+      const repeatEvents: Event[] = [
+        {
+          id: '1-1',
+          title: '팀 미팅',
+          date: '2025-01-06',
+          startTime: '09:00',
+          endTime: '10:00',
+          description: '주간 팀 미팅',
+          location: '회의실 A',
+          category: '업무',
+          repeat: { type: 'weekly', interval: 1, endDate: '2025-01-29' },
+          notificationTime: 10,
+        },
+      ];
+
+      // When: 존재하지 않는 ID로 삭제 시도
+      const remainingEvents = deleteSingleRepeatEvent(repeatEvents, 'non-existent-id');
+
+      // Then: 원본 목록이 그대로 반환되어야 함
+      expect(remainingEvents).toHaveLength(1);
+      expect(remainingEvents[0].id).toBe('1-1');
+      expect(remainingEvents).toEqual(repeatEvents);
+    });
+  });
+
+  describe('단일 삭제 후 반복 일정 상태', () => {
+    it('삭제 후 남은 일정들은 여전히 반복 일정으로 유지된다', () => {
+      // Given: 매주 반복하는 일정들
+      const repeatEvents: Event[] = [
+        {
+          id: 'weekly-1',
+          title: '팀 미팅',
+          date: '2025-01-06',
+          startTime: '09:00',
+          endTime: '10:00',
+          description: '주간 팀 미팅',
+          location: '회의실 A',
+          category: '업무',
+          repeat: { type: 'weekly', interval: 1, endDate: '2025-01-29' },
+          notificationTime: 10,
+        },
+        {
+          id: 'weekly-2',
+          title: '팀 미팅',
+          date: '2025-01-13',
+          startTime: '09:00',
+          endTime: '10:00',
+          description: '주간 팀 미팅',
+          location: '회의실 A',
+          category: '업무',
+          repeat: { type: 'weekly', interval: 1, endDate: '2025-01-29' },
+          notificationTime: 10,
+        },
+      ];
+
+      // When: 첫 번째 일정 삭제
+      const remainingEvents = deleteSingleRepeatEvent(repeatEvents, 'weekly-1');
+
+      // Then: 남은 일정은 여전히 반복 일정이어야 함
+      expect(remainingEvents).toHaveLength(1);
+      expect(isRepeatEvent(remainingEvents[0])).toBe(true);
+      expect(remainingEvents[0].repeat.type).toBe('weekly');
+    });
+
+    it('모든 반복 일정을 삭제하면 빈 배열이 반환된다', () => {
+      // Given: 반복 일정들
+      const repeatEvents: Event[] = [
+        {
+          id: 'single-1',
+          title: '일회성 미팅',
+          date: '2025-01-06',
+          startTime: '09:00',
+          endTime: '10:00',
+          description: '일회성 미팅',
+          location: '회의실 A',
+          category: '업무',
+          repeat: { type: 'none', interval: 1, endDate: undefined },
+          notificationTime: 10,
+        },
+      ];
+
+      // When: 유일한 일정 삭제
+      const remainingEvents = deleteSingleRepeatEvent(repeatEvents, 'single-1');
+
+      // Then: 빈 배열이 반환되어야 함
+      expect(remainingEvents).toHaveLength(0);
+      expect(remainingEvents).toEqual([]);
+    });
+  });
+
+  describe('단일 삭제 시나리오', () => {
+    it('매일 반복 일정의 특정 날짜를 삭제할 수 있다', () => {
+      // Given: 매일 반복 일정들
+      const dailyRepeatEvents: Event[] = [
+        {
+          id: 'daily-1',
+          title: '아침 운동',
+          date: '2025-01-01',
+          startTime: '06:00',
+          endTime: '07:00',
+          description: '매일 아침 운동',
+          location: '집',
+          category: '개인',
+          repeat: { type: 'daily', interval: 1, endDate: '2025-01-05' },
+          notificationTime: 5,
+        },
+        {
+          id: 'daily-2',
+          title: '아침 운동',
+          date: '2025-01-02',
+          startTime: '06:00',
+          endTime: '07:00',
+          description: '매일 아침 운동',
+          location: '집',
+          category: '개인',
+          repeat: { type: 'daily', interval: 1, endDate: '2025-01-05' },
+          notificationTime: 5,
+        },
+        {
+          id: 'daily-3',
+          title: '아침 운동',
+          date: '2025-01-03',
+          startTime: '06:00',
+          endTime: '07:00',
+          description: '매일 아침 운동',
+          location: '집',
+          category: '개인',
+          repeat: { type: 'daily', interval: 1, endDate: '2025-01-05' },
+          notificationTime: 5,
+        },
+      ];
+
+      // When: 1월 2일 일정 삭제
+      const remainingEvents = deleteSingleRepeatEvent(dailyRepeatEvents, 'daily-2');
+
+      // Then: 1월 2일을 제외한 나머지 일정들이 남아야 함
+      expect(remainingEvents).toHaveLength(2);
+      expect(remainingEvents[0].date).toBe('2025-01-01');
+      expect(remainingEvents[1].date).toBe('2025-01-03');
+      expect(remainingEvents.find((event) => event.date === '2025-01-02')).toBeUndefined();
+    });
+
+    it('매월 반복 일정의 특정 달을 삭제할 수 있다', () => {
+      // Given: 매월 반복 일정들
+      const monthlyRepeatEvents: Event[] = [
+        {
+          id: 'monthly-1',
+          title: '월말 정리',
+          date: '2025-01-31',
+          startTime: '18:00',
+          endTime: '19:00',
+          description: '매월 말 정리 작업',
+          location: '사무실',
+          category: '업무',
+          repeat: { type: 'monthly', interval: 1, endDate: '2025-03-31' },
+          notificationTime: 30,
+        },
+        {
+          id: 'monthly-2',
+          title: '월말 정리',
+          date: '2025-02-28',
+          startTime: '18:00',
+          endTime: '19:00',
+          description: '매월 말 정리 작업',
+          location: '사무실',
+          category: '업무',
+          repeat: { type: 'monthly', interval: 1, endDate: '2025-03-31' },
+          notificationTime: 30,
+        },
+        {
+          id: 'monthly-3',
+          title: '월말 정리',
+          date: '2025-03-31',
+          startTime: '18:00',
+          endTime: '19:00',
+          description: '매월 말 정리 작업',
+          location: '사무실',
+          category: '업무',
+          repeat: { type: 'monthly', interval: 1, endDate: '2025-03-31' },
+          notificationTime: 30,
+        },
+      ];
+
+      // When: 2월 28일 일정 삭제
+      const remainingEvents = deleteSingleRepeatEvent(monthlyRepeatEvents, 'monthly-2');
+
+      // Then: 2월 28일을 제외한 나머지 일정들이 남아야 함
+      expect(remainingEvents).toHaveLength(2);
+      expect(remainingEvents[0].date).toBe('2025-01-31');
+      expect(remainingEvents[1].date).toBe('2025-03-31');
+      expect(remainingEvents.find((event) => event.date === '2025-02-28')).toBeUndefined();
+    });
+  });
+});
diff --git a/src/__tests__/unit/repeatEventSingleEdit.spec.ts b/src/__tests__/unit/repeatEventSingleEdit.spec.ts
new file mode 100644
index 00000000..719a5f78
--- /dev/null
+++ b/src/__tests__/unit/repeatEventSingleEdit.spec.ts
@@ -0,0 +1,196 @@
+import { describe, it, expect } from 'vitest';
+
+import { Event } from '../../types';
+import { createSingleEditEvent, isRepeatEvent } from '../../utils/repeatEventUtils';
+
+describe('반복 일정 단일 수정 기능', () => {
+  describe('단일 수정 시 반복 일정을 단일 일정으로 변경', () => {
+    it('반복 일정을 수정하면 단일 일정으로 변경된다', () => {
+      // Given: 매주 반복하는 일정
+      const originalEvent: Event = {
+        id: '1',
+        title: '팀 미팅',
+        date: '2025-01-06',
+        startTime: '09:00',
+        endTime: '10:00',
+        description: '주간 팀 미팅',
+        location: '회의실 A',
+        category: '업무',
+        repeat: { type: 'weekly', interval: 1, endDate: '2025-12-31' },
+        notificationTime: 10,
+      };
+
+      // When: 해당 일정을 단일 수정
+      const singleEditEvent = createSingleEditEvent(originalEvent, '2025-01-06');
+
+      // Then: 반복 설정이 'none'으로 변경되어야 함
+      expect(singleEditEvent.repeat.type).toBe('none');
+      expect(singleEditEvent.id).not.toBe(originalEvent.id);
+      expect(singleEditEvent.date).toBe('2025-01-06');
+    });
+
+    it('단일 수정된 일정은 반복 아이콘이 표시되지 않는다', () => {
+      // Given: 단일 수정된 일정
+      const editedEvent: Event = {
+        id: '1',
+        title: '팀 미팅 (수정됨)',
+        date: '2025-01-06',
+        startTime: '09:00',
+        endTime: '10:00',
+        description: '주간 팀 미팅',
+        location: '회의실 A',
+        category: '업무',
+        repeat: { type: 'none', interval: 1, endDate: undefined },
+        notificationTime: 10,
+      };
+
+      // When: 반복 아이콘 표시 여부 확인
+      const shouldShowRepeatIcon = isRepeatEvent(editedEvent);
+
+      // Then: 반복 아이콘이 표시되지 않아야 함
+      expect(shouldShowRepeatIcon).toBe(false);
+      expect(editedEvent.repeat.type).toBe('none');
+    });
+
+    it('단일 수정 시 원본 반복 일정은 그대로 유지된다', () => {
+      // Given: 원본 반복 일정과 단일 수정된 일정
+      const originalRepeatEvent: Event = {
+        id: '1',
+        title: '팀 미팅',
+        date: '2025-01-06',
+        startTime: '09:00',
+        endTime: '10:00',
+        description: '주간 팀 미팅',
+        location: '회의실 A',
+        category: '업무',
+        repeat: { type: 'weekly', interval: 1, endDate: '2025-12-31' },
+        notificationTime: 10,
+      };
+
+      const singleEditedEvent = createSingleEditEvent(originalRepeatEvent, '2025-01-06');
+
+      // When: 두 일정의 반복 설정 비교
+      const originalIsRepeating = isRepeatEvent(originalRepeatEvent);
+      const editedIsRepeating = isRepeatEvent(singleEditedEvent);
+
+      // Then: 원본은 반복 일정으로 유지되고, 수정된 것은 단일 일정이 되어야 함
+      expect(originalIsRepeating).toBe(true);
+      expect(editedIsRepeating).toBe(false);
+      expect(originalRepeatEvent.repeat.type).toBe('weekly');
+      expect(singleEditedEvent.repeat.type).toBe('none');
+    });
+
+    it('단일 수정된 일정은 고유한 ID를 가져야 한다', () => {
+      // Given: 반복 일정
+      const originalEvent: Event = {
+        id: '1',
+        title: '팀 미팅',
+        date: '2025-01-06',
+        startTime: '09:00',
+        endTime: '10:00',
+        description: '주간 팀 미팅',
+        location: '회의실 A',
+        category: '업무',
+        repeat: { type: 'weekly', interval: 1, endDate: '2025-12-31' },
+        notificationTime: 10,
+      };
+
+      // When: 단일 수정 이벤트 생성
+      const singleEditEvent = createSingleEditEvent(originalEvent, '2025-01-06');
+
+      // Then: 고유한 ID를 가져야 함
+      expect(singleEditEvent.id).not.toBe(originalEvent.id);
+      expect(singleEditEvent.id).toContain(originalEvent.id);
+      expect(singleEditEvent.id).toContain('single-edit');
+    });
+  });
+
+  describe('단일 수정 UI 동작', () => {
+    it('반복 일정에 수정 버튼을 클릭하면 단일 수정 옵션이 표시된다', () => {
+      // Given: 반복 일정
+      const repeatEvent: Event = {
+        id: '1',
+        title: '팀 미팅',
+        date: '2025-01-06',
+        startTime: '09:00',
+        endTime: '10:00',
+        description: '주간 팀 미팅',
+        location: '회의실 A',
+        category: '업무',
+        repeat: { type: 'weekly', interval: 1, endDate: '2025-12-31' },
+        notificationTime: 10,
+      };
+
+      // When: 수정 버튼 클릭 시 단일 수정 옵션 확인
+      const hasSingleEditOption = isRepeatEvent(repeatEvent);
+
+      // Then: 단일 수정 옵션이 표시되어야 함
+      expect(hasSingleEditOption).toBe(true);
+      expect(repeatEvent.repeat.type).toBe('weekly');
+    });
+
+    it('단일 수정 옵션을 선택하면 수정 모드로 진입한다', () => {
+      // Given: 반복 일정 수정 모드
+      const isEditingMode = true;
+      const isSingleEdit = true;
+
+      // When: 단일 수정 모드 진입
+      const shouldEnterEditMode = isEditingMode && isSingleEdit;
+
+      // Then: 수정 모드로 진입해야 함
+      expect(shouldEnterEditMode).toBe(true);
+      expect(isEditingMode).toBe(true);
+      expect(isSingleEdit).toBe(true);
+    });
+  });
+
+  describe('단일 수정 시나리오', () => {
+    it('매일 반복 일정의 특정 날짜를 단일 수정할 수 있다', () => {
+      // Given: 매일 반복 일정
+      const dailyRepeatEvent: Event = {
+        id: 'daily-1',
+        title: '아침 운동',
+        date: '2025-01-01',
+        startTime: '06:00',
+        endTime: '07:00',
+        description: '매일 아침 운동',
+        location: '집',
+        category: '개인',
+        repeat: { type: 'daily', interval: 1, endDate: '2025-01-31' },
+        notificationTime: 5,
+      };
+
+      // When: 1월 15일만 단일 수정
+      const singleEditEvent = createSingleEditEvent(dailyRepeatEvent, '2025-01-15');
+
+      // Then: 단일 수정된 일정이 생성되어야 함
+      expect(singleEditEvent.repeat.type).toBe('none');
+      expect(singleEditEvent.date).toBe('2025-01-15');
+      expect(singleEditEvent.title).toBe('아침 운동');
+    });
+
+    it('매월 반복 일정의 특정 달을 단일 수정할 수 있다', () => {
+      // Given: 매월 반복 일정
+      const monthlyRepeatEvent: Event = {
+        id: 'monthly-1',
+        title: '월말 정리',
+        date: '2025-01-31',
+        startTime: '18:00',
+        endTime: '19:00',
+        description: '매월 말 정리 작업',
+        location: '사무실',
+        category: '업무',
+        repeat: { type: 'monthly', interval: 1, endDate: '2025-12-31' },
+        notificationTime: 30,
+      };
+
+      // When: 3월 31일만 단일 수정
+      const singleEditEvent = createSingleEditEvent(monthlyRepeatEvent, '2025-03-31');
+
+      // Then: 단일 수정된 일정이 생성되어야 함
+      expect(singleEditEvent.repeat.type).toBe('none');
+      expect(singleEditEvent.date).toBe('2025-03-31');
+      expect(singleEditEvent.title).toBe('월말 정리');
+    });
+  });
+});
diff --git a/src/components/RepeatEventIcon.tsx b/src/components/RepeatEventIcon.tsx
new file mode 100644
index 00000000..10079a03
--- /dev/null
+++ b/src/components/RepeatEventIcon.tsx
@@ -0,0 +1,44 @@
+import { Repeat } from '@mui/icons-material';
+import { Box, Tooltip } from '@mui/material';
+
+import { getRepeatDisplayInfo } from '../utils/eventStateUtils';
+
+interface RepeatEventIconProps {
+  repeatType: 'none' | 'daily' | 'weekly' | 'monthly' | 'yearly';
+  interval?: number;
+  endDate?: string;
+}
+
+export function RepeatEventIcon({ repeatType, interval = 1, endDate }: RepeatEventIconProps) {
+  if (repeatType === 'none') {
+    return null;
+  }
+
+  const mockEvent = {
+    id: 'temp',
+    title: 'temp',
+    date: '2025-01-01',
+    startTime: '09:00',
+    endTime: '10:00',
+    description: '',
+    location: '',
+    category: '업무',
+    repeat: { type: repeatType, interval, endDate },
+    notificationTime: 0,
+  };
+
+  const { repeatText } = getRepeatDisplayInfo(mockEvent);
+
+  return (
+    <Tooltip title={repeatText} arrow>
+      <Box component="span" sx={{ display: 'inline-flex', alignItems: 'center' }}>
+        <Repeat
+          fontSize="small"
+          color="primary"
+          data-testid="repeat-icon"
+          aria-label={`반복 일정: ${repeatText}`}
+        />
+      </Box>
+    </Tooltip>
+  );
+}
diff --git a/src/hooks/useEventForm.ts b/src/hooks/useEventForm.ts
index 9dfcc46a..225ce1ad 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?.repeat.type ? 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/utils/eventStateUtils.ts b/src/utils/eventStateUtils.ts
new file mode 100644
index 00000000..21bc191c
--- /dev/null
+++ b/src/utils/eventStateUtils.ts
@@ -0,0 +1,59 @@
+import { Event } from '../types';
+
+export const isRepeatingEvent = (event: Event) => {
+  return event.repeat.type !== 'none';
+};
+
+export function getRepeatDisplayInfo(event: Event): {
+  isRepeating: boolean;
+  repeatText: string;
+  shouldShowIcon: boolean;
+} {
+  const isRepeating = event.repeat.type !== 'none';
+
+  if (!isRepeating) {
+    return { isRepeating: false, repeatText: '', shouldShowIcon: false };
+  }
+
+  const typeText = {
+    daily: '일',
+    weekly: '주',
+    monthly: '월',
+    yearly: '년',
+    none: '',
+  }[event.repeat.type];
+
+  const repeatText = `${event.repeat.interval}${typeText}마다`;
+
+  return {
+    isRepeating: true,
+    repeatText,
+    shouldShowIcon: true,
+  };
+}
+
+export function getRepeatingEvents(events: Event[]): Event[] {
+  return events.filter(isRepeatingEvent);
+}
+
+export function groupEventsByRepeatType(events: Event[]): {
+  daily: Event[];
+  weekly: Event[];
+  monthly: Event[];
+  yearly: Event[];
+  none: Event[];
+} {
+  const initialGroups = {
+    daily: [] as Event[],
+    weekly: [] as Event[],
+    monthly: [] as Event[],
+    yearly: [] as Event[],
+    none: [] as Event[],
+  };
+
+  return events.reduce((groups, event) => {
+    const type = event.repeat.type;
+    groups[type].push(event);
+    return groups;
+  }, initialGroups);
+}
diff --git a/src/utils/eventUpdateUtils.ts b/src/utils/eventUpdateUtils.ts
new file mode 100644
index 00000000..d141b4cc
--- /dev/null
+++ b/src/utils/eventUpdateUtils.ts
@@ -0,0 +1,14 @@
+import { Event, RepeatInfo } from '../types';
+
+/**
+ * 이벤트의 반복 설정을 업데이트하는 함수
+ * @param event - 업데이트할 이벤트
+ * @param newRepeat - 새로운 반복 설정
+ * @returns 업데이트된 이벤트 (원본 객체는 변경하지 않음)
+ */
+export const updateEventRepeat = (event: Event, newRepeat: RepeatInfo): Event => {
+  return {
+    ...event,
+    repeat: newRepeat,
+  };
+};
diff --git a/src/utils/eventUtils.ts b/src/utils/eventUtils.ts
index 9e75e947..f8c6e59a 100644
--- a/src/utils/eventUtils.ts
+++ b/src/utils/eventUtils.ts
@@ -56,3 +56,24 @@ export function getFilteredEvents(
 
   return searchedEvents;
 }
+
+export function createEvent(
+  type: 'single' | 'repeating',
+  repeatType: 'none' | 'daily' | 'weekly' | 'monthly' | 'yearly',
+  interval: number
+): Event {
+  const title = type === 'single' ? 'Single Event' : `Repeating Event ${repeatType} ${interval}`;
+
+  return {
+    id: `event-${type}-${repeatType}-${interval}`,
+    title,
+    date: '2025-01-01',
+    startTime: '09:00',
+    endTime: '10:00',
+    description: '',
+    location: '',
+    category: '업무',
+    repeat: { type: repeatType, interval, endDate: undefined },
+    notificationTime: 0,
+  };
+}
diff --git a/src/utils/repeatEventUtils.ts b/src/utils/repeatEventUtils.ts
new file mode 100644
index 00000000..9fcaffe4
--- /dev/null
+++ b/src/utils/repeatEventUtils.ts
@@ -0,0 +1,196 @@
+import { RepeatInfo, Event } from '../types';
+
+interface RepeatEventInput {
+  date: string;
+  repeatType: RepeatInfo['type'];
+  interval: number;
+  endDate: string;
+}
+
+export const generateRepeatDates = (event: RepeatEventInput): string[] => {
+  const { repeatType } = event;
+
+  // 입력 유효성 검사
+  if (!isValidDate(event.date) || !isValidDate(event.endDate)) {
+    throw new Error('Invalid date format');
+  }
+
+  // 시작일과 종료일 비교
+  if (new Date(event.date) > new Date(event.endDate)) {
+    return [];
+  }
+
+  if (repeatType === 'daily') {
+    return generateDailyRepeatDates(event);
+  }
+
+  if (repeatType === 'weekly') {
+    return generateWeeklyRepeatDates(event);
+  }
+
+  if (repeatType === 'monthly') {
+    return generateMonthlyRepeatDates(event);
+  }
+
+  if (repeatType === 'yearly') {
+    return generateYearlyRepeatDates(event);
+  }
+
+  return [];
+};
+
+const generateDailyRepeatDates = (event: RepeatEventInput): string[] => {
+  const dates: string[] = [];
+  let currentDate = new Date(event.date);
+  const endDate = new Date(event.endDate);
+
+  while (currentDate <= endDate) {
+    dates.push(formatDate(currentDate));
+    currentDate.setDate(currentDate.getDate() + event.interval);
+  }
+
+  return dates;
+};
+
+const generateWeeklyRepeatDates = (event: RepeatEventInput): string[] => {
+  const dates: string[] = [];
+  let currentDate = new Date(event.date);
+  const endDate = new Date(event.endDate);
+
+  while (currentDate <= endDate) {
+    dates.push(formatDate(currentDate));
+    currentDate.setDate(currentDate.getDate() + event.interval * 7);
+  }
+
+  return dates;
+};
+
+const generateMonthlyRepeatDates = (event: RepeatEventInput): string[] => {
+  const dates: string[] = [];
+  let currentDate = new Date(event.date);
+  const endDate = new Date(event.endDate);
+  const originalDay = currentDate.getDate();
+
+  while (currentDate <= endDate) {
+    dates.push(formatDate(currentDate));
+
+    // 다음 달 계산
+    let nextMonth = currentDate.getMonth() + event.interval;
+    let nextYear = currentDate.getFullYear() + Math.floor(nextMonth / 12);
+    nextMonth = nextMonth % 12;
+
+    // 원래 날짜가 다음 달에 존재하지 않는 경우 해당 달을 건너뛰기
+    const lastDayOfNextMonth = getLastDayOfMonth(nextYear, nextMonth);
+
+    if (originalDay > lastDayOfNextMonth) {
+      // 해당 달을 건너뛰고 다음 달의 같은 날짜로 설정
+      nextMonth = nextMonth + 1;
+      if (nextMonth >= 12) {
+        nextMonth = 0;
+        nextYear += 1;
+      }
+
+      // 다음 달도 원래 날짜가 없으면 계속 건너뛰기
+      while (getLastDayOfMonth(nextYear, nextMonth) < originalDay) {
+        nextMonth += 1;
+        if (nextMonth >= 12) {
+          nextMonth = 0;
+          nextYear += 1;
+        }
+      }
+    }
+
+    const nextDate = new Date(nextYear, nextMonth, originalDay);
+
+    // endDate를 초과하면 종료
+    if (nextDate > endDate) {
+      break;
+    }
+
+    currentDate = nextDate;
+  }
+
+  return dates;
+};
+
+const generateYearlyRepeatDates = (event: RepeatEventInput): string[] => {
+  const dates: string[] = [];
+  let currentDate = new Date(event.date);
+  const endDate = new Date(event.endDate);
+  const originalMonth = currentDate.getMonth();
+  const originalDay = currentDate.getDate();
+
+  while (currentDate <= endDate) {
+    dates.push(formatDate(currentDate));
+
+    // 다음 해 계산
+    let nextYear = currentDate.getFullYear() + event.interval;
+
+    // 원래 날짜가 다음 해에 존재하지 않는 경우 해당 해를 건너뛰기
+    const lastDayOfNextMonth = getLastDayOfMonth(nextYear, originalMonth);
+
+    if (originalDay > lastDayOfNextMonth) {
+      // 해당 해를 건너뛰고 다음 해의 같은 날짜로 설정
+      nextYear += 1;
+
+      // 다음 해도 원래 날짜가 없으면 계속 건너뛰기
+      while (getLastDayOfMonth(nextYear, originalMonth) < originalDay) {
+        nextYear += 1;
+      }
+    }
+
+    const nextDate = new Date(nextYear, originalMonth, originalDay);
+
+    // endDate를 초과하면 종료
+    if (nextDate > endDate) {
+      break;
+    }
+
+    currentDate = nextDate;
+  }
+
+  return dates;
+};
+
+// 날짜 유효성 검사
+const isValidDate = (dateString: string): boolean => {
+  const date = new Date(dateString);
+  return date instanceof Date && !isNaN(date.getTime());
+};
+
+// 월의 마지막 날짜 계산
+const getLastDayOfMonth = (year: number, month: number): number => {
+  return new Date(year, month + 1, 0).getDate();
+};
+
+// 날짜를 YYYY-MM-DD 형식으로 변환
+const formatDate = (date: Date): string => {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  return `${year}-${month}-${day}`;
+};
+
+// 반복 일정인지 확인하는 함수
+export const isRepeatEvent = (event: Event): boolean => {
+  return event.repeat.type !== 'none';
+};
+
+// 반복 일정을 단일 수정 이벤트로 생성하는 함수
+export const createSingleEditEvent = (originalEvent: Event, targetDate: string): Event => {
+  return {
+    ...originalEvent,
+    id: `${originalEvent.id}-single-edit-${targetDate}`,
+    date: targetDate,
+    repeat: {
+      type: 'none',
+      interval: 1,
+      endDate: undefined,
+    },
+  };
+};
+
+// 반복 일정 중 특정 일정만 삭제하는 함수
+export const deleteSingleRepeatEvent = (events: Event[], eventIdToDelete: string): Event[] => {
+  return events.filter((event) => event.id !== eventIdToDelete);
+};