v0.1.17 - 목표 패널 및 D-DAY 선택 추가

HANDOFF.md

@@ -4,7 +4,7 @@
 
 - 프로젝트명: 10 Minute Planner 웹 UI
 - 기술 스택: Vue 3 + Vite + TailwindCSS + JavaScript
-- 현재 기준 버전: `v0.1.11`
+- 현재 기준 버전: `v0.1.17`
 - Git 원격 저장소: `https://git.sori.studio/zenn/planner.sori.studio.git`
 
 ## 기준 디자인
@@ -31,6 +31,7 @@
 - 백엔드 엔트리 포인트: `backend/src/server.js`
 - 백엔드 DB 스키마: `backend/src/db/schema.js`
 - 백엔드 인증 라우트: `backend/src/routes/auth.js`
+- 백엔드 목표 라우트: `backend/src/routes/goals.js`
 - 백엔드 비밀번호/세션 유틸: `backend/src/lib/password.js`
 - Tailwind 설정은 완료되어 있으며, 이 프로젝트의 스타일링 기준으로 유지한다.
 - 현재 선택 날짜는 시스템 날짜 기준으로 시작한다.
@@ -51,6 +52,8 @@
 - `localStorage` 접근 로직은 `src/lib/plannerStorage.js`로 분리하기 시작했고, 이후 API/DB adapter로 교체하기 쉬운 구조로 정리 중이다.
 - 프론트는 헤더에서 `LOGIN` / `SIGN UP` 모달을 열 수 있고, 로그인 상태면 닉네임과 `LOGOUT` 버튼을 표시한다.
 - 인증 토큰과 현재 사용자 정보는 프론트 로컬 저장소에 따로 유지하고, 앱 시작 시 `/api/auth/me`로 세션 복원을 시도한다.
+- 프론트 플래너 API 클라이언트는 `src/lib/plannerApi.js`에 추가되었다.
+- 프론트 목표 API 클라이언트는 `src/lib/goalsApi.js`에 추가되었다.
 - 루트에서 `npm run dev:backend`, `npm run db:generate`, `npm run db:migrate`로 백엔드 명령을 호출할 수 있다.
 - 상단 전환 버튼으로 `PLANNER / STATS` 화면을 오갈 수 있다.
 - 통계 화면에서는 전체 집중 시간, 평균 완료율, 기록 일수, 최근 7일 흐름, 최근 기록, 베스트 데이를 보여준다.
@@ -116,7 +119,18 @@
 - 현재 인증 방식은 Bearer 토큰 기반의 간단한 세션 구조이며, 추후 쿠키/리프레시 토큰 전략으로 확장할 수 있다.
 - 다음 프론트 단계에서는 `src/lib/plannerStorage.js`를 유지하되, 인증 이후 백엔드 저장소 adapter를 추가해서 `localStorage`와 전환 가능하게 만드는 흐름이 좋다.
 - 현재 프론트는 인증만 연결된 상태이고, 플래너 저장은 아직 `localStorage` 기준이다.
-- 다음 단계는 `plannerStorage`에 백엔드 adapter를 추가해서 로그인 시 서버 저장을 우선 사용하도록 연결하는 것이다.
+- 로그인 상태에서는 플래너 수정 시 날짜별 서버 저장을 예약하고, 로그인 직후에는 서버 데이터를 먼저 가져오도록 연결하기 시작했다.
+- 현재는 로컬 저장도 계속 유지하면서 서버 저장을 병행하는 과도기 구조다.
+- 로그인 시 서버 플래너 데이터로 `plannerRecords`를 교체하고, 로그아웃 시에는 로컬 저장 기반 데이터로 다시 복귀하도록 정리했다.
+- 이로 인해 다른 사용자 로그인 시 이전 로컬 데이터가 서버 계정 데이터와 섞일 위험을 줄였다.
+- 로그인 상태에서 특정 날짜의 플래너 내용을 완전히 비우면, 서버 저장 대신 해당 날짜 엔트리를 삭제하도록 정리했다.
+- 현재는 로그인 전 플래너 진입을 막고, 인증 후에만 실제 플래너/통계 화면을 사용하도록 변경했다.
+- 클라우드 저장 상태는 헤더가 아니라 오른쪽 하단의 작은 토스트 형태로 표시되도록 변경했다.
+- 저장 완료 토스트는 한 줄짜리의 작은 상태 문구로 줄여서 존재감을 낮췄다.
+- D-DAY는 본문 직접 입력이 아니라, 날짜별로 선택한 대표 목표를 보여주는 구조로 실제 연결되기 시작했다.
+- 오른쪽 패널에 `D-DAY 사용` 토글, 목표 검색, 목표 선택, 목표 생성 폼이 추가되었다.
+- 목표가 없거나 `D-DAY 사용`이 꺼져 있으면 본문 D-DAY 블록은 숨긴다.
+- 목표 데이터는 현재 사용자 기준으로 서버에서 관리되며, 플래너 레코드에는 목표 사용 여부와 선택한 목표 ID를 함께 저장한다.
 - 이미지 저장 기능은 추후 `print-only` 또는 별도 export 전용 레이아웃을 기준으로 구현하면 화면/인쇄/공유 결과를 맞추기 쉽다.
 - Docker Compose는 프론트엔드와 백엔드를 함께 올리는 기준으로 설계하되, NAS 환경에 맞는 볼륨과 재시작 정책도 함께 고려한다.
 

TODO.md

@@ -7,7 +7,7 @@
 - 기본 레이아웃은 `1페이지 + 우측 정보 패널`을 유지한다.
 - `2페이지 펼침 보기`는 비교용 보조 모드로 유지한다.
 - 스타일은 Vue + TailwindCSS 기준으로 구현한다.
-- D-DAY는 목표 관리 패널과 연결되는 기능으로 추후 구현한다.
+- D-DAY는 목표 관리 패널과 연결하는 구조로 전환했고, 세부 확장은 계속 진행한다.
 
 ## 1단계: 플래너 핵심 상호작용
 
@@ -36,10 +36,15 @@
 
 ## 3단계: 목표와 회고 기능
 
-- [ ] 목표 관리 패널을 설계한다.
+- [x] 목표 관리 패널 기본 구조를 설계한다.
-- [ ] 선택한 목표 기준으로 `D-DAY`가 자동 계산되게 한다.
+- [x] 선택한 목표 기준으로 `D-DAY`가 자동 계산되게 한다.
 - [ ] 우측 요약 패널의 `PREV SNAPSHOT`, `READ NEXT`를 실제 데이터 기반으로 연결한다.
 - [ ] 다음날 할 일 자동 제안 규칙을 정리한다.
+- [x] 오른쪽 패널에 `D-DAY 사용` 토글과 목표 검색/선택 UI를 추가한다.
+- [x] 목표를 여러 개 생성하고 날짜별 대표 목표를 선택할 수 있게 한다.
+- [ ] 목표 완료 처리와 보관 상태를 구분한다.
+- [ ] 목표 편집/삭제 UI를 추가한다.
+- [ ] 목표 목록 정렬 규칙과 검색 UX를 다듬는다.
 
 ## 4단계: 데이터 구조와 저장
 
@@ -84,6 +89,8 @@
 ## 메모
 
 - D-DAY는 현재 보류 상태다. 목표 패널 설계 후 연결한다.
+- D-DAY는 본문에 직접 입력하는 방식보다, 별도 목표 목록에서 선택한 대표 목표를 보여주는 구조가 더 적합하다.
+- 목표가 없는 경우 본문 D-DAY 영역은 숨기고, 오른쪽 패널의 `D-DAY 사용` 메뉴에서 검색/선택하도록 유도한다.
 - `TIME TABLE` 드래그는 단순 사각형 선택이 아니라 시간 셀 단위의 연속 선택으로 해석한다.
 - 현재는 `localStorage`로 개발을 진행하지만, 적절한 시점에 DB를 붙여 사용자별 저장 구조로 확장해야 한다.
 - 현재 `localStorage` 저장 로직은 분리 가능한 형태로 정리 중이며, 이후 API/DB adapter로 교체하기 쉽게 유지한다.
@@ -94,5 +101,10 @@
 - 현재 백엔드는 `backend/` 폴더에 `Fastify + Drizzle + SQLite` 기준 초안이 추가되었다.
 - 현재 백엔드는 회원가입, 로그인, 현재 사용자 확인용 기본 인증 API까지 포함한다.
 - 현재 백엔드는 사용자별 플래너 단건 저장/조회와 범위 조회 API까지 포함한다.
+- 현재 백엔드는 사용자별 목표 목록 조회와 목표 생성 API까지 포함한다.
 - 프론트에는 로그인/회원가입 모달과 현재 사용자 상태 표시가 추가되었다.
+- 로그인 상태일 때는 서버 저장을 우선 사용하는 흐름으로 전환 중이다.
+- 로그인 전에는 플래너 본문을 사용하지 못하도록 막고, 인증 후 사용 흐름으로 정리했다.
+- 현재는 각 날짜 플래너가 대표 목표 하나를 선택해 `D-DAY`에 연결하는 구조다.
+- 목표가 선택되지 않았거나 `D-DAY 사용`이 꺼져 있으면 본문 `D-DAY` 영역은 숨긴다.
 - 구현할 때마다 완료된 항목은 체크하고, 큰 결정사항은 `HANDOFF.md`에도 함께 반영한다.

backend/src/db/init.js

@@ -32,5 +32,18 @@ export function ensureDatabaseSchema() {
 
     CREATE UNIQUE INDEX IF NOT EXISTS planner_entries_user_date_unique
     ON planner_entries (user_id, entry_date);
+
+    CREATE TABLE IF NOT EXISTS goals (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id INTEGER NOT NULL,
+      title TEXT NOT NULL,
+      target_date TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'active',
+      color TEXT NOT NULL DEFAULT '#1c1917',
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      completed_at INTEGER,
+      FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
+    );
   `)
 }

backend/src/db/schema.js

@@ -31,3 +31,15 @@ export const plannerEntries = sqliteTable(
     userDateUnique: uniqueIndex('planner_entries_user_date_unique').on(table.userId, table.entryDate),
   }),
 )
+
+export const goals = sqliteTable('goals', {
+  id: integer('id').primaryKey({ autoIncrement: true }),
+  userId: integer('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
+  title: text('title').notNull(),
+  targetDate: text('target_date').notNull(),
+  status: text('status').notNull().default('active'),
+  color: text('color').notNull().default('#1c1917'),
+  createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),
+  updatedAt: integer('updated_at', { mode: 'timestamp_ms' }).notNull(),
+  completedAt: integer('completed_at', { mode: 'timestamp_ms' }),
+})

backend/src/routes/goals.js

@@ -0,0 +1,103 @@
+import { and, asc, eq, like } from 'drizzle-orm'
+import { z } from 'zod'
+import { db } from '../db/client.js'
+import { goals } from '../db/schema.js'
+import { findAuthenticatedUser } from '../lib/authSession.js'
+
+const goalSchema = z.object({
+  title: z.string().trim().min(1).max(80),
+  targetDate: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  color: z.string().trim().min(4).max(32).optional(),
+})
+
+const goalQuerySchema = z.object({
+  query: z.string().trim().optional(),
+  status: z.enum(['active', 'done', 'archived', 'all']).optional(),
+})
+
+async function requireAuthenticatedUser(request, reply) {
+  const user = await findAuthenticatedUser(request)
+
+  if (!user) {
+    reply.code(401).send({
+      message: '인증이 필요합니다.',
+    })
+    return null
+  }
+
+  return user
+}
+
+export async function registerGoalRoutes(app) {
+  app.get('/api/goals', async (request, reply) => {
+    const user = await requireAuthenticatedUser(request, reply)
+
+    if (!user) {
+      return
+    }
+
+    const query = goalQuerySchema.safeParse(request.query ?? {})
+
+    if (!query.success) {
+      return reply.code(400).send({
+        message: '목표 조회 조건이 올바르지 않습니다.',
+        issues: query.error.flatten(),
+      })
+    }
+
+    const filters = [eq(goals.userId, user.id)]
+
+    if (query.data.status && query.data.status !== 'all') {
+      filters.push(eq(goals.status, query.data.status))
+    }
+
+    if (query.data.query) {
+      filters.push(like(goals.title, `%${query.data.query}%`))
+    }
+
+    const items = await db
+      .select()
+      .from(goals)
+      .where(and(...filters))
+      .orderBy(asc(goals.targetDate), asc(goals.id))
+
+    return { goals: items }
+  })
+
+  app.post('/api/goals', async (request, reply) => {
+    const user = await requireAuthenticatedUser(request, reply)
+
+    if (!user) {
+      return
+    }
+
+    const payload = goalSchema.safeParse(request.body)
+
+    if (!payload.success) {
+      return reply.code(400).send({
+        message: '목표 입력값이 올바르지 않습니다.',
+        issues: payload.error.flatten(),
+      })
+    }
+
+    const now = new Date()
+
+    const [goal] = await db
+      .insert(goals)
+      .values({
+        userId: user.id,
+        title: payload.data.title,
+        targetDate: payload.data.targetDate,
+        color: payload.data.color ?? '#1c1917',
+        status: 'active',
+        createdAt: now,
+        updatedAt: now,
+      })
+      .returning()
+
+    return reply.code(201).send({
+      message: '목표가 추가되었습니다.',
+      goal,
+    })
+  })
+}

backend/src/routes/planner.js

@@ -162,4 +162,35 @@ export async function registerPlannerRoutes(app) {
       },
     }
   })
+
+  app.delete('/api/planner/:entryDate', async (request, reply) => {
+    const user = await requireAuthenticatedUser(request, reply)
+
+    if (!user) {
+      return
+    }
+
+    const dateResult = dateSchema.safeParse(request.params.entryDate)
+
+    if (!dateResult.success) {
+      return reply.code(400).send({
+        message: '날짜 형식이 올바르지 않습니다.',
+      })
+    }
+
+    const deletedEntries = await db
+      .delete(plannerEntries)
+      .where(
+        and(
+          eq(plannerEntries.userId, user.id),
+          eq(plannerEntries.entryDate, dateResult.data),
+        ),
+      )
+      .returning()
+
+    return {
+      message: deletedEntries.length > 0 ? '플래너가 삭제되었습니다.' : '삭제할 플래너가 없습니다.',
+      deleted: deletedEntries.length > 0,
+    }
+  })
 }

backend/src/server.js

@@ -4,6 +4,7 @@ import { env } from './config.js'
 import { sqlite } from './db/client.js'
 import { ensureDatabaseSchema } from './db/init.js'
 import { registerAuthRoutes } from './routes/auth.js'
+import { registerGoalRoutes } from './routes/goals.js'
 import { registerPlannerRoutes } from './routes/planner.js'
 
 const app = Fastify({
@@ -18,6 +19,7 @@ await app.register(cors, {
 })
 
 await registerAuthRoutes(app)
+await registerGoalRoutes(app)
 await registerPlannerRoutes(app)
 
 app.get('/health', async () => {
@@ -39,6 +41,7 @@ app.get('/api/meta', async () => ({
   orm: 'drizzle',
   notes: [
     '회원가입, 로그인, 현재 사용자 확인 API가 준비되어 있습니다.',
+    '사용자별 목표 목록과 생성 API가 준비되어 있습니다.',
     '사용자별 플래너 저장 및 조회 API가 준비되어 있습니다.',
   ],
 }))

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "ten-minute-planner",
-  "version": "0.1.11",
+  "version": "0.1.17",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "ten-minute-planner",
-      "version": "0.1.11",
+      "version": "0.1.17",
       "dependencies": {
         "vue": "^3.5.13"
       },

package.json

@@ -1,7 +1,7 @@
 {
   "name": "ten-minute-planner",
   "private": true,
-  "version": "0.1.11",
+  "version": "0.1.17",
   "type": "module",
   "scripts": {
     "dev": "vite",

src/App.vue

@@ -12,9 +12,12 @@ import {
   readAuthState,
   signup,
 } from './lib/authClient'
+import { createGoal, fetchGoals } from './lib/goalsApi'
+import { deletePlannerEntry, fetchPlannerEntries, savePlannerEntry } from './lib/plannerApi'
 import {
   createInitialPlannerRecords,
   persistPlannerState,
+  readPlannerStorageState,
   restorePlannerUiState,
 } from './lib/plannerStorage'
 
@@ -27,6 +30,13 @@ const authBusy = ref(false)
 const authMessage = ref('')
 const authToken = ref('')
 const currentUser = ref(null)
+const goals = ref([])
+const goalQuery = ref('')
+const goalBusy = ref(false)
+const goalMessage = ref('')
+const syncStatus = ref('local')
+const syncMessage = ref('')
+const syncToastVisible = ref(false)
 const selectedDate = ref(new Date())
 const calendarViewDate = ref(new Date(selectedDate.value))
 const statsRangeStart = ref(toKey(new Date(new Date().setDate(new Date().getDate() - 6))))
@@ -36,6 +46,10 @@ const authForm = reactive({
   email: '',
   password: '',
 })
+const goalForm = reactive({
+  title: '',
+  targetDate: '',
+})
 
 const hours = [
   '6', '7', '8', '9', '10', '11', '12',
@@ -46,6 +60,9 @@ const hours = [
 
 const timetableCellCount = hours.length * 6
 let printPageStyleElement = null
+let isHydratingRemoteRecords = false
+const syncTimers = new Map()
+let syncToastTimer = null
 
 function createEmptyTimetable() {
   return Array.from({ length: timetableCellCount }, () => false)
@@ -170,8 +187,9 @@ function startOfDay(date) {
 
 function buildFallbackRecord(date) {
   return {
-    dday: 'D-00 FOCUS',
     comment: '',
+    goalEnabled: false,
+    selectedGoalId: null,
     tasks: Array.from({ length: 15 }, (_, index) => ({
       label: '',
       title: '',
@@ -190,6 +208,8 @@ function buildFallbackRecord(date) {
 function normalizeRecord(record) {
   return {
     ...record,
+    goalEnabled: Boolean(record.goalEnabled),
+    selectedGoalId: record.selectedGoalId ?? null,
     tasks: record.tasks.map((task, index) => ({
       label: task.label ?? task.id ?? '',
       title: task.title ?? '',
@@ -292,6 +312,36 @@ const markedDateKeys = computed(() =>
 )
 
 const isAuthenticated = computed(() => Boolean(authToken.value && currentUser.value))
+const filteredGoals = computed(() => {
+  const query = goalQuery.value.trim().toLowerCase()
+
+  if (!query) {
+    return goals.value
+  }
+
+  return goals.value.filter((goal) =>
+    goal.title.toLowerCase().includes(query),
+  )
+})
+const plannerGoal = computed(() =>
+  goals.value.find((goal) => goal.id === planner.value.selectedGoalId) ?? null,
+)
+const plannerDday = computed(() => {
+  if (!planner.value.goalEnabled || !plannerGoal.value) {
+    return ''
+  }
+
+  const targetDate = startOfDay(toDateValue(plannerGoal.value.targetDate))
+  const currentDate = startOfDay(selectedDate.value)
+  const diffDays = Math.round((targetDate.getTime() - currentDate.getTime()) / (24 * 60 * 60 * 1000))
+  const badge =
+    diffDays === 0 ? 'D-DAY' : diffDays > 0 ? `D-${diffDays}` : `D+${Math.abs(diffDays)}`
+
+  return `${badge} ${plannerGoal.value.title}`
+})
+const showPlannerDday = computed(() =>
+  planner.value.goalEnabled && Boolean(plannerGoal.value),
+)
 
 const filledTasks = computed(() =>
   planner.value.tasks.filter((task) => task.title.trim()),
@@ -357,30 +407,53 @@ function selectDate(date) {
 
 function updateComment(record, value) {
   record.comment = value
+  schedulePlannerSyncForRecord(record)
+}
+
+function updateGoalEnabled(record, value) {
+  record.goalEnabled = value
+
+  if (!value) {
+    record.selectedGoalId = null
+  }
+
+  schedulePlannerSyncForRecord(record)
+}
+
+function selectGoalForPlanner(record, goalId) {
+  record.goalEnabled = true
+  record.selectedGoalId = goalId
+  schedulePlannerSyncForRecord(record)
 }
 
 function updateTaskLabel(record, { index, value }) {
   record.tasks[index].label = value
+  schedulePlannerSyncForRecord(record)
 }
 
 function updateTaskTitle(record, { index, value }) {
   record.tasks[index].title = value
+  schedulePlannerSyncForRecord(record)
 }
 
 function toggleTask(record, index) {
   record.tasks[index].checked = !record.tasks[index].checked
+  schedulePlannerSyncForRecord(record)
 }
 
 function updateMemo(record, { index, value }) {
   record.memo[index].text = value
+  schedulePlannerSyncForRecord(record)
 }
 
 function updateMemoLabel(record, { index, value }) {
   record.memo[index].label = value
+  schedulePlannerSyncForRecord(record)
 }
 
 function updateTimetable(record, nextTimetable) {
   record.timetable = nextTimetable
+  schedulePlannerSyncForRecord(record)
 }
 
 function hasPlannerContent(record) {
@@ -545,6 +618,7 @@ watch(
       calendarViewDate: calendarViewDate.value,
       statsRangeStart: normalizedStatsRange.value.startKey,
       statsRangeEnd: normalizedStatsRange.value.endKey,
+      includeRecords: !isAuthenticated.value,
     })
   },
   { deep: true },
@@ -560,6 +634,31 @@ function clearTaskLabels(record) {
   record.tasks.forEach((task) => {
     task.label = ''
   })
+  schedulePlannerSyncForRecord(record)
+}
+
+function setSyncFeedback(status, message, options = {}) {
+  const {
+    visible = true,
+    duration = 1600,
+    sticky = false,
+  } = options
+
+  syncStatus.value = status
+  syncMessage.value = message
+
+  if (syncToastTimer) {
+    window.clearTimeout(syncToastTimer)
+    syncToastTimer = null
+  }
+
+  syncToastVisible.value = visible
+
+  if (visible && !sticky) {
+    syncToastTimer = window.setTimeout(() => {
+      syncToastVisible.value = false
+    }, duration)
+  }
 }
 
 function resetAuthForm() {
@@ -568,6 +667,11 @@ function resetAuthForm() {
   authForm.password = ''
 }
 
+function resetGoalForm() {
+  goalForm.title = ''
+  goalForm.targetDate = ''
+}
+
 function openAuthDialog(mode = 'login') {
   authMode.value = mode
   authMessage.value = ''
@@ -584,13 +688,16 @@ function updateAuthField({ field, value }) {
   authForm[field] = value
 }
 
-function applyAuthSuccess(data) {
+async function applyAuthSuccess(data) {
   authToken.value = data.token
   currentUser.value = data.user
+  setSyncFeedback('cloud', '클라우드 동기화 연결됨')
   persistAuthState({
     token: data.token,
     user: data.user,
   })
+  await loadGoals()
+  await hydratePlannerRecordsFromApi()
   closeAuthDialog()
 }
 
@@ -611,7 +718,7 @@ async function submitAuthForm() {
             password: authForm.password,
           })
 
-    applyAuthSuccess(result)
+    await applyAuthSuccess(result)
   } catch (error) {
     authMessage.value = error.message || '인증 처리 중 문제가 발생했습니다.'
   } finally {
@@ -632,21 +739,215 @@ async function restoreAuthSession() {
   try {
     const result = await fetchCurrentUser(savedAuth.token)
     currentUser.value = result.user
+    setSyncFeedback('cloud', '클라우드 동기화 연결됨')
     persistAuthState({
       token: savedAuth.token,
       user: result.user,
     })
+    await loadGoals()
+    await hydratePlannerRecordsFromApi()
   } catch (error) {
     authToken.value = ''
     currentUser.value = null
+    setSyncFeedback('local', '로그인 후 클라우드 저장을 사용할 수 있습니다.', {
+      visible: false,
+    })
     clearAuthState()
   }
 }
 
 function logout() {
+  clearPendingSyncTimers()
   authToken.value = ''
   currentUser.value = null
+  goals.value = []
+  goalQuery.value = ''
+  goalMessage.value = ''
+  setSyncFeedback('local', '로그인 후 클라우드 저장을 사용할 수 있습니다.', {
+    visible: false,
+  })
   clearAuthState()
+  restoreLocalPlannerRecords()
+}
+
+async function loadGoals() {
+  if (!authToken.value) {
+    return
+  }
+
+  goalBusy.value = true
+
+  try {
+    const result = await fetchGoals(authToken.value, {
+      status: 'active',
+    })
+
+    goals.value = result.goals
+    goalMessage.value = ''
+  } catch (error) {
+    goalMessage.value = error.message || '목표를 불러오지 못했습니다.'
+  } finally {
+    goalBusy.value = false
+  }
+}
+
+async function submitGoal() {
+  if (!goalForm.title.trim() || !goalForm.targetDate) {
+    goalMessage.value = '목표 이름과 날짜를 입력해 주세요.'
+    return
+  }
+
+  goalBusy.value = true
+  goalMessage.value = ''
+
+  try {
+    const result = await createGoal(authToken.value, {
+      title: goalForm.title.trim(),
+      targetDate: goalForm.targetDate,
+    })
+
+    goals.value = [...goals.value, result.goal].sort((left, right) =>
+      left.targetDate.localeCompare(right.targetDate),
+    )
+    selectGoalForPlanner(planner.value, result.goal.id)
+    resetGoalForm()
+    goalQuery.value = ''
+    goalMessage.value = '목표가 추가되었습니다.'
+  } catch (error) {
+    goalMessage.value = error.message || '목표를 추가하지 못했습니다.'
+  } finally {
+    goalBusy.value = false
+  }
+}
+
+function replacePlannerRecords(nextRecords) {
+  Object.keys(plannerRecords).forEach((key) => {
+    delete plannerRecords[key]
+  })
+
+  Object.entries(nextRecords).forEach(([key, record]) => {
+    plannerRecords[key] = record
+  })
+}
+
+function restoreLocalPlannerRecords() {
+  replacePlannerRecords(createInitialPlannerRecords(plannerSeed, normalizeRecord))
+
+  const savedState = readPlannerStorageState()
+
+  if (savedState.selectedDate) {
+    selectedDate.value = toDateValue(savedState.selectedDate, selectedDate.value)
+  }
+
+  if (savedState.calendarViewDate) {
+    calendarViewDate.value = toDateValue(savedState.calendarViewDate, selectedDate.value)
+  }
+}
+
+function findRecordKey(record) {
+  return Object.entries(plannerRecords).find(([, value]) => value === record)?.[0] ?? null
+}
+
+function clearPendingSyncTimers() {
+  syncTimers.forEach((timerId) => {
+    window.clearTimeout(timerId)
+  })
+  syncTimers.clear()
+}
+
+function schedulePlannerSyncForRecord(record) {
+  const recordKey = findRecordKey(record)
+
+  if (!recordKey) {
+    return
+  }
+
+  schedulePlannerSync(recordKey)
+}
+
+function schedulePlannerSync(recordKey) {
+  if (!isAuthenticated.value || isHydratingRemoteRecords) {
+    return
+  }
+
+  if (syncTimers.has(recordKey)) {
+    window.clearTimeout(syncTimers.get(recordKey))
+  }
+
+  setSyncFeedback('syncing', '클라우드 저장 중...', {
+    sticky: true,
+  })
+
+  const timerId = window.setTimeout(async () => {
+    syncTimers.delete(recordKey)
+
+    try {
+      const record = plannerRecords[recordKey]
+
+      if (!record) {
+        if (syncTimers.size === 0) {
+          setSyncFeedback('cloud', '클라우드 동기화 연결됨')
+        }
+        return
+      }
+
+      if (!hasPlannerContent(record)) {
+        await deletePlannerEntry(authToken.value, recordKey)
+
+        if (syncTimers.size === 0) {
+          setSyncFeedback('cloud', '클라우드에서 삭제됨')
+        }
+        return
+      }
+
+      await savePlannerEntry(authToken.value, recordKey, {
+        ...record,
+        tasks: record.tasks.map((task) => ({ ...task })),
+        memo: record.memo.map((item) => ({ ...item })),
+        timetable: [...record.timetable],
+      })
+
+      if (syncTimers.size === 0) {
+        setSyncFeedback('cloud', '클라우드에 저장됨')
+      }
+    } catch (error) {
+      setSyncFeedback('error', error.message || '클라우드 저장에 실패했습니다.', {
+        duration: 3200,
+      })
+    }
+  }, 500)
+
+  syncTimers.set(recordKey, timerId)
+}
+
+async function hydratePlannerRecordsFromApi() {
+  if (!authToken.value) {
+    return
+  }
+
+  isHydratingRemoteRecords = true
+  setSyncFeedback('syncing', '클라우드 데이터를 불러오는 중...', {
+    sticky: true,
+  })
+
+  try {
+    const result = await fetchPlannerEntries(authToken.value)
+    const remoteRecords = {}
+
+    result.entries.forEach((entry) => {
+      remoteRecords[entry.entryDate] = normalizeRecord(entry.payload)
+    })
+
+    replacePlannerRecords(remoteRecords)
+
+    setSyncFeedback('cloud', '클라우드 동기화 연결됨')
+  } catch (error) {
+    setSyncFeedback('error', error.message || '클라우드 데이터를 불러오지 못했습니다.', {
+      duration: 3200,
+    })
+  } finally {
+    isHydratingRemoteRecords = false
+  }
 }
 
 function applyPrintPageStyle(layout) {
@@ -677,6 +978,9 @@ async function printSelectedPlanner(layout = 'single') {
 }
 
 onMounted(() => {
+  setSyncFeedback('local', '로그인 후 클라우드 저장을 사용할 수 있습니다.', {
+    visible: false,
+  })
   restoreAuthSession()
 })
 </script>
@@ -729,7 +1033,10 @@ onMounted(() => {
                 </button>
               </template>
             </div>
-            <div class="inline-flex rounded-full border border-stone-200 bg-stone-100 p-1">
+            <div
+              v-if="isAuthenticated"
+              class="inline-flex rounded-full border border-stone-200 bg-stone-100 p-1"
+            >
               <button
                 type="button"
                 class="rounded-full px-4 py-2 text-xs font-bold tracking-[0.14em] transition"
@@ -747,7 +1054,10 @@ onMounted(() => {
                 STATS
               </button>
             </div>
-            <div class="inline-flex rounded-full border border-stone-200 bg-stone-100 p-1">
+            <div
+              v-if="isAuthenticated"
+              class="inline-flex rounded-full border border-stone-200 bg-stone-100 p-1"
+            >
               <button
                 type="button"
                 class="rounded-full px-4 py-2 text-xs font-bold tracking-[0.14em] transition"
@@ -765,7 +1075,10 @@ onMounted(() => {
                 2 PAGE SPREAD
               </button>
             </div>
-            <div class="inline-flex items-center gap-2 rounded-full border border-stone-200 bg-white px-2 py-2">
+            <div
+              v-if="isAuthenticated"
+              class="inline-flex items-center gap-2 rounded-full border border-stone-200 bg-white px-2 py-2"
+            >
               <button
                 type="button"
                 class="rounded-full border border-stone-200 px-3 py-2 text-xs font-bold tracking-[0.14em] text-stone-600 transition hover:border-stone-400 hover:text-ink"
@@ -782,7 +1095,7 @@ onMounted(() => {
               </button>
             </div>
             <div
-              v-if="screenMode === 'planner'"
+              v-if="isAuthenticated && screenMode === 'planner'"
               class="inline-flex items-center gap-2 rounded-full border border-stone-200 bg-white px-2 py-2"
             >
               <button
@@ -805,7 +1118,64 @@ onMounted(() => {
       </header>
 
       <section
-        v-if="screenMode === 'planner' && viewMode === 'focus'"
+        v-if="!isAuthenticated"
+        class="print-hidden rounded-[32px] border border-white/60 bg-white/65 p-6 shadow-[0_24px_80px_rgba(28,25,23,0.08)] sm:p-8"
+      >
+        <div class="mx-auto flex max-w-3xl flex-col gap-6 text-center">
+          <div class="space-y-3">
+            <p class="text-[11px] font-bold uppercase tracking-[0.28em] text-stone-500">Members Only</p>
+            <h2 class="text-3xl font-semibold tracking-[-0.05em] text-stone-900 sm:text-4xl">
+              로그인 후 플래너를 작성하고<br>
+              클라우드에 안전하게 저장하세요
+            </h2>
+            <p class="mx-auto max-w-2xl text-sm leading-7 text-stone-600 sm:text-base">
+              이제 플래너는 사용자 계정 기준으로 문서와 통계가 연결됩니다. 로그인하지 않은 상태에서는 데이터가 섞일 수 있어
+              작성 화면을 열지 않도록 변경했습니다.
+            </p>
+          </div>
+
+          <div class="grid gap-4 rounded-[28px] border border-stone-200 bg-[#fbf7f0] p-5 text-left sm:grid-cols-3">
+            <article class="rounded-2xl border border-stone-200 bg-white px-4 py-5">
+              <p class="text-[10px] font-bold tracking-[0.18em] text-stone-500">ACCOUNT</p>
+              <p class="mt-3 text-sm font-semibold leading-6 text-stone-800">
+                회원가입 후 사용자별 플래너와 통계를 분리해서 관리합니다.
+              </p>
+            </article>
+            <article class="rounded-2xl border border-stone-200 bg-white px-4 py-5">
+              <p class="text-[10px] font-bold tracking-[0.18em] text-stone-500">CLOUD SAVE</p>
+              <p class="mt-3 text-sm font-semibold leading-6 text-stone-800">
+                작성 내용은 날짜별로 서버에 저장되고, 다른 기기에서도 이어볼 수 있습니다.
+              </p>
+            </article>
+            <article class="rounded-2xl border border-stone-200 bg-white px-4 py-5">
+              <p class="text-[10px] font-bold tracking-[0.18em] text-stone-500">PRINT & STATS</p>
+              <p class="mt-3 text-sm font-semibold leading-6 text-stone-800">
+                로그인 기반 데이터로 통계와 출력 흐름을 안정적으로 맞춰갑니다.
+              </p>
+            </article>
+          </div>
+
+          <div class="flex flex-col items-center justify-center gap-3 sm:flex-row">
+            <button
+              type="button"
+              class="rounded-full border border-stone-300 bg-white px-6 py-3 text-xs font-bold tracking-[0.18em] text-stone-700 transition hover:border-stone-500 hover:text-stone-900"
+              @click="openAuthDialog('login')"
+            >
+              LOGIN
+            </button>
+            <button
+              type="button"
+              class="rounded-full bg-stone-900 px-6 py-3 text-xs font-bold tracking-[0.18em] text-white transition hover:bg-stone-700"
+              @click="openAuthDialog('signup')"
+            >
+              SIGN UP
+            </button>
+          </div>
+        </div>
+      </section>
+
+      <section
+        v-else-if="screenMode === 'planner' && viewMode === 'focus'"
         class="print-hidden grid gap-6 xl:grid-cols-[minmax(0,1fr)_320px]"
       >
         <div class="print-target">
@@ -813,7 +1183,8 @@ onMounted(() => {
             :date-main="selectedDateDisplay.main"
             :date-weekday="selectedDateDisplay.weekday"
             :date-weekday-tone="selectedDateDisplay.weekdayTone"
-            :dday="planner.dday"
+            :dday="plannerDday"
+            :show-dday="showPlannerDday"
             :comment="planner.comment"
             :total-time="formatTotalTime(planner)"
             :tasks="planner.tasks"
@@ -880,6 +1251,96 @@ onMounted(() => {
             </div>
           </section>
 
+          <section class="border border-stone-200 bg-white/80 p-5">
+            <div class="flex items-start justify-between gap-3">
+              <div>
+                <p class="text-[11px] font-bold tracking-[0.22em] text-ink">D-DAY 사용</p>
+                <p class="mt-2 text-[11px] font-semibold leading-5 tracking-[0.06em] text-stone-600">
+                  목표를 검색해서 오늘의 대표 목표로 선택하면 본문 상단 D-DAY에 표시됩니다.
+                </p>
+              </div>
+              <button
+                type="button"
+                class="rounded-full border px-3 py-2 text-[10px] font-bold tracking-[0.16em] transition"
+                :class="planner.goalEnabled ? 'border-stone-900 bg-stone-900 text-white' : 'border-stone-300 text-stone-500'"
+                @click="updateGoalEnabled(planner, !planner.goalEnabled)"
+              >
+                {{ planner.goalEnabled ? 'ON' : 'OFF' }}
+              </button>
+            </div>
+
+            <div class="mt-4 space-y-3">
+              <div v-if="planner.goalEnabled && plannerGoal" class="rounded-2xl border border-stone-200 bg-white px-4 py-3">
+                <p class="text-[10px] font-bold tracking-[0.16em] text-stone-500">현재 목표</p>
+                <p class="mt-2 text-sm font-semibold tracking-[0.02em] text-stone-900">{{ plannerGoal.title }}</p>
+                <p class="mt-1 text-[11px] font-semibold tracking-[0.06em] text-stone-500">
+                  목표일 {{ plannerGoal.targetDate }} / {{ plannerDday }}
+                </p>
+              </div>
+
+              <div v-if="goals.length > 0" class="space-y-2">
+                <input
+                  v-model="goalQuery"
+                  type="text"
+                  class="w-full rounded-2xl border border-stone-300 bg-white px-4 py-3 text-sm font-semibold text-stone-800 outline-none transition focus:border-stone-500"
+                  placeholder="목표 검색"
+                />
+                <div class="max-h-52 space-y-2 overflow-y-auto pr-1">
+                  <button
+                    v-for="goal in filteredGoals"
+                    :key="goal.id"
+                    type="button"
+                    class="w-full rounded-2xl border px-4 py-3 text-left transition"
+                    :class="planner.selectedGoalId === goal.id ? 'border-stone-900 bg-stone-900 text-white' : 'border-stone-200 bg-white text-stone-800 hover:border-stone-400'"
+                    @click="selectGoalForPlanner(planner, goal.id)"
+                  >
+                    <p class="text-sm font-semibold tracking-[0.02em]">{{ goal.title }}</p>
+                    <p
+                      class="mt-1 text-[11px] font-semibold tracking-[0.06em]"
+                      :class="planner.selectedGoalId === goal.id ? 'text-stone-200' : 'text-stone-500'"
+                    >
+                      목표일 {{ goal.targetDate }}
+                    </p>
+                  </button>
+                </div>
+              </div>
+
+              <div v-else class="rounded-2xl border border-dashed border-stone-300 bg-white/70 px-4 py-4">
+                <p class="text-[11px] font-semibold leading-5 tracking-[0.06em] text-stone-500">
+                  아직 목표가 없습니다. 아래에서 첫 목표를 추가해 주세요.
+                </p>
+              </div>
+
+              <div class="rounded-2xl border border-stone-200 bg-[#fbf7f0] p-4">
+                <p class="text-[10px] font-bold tracking-[0.16em] text-stone-500">새 목표 추가</p>
+                <div class="mt-3 space-y-2">
+                  <input
+                    v-model="goalForm.title"
+                    type="text"
+                    class="w-full rounded-2xl border border-stone-300 bg-white px-4 py-3 text-sm font-semibold text-stone-800 outline-none transition focus:border-stone-500"
+                    placeholder="예: 자격증 시험 / 런칭 / 프로젝트 마감"
+                  />
+                  <input
+                    v-model="goalForm.targetDate"
+                    type="date"
+                    class="w-full rounded-2xl border border-stone-300 bg-white px-4 py-3 text-sm font-semibold text-stone-800 outline-none transition focus:border-stone-500"
+                  />
+                  <button
+                    type="button"
+                    class="w-full rounded-full bg-stone-900 px-4 py-3 text-[10px] font-bold tracking-[0.18em] text-white transition hover:bg-stone-700 disabled:cursor-not-allowed disabled:bg-stone-400"
+                    :disabled="goalBusy"
+                    @click="submitGoal"
+                  >
+                    {{ goalBusy ? '추가 중...' : 'GOAL ADD' }}
+                  </button>
+                </div>
+                <p v-if="goalMessage" class="mt-3 text-[11px] font-semibold leading-5 tracking-[0.06em] text-stone-600">
+                  {{ goalMessage }}
+                </p>
+              </div>
+            </div>
+          </section>
+
           <MiniCalendar
             :month-label="monthLabel"
             :year-label="yearLabel"
@@ -933,7 +1394,8 @@ onMounted(() => {
               :date-main="selectedDateDisplay.main"
               :date-weekday="selectedDateDisplay.weekday"
               :date-weekday-tone="selectedDateDisplay.weekdayTone"
-              :dday="planner.dday"
+              :dday="plannerDday"
+              :show-dday="showPlannerDday"
               :comment="planner.comment"
               :total-time="formatTotalTime(planner)"
               :tasks="planner.tasks"
@@ -954,7 +1416,8 @@ onMounted(() => {
               :date-main="secondaryDateDisplay.main"
               :date-weekday="secondaryDateDisplay.weekday"
               :date-weekday-tone="secondaryDateDisplay.weekdayTone"
-              :dday="secondaryPlanner.dday"
+              :dday="''"
+              :show-dday="false"
               :comment="secondaryPlanner.comment"
               :total-time="formatTotalTime(secondaryPlanner)"
               :tasks="secondaryPlanner.tasks"
@@ -987,14 +1450,15 @@ onMounted(() => {
         @update:range-end="statsRangeEnd = $event"
       />
 
-      <section class="print-only">
+      <section v-if="isAuthenticated" class="print-only">
         <div v-if="printLayout === 'single'" class="print-paper print-paper--single">
           <div class="print-sheet-frame">
             <PlannerPage
               :date-main="selectedDateDisplay.main"
               :date-weekday="selectedDateDisplay.weekday"
               :date-weekday-tone="selectedDateDisplay.weekdayTone"
-              :dday="planner.dday"
+              :dday="plannerDday"
+              :show-dday="showPlannerDday"
               :comment="planner.comment"
               :total-time="formatTotalTime(planner)"
               :tasks="planner.tasks"
@@ -1018,7 +1482,8 @@ onMounted(() => {
               :date-main="selectedDateDisplay.main"
               :date-weekday="selectedDateDisplay.weekday"
               :date-weekday-tone="selectedDateDisplay.weekdayTone"
-              :dday="planner.dday"
+              :dday="plannerDday"
+              :show-dday="showPlannerDday"
               :comment="planner.comment"
               :total-time="formatTotalTime(planner)"
               :tasks="planner.tasks"
@@ -1039,7 +1504,8 @@ onMounted(() => {
               :date-main="secondaryDateDisplay.main"
               :date-weekday="secondaryDateDisplay.weekday"
               :date-weekday-tone="secondaryDateDisplay.weekdayTone"
-              :dday="secondaryPlanner.dday"
+              :dday="''"
+              :show-dday="false"
               :comment="secondaryPlanner.comment"
               :total-time="formatTotalTime(secondaryPlanner)"
               :tasks="secondaryPlanner.tasks"
@@ -1070,5 +1536,26 @@ onMounted(() => {
       @switch-mode="authMode = $event; authMessage = ''"
       @update:field="updateAuthField"
     />
+
+    <transition
+      enter-active-class="transition duration-200 ease-out"
+      enter-from-class="translate-y-2 opacity-0"
+      enter-to-class="translate-y-0 opacity-100"
+      leave-active-class="transition duration-200 ease-in"
+      leave-from-class="translate-y-0 opacity-100"
+      leave-to-class="translate-y-2 opacity-0"
+    >
+      <div
+        v-if="isAuthenticated && syncToastVisible"
+        class="pointer-events-none fixed bottom-5 right-5 z-40 max-w-[240px] rounded-full border border-stone-200/70 bg-white/80 px-3 py-2 shadow-[0_10px_24px_rgba(28,25,23,0.08)] backdrop-blur"
+      >
+        <p
+          class="text-[11px] font-semibold tracking-[0.04em]"
+          :class="syncStatus === 'error' ? 'text-red-500' : syncStatus === 'syncing' ? 'text-blue-500' : 'text-stone-500'"
+        >
+          {{ syncMessage }}
+        </p>
+      </div>
+    </transition>
   </main>
 </template>

src/components/PlannerPage.vue

@@ -16,7 +16,11 @@ const props = defineProps({
   },
   dday: {
     type: String,
-    required: true,
+    default: '',
+  },
+  showDday: {
+    type: Boolean,
+    default: true,
   },
   comment: {
     type: String,
@@ -119,14 +123,14 @@ onBeforeUnmount(() => {
   >
     <div class="flex flex-col gap-4 py-[18px]">
       <div class="flex gap-4">
-        <div class="relative h-[90px] w-[394px] flex-1 border-t border-ink px-[10px] pt-[10px]">
+        <div class="relative h-[90px] border-t border-ink px-[10px] pt-[10px]" :class="props.showDday ? 'w-[394px] flex-1' : 'w-full flex-1'">
           <span class="absolute -top-2 left-0 bg-paper px-[2px] text-muted">YEAR / MONTH / DAY</span>
           <p class="pt-6 text-xs tracking-[0.24em] text-ink sm:text-sm">
             <span>{{ dateMain }}</span>
             <span class="ml-1" :class="dateWeekdayTone">{{ dateWeekday }}</span>
           </p>
         </div>
-        <div class="relative h-[90px] w-[210px] border-t border-ink px-[10px] pt-[10px]">
+        <div v-if="props.showDday" class="relative h-[90px] w-[210px] border-t border-ink px-[10px] pt-[10px]">
           <span class="absolute -top-2 left-0 bg-paper px-[2px] text-muted">D-DAY</span>
           <p class="pt-6 text-xs tracking-[0.24em] text-ink sm:text-sm">{{ dday }}</p>
         </div>

src/lib/goalsApi.js

@@ -0,0 +1,49 @@
+const API_BASE_URL = import.meta.env.VITE_API_BASE_URL ?? 'http://localhost:3001'
+
+function buildHeaders(token) {
+  return {
+    'Content-Type': 'application/json',
+    Authorization: `Bearer ${token}`,
+  }
+}
+
+async function request(path, { method = 'GET', token, body } = {}) {
+  const response = await fetch(`${API_BASE_URL}${path}`, {
+    method,
+    headers: buildHeaders(token),
+    body: body ? JSON.stringify(body) : undefined,
+  })
+
+  const data = await response.json().catch(() => ({}))
+
+  if (!response.ok) {
+    throw new Error(data.message || '목표 데이터를 처리하지 못했습니다.')
+  }
+
+  return data
+}
+
+export async function fetchGoals(token, { query = '', status = 'active' } = {}) {
+  const searchParams = new URLSearchParams()
+
+  if (query) {
+    searchParams.set('query', query)
+  }
+
+  if (status) {
+    searchParams.set('status', status)
+  }
+
+  const queryString = searchParams.toString()
+  return request(`/api/goals${queryString ? `?${queryString}` : ''}`, {
+    token,
+  })
+}
+
+export async function createGoal(token, payload) {
+  return request('/api/goals', {
+    method: 'POST',
+    token,
+    body: payload,
+  })
+}

src/lib/plannerApi.js

@@ -0,0 +1,58 @@
+const API_BASE_URL = import.meta.env.VITE_API_BASE_URL ?? 'http://localhost:3001'
+
+function buildHeaders(token) {
+  return {
+    'Content-Type': 'application/json',
+    Authorization: `Bearer ${token}`,
+  }
+}
+
+async function request(path, { method = 'GET', token, body } = {}) {
+  const response = await fetch(`${API_BASE_URL}${path}`, {
+    method,
+    headers: buildHeaders(token),
+    body: body ? JSON.stringify(body) : undefined,
+  })
+
+  const data = await response.json().catch(() => ({}))
+
+  if (!response.ok) {
+    throw new Error(data.message || '플래너 데이터를 처리하지 못했습니다.')
+  }
+
+  return data
+}
+
+export async function fetchPlannerEntries(token, range = {}) {
+  const searchParams = new URLSearchParams()
+
+  if (range.from) {
+    searchParams.set('from', range.from)
+  }
+
+  if (range.to) {
+    searchParams.set('to', range.to)
+  }
+
+  const query = searchParams.toString()
+  return request(`/api/planner${query ? `?${query}` : ''}`, {
+    token,
+  })
+}
+
+export async function savePlannerEntry(token, entryDate, payload) {
+  return request(`/api/planner/${entryDate}`, {
+    method: 'PUT',
+    token,
+    body: {
+      payload,
+    },
+  })
+}
+
+export async function deletePlannerEntry(token, entryDate) {
+  return request(`/api/planner/${entryDate}`, {
+    method: 'DELETE',
+    token,
+  })
+}

src/lib/plannerStorage.js

@@ -13,6 +13,10 @@ function readStorageState() {
   }
 }
 
+export function readPlannerStorageState() {
+  return readStorageState()
+}
+
 export function createInitialPlannerRecords(seedRecords, normalizeRecord) {
   const baseRecords = Object.fromEntries(
     Object.entries(seedRecords).map(([key, record]) => [key, normalizeRecord(record)]),
@@ -62,31 +66,37 @@ export function persistPlannerState({
   calendarViewDate,
   statsRangeStart,
   statsRangeEnd,
+  includeRecords = true,
 }) {
   if (typeof window === 'undefined') {
     return
   }
 
-  const serializableRecords = Object.fromEntries(
+  const previousState = readStorageState()
-    Object.entries(plannerRecords).map(([key, record]) => [
+  const nextState = {
-      key,
+    ...previousState,
-      {
+    selectedDate: selectedDate.toISOString(),
-        ...record,
+    calendarViewDate: calendarViewDate.toISOString(),
-        tasks: record.tasks.map((task) => ({ ...task })),
+    statsRangeStart,
-        memo: record.memo.map((item) => ({ ...item })),
+    statsRangeEnd,
-        timetable: [...record.timetable],
+  }
-      },
+
-    ]),
+  if (includeRecords) {
-  )
+    nextState.records = Object.fromEntries(
+      Object.entries(plannerRecords).map(([key, record]) => [
+        key,
+        {
+          ...record,
+          tasks: record.tasks.map((task) => ({ ...task })),
+          memo: record.memo.map((item) => ({ ...item })),
+          timetable: [...record.timetable],
+        },
+      ]),
+    )
+  }
 
   window.localStorage.setItem(
     STORAGE_KEY,
-    JSON.stringify({
+    JSON.stringify(nextState),
-      selectedDate: selectedDate.toISOString(),
-      calendarViewDate: calendarViewDate.toISOString(),
-      statsRangeStart,
-      statsRangeEnd,
-      records: serializableRecords,
-    }),
   )
 }