모바일 플래너 여백과 타임테이블 터치 개선

HANDOFF.md

@@ -4,7 +4,7 @@
 
 - 프로젝트명: 10 Minute Planner 웹 UI
 - 기술 스택: Vue 3 + Vite + TailwindCSS + JavaScript
-- 현재 기준 버전: `v0.1.43` 준비 중
+- 현재 기준 버전: `v0.1.56`
 - Git 원격 저장소: `https://git.sori.studio/zenn/planner.sori.studio.git`
 
 ## 기준 디자인
@@ -38,6 +38,7 @@
 - 백엔드 Dockerfile: `backend/Dockerfile`
 - nginx 프록시 설정: `deploy/nginx/default.conf`
 - 실행 가이드 문서: `README.md`
+- 사이트 기본 메타 태그와 파비콘/링크 이미지: `index.html`, `public/assets/favicon.png`, `public/assets/og-image.png`
 - Tailwind 설정은 완료되어 있으며, 이 프로젝트의 스타일링 기준으로 유지한다.
 - 현재 선택 날짜는 시스템 날짜 기준으로 시작한다.
 - `COMMENT`, `TASKS`, `MEMO`는 화면에서 바로 편집할 수 있다.
@@ -49,11 +50,17 @@
 - `TIME TABLE`은 우클릭 드래그 시 선택된 블록을 지우는 방식으로도 편집할 수 있다.
 - `TIME TABLE` 숫자 영역은 선택/드래그로 텍스트가 잡히지 않도록 막아두었다.
 - `TOTAL TIME`은 타임테이블에서 선택된 블록 수를 기준으로 자동 계산된다.
+- `TIME TABLE` 라벨은 왼쪽 클릭 시 현재 날짜 타임테이블을 복사하고, 오른쪽 클릭 시 붙여넣기 메뉴를 연다.
+- `TIME TABLE` 라벨 오른쪽의 `?` 아이콘으로 복사/붙여넣기 사용법을 바로 볼 수 있다.
+- 타임테이블 복사/붙여넣기 결과는 오른쪽 아래 상태 토스트로 바로 안내한다.
+- 모바일과 태블릿처럼 `TIME TABLE`이 아래로 내려가는 구간에서는 6칸 그리드가 남는 폭을 더 넓게 채우도록 조정했다.
+- 미니 달력의 월 이동, 연도 선택, 날짜 버튼은 `mousedown.prevent`로 포커스만 잡히고 실제 이동은 두 번째 클릭에 되는 느낌을 줄이도록 보정했다.
 - 달력은 연/월 이동이 가능하며, 현재 보이는 월과 선택된 날짜 상태를 분리해서 관리한다.
 - 달력 상단은 월 좌우 화살표, 클릭형 연도 선택, `TODAY` 버튼 구조로 동작한다.
 - 입력 내용이 있는 날짜는 달력 하단에 빨간 점으로 표시된다.
 - 상단 날짜 표시에서는 토요일의 `(토)`만 파란색, 일요일의 `(일)`만 빨간색으로 표시한다.
-- 플래너 상태는 `localStorage`에 저장되며, 날짜별 기록과 선택 날짜, 달력 보고 있던 월까지 복원된다.
+- 플래너 상태는 `localStorage`에 저장되며, 날짜별 기록과 통계 범위 같은 UI 상태를 복원한다.
+- 플래너 기록 자체는 로컬에 남기되, 앱을 새로 열 때 기본 기준 날짜는 마지막 열람 날짜가 아니라 항상 오늘 날짜로 맞춘다.
 - `localStorage` 접근 로직은 `src/lib/plannerStorage.js`로 분리하기 시작했고, 이후 API/DB adapter로 교체하기 쉬운 구조로 정리 중이다.
 - 프론트는 헤더에서 `LOGIN` / `SIGN UP` 모달을 열 수 있고, 로그인 상태면 닉네임과 `LOGOUT` 버튼을 표시한다.
 - 인증 토큰과 현재 사용자 정보는 프론트 로컬 저장소에 따로 유지하고, 앱 시작 시 `/api/auth/me`로 세션 복원을 시도한다.
@@ -120,92 +127,10 @@
 
 ## 다음 권장 작업
 
-- `TODO.md` 기준으로 작은 단위씩 구현을 진행한다.
+- 목표 화면에 완료 처리와 보관 상태를 분리해서, 진행 중 목표와 지난 목표를 더 명확하게 나눈다.
-- 목표나 통계 기능보다 먼저, 플래너 본문의 입력과 상호작용을 우선 구현한다.
+- `READ NEXT`의 자동 제안 규칙을 더 자연스럽게 다듬고, 빈 상태 문구도 상황별로 정리한다.
-- 통계 화면 구현은 현재 `localStorage` 기반으로 먼저 진행해도 된다.
+- 공유용 이미지 저장 기능을 인쇄 레이아웃과 같은 기준으로 설계하고 구현한다.
-- DB는 기능 탐색 속도를 해치지 않는 선에서, 저장 레이어를 분리할 수 있는 적절한 시점에 붙이는 것이 좋다.
+- 로그인/인증 관련 rate limit 정책을 정해서 무차별 대입 시도를 방어한다.
-- 현재 기준 추천 백엔드 방향은 `Vue 프론트엔드 + Node.js API + PostgreSQL`이다.
-- Docker 배포를 시작하는 시점이므로 SQLite보다 PostgreSQL을 기본 저장소로 유지하는 편이 낫다.
-- 현재 인증 방식은 Bearer 토큰 기반의 간단한 세션 구조이며, 추후 쿠키/리프레시 토큰 전략으로 확장할 수 있다.
-- 다음 프론트 단계에서는 `src/lib/plannerStorage.js`를 유지하되, 인증 이후 백엔드 저장소 adapter를 추가해서 `localStorage`와 전환 가능하게 만드는 흐름이 좋다.
-- 현재 프론트는 인증만 연결된 상태이고, 플래너 저장은 아직 `localStorage` 기준이다.
-- 로그인 상태에서는 플래너 수정 시 날짜별 서버 저장을 예약하고, 로그인 직후에는 서버 데이터를 먼저 가져오도록 연결하기 시작했다.
-- 현재는 로컬 저장도 계속 유지하면서 서버 저장을 병행하는 과도기 구조다.
-- 로그인 시 서버 플래너 데이터로 `plannerRecords`를 교체하고, 로그아웃 시에는 로컬 저장 기반 데이터로 다시 복귀하도록 정리했다.
-- 이로 인해 다른 사용자 로그인 시 이전 로컬 데이터가 서버 계정 데이터와 섞일 위험을 줄였다.
-- 로그인 상태에서 특정 날짜의 플래너 내용을 완전히 비우면, 서버 저장 대신 해당 날짜 엔트리를 삭제하도록 정리했다.
-- 현재는 로그인 전 플래너 진입을 막고, 인증 후에만 실제 플래너/통계 화면을 사용하도록 변경했다.
-- 클라우드 저장 상태는 헤더가 아니라 오른쪽 하단의 작은 토스트 형태로 표시되도록 변경했다.
-- 저장 완료 토스트는 한 줄짜리의 작은 상태 문구로 줄여서 존재감을 낮췄다.
-- D-DAY는 플래너 안에서 목표를 고르는 구조가 아니라, GOALS 화면에서 목표와 표시 기간을 먼저 설정하는 구조로 정리했다.
-- 플래너 화면 오른쪽 패널에서는 현재 날짜에 적용된 목표가 있을 때만 D-DAY 토글을 켤 수 있고, 목표 검색 UI는 제거했다.
-- 목표는 `active_from`, `active_until` 기간을 가질 수 있고, 현재 날짜가 그 범위에 들어올 때만 플래너 본문 D-DAY 후보가 된다.
-- TASK LABELS도 별도 버튼 2개 대신 동일한 토글 UI로 단순화했다. ON이면 01~15를 채우고 OFF이면 비운다.
-- SETTINGS 화면이 추가되어 닉네임, 이메일, 비밀번호 변경을 분리해서 관리할 수 있다.
-- 백엔드에는 `/api/auth/profile`, `/api/auth/password`, `/api/goals/:goalId` 수정 API가 추가되었다.
-- 백엔드에는 `/api/goals/:goalId` 삭제 API도 추가되었다.
-- 왼쪽 사이드, 플래너 본문 래퍼, 오른쪽 정보 패널 모두 둥근 카드 톤으로 맞춰서 화면 전체의 통일감을 높였다.
-- 플래너 집중 보기에서는 본문과 오른쪽 패널이 각각 독립 스크롤되도록 바뀌어서 동시에 참조하기 쉽다.
-- TASK LABELS, D-DAY 토글은 공통 사이즈의 스위치로 통일했고, `translate` 기반 애니메이션으로 부드럽게 움직이게 했다.
-- 목표 생성 폼은 기본적으로 `표시 시작일 = 오늘`, `표시 종료일 = 목표일` 흐름으로 자동 채워진다.
-- D-DAY 기간은 서로 겹칠 수 없고, 프론트와 백엔드 모두 중복 기간을 감지하면 저장을 막는다.
-- 현재 날짜에 적용된 목표가 있는 경우 D-DAY는 기본적으로 보이고, 해당 날짜에서만 토글로 숨길 수 있다.
-- 목표 상태 개념은 제거했고, 목표는 기간이 있으면 곧바로 D-DAY 후보가 되는 단순 구조로 정리했다.
-- GOALS 화면에서는 수정 중인 카드가 시각적으로 강조되고, 목표 삭제 버튼이 추가되었다.
-- 목표 삭제 시 과거 날짜를 포함해 어떤 날짜에서도 해당 목표는 더 이상 표시되지 않는다.
-- 우측 패널의 `PREV SNAPSHOT`은 선택 날짜 이전의 가장 최근 기록을 읽어서 날짜, 집중 시간, 완료 개수, 코멘트 또는 대표 작업을 보여준다.
-- 우측 패널의 `READ NEXT`는 다음 날 첫 작업, 오늘의 미완료 작업, 오늘 코멘트를 기반으로 이어보기 문구를 자동 생성한다.
-- 백엔드는 SQLite 파일 기반 구조에서 PostgreSQL 연결 구조로 교체되었다.
-- `planner_entries.payload`는 문자열이 아니라 PostgreSQL `JSONB`로 저장되도록 바뀌었다.
-- `docker-compose.yml` 기준으로 `postgres`, `backend`, `frontend(nginx)` 3개 서비스 초안이 추가되었다.
-- 프론트는 nginx에서 `/api`를 백엔드로 프록시하는 구조라서, 배포 시 브라우저가 별도 API 포트를 직접 알 필요가 없다.
-- 프론트 API 클라이언트는 `VITE_API_BASE_URL` 끝에 `/api`가 포함되어 있어도 `/api/api/...` 중복 주소가 생기지 않도록 정규화한다.
-- 로그인 실패 시에는 내부 라우트 문자열이나 서버 경로를 그대로 노출하지 않고, 사용자용 안내 문구만 보여준다.
-- 비로그인 상태에서는 왼쪽 사이드 내비게이션을 숨기고, 중앙 로그인 안내 화면만 보여주도록 정리했다.
-- 배포용 `docker-compose.yml`과 별도로 개발용 `docker-compose.dev.yml`을 추가했다.
-- 개발용 compose는 프론트 `5173`, 백엔드 `3001`, PostgreSQL `5432`를 열고, 소스 마운트 + Vite HMR + Node watch 기반으로 자동 반영된다.
-- 개발/배포 실행 방법은 루트 `README.md`에 먼저 적고, `HANDOFF.md`에는 변경 이유와 주의사항 위주로 남긴다.
-- API 클라이언트는 body가 없는 `GET`, `DELETE` 요청에 `Content-Type: application/json`을 붙이지 않도록 수정했다. 날짜 선택 시 발생하던 `Body cannot be empty...` 오류는 이 문제였다.
-- 날짜 이동 중 목표 자동 보정으로 `goalEnabled`만 꺼지는 경우에는, 실제 내용이 없는 기록이라면 클라우드 동기화 토스트를 띄우지 않도록 정리했다.
-- 집중 보기에서 오른쪽 패널 폭을 넓혀 `1920x1080` 기준 활용도를 높였고, `TASK LABELS / D-DAY / CALENDAR`는 상단 고정 영역으로 올렸다.
-- `STATS`와 `NEXT DAY`는 반반 카드가 아니라 각각 한 줄씩 쓰도록 바꿔서 날짜 길이에 따라 높이가 흔들리는 문제를 줄였다.
-- 미니 달력은 42칸 기준으로 렌더링하고, 요일 헤더를 `SUN ~ SAT` 순서로 고정해서 일요일 시작 달력 기준을 더 명확하게 맞췄다.
-- 집중 보기 오른쪽 패널은 다시 정리해서 `왼쪽 컬럼: CALENDAR / TASK LABELS / D-DAY`, `오른쪽 컬럼: STATS / NEXT DAY`, `하단 전체 폭: READ NEXT / PREV SNAPSHOT` 구조로 맞췄다.
-- 달력은 과하게 키우지 않고 컴팩트한 크기를 유지한 채, 우측 정보 패널 내부 배치만 다시 조정하는 쪽으로 방향을 잡았다.
-- `PRINT 2-UP`은 브라우저/프린터 기본 여백 차이로 오른쪽 페이지가 잘릴 수 있어서, 프레임 폭과 스케일을 조금 더 보수적으로 줄여 안정성을 높였다.
-- 플래너 집중 보기 반응형 기준은 `1620px 이상: 우측 패널 2열`, `1280px 이상 ~ 1619px 이하: 우측 패널 1열 + 최대 360px`, `1280px 미만: 우측 패널 오버레이` 구조로 다시 정리했다.
-- 오버레이 구간에서는 본문 오른쪽 위의 `OPEN SIDE PANEL` 버튼으로 패널을 열고, 배경 클릭이나 `CLOSE` 버튼으로 닫는다.
-- `2 PAGE SPREAD`는 화면 폭을 기준으로 배율을 자동 계산해서 오른쪽 페이지가 잘리는 현상을 줄이는 방향으로 조정했다.
-- `1280px` 미만에서는 왼쪽 내비게이션도 본문 위에 쌓이지 않고 `MENU` 버튼으로 여는 드로어형 패널로 전환된다.
-- 태블릿/모바일 구간에서는 `왼쪽 내비게이션 드로어 + 오른쪽 정보 패널 오버레이 + 본문 단일 컬럼` 조합으로 보는 흐름을 기본값으로 삼는다.
-- 통계 화면과 우측 `FOCUSED TIME` 요약처럼 사용자에게 보여주는 집중 시간 표기는 `00H 00M` 대신 `00시간 00분` 한글 형식으로 바꿨다.
-- 좌측 메뉴 드로어와 우측 정보 패널 오버레이는 이제 열고 닫힐 때 페이드 + 슬라이드 애니메이션이 적용된다.
-- 모바일처럼 좁은 화면에서는 본문 래퍼 패딩을 조금 줄이고, 우측 패널 열기 버튼 문구를 `INFO`로 축약해 밀도를 낮췄다.
-- 플래너 본문은 작은 화면에서 상단 정보 영역이 세로로 쌓이고, `TIME TABLE`이 아래로 내려가도록 조정했다.
-- 모바일 구간에서는 TASKS / MEMO 행 높이와 좌우 패딩을 조금 줄여 입력 밀도를 낮췄고, 타임테이블은 필요할 때만 최소 가로 스크롤이 생기도록 바뀌었다.
-- 미니 달력은 모바일 구간에서 패딩, 월 이동 버튼, 요일 헤더, 날짜 셀 크기를 한 단계 더 줄여서 카드 내부 밀도를 정리했다.
-- 연도 선택 팝오버는 좁은 화면에서 카드 전체 폭을 활용하고, 넓은 화면에서는 기존 우측 드롭다운 폭을 유지한다.
-- 플래너 본문 안의 `TOTAL TIME` 라벨도 `총 시간`으로 바꿔서 영어 라벨을 줄였다.
-- 사용자 노출 메뉴 문구는 `보기 방식 / 날짜 이동 / 인쇄 / 1페이지 + 정보 / 2페이지 펼침 / 이전 날 / 다음 날 / 1장 인쇄 / 2장 인쇄`처럼 한글 중심으로 정리하기 시작했다.
-- 2페이지 펼침 보기 배율 계산에서 데스크톱 여유 폭을 더 보수적으로 잡아, `1920px` 근처에서 우측 페이지가 잘려 가로 스크롤이 생기던 문제를 줄이는 방향으로 조정했다.
-- 달력 날짜 버튼은 셀 안쪽에 고정 크기 원형 버튼으로 다시 배치해서 모바일에서 서로 겹쳐 보이는 현상을 줄였다.
-- 좌측 상단 소개 영역은 개발 설명 문장을 빼고, 서비스 소개용 짧은 카피와 배지 스타일로 다시 구성했다.
-- 달력 날짜 버튼은 의도상 원형이며, 현재는 `size` 고정 기준으로 다시 맞춰서 타원처럼 보이는 인상을 줄이는 방향으로 정리했다.
-- 플래너 본문, 2페이지 펼침, 인쇄 전용 `PlannerPage` 모두 `총 시간` 값은 `00시간 00분` 한글 포맷으로 통일했다.
-- 모바일 대응 이후 인쇄에서 `TIME TABLE`이 사라지던 문제를 막기 위해, print 시에는 `PlannerPage` 내부 레이아웃을 다시 가로 배치로 고정하고 타임테이블 오버플로를 해제하도록 보정했다.
-- 인쇄 레이아웃은 추가로 미세 조정해 `COMMENT` 영역이 잘리지 않도록 textarea 높이/행간을 print 전용으로 풀고, `1-UP` / `2-UP` 배율도 프레임 실측 기준으로 다시 계산했다.
-- `TODO.md`는 중복 체크 항목을 정리했고, 인증 확장을 위해 `이메일 인증 / 비밀번호 재설정 / rate limit / 메일 인프라` 작업을 별도 항목으로 추가했다.
-- Resend 무료 플랜은 도메인 1개 제약이 있어 현재 프로젝트 인증 메일에는 바로 쓰기 어렵다. 다음 단계에서는 AWS SES 또는 범용 SMTP 공급자 기준으로 메일 발송 추상화를 붙이는 쪽이 적합하다.
-- 현재 인증 메일/재설정 메일은 실제 발송 대신 개발용 `previewUrl`을 응답으로 돌려주는 단계다. 프론트 UI 연결과 실제 메일러 연결은 다음 단계에서 마무리하면 된다.
-- 미니 달력 날짜 버튼은 원형 비율이 흔들리지 않도록 고정 `width/height` 기준으로 다시 맞췄다.
-- 플래너 본문 D-DAY 텍스트는 3줄까지만 보이고, 넘치면 말줄임 처리되도록 정리했다.
-- 목표가 없는 빈 날짜에서는 `D-DAY 사용` 토글이 저장 상태와 무관하게 `OFF + 비활성`처럼 보이도록 보정했다.
-- 관리자 전용 `ADMIN` 메뉴와 기본 대시보드가 추가되었다. 현재는 사용자 수, 최근 접속, 문서 수, 목표 수, 계정별 최종 접속일을 읽기 전용으로 확인할 수 있다.
-- `users` 테이블에 `login_id`, `role`, `last_login_at` 컬럼이 추가되었다.
-- 관리자 계정은 이제 이메일이 아니라 별도 자동 생성 계정으로 관리한다.
-- 관리자 계정은 서버 시작 시 `ADMIN_ACCOUNT_ID`, `ADMIN_ACCOUNT_PASSWORD`, `ADMIN_ACCOUNT_EMAIL`, `ADMIN_ACCOUNT_NICKNAME` 환경변수 조합으로 자동 생성된다.
-- 관리자 아이디와 비밀번호는 저장소 문서에 실제 값을 남기지 않고, Docker 배포 시 루트 `.env` 같은 비공개 환경변수 파일에서만 관리한다.
-- 관리자 대시보드는 현재 읽기 전용이며, 계정 정지/삭제/강제 로그아웃 같은 실제 운영 액션은 아직 없다.
 - 배포용 `docker-compose.yml`은 현재 PostgreSQL 외부 포트 `45432`, 프론트 외부 포트 `48081` 기준이며, DB 계정/비밀번호는 루트 `.env`에서 주입한다.
 - 설정 화면의 보조 메모 카드는 주석 처리되어 현재는 보이지 않는다.
 - 비로그인 랜딩 카드는 상단 고정이 아니라 화면 중앙에 오도록 정렬을 수정했다.
@@ -222,21 +147,32 @@
 - 왼쪽 사이드바의 인쇄 영역은 `PRINT` 버튼 하나로 줄이고, 클릭 시 모달에서 시작일/종료일과 `1페이지씩` 또는 `2페이지씩` 출력 방식을 선택한다. 인쇄 전용 렌더링은 선택 기간의 날짜를 순서대로 여러 장 생성하며, 2페이지씩 출력에서 홀수 날짜가 남으면 오른쪽은 빈 페이지 프레임으로 둔다.
 - 회원가입과 프로필 수정 시 이메일뿐 아니라 닉네임 중복도 서버에서 409로 막는다. 비밀번호 재설정 API는 로그인 모달의 `비밀번호 찾기` 흐름과 연결되어 있고, `/reset-password?token=...` URL로 들어오면 새 비밀번호 설정 모드가 열린다. 실제 메일 발송 전까지는 백엔드 응답의 `resetPreviewUrl`을 개발용 링크로 표시한다.
 - Resend 메일러가 추가되었다. `RESEND_API_KEY`, `MAIL_FROM_EMAIL`, `MAIL_FROM_NAME`, `APP_BASE_URL` 환경변수를 설정하면 이메일 인증과 비밀번호 재설정 메일을 실제로 발송한다. API 키는 저장소에 커밋하지 말고 루트 `.env`/`.env.dev`에만 넣는다.
+- 메일 발송 인프라는 현재 Resend 기준으로 확정했다. 자동 로그아웃 옵션은 플래너를 오래 띄워두는 사용 흐름과 맞지 않아 TODO 대상에서 제외했다.
 - 인증/비밀번호 재설정 개발용 링크는 `AUTH_PREVIEW_LINKS=true`일 때만 API 응답에 포함된다. 운영 `.env`는 반드시 `AUTH_PREVIEW_LINKS=false`로 두어야 하며, 현재 예시 파일도 false가 기본값이다.
 - 회원가입은 이제 자동 로그인되지 않는다. 인증 메일 발송 후 `이메일 인증 후 로그인` 안내만 보여주고, 일반 사용자는 이메일 인증 전까지 로그인할 수 없다.
 - 기존에 발급된 세션이라도 일반 사용자 이메일 인증이 안 되어 있으면 `/api/auth/me` 단계에서 세션을 즉시 폐기한다. 운영 중 인증 정책을 켠 뒤에도 미인증 세션이 남지 않게 하기 위한 장치다.
 - 비밀번호 재설정/이메일 인증용 개발 링크는 `AUTH_PREVIEW_LINKS=true`여도 `APP_BASE_URL`이 `localhost` 또는 `127.0.0.1`일 때만 응답에 포함한다. 상용 서버에서 링크가 그대로 보이면 이 조건부터 확인한다.
 - 프론트는 `/verify-email?token=...` 진입 시 인증을 바로 확정하고 로그인 모달에 결과 메시지를 띄운다. `/reset-password?token=...`은 기존처럼 비밀번호 재설정 모달을 연다.
+- 로그인 모달에는 `이메일 인증 메일 다시 보내기` 버튼이 추가되었다. 이메일 주소를 입력한 상태에서 바로 인증 메일 재전송을 요청할 수 있어, 가입 후 메일을 못 받은 사용자가 로그인 단계에서 막히지 않게 했다.
+- 인증 메일 재전송 버튼은 항상 보이지 않는다. 로그인 모달에서 이메일 인증 관련 안내 메시지가 보일 때만 메시지 박스 오른쪽에 함께 노출한다.
+- 인증 메일 재전송 버튼은 현재 `이메일 인증을 완료한 뒤 로그인해 주세요.` 안내가 있을 때만 표시한다. 인증 완료 메시지나 일반 안내 문구에서는 보이지 않도록 조건을 좁혔다.
 - SETTINGS 화면에 일반 사용자 전용 `회원 탈퇴` 카드가 추가되었다. 현재 비밀번호 확인 후 계정, 플래너 기록, 목표, 세션, 인증 토큰이 함께 삭제된다. 기본 관리자 계정은 이 경로에서 삭제하지 못하게 막는다.
+- `/api/auth/logout`이 추가되어 로그아웃 시 프론트 저장 토큰만 지우는 것이 아니라 서버 세션도 함께 폐기한다.
+- SETTINGS 화면 왼쪽 카드에 현재 기기 로그인 유지 방식(`로그인 유지` 또는 브라우저 세션만 유지), 최근 로그인 시각, 이메일 인증 상태를 보여준다.
+- 현재 로그인 유지 방식은 `authPersist` 상태로 함께 들고 가며, 프로필 저장 후에도 원래 저장 방식(localStorage/sessionStorage)을 유지하도록 정리했다.
+- 사용자 테이블에 `disabledAt` 컬럼이 추가되었다. 관리자가 비활성화한 계정은 즉시 현재 세션이 모두 종료되고, 이후 로그인도 차단된다.
+- 관리자 화면에서 일반 사용자 계정에 대해 `비활성화/다시 허용`, `강제 로그아웃`, `삭제`를 실행할 수 있다. 관리자 계정은 이 화면에서 비활성화하거나 삭제하지 못하게 막는다.
+- 관리자 사용자 목록에는 현재 활성 세션 수와 비활성화 상태가 함께 표시된다.
 - `5173` 포트가 직접 `npm run dev` 없이 열려 있으면 대부분 `ten-minute-frontend-dev` 컨테이너가 떠 있는 상태다. 개발용 Docker를 끄려면 `docker compose -f docker-compose.dev.yml down`을 사용한다.
 - 현재 환경에서는 Docker 데몬이 꺼져 있어서 `docker compose build` 실검증은 하지 못했고, 데몬 시작 후 다시 확인이 필요하다.
 - 이미지 저장 기능은 추후 `print-only` 또는 별도 export 전용 레이아웃을 기준으로 구현하면 화면/인쇄/공유 결과를 맞추기 쉽다.
 - Docker Compose는 프론트엔드와 백엔드를 함께 올리는 기준으로 설계하되, NAS 환경에 맞는 볼륨과 재시작 정책도 함께 고려한다.
+- Docker Compose 개발/배포 파일에는 `TZ=Asia/Seoul`을 명시해 NAS와 컨테이너 내부 기준 시간이 한국 시간으로 맞도록 유지한다.
 - 플래너 본문 라벨은 더 이상 `bg-paper` 배경으로 선을 덮지 않는다. `라벨 + 오른쪽 선` 구조로 바꿔 화면과 인쇄에서 노란 배경이 튀지 않도록 정리했다.
 - 날짜에 적용되는 목표가 새로 생기면 D-DAY는 기본 표시된다. 사용자가 해당 날짜에서 직접 `D-DAY 사용`을 끈 경우에만 로컬 숨김 목록에 저장해 다시 숨긴다.
 - 비로그인 랜딩은 모바일에서 `카드 안 카드`처럼 보이지 않도록 기능 설명 카드를 얇은 리스트로 단순화했고, `LOGIN` / `SIGN UP` 버튼은 같은 너비와 높이로 맞췄다. 로그인/회원가입 모달도 하단 전환 영역을 별도 카드 대신 구분선 형태로 정리했다.
 - 로그인 모달에 `로그인 유지` 체크박스를 추가했다. 기본값은 OFF이며, OFF 상태에서는 인증 토큰을 `sessionStorage`에 저장해 브라우저 세션이 끝나면 사라지고, ON 상태에서만 `localStorage`에 저장한다.
-- 현재 로그아웃은 프론트 저장 토큰을 지우는 수준이다. 개인 기록 서비스 성격을 고려하면 다음 단계에서 서버 세션 폐기 API와 미사용 자동 로그아웃 옵션을 추가하는 편이 좋다.
+- 현재 로그아웃은 `/api/auth/logout`으로 서버 세션까지 함께 폐기한다. 자동 로그아웃 옵션은 플래너를 오래 열어두는 사용 흐름과 맞지 않아 추가 대상에서 제외했다.
 - 비로그인 랜딩에 `DEMO VIEW`를 추가했다. 데모는 실제 저장/로그인 상태와 분리된 읽기 전용 샘플이며, 어제/오늘/내일 3일치 플래너를 전환해서 제품 감각을 먼저 볼 수 있다.
 - 플래너 본문 `MEMO`와 `TIME TABLE` 하단 높이를 맞추기 위해 TASK/MEMO 리스트 간격과 행 높이를 조정했다. TASK 드래그 선택 피드백은 레이아웃 흔들림을 줄이도록 ring 대신 배경색만 사용한다.
 - 이월된 할 일은 `carryoverFrom` 날짜를 가진다. TASK 본문에는 `이월` 배지를 표시하고, 클릭하면 오른쪽 `READ NEXT` 영역에 원래 시작 날짜를 안내한다.
@@ -246,6 +182,9 @@
 - `BEST DAY`는 선택 기간 안에서 집중 시간이 가장 긴 날짜를 고르고, `RECENT RECORDS`는 선택 기간 안의 기록을 날짜 내림차순으로 최대 5개 보여준다.
 - `CARRYOVER TASK` 선택 모달은 ESC로 닫힌다. 이월 배지의 시작일 안내는 오른쪽 패널 메시지 대신 배지 옆 팝업으로 표시한다.
 - 통계의 `BEST DAY`, `RECENT RECORDS` 기준 설명은 본문 문장 대신 물음표 가이드 팝업으로 제공한다.
+- 운영 링크 미리보기용 title/description/Open Graph/Twitter Card 메타 태그를 추가했다. 루트 PNG 요청이 앞단 프록시에서 403이 나는 환경을 피하기 위해 파비콘은 `/assets/favicon.png`, 링크 카드 이미지는 `/assets/og-image.png` 경로로 제공한다.
+- 모바일 focus 화면에서는 플래너 바깥 래핑 카드의 padding을 제거해 플래너 자체 여백만 남긴다.
+- 모바일 타임테이블은 일반 터치/스크롤 중에는 칠하지 않고, 약 420ms 롱터치가 성립된 뒤에만 드래그 편집을 시작한다.
 
 ## 갱신 규칙
 

README.md

@@ -69,6 +69,7 @@ docker compose up -d --build
 - 프론트엔드 nginx
 - 백엔드 Fastify
 - PostgreSQL
+- 배포/개발 컨테이너 시간대: `Asia/Seoul`
 
 ### 3. 실행 상태 확인하기
 

TODO.md

@@ -18,6 +18,7 @@
 - [x] `TIME TABLE`을 마우스 드래그로 칠할 수 있게 만든다.
 - [x] `TIME TABLE` 드래그가 여러 줄을 지나가더라도 시간 흐름 기준으로 연속 선택되도록 처리한다.
 - [x] 선택된 `TIME TABLE` 구간을 기준으로 `TOTAL TIME`을 자동 계산한다.
+- [x] 원하는 날짜의 `TIME TABLE`을 다른 날짜로 복사할 수 있게 한다.
 
 ## 2단계: 달력과 이동 기능
 
@@ -33,6 +34,7 @@
 - [x] 달력 상단은 좌우 화살표로 월 이동하는 구조가 더 적합하다.
 - [x] 연도 클릭 시 연도 선택 UI가 열려야 한다.
 - [x] 오늘 날짜로 즉시 돌아가는 버튼이 필요하다.
+- [x] 모바일에서 플래너 래핑 카드 여백을 줄이고 타임테이블은 롱터치 후 드래그로만 편집되게 한다.
 
 ## 3단계: 목표와 회고 기능
 
@@ -51,14 +53,14 @@
 
 ## 4단계: 데이터 구조와 저장
 
-- [ ] 플래너 데이터 구조를 날짜별 상태 중심으로 정리한다.
+- [x] 플래너 데이터 구조를 날짜별 상태 중심으로 정리한다.
 - [x] 입력 데이터의 저장 위치를 결정한다.
 - [x] 로컬 저장 또는 외부 저장 방식 중 우선 구현 방식을 정한다.
 - [x] 입력 상태가 새로고침 후에도 유지되도록 만든다.
 - [x] DB 전환 시점을 잡을 수 있도록 저장 레이어를 분리한다.
 - [x] 회원 가입 및 로그인 구조를 고려한 사용자별 데이터 모델을 설계한다.
 - [x] 사용자별 문서 저장/조회 흐름을 정리한다.
-- [ ] 출력용 문서 포맷과 프린트 흐름을 고려한 데이터 구조를 정리한다.
+- [x] 출력용 문서 포맷과 프린트 흐름을 고려한 데이터 구조를 정리한다.
 
 ## 추가 반영 메모
 
@@ -71,7 +73,7 @@
 - [x] 통계 페이지 라우팅 또는 화면 전환 구조를 설계한다.
 - [x] 집중 시간, 완료율, 연속 기록 같은 핵심 지표를 정의한다.
 - [x] 사용자가 시작일과 종료일을 선택해서 기간별 통계를 볼 수 있게 한다.
-- [ ] 사용자 개인 통계 화면 기준을 정리한다.
+- [x] 사용자 개인 통계 화면 기준을 정리한다.
 
 ## 6단계: 계정 및 서비스 확장
 
@@ -79,14 +81,15 @@
 - [x] 사용자 설정 화면에서 닉네임 / 이메일 / 비밀번호 수정 흐름을 분리한다.
 - [x] 상단 헤더를 왼쪽 사이드 내비게이션 구조로 재배치한다.
 - [x] 본문과 오른쪽 패널이 각각 독립 스크롤되도록 조정한다.
-- [ ] 사용자별 문서 분리 저장 구조를 설계한다.
+- [x] 사용자별 문서 분리 저장 구조를 설계한다.
-- [ ] 공유가 아닌 개인 보관용 서비스 흐름으로 요구사항을 정리한다.
+- [x] 공유가 아닌 개인 보관용 서비스 흐름으로 요구사항을 정리한다.
 - [x] 향후 출력 기능을 위한 인쇄 레이아웃 요구사항을 정리한다.
 - [x] A4 가로 기준 2장 출력 모드를 지원한다.
 - [x] `1-UP` 세로 인쇄 / `2-UP` 가로 인쇄 기준을 분리한다.
 - [ ] 공유를 위한 이미지 저장 기능을 추가한다.
 - [x] Docker 배포 구조를 정리한다.
 - [x] UGREEN NAS 기준 `docker-compose.yml` 초안을 작성한다.
+- [x] 운영 링크 미리보기용 사이트 제목/소개글 메타 태그와 파비콘을 추가한다.
 - [x] 백엔드 기본 스캐폴딩을 추가한다.
 - [x] PostgreSQL 전환 초안을 적용한다.
 - [x] 로그인 화면 문구와 관리자 정보 노출 지점을 일반 사용자 기준으로 정리한다.
@@ -94,48 +97,13 @@
 - [x] 미완료 항목을 다음 날짜 빈칸으로 이월하는 버튼을 추가한다.
 - [x] 이월된 할 일에 배지를 표시하고 원래 시작 날짜를 확인할 수 있게 한다.
 - [x] 이월된 할 일을 체크할 때 이전 날짜까지 함께 완료할지 선택하는 정책을 추가한다.
-- [ ] 이메일 인증 플로우를 설계하고 구현한다.
+- [x] 이메일 인증 플로우를 설계하고 구현한다.
-- [ ] 비밀번호 찾기 / 재설정 토큰 흐름을 추가한다.
+- [x] 비밀번호 찾기 / 재설정 토큰 흐름을 추가한다.
 - [ ] 로그인 및 인증 관련 rate limit / 잠금 정책을 추가한다.
 - [x] 로그인 유지 여부를 사용자가 선택할 수 있게 한다.
-- [ ] 일정 시간 미사용 시 자동 로그아웃 옵션을 추가한다.
+- [x] 설정 화면에서 현재 기기 로그인 상태와 저장 방식을 안내한다.
-- [ ] 설정 화면에서 현재 기기 로그인 상태와 저장 방식을 안내한다.
+- [x] 서버 세션을 명시적으로 폐기하는 로그아웃 API를 추가한다.
-- [ ] 서버 세션을 명시적으로 폐기하는 로그아웃 API를 추가한다.
+- [x] 메일 발송 인프라와 발신 도메인 정책을 Resend 기준으로 확정한다.
-- [ ] 메일 발송 인프라와 발신 도메인 정책을 확정한다.
+- [x] 관리자 페이지에서 계정 비활성화 / 강제 로그아웃 / 삭제 기능을 추가한다.
-- [ ] Resend 무료 플랜 대체 수단으로 SES 또는 일반 SMTP 연동 방식을 확정한다.
+- [x] 관리자 페이지에서 사용자별 문서 상세 조회 기능을 추가한다.
-- [ ] 관리자 페이지에서 계정 비활성화 / 강제 로그아웃 / 삭제 기능을 추가한다.
+- [x] 관리자 페이지에서 검색 / 정렬 / 필터 UX를 추가한다.
-- [ ] 관리자 페이지에서 사용자별 문서 상세 조회 기능을 추가한다.
-- [ ] 관리자 페이지에서 검색 / 정렬 / 필터 UX를 추가한다.
-
-## 메모
-
-- D-DAY는 현재 보류 상태다. 목표 패널 설계 후 연결한다.
-- D-DAY는 본문에 직접 입력하는 방식보다, 별도 목표 목록에서 선택한 대표 목표를 보여주는 구조가 더 적합하다.
-- 목표가 없는 경우 본문 D-DAY 영역은 숨기고, 오른쪽 패널의 `D-DAY 사용` 메뉴에서 검색/선택하도록 유도한다.
-- `TIME TABLE` 드래그는 단순 사각형 선택이 아니라 시간 셀 단위의 연속 선택으로 해석한다.
-- 현재는 `localStorage`로 개발을 진행하지만, 적절한 시점에 DB를 붙여 사용자별 저장 구조로 확장해야 한다.
-- 현재 `localStorage` 저장 로직은 분리 가능한 형태로 정리 중이며, 이후 API/DB adapter로 교체하기 쉽게 유지한다.
-- 최종적으로는 회원 가입 후 각자 자신의 문서를 작성/관리하고, 개인 통계를 확인하며, 특정 날짜 문서를 출력할 수 있어야 한다.
-- 실제 인쇄는 HTML/CSS 기반 프린트 레이아웃으로 유지하고, 공유용으로는 별도의 이미지 저장 기능을 추가하는 방향이 적합하다.
-- 최종 배포는 UGREEN NAS에서 Docker 기반으로 동작할 예정이며, 포트와 실제 서비스 구성은 추후 확정한다.
-- 백엔드는 빠른 목업이면 PocketBase도 가능하지만, 현재 방향상 커스텀 로직과 확장성을 생각하면 전용 Node.js API + DB 조합을 우선 검토한다.
-- 현재 백엔드는 `backend/` 폴더에 `Fastify + Drizzle + PostgreSQL` 기준으로 전환 중이다.
-- 현재 백엔드는 회원가입, 로그인, 현재 사용자 확인용 기본 인증 API까지 포함한다.
-- 현재 백엔드는 사용자별 플래너 단건 저장/조회와 범위 조회 API까지 포함한다.
-- 현재 백엔드는 사용자별 목표 목록 조회와 목표 생성 API까지 포함한다.
-- 현재는 `docker-compose.yml`로 `postgres + backend + frontend(nginx)` 초안을 올릴 수 있게 정리했다.
-- 현재 환경에서는 Docker 데몬이 꺼져 있어 `docker compose build` 실검증은 아직 완료하지 못했다.
-- 프론트에는 로그인/회원가입 모달과 현재 사용자 상태 표시가 추가되었다.
-- 로그인 상태일 때는 서버 저장을 우선 사용하는 흐름으로 전환 중이다.
-- 로그인 전에는 플래너 본문을 사용하지 못하도록 막고, 인증 후 사용 흐름으로 정리했다.
-- 현재는 각 날짜 플래너가 대표 목표 하나를 선택해 `D-DAY`에 연결하는 구조다.
-- 목표는 별도 GOALS 화면에서 검색/생성/기간 설정을 관리하고, 플래너에서는 표시 ON/OFF만 다룬다.
-- 목표가 현재 날짜에 적용되지 않았거나 `D-DAY 사용`이 꺼져 있으면 본문 `D-DAY` 영역은 숨긴다.
-- 현재 날짜에 적용된 목표가 있으면 D-DAY는 기본적으로 보이고, 사용자가 해당 날짜에서만 OFF로 끌 수 있다.
-- 목표 생성 시 표시 시작일 기본값은 오늘, 표시 종료일 기본값은 목표일로 맞춘다.
-- 표시 기간이 다른 진행 중 목표와 겹치면 프론트와 백엔드 모두 저장을 막는다.
-- TASK LABELS는 버튼 묶음 대신 동일한 토글 패턴으로 단순화했다.
-- 구현할 때마다 완료된 항목은 체크하고, 큰 결정사항은 `HANDOFF.md`에도 함께 반영한다.
-- Resend 무료 플랜은 도메인 수 제약이 있으므로, 실제 인증 메일은 AWS SES 또는 별도 SMTP 서비스 전환을 전제로 설계하는 편이 안전하다.
-- 관리자 기능은 읽기 전용 대시보드부터 시작하고, 실제 정리 액션은 권한/감사 로그 정책을 정한 뒤 추가하는 편이 안전하다.
-- 관리자 아이디/비밀번호는 README나 HANDOFF에 실제 값으로 남기지 않고, Docker 배포용 비공개 `.env`에서만 관리한다.

backend/src/db/init.js

@@ -9,6 +9,7 @@ export async function ensureDatabaseSchema() {
       password_hash VARCHAR(255) NOT NULL,
       nickname VARCHAR(60) NOT NULL,
       role VARCHAR(20) NOT NULL DEFAULT 'user',
+      disabled_at TIMESTAMPTZ,
       email_verified_at TIMESTAMPTZ,
       last_login_at TIMESTAMPTZ,
       created_at TIMESTAMPTZ NOT NULL,
@@ -21,6 +22,9 @@ export async function ensureDatabaseSchema() {
     ALTER TABLE users
     ADD COLUMN IF NOT EXISTS role VARCHAR(20) NOT NULL DEFAULT 'user';
 
+    ALTER TABLE users
+    ADD COLUMN IF NOT EXISTS disabled_at TIMESTAMPTZ;
+
     ALTER TABLE users
     ADD COLUMN IF NOT EXISTS email_verified_at TIMESTAMPTZ;
 

backend/src/db/schema.js

@@ -16,6 +16,7 @@ export const users = pgTable('users', {
   passwordHash: varchar('password_hash', { length: 255 }).notNull(),
   nickname: varchar('nickname', { length: 60 }).notNull(),
   role: varchar('role', { length: 20 }).notNull().default('user'),
+  disabledAt: timestamp('disabled_at', { withTimezone: true }),
   emailVerifiedAt: timestamp('email_verified_at', { withTimezone: true }),
   lastLoginAt: timestamp('last_login_at', { withTimezone: true }),
   createdAt: timestamp('created_at', { withTimezone: true }).notNull(),

backend/src/lib/authSession.js

@@ -14,6 +14,10 @@ function getBearerToken(request) {
   return authorization.slice('Bearer '.length).trim()
 }
 
+export function getSessionTokenFromRequest(request) {
+  return getBearerToken(request)
+}
+
 export async function createSession(userId) {
   const token = createSessionToken()
   const tokenHash = hashSessionToken(token)
@@ -61,6 +65,11 @@ export async function findAuthenticatedUser(request) {
     .where(eq(users.id, session.userId))
     .limit(1)
 
+  if (user?.disabledAt) {
+    await db.delete(authSessions).where(eq(authSessions.id, session.id))
+    return null
+  }
+
   if (user && user.role !== 'admin' && !user.emailVerifiedAt) {
     await db.delete(authSessions).where(eq(authSessions.id, session.id))
     return null
@@ -68,3 +77,17 @@ export async function findAuthenticatedUser(request) {
 
   return user ?? null
 }
+
+export async function revokeSessionByToken(token) {
+  if (!token) {
+    return false
+  }
+
+  const tokenHash = hashSessionToken(token)
+  const deletedSessions = await db
+    .delete(authSessions)
+    .where(eq(authSessions.tokenHash, tokenHash))
+    .returning({ id: authSessions.id })
+
+  return deletedSessions.length > 0
+}

backend/src/routes/admin.js

@@ -1,7 +1,13 @@
-import { sql } from 'drizzle-orm'
+import { and, eq, sql } from 'drizzle-orm'
+import { z } from 'zod'
 import { db } from '../db/client.js'
 import { findAuthenticatedUser } from '../lib/authSession.js'
-import { users } from '../db/schema.js'
+import { authSessions, users } from '../db/schema.js'
+
+const adminUserIdSchema = z.coerce.number().int().positive()
+const adminStatusSchema = z.object({
+  disabled: z.boolean(),
+})
 
 async function requireAdminUser(request, reply) {
   const user = await findAuthenticatedUser(request)
@@ -35,6 +41,7 @@ export async function registerAdminRoutes(app) {
       .select({
         totalUsers: sql`count(*)::int`,
         totalAdmins: sql`count(*) filter (where ${users.role} = 'admin')::int`,
+        disabledUsers: sql`count(*) filter (where ${users.disabledAt} is not null)::int`,
         verifiedUsers: sql`count(*) filter (where ${users.emailVerifiedAt} is not null)::int`,
         activeUsers30d: sql`count(*) filter (where ${users.lastLoginAt} >= now() - interval '30 days')::int`,
         newUsers7d: sql`count(*) filter (where ${users.createdAt} >= now() - interval '7 days')::int`,
@@ -54,16 +61,19 @@ export async function registerAdminRoutes(app) {
         u.nickname,
         u.email,
         u.role,
+        u.disabled_at as "disabledAt",
         u.created_at as "createdAt",
         u.email_verified_at as "emailVerifiedAt",
         u.last_login_at as "lastLoginAt",
         count(distinct pe.id)::int as "plannerEntryCount",
         count(distinct g.id)::int as "goalCount",
+        count(distinct s.id)::int as "activeSessionCount",
         max(pe.entry_date) as "lastEntryDate",
         max(pe.updated_at) as "lastEntryUpdatedAt"
       from users u
       left join planner_entries pe on pe.user_id = u.id
       left join goals g on g.user_id = u.id
+      left join auth_sessions s on s.user_id = u.id and s.expires_at > now()
       group by u.id
       order by coalesce(u.last_login_at, u.created_at) desc, u.id desc
     `)
@@ -88,6 +98,7 @@ export async function registerAdminRoutes(app) {
         verifiedUsers: summary?.verifiedUsers ?? 0,
         activeUsers30d: summary?.activeUsers30d ?? 0,
         newUsers7d: summary?.newUsers7d ?? 0,
+        disabledUsers: summary?.disabledUsers ?? 0,
         totalPlannerEntries: plannerCountResult.rows[0]?.count ?? 0,
         totalGoals: goalCountResult.rows[0]?.count ?? 0,
       },
@@ -100,4 +111,233 @@ export async function registerAdminRoutes(app) {
       recentLogins: recentLoginsResult.rows,
     }
   })
+
+  app.get('/api/admin/users/:userId/detail', async (request, reply) => {
+    const adminUser = await requireAdminUser(request, reply)
+
+    if (!adminUser) {
+      return
+    }
+
+    const userIdResult = adminUserIdSchema.safeParse(request.params.userId)
+
+    if (!userIdResult.success) {
+      return reply.code(400).send({
+        message: '대상 사용자 값이 올바르지 않습니다.',
+      })
+    }
+
+    const userId = userIdResult.data
+
+    const detailResult = await db.execute(sql`
+      select
+        u.id,
+        u.nickname,
+        u.email,
+        u.role,
+        u.disabled_at as "disabledAt",
+        u.created_at as "createdAt",
+        u.updated_at as "updatedAt",
+        u.email_verified_at as "emailVerifiedAt",
+        u.last_login_at as "lastLoginAt",
+        count(distinct pe.id)::int as "plannerEntryCount",
+        count(distinct g.id)::int as "goalCount",
+        count(distinct s.id)::int as "activeSessionCount"
+      from users u
+      left join planner_entries pe on pe.user_id = u.id
+      left join goals g on g.user_id = u.id
+      left join auth_sessions s on s.user_id = u.id and s.expires_at > now()
+      where u.id = ${userId}
+      group by u.id
+      limit 1
+    `)
+
+    const detailUser = detailResult.rows[0]
+
+    if (!detailUser) {
+      return reply.code(404).send({
+        message: '대상 사용자를 찾을 수 없습니다.',
+      })
+    }
+
+    const plannerEntriesResult = await db.execute(sql`
+      select
+        entry_date as "entryDate",
+        payload,
+        created_at as "createdAt",
+        updated_at as "updatedAt"
+      from planner_entries
+      where user_id = ${userId}
+      order by entry_date desc
+      limit 12
+    `)
+
+    const goalsResult = await db.execute(sql`
+      select
+        id,
+        title,
+        target_date as "targetDate",
+        active_from as "activeFrom",
+        active_until as "activeUntil",
+        color,
+        created_at as "createdAt",
+        updated_at as "updatedAt"
+      from goals
+      where user_id = ${userId}
+      order by updated_at desc, id desc
+      limit 20
+    `)
+
+    return {
+      user: detailUser,
+      plannerEntries: plannerEntriesResult.rows,
+      goals: goalsResult.rows,
+    }
+  })
+
+  app.put('/api/admin/users/:userId/status', async (request, reply) => {
+    const adminUser = await requireAdminUser(request, reply)
+
+    if (!adminUser) {
+      return
+    }
+
+    const userIdResult = adminUserIdSchema.safeParse(request.params.userId)
+    const payload = adminStatusSchema.safeParse(request.body)
+
+    if (!userIdResult.success || !payload.success) {
+      return reply.code(400).send({
+        message: '관리자 요청 값이 올바르지 않습니다.',
+      })
+    }
+
+    const userId = userIdResult.data
+
+    const [targetUser] = await db
+      .select()
+      .from(users)
+      .where(eq(users.id, userId))
+      .limit(1)
+
+    if (!targetUser) {
+      return reply.code(404).send({
+        message: '대상 사용자를 찾을 수 없습니다.',
+      })
+    }
+
+    if (targetUser.role === 'admin') {
+      return reply.code(403).send({
+        message: '관리자 계정 상태는 여기서 변경할 수 없습니다.',
+      })
+    }
+
+    const disabled = payload.data.disabled
+    const now = new Date()
+
+    const [updatedUser] = await db
+      .update(users)
+      .set({
+        disabledAt: disabled ? now : null,
+        updatedAt: now,
+      })
+      .where(eq(users.id, userId))
+      .returning()
+
+    if (disabled) {
+      await db.delete(authSessions).where(eq(authSessions.userId, userId))
+    }
+
+    return {
+      message: disabled ? '계정을 비활성화했습니다.' : '계정을 다시 사용할 수 있게 했습니다.',
+      user: updatedUser,
+    }
+  })
+
+  app.post('/api/admin/users/:userId/revoke-sessions', async (request, reply) => {
+    const adminUser = await requireAdminUser(request, reply)
+
+    if (!adminUser) {
+      return
+    }
+
+    const userIdResult = adminUserIdSchema.safeParse(request.params.userId)
+
+    if (!userIdResult.success) {
+      return reply.code(400).send({
+        message: '대상 사용자 값이 올바르지 않습니다.',
+      })
+    }
+
+    const userId = userIdResult.data
+
+    const [targetUser] = await db
+      .select()
+      .from(users)
+      .where(eq(users.id, userId))
+      .limit(1)
+
+    if (!targetUser) {
+      return reply.code(404).send({
+        message: '대상 사용자를 찾을 수 없습니다.',
+      })
+    }
+
+    if (targetUser.role === 'admin') {
+      return reply.code(403).send({
+        message: '관리자 계정 세션은 여기서 정리하지 않습니다.',
+      })
+    }
+
+    const deletedSessions = await db
+      .delete(authSessions)
+      .where(eq(authSessions.userId, userId))
+      .returning({ id: authSessions.id })
+
+    return {
+      message: deletedSessions.length > 0 ? '해당 사용자의 로그인 세션을 모두 종료했습니다.' : '종료할 로그인 세션이 없습니다.',
+      revokedCount: deletedSessions.length,
+    }
+  })
+
+  app.delete('/api/admin/users/:userId', async (request, reply) => {
+    const adminUser = await requireAdminUser(request, reply)
+
+    if (!adminUser) {
+      return
+    }
+
+    const userIdResult = adminUserIdSchema.safeParse(request.params.userId)
+
+    if (!userIdResult.success) {
+      return reply.code(400).send({
+        message: '대상 사용자 값이 올바르지 않습니다.',
+      })
+    }
+
+    const userId = userIdResult.data
+
+    const [targetUser] = await db
+      .select()
+      .from(users)
+      .where(eq(users.id, userId))
+      .limit(1)
+
+    if (!targetUser) {
+      return reply.code(404).send({
+        message: '대상 사용자를 찾을 수 없습니다.',
+      })
+    }
+
+    if (targetUser.role === 'admin') {
+      return reply.code(403).send({
+        message: '관리자 계정은 여기서 삭제할 수 없습니다.',
+      })
+    }
+
+    await db.delete(users).where(and(eq(users.id, userId), eq(users.role, 'user')))
+
+    return {
+      message: '사용자 계정과 관련 데이터를 삭제했습니다.',
+    }
+  })
 }

backend/src/routes/auth.js

@@ -3,7 +3,7 @@ import { z } from 'zod'
 import { db } from '../db/client.js'
 import { authSessions, emailVerificationTokens, passwordResetTokens, users } from '../db/schema.js'
 import { createSessionToken, hashSessionToken, hashPassword, verifyPassword } from '../lib/password.js'
-import { createSession, findAuthenticatedUser } from '../lib/authSession.js'
+import { createSession, findAuthenticatedUser, getSessionTokenFromRequest, revokeSessionByToken } from '../lib/authSession.js'
 import { sendPasswordResetEmail, sendVerificationEmail } from '../lib/mailer.js'
 import { env } from '../config.js'
 
@@ -106,6 +106,7 @@ function sanitizeUser(user) {
     loginId: user.loginId,
     nickname: user.nickname,
     role: user.role,
+    disabledAt: user.disabledAt,
     emailVerifiedAt: user.emailVerifiedAt,
     lastLoginAt: user.lastLoginAt,
     createdAt: user.createdAt,
@@ -239,6 +240,12 @@ export async function registerAuthRoutes(app) {
       })
     }
 
+    if (user.disabledAt) {
+      return reply.code(403).send({
+        message: '비활성화된 계정입니다. 관리자에게 문의해 주세요.',
+      })
+    }
+
     if (user.role !== 'admin' && !user.emailVerifiedAt) {
       return reply.code(403).send({
         message: '이메일 인증을 완료한 뒤 로그인해 주세요.',
@@ -279,6 +286,22 @@ export async function registerAuthRoutes(app) {
     }
   })
 
+  app.post('/api/auth/logout', async (request, reply) => {
+    const token = getSessionTokenFromRequest(request)
+
+    if (!token) {
+      return reply.code(401).send({
+        message: '인증이 필요합니다.',
+      })
+    }
+
+    await revokeSessionByToken(token)
+
+    return {
+      message: '로그아웃되었습니다.',
+    }
+  })
+
   app.put('/api/auth/profile', async (request, reply) => {
     const user = await findAuthenticatedUser(request)
 

docker-compose.dev.yml

@@ -4,6 +4,8 @@ services:
     container_name: ten-minute-postgres-dev
     env_file:
       - ./.env.dev
+    environment:
+      TZ: Asia/Seoul
     volumes:
       - postgres_dev_data:/var/lib/postgresql/data
     ports:
@@ -26,6 +28,7 @@ services:
       PORT: 3001
       CORS_ORIGIN: http://localhost:5173
       SESSION_TTL_DAYS: 30
+      TZ: Asia/Seoul
     volumes:
       - ./backend:/app
       - backend_node_modules:/app/node_modules
@@ -44,6 +47,7 @@ services:
     environment:
       VITE_API_BASE_URL: http://localhost:3001
       CHOKIDAR_USEPOLLING: "true"
+      TZ: Asia/Seoul
     volumes:
       - .:/app
       - /app/backend

docker-compose.yml

@@ -4,6 +4,8 @@ services:
     container_name: ten-minute-postgres
     env_file:
       - ./.env
+    environment:
+      TZ: Asia/Seoul
     volumes:
       - postgres_data:/var/lib/postgresql/data
     ports:
@@ -25,6 +27,7 @@ services:
       PORT: 3001
       CORS_ORIGIN: http://localhost:48081
       SESSION_TTL_DAYS: 30
+      TZ: Asia/Seoul
     depends_on:
       postgres:
         condition: service_healthy
@@ -38,6 +41,8 @@ services:
       args:
         VITE_API_BASE_URL: /api
     container_name: ten-minute-frontend
+    environment:
+      TZ: Asia/Seoul
     depends_on:
       - backend
     ports:

index.html

@@ -3,7 +3,32 @@
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>10분 플래너</title>
+    <meta name="theme-color" content="#f5f2eb" />
+    <meta
+      name="description"
+      content="10분 단위로 하루를 기록하고 계획하는 차분한 종이 다이어리형 플래너입니다."
+    />
+    <meta property="og:type" content="website" />
+    <meta property="og:locale" content="ko_KR" />
+    <meta property="og:site_name" content="10 Minute Planner" />
+    <meta property="og:title" content="10 Minute Planner" />
+    <meta
+      property="og:description"
+      content="10분 단위로 하루를 기록하고 계획하는 차분한 종이 다이어리형 플래너입니다."
+    />
+    <meta property="og:image" content="/assets/og-image.png" />
+    <meta property="og:image:type" content="image/png" />
+    <meta property="og:image:width" content="1731" />
+    <meta property="og:image:height" content="909" />
+    <meta name="twitter:card" content="summary_large_image" />
+    <meta name="twitter:title" content="10 Minute Planner" />
+    <meta
+      name="twitter:description"
+      content="10분 단위로 하루를 기록하고 계획하는 차분한 종이 다이어리형 플래너입니다."
+    />
+    <meta name="twitter:image" content="/assets/og-image.png" />
+    <link rel="icon" type="image/png" href="/assets/favicon.png" />
+    <title>10 Minute Planner</title>
   </head>
   <body class="bg-stone-100">
     <div id="app"></div>

package-lock.json

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

package.json

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

src/App.vue

@@ -8,17 +8,25 @@ import MiniCalendar from './components/MiniCalendar.vue'
 import PlannerPage from './components/PlannerPage.vue'
 import SettingsDashboard from './components/SettingsDashboard.vue'
 import StatsDashboard from './components/StatsDashboard.vue'
-import { fetchAdminOverview } from './lib/adminApi'
+import {
+  deleteAdminUser,
+  fetchAdminOverview,
+  fetchAdminUserDetail,
+  revokeAdminUserSessions,
+  updateAdminUserStatus,
+} from './lib/adminApi'
 import {
   clearAuthState,
   confirmVerification,
   deleteAccount,
   fetchCurrentUser,
+  logout as logoutRequest,
   confirmPasswordReset,
   login,
   persistAuthState,
   readAuthState,
   requestPasswordReset,
+  requestVerification,
   signup,
   updatePassword,
   updateProfile,
@@ -29,7 +37,6 @@ import { deletePlannerEntry, fetchPlannerEntries, savePlannerEntry } from './lib
 import {
   createInitialPlannerRecords,
   persistPlannerState,
-  readPlannerStorageState,
   restorePlannerUiState,
 } from './lib/plannerStorage'
 
@@ -37,6 +44,7 @@ const GUIDE_TOOLTIP_STORAGE_KEY = 'ten-minute-guide-tooltips-hidden'
 const DDAY_DISABLED_STORAGE_KEY = 'ten-minute-dday-disabled-dates'
 const CARRYOVER_CHECK_POLICY_STORAGE_KEY = 'ten-minute-carryover-check-policy'
 const CARRYOVER_CHECK_POLICIES = ['ask', 'all', 'current']
+const TIMETABLE_CLIPBOARD_PREFIX = 'TEN_MINUTE_TIMETABLE:'
 const screenMode = ref('planner')
 const viewMode = ref('focus')
 const printLayout = ref('single')
@@ -48,6 +56,7 @@ const authMode = ref('login')
 const authBusy = ref(false)
 const authMessage = ref('')
 const authToken = ref('')
+const authPersist = ref(false)
 const currentUser = ref(null)
 const goals = ref([])
 const goalQuery = ref('')
@@ -106,10 +115,13 @@ const guideTooltipResetMessage = ref('')
 const hiddenGuideTooltips = ref(readHiddenGuideTooltips())
 const ddayDisabledDateKeys = ref(readDdayDisabledDateKeys())
 const adminBusy = ref(false)
+const adminActionUserId = ref(null)
+const adminDetailBusy = ref(false)
 const adminMessage = ref('')
 const adminOverview = ref({
   totalUsers: 0,
   totalAdmins: 0,
+  disabledUsers: 0,
   verifiedUsers: 0,
   activeUsers30d: 0,
   newUsers7d: 0,
@@ -118,6 +130,16 @@ const adminOverview = ref({
 })
 const adminUsers = ref([])
 const adminRecentLogins = ref([])
+const adminSelectedUserId = ref(null)
+const adminUserDetail = ref(null)
+const timetableClipboard = ref(null)
+const timetableContextMenu = ref({
+  open: false,
+  x: 0,
+  y: 0,
+  dateKey: '',
+  record: null,
+})
 
 const hours = [
   '6', '7', '8', '9', '10', '11', '12',
@@ -507,6 +529,7 @@ const secondaryDate = computed(() => {
 })
 
 const secondaryPlanner = computed(() => getPlannerRecord(secondaryDate.value))
+const secondaryDateKey = computed(() => toKey(secondaryDate.value))
 
 function getDateDisplay(date) {
   const main = `${date.getFullYear()}. ${`${date.getMonth() + 1}`.padStart(2, '0')}. ${`${date.getDate()}`.padStart(2, '0')}.`
@@ -623,6 +646,29 @@ const markedDateKeys = computed(() =>
 
 const isAuthenticated = computed(() => Boolean(authToken.value && currentUser.value))
 const isAdmin = computed(() => currentUser.value?.role === 'admin')
+const authSessionInfo = computed(() => ({
+  storageLabel: authPersist.value ? '이 기기에서 로그인 유지 중' : '브라우저를 닫으면 로그아웃',
+  storageDescription: authPersist.value
+    ? '현재 기기에서는 localStorage에 로그인 상태를 저장합니다.'
+    : '현재 기기에서는 sessionStorage에만 로그인 상태를 유지합니다.',
+  lastLoginLabel: formatSessionDate(currentUser.value?.lastLoginAt),
+  verificationLabel: currentUser.value?.role === 'admin'
+    ? '관리자 기본 계정'
+    : currentUser.value?.emailVerifiedAt
+      ? '이메일 인증 완료'
+      : '이메일 인증 필요',
+}))
+const showVerificationResend = computed(() => {
+  if (authMode.value !== 'login') {
+    return false
+  }
+
+  if (!authForm.email.includes('@')) {
+    return false
+  }
+
+  return authMessage.value.includes('이메일 인증을 완료한 뒤 로그인해 주세요.')
+})
 const filteredGoals = computed(() => {
   const query = goalQuery.value.trim().toLowerCase()
   return goals.value.filter((goal) => {
@@ -876,6 +922,11 @@ function handleGlobalKeydown(event) {
     event.preventDefault()
     closeCarryoverCheckPrompt()
   }
+
+  if (event.key === 'Escape' && timetableContextMenu.value.open) {
+    event.preventDefault()
+    closeTimetableContextMenu()
+  }
 }
 
 function clearTasks(record, indexes) {
@@ -933,6 +984,115 @@ function carryIncompleteTasksToNextDay() {
       : `${nextDateLabel} 빈칸 ${copyCount}개까지만 이월했습니다.`
 }
 
+function normalizeTimetableClipboard(candidate) {
+  if (!candidate || typeof candidate !== 'object') {
+    return null
+  }
+
+  const sourceDateKey = typeof candidate.sourceDateKey === 'string' ? candidate.sourceDateKey : ''
+  const timetable = Array.isArray(candidate.timetable) ? candidate.timetable : []
+
+  if (!sourceDateKey || timetable.length !== timetableCellCount || timetable.some((value) => typeof value !== 'boolean')) {
+    return null
+  }
+
+  return {
+    sourceDateKey,
+    timetable: [...timetable],
+  }
+}
+
+async function copyTimetableToClipboard(record, sourceDateKey) {
+  const clipboardPayload = normalizeTimetableClipboard({
+    sourceDateKey,
+    timetable: record.timetable,
+  })
+
+  if (!clipboardPayload) {
+    setSyncFeedback('local', '복사할 타임테이블을 찾지 못했습니다.')
+    return
+  }
+
+  timetableClipboard.value = clipboardPayload
+
+  let copiedToSystemClipboard = false
+
+  try {
+    if (typeof navigator !== 'undefined' && navigator.clipboard?.writeText) {
+      await navigator.clipboard.writeText(
+        `${TIMETABLE_CLIPBOARD_PREFIX}${JSON.stringify(clipboardPayload)}`,
+      )
+      copiedToSystemClipboard = true
+    }
+  } catch (error) {
+    copiedToSystemClipboard = false
+  }
+
+  setSyncFeedback(
+    'local',
+    copiedToSystemClipboard
+      ? `${createDateLabel(sourceDateKey)} 타임테이블을 클립보드에 저장했습니다.`
+      : `${createDateLabel(sourceDateKey)} 타임테이블을 앱 안에 복사했습니다.`,
+  )
+}
+
+function pasteTimetableFromClipboard(record, targetDateKey, clipboardPayload = timetableClipboard.value) {
+  const normalizedClipboard = normalizeTimetableClipboard(clipboardPayload)
+
+  if (!normalizedClipboard) {
+    setSyncFeedback('local', '붙여넣을 타임테이블이 없습니다.')
+    return
+  }
+
+  record.timetable = [...normalizedClipboard.timetable]
+  schedulePlannerSyncForRecord(record)
+  timetableClipboard.value = normalizedClipboard
+
+  setSyncFeedback(
+    'local',
+    normalizedClipboard.timetable.some(Boolean)
+      ? `${createDateLabel(normalizedClipboard.sourceDateKey)} 타임테이블을 ${createDateLabel(targetDateKey)}에 붙여넣었습니다.`
+      : `${createDateLabel(normalizedClipboard.sourceDateKey)} 타임테이블이 비어 있어 ${createDateLabel(targetDateKey)}도 비웠습니다.`,
+  )
+}
+
+async function handleTimetableHeaderAction(record, dateKey) {
+  closeTimetableContextMenu()
+  await copyTimetableToClipboard(record, dateKey)
+}
+
+function openTimetableContextMenu(record, dateKey, event) {
+  timetableContextMenu.value = {
+    open: true,
+    x: event.clientX,
+    y: event.clientY,
+    dateKey,
+    record,
+  }
+}
+
+function closeTimetableContextMenu() {
+  timetableContextMenu.value = {
+    open: false,
+    x: 0,
+    y: 0,
+    dateKey: '',
+    record: null,
+  }
+}
+
+function pasteTimetableToContextTarget() {
+  const { record, dateKey } = timetableContextMenu.value
+
+  if (!record || !dateKey) {
+    closeTimetableContextMenu()
+    return
+  }
+
+  pasteTimetableFromClipboard(record, dateKey)
+  closeTimetableContextMenu()
+}
+
 function updateMemo(record, { index, value }) {
   record.memo[index].text = value
   schedulePlannerSyncForRecord(record)
@@ -1444,6 +1604,20 @@ function syncProfileForm() {
   profileForm.email = currentUser.value?.email ?? ''
 }
 
+function formatSessionDate(value) {
+  if (!value) {
+    return '기록이 없습니다.'
+  }
+
+  const date = new Date(value)
+
+  if (Number.isNaN(date.getTime())) {
+    return '기록이 없습니다.'
+  }
+
+  return `${date.getFullYear()}. ${`${date.getMonth() + 1}`.padStart(2, '0')}. ${`${date.getDate()}`.padStart(2, '0')} ${`${date.getHours()}`.padStart(2, '0')}:${`${date.getMinutes()}`.padStart(2, '0')}`
+}
+
 function resetPasswordForm() {
   passwordForm.currentPassword = ''
   passwordForm.newPassword = ''
@@ -1532,6 +1706,7 @@ function updateAuthField({ field, value }) {
 
 async function applyAuthSuccess(data, persist = false) {
   authToken.value = data.token
+  authPersist.value = persist
   currentUser.value = data.user
   setSyncFeedback('cloud', '클라우드 동기화 연결됨')
   persistAuthState({
@@ -1600,6 +1775,28 @@ async function submitAuthForm() {
   }
 }
 
+async function resendVerificationEmail() {
+  const email = authForm.email.trim()
+
+  if (!email || !email.includes('@')) {
+    authMessage.value = '인증 메일을 다시 받으려면 이메일 주소를 먼저 입력해 주세요.'
+    return
+  }
+
+  authBusy.value = true
+
+  try {
+    const result = await requestVerification({ email }, authToken.value || undefined)
+    authMessage.value = result.verificationPreviewUrl
+      ? `${result.message} 개발용 링크: ${result.verificationPreviewUrl}`
+      : result.message
+  } catch (error) {
+    authMessage.value = toUserFacingApiError(error, '인증 메일을 다시 보내지 못했습니다.')
+  } finally {
+    authBusy.value = false
+  }
+}
+
 async function restoreAuthSession() {
   const savedAuth = readAuthState()
 
@@ -1608,6 +1805,7 @@ async function restoreAuthSession() {
   }
 
   authToken.value = savedAuth.token
+  authPersist.value = savedAuth.persist
   currentUser.value = savedAuth.user ?? null
 
   try {
@@ -1625,6 +1823,7 @@ async function restoreAuthSession() {
     syncProfileForm()
   } catch (error) {
     authToken.value = ''
+    authPersist.value = false
     currentUser.value = null
     setSyncFeedback('local', '로그인 후 클라우드 저장을 사용할 수 있습니다.', {
       visible: false,
@@ -1633,9 +1832,10 @@ async function restoreAuthSession() {
   }
 }
 
-function logout() {
+function clearAuthenticatedState() {
   clearPendingSyncTimers()
   authToken.value = ''
+  authPersist.value = false
   currentUser.value = null
   goals.value = []
   goalQuery.value = ''
@@ -1643,10 +1843,13 @@ function logout() {
   adminMessage.value = ''
   adminUsers.value = []
   adminRecentLogins.value = []
+  adminSelectedUserId.value = null
+  adminUserDetail.value = null
   accountDeleteMessage.value = ''
   adminOverview.value = {
     totalUsers: 0,
     totalAdmins: 0,
+    disabledUsers: 0,
     verifiedUsers: 0,
     activeUsers30d: 0,
     newUsers7d: 0,
@@ -1666,10 +1869,26 @@ function logout() {
   resetAccountDeleteForm()
 }
 
+async function logout() {
+  const token = authToken.value
+
+  if (token) {
+    try {
+      await logoutRequest(token)
+    } catch (error) {
+      console.warn('서버 로그아웃 처리에 실패했습니다.', error)
+    }
+  }
+
+  clearAuthenticatedState()
+}
+
 async function loadAdminDashboard() {
   if (!authToken.value || !isAdmin.value) {
     adminUsers.value = []
     adminRecentLogins.value = []
+    adminSelectedUserId.value = null
+    adminUserDetail.value = null
     adminMessage.value = ''
     return
   }
@@ -1689,6 +1908,110 @@ async function loadAdminDashboard() {
   }
 }
 
+async function loadAdminUserDetail(userId) {
+  if (!authToken.value || !isAdmin.value) {
+    return
+  }
+
+  adminDetailBusy.value = true
+
+  try {
+    const result = await fetchAdminUserDetail(authToken.value, userId)
+    adminSelectedUserId.value = userId
+    adminUserDetail.value = result
+    adminMessage.value = ''
+  } catch (error) {
+    adminMessage.value = error.message || '사용자 상세 정보를 불러오지 못했습니다.'
+  } finally {
+    adminDetailBusy.value = false
+  }
+}
+
+function selectAdminUser(user) {
+  if (adminSelectedUserId.value === user.id && adminUserDetail.value) {
+    adminSelectedUserId.value = null
+    adminUserDetail.value = null
+    return
+  }
+
+  void loadAdminUserDetail(user.id)
+}
+
+async function toggleAdminUserStatus(user) {
+  const willDisable = !user.disabledAt
+  const confirmed = window.confirm(
+    willDisable
+      ? `"${user.nickname}" 계정을 비활성화할까요? 즉시 로그인할 수 없고 현재 세션도 종료됩니다.`
+      : `"${user.nickname}" 계정을 다시 사용할 수 있게 할까요?`,
+  )
+
+  if (!confirmed) {
+    return
+  }
+
+  adminActionUserId.value = user.id
+
+  try {
+    const result = await updateAdminUserStatus(authToken.value, user.id, willDisable)
+    adminMessage.value = result.message || '계정 상태를 변경했습니다.'
+    await loadAdminDashboard()
+    if (adminSelectedUserId.value === user.id) {
+      await loadAdminUserDetail(user.id)
+    }
+  } catch (error) {
+    adminMessage.value = error.message || '계정 상태를 변경하지 못했습니다.'
+  } finally {
+    adminActionUserId.value = null
+  }
+}
+
+async function revokeAdminSessions(user) {
+  const confirmed = window.confirm(`"${user.nickname}" 사용자를 현재 로그인된 모든 기기에서 로그아웃시킬까요?`)
+
+  if (!confirmed) {
+    return
+  }
+
+  adminActionUserId.value = user.id
+
+  try {
+    const result = await revokeAdminUserSessions(authToken.value, user.id)
+    adminMessage.value = result.message || '사용자 세션을 정리했습니다.'
+    await loadAdminDashboard()
+    if (adminSelectedUserId.value === user.id) {
+      await loadAdminUserDetail(user.id)
+    }
+  } catch (error) {
+    adminMessage.value = error.message || '사용자 세션을 종료하지 못했습니다.'
+  } finally {
+    adminActionUserId.value = null
+  }
+}
+
+async function removeAdminUser(user) {
+  const confirmed = window.confirm(`"${user.nickname}" 계정을 삭제할까요? 플래너 기록과 목표 데이터도 함께 삭제됩니다.`)
+
+  if (!confirmed) {
+    return
+  }
+
+  adminActionUserId.value = user.id
+
+  try {
+    const result = await deleteAdminUser(authToken.value, user.id)
+    adminMessage.value = result.message || '사용자 계정을 삭제했습니다.'
+    await loadAdminDashboard()
+    if (adminSelectedUserId.value === user.id) {
+      adminSelectedUserId.value = null
+      adminUserDetail.value = null
+    }
+  } catch (error) {
+    adminMessage.value = error.message || '사용자 계정을 삭제하지 못했습니다.'
+  } finally {
+    adminActionUserId.value = null
+  }
+}
+
 async function loadGoals() {
   if (!authToken.value) {
     return
@@ -1881,6 +2204,7 @@ async function submitProfileForm() {
     persistAuthState({
       token: authToken.value,
       user: result.user,
+      persist: authPersist.value,
     })
     syncProfileForm()
     await loadAdminDashboard()
@@ -1943,7 +2267,7 @@ async function submitDeleteAccount() {
       currentPassword: accountDeleteForm.currentPassword,
     })
     resetAccountDeleteForm()
-    logout()
+    clearAuthenticatedState()
     authMessage.value = ''
     window.alert(result.message || '회원 탈퇴가 완료되었습니다.')
   } catch (error) {
@@ -1965,16 +2289,8 @@ function replacePlannerRecords(nextRecords) {
 
 function restoreLocalPlannerRecords() {
   replacePlannerRecords(createInitialPlannerRecords(plannerSeed, normalizeRecord))
-
+  selectedDate.value = new Date()
-  const savedState = readPlannerStorageState()
+  calendarViewDate.value = new Date(selectedDate.value)
-
-  if (savedState.selectedDate) {
-    selectedDate.value = toDateValue(savedState.selectedDate, selectedDate.value)
-  }
-
-  if (savedState.calendarViewDate) {
-    calendarViewDate.value = toDateValue(savedState.calendarViewDate, selectedDate.value)
-  }
 }
 
 function findRecordKey(record) {
@@ -2649,8 +2965,8 @@ onBeforeUnmount(() => {
           />
         </Transition>
 
-        <div class="scrollbar-hide print-target border border-white/60 bg-white/45 xl:h-full xl:min-h-0 xl:overflow-y-auto xl:pr-3" :class="isCompactMobile ? 'rounded-[24px] p-3' : 'rounded-[28px] p-4'">
+        <div class="scrollbar-hide print-target border border-white/60 bg-white/45 xl:h-full xl:min-h-0 xl:overflow-y-auto xl:pr-3" :class="isCompactMobile ? 'rounded-[24px] p-2' : 'rounded-[28px] p-4'">
-          <div v-if="isOverlayFocusSidebar" class="mb-4 flex justify-end">
+          <div v-if="isOverlayFocusSidebar" class="mb-3 flex justify-end px-2 sm:px-0">
             <button
               type="button"
               class="rounded-full border border-stone-200 bg-white px-4 py-2 text-[11px] font-bold tracking-[0.16em] text-stone-700 transition hover:border-stone-400 hover:text-ink"
@@ -2659,27 +2975,29 @@ onBeforeUnmount(() => {
               {{ isCompactMobile ? 'INFO' : 'OPEN SIDE PANEL' }}
             </button>
           </div>
-          <PlannerPage
+            <PlannerPage
-            :date-main="selectedDateDisplay.main"
+              :date-main="selectedDateDisplay.main"
-            :date-weekday="selectedDateDisplay.weekday"
+              :date-weekday="selectedDateDisplay.weekday"
-            :date-weekday-tone="selectedDateDisplay.weekdayTone"
+              :date-weekday-tone="selectedDateDisplay.weekdayTone"
-            :dday="plannerDday"
+              :dday="plannerDday"
-            :show-dday="showPlannerDday"
+              :show-dday="showPlannerDday"
-            :comment="planner.comment"
+              :comment="planner.comment"
-            :total-time="formatTotalTimeKorean(planner)"
+              :total-time="formatTotalTimeKorean(planner)"
-            :tasks="planner.tasks"
+              :tasks="planner.tasks"
-            :memo="planner.memo"
+              :memo="planner.memo"
-            :hours="hours"
+              :hours="hours"
-            :timetable="planner.timetable"
+              :timetable="planner.timetable"
-            @update:comment="updateComment(planner, $event)"
+              @update:comment="updateComment(planner, $event)"
-            @update:task-label="updateTaskLabel(planner, $event)"
+              @update:task-label="updateTaskLabel(planner, $event)"
-            @update:task-title="updateTaskTitle(planner, $event)"
+              @update:task-title="updateTaskTitle(planner, $event)"
-            @toggle:task="toggleTask(planner, $event)"
+              @toggle:task="toggleTask(planner, $event)"
-            @clear:tasks="clearTasks(planner, $event)"
+              @clear:tasks="clearTasks(planner, $event)"
-            @update:memo-label="updateMemoLabel(planner, $event)"
+              @update:memo-label="updateMemoLabel(planner, $event)"
-            @update:memo="updateMemo(planner, $event)"
+              @update:memo="updateMemo(planner, $event)"
-            @update:timetable="updateTimetable(planner, $event)"
+              @update:timetable="updateTimetable(planner, $event)"
-          />
+              @timetable-action="handleTimetableHeaderAction(planner, selectedDateKey)"
+              @timetable-contextmenu="openTimetableContextMenu(planner, selectedDateKey, $event)"
+            />
         </div>
 
         <aside
@@ -2999,6 +3317,8 @@ onBeforeUnmount(() => {
               @update:memo-label="updateMemoLabel(planner, $event)"
               @update:memo="updateMemo(planner, $event)"
               @update:timetable="updateTimetable(planner, $event)"
+              @timetable-action="handleTimetableHeaderAction(planner, selectedDateKey)"
+              @timetable-contextmenu="openTimetableContextMenu(planner, selectedDateKey, $event)"
             />
           </div>
           <div class="print-hidden overflow-hidden" :style="spreadPageFrameStyle">
@@ -3023,6 +3343,8 @@ onBeforeUnmount(() => {
               @update:memo-label="updateMemoLabel(secondaryPlanner, $event)"
               @update:memo="updateMemo(secondaryPlanner, $event)"
               @update:timetable="updateTimetable(secondaryPlanner, $event)"
+              @timetable-action="handleTimetableHeaderAction(secondaryPlanner, secondaryDateKey)"
+              @timetable-contextmenu="openTimetableContextMenu(secondaryPlanner, secondaryDateKey, $event)"
             />
           </div>
         </div>
@@ -3060,6 +3382,7 @@ onBeforeUnmount(() => {
         :account-delete-form="accountDeleteForm"
         :account-delete-busy="accountDeleteBusy"
         :account-delete-message="accountDeleteMessage"
+        :auth-session-info="authSessionInfo"
         :guide-tooltip-reset-message="guideTooltipResetMessage"
         :carryover-check-policy="carryoverCheckPolicy"
         @update:profile-field="updateProfileField"
@@ -3077,9 +3400,17 @@ onBeforeUnmount(() => {
         class="scrollbar-hide print-hidden xl:h-full xl:overflow-y-auto"
         :summary="adminOverview"
         :users="adminUsers"
+        :selected-user-id="adminSelectedUserId"
+        :user-detail="adminUserDetail"
         :recent-logins="adminRecentLogins"
         :busy="adminBusy"
+        :action-busy-user-id="adminActionUserId"
+        :detail-busy="adminDetailBusy"
         :message="adminMessage"
+        @select-user="selectAdminUser"
+        @toggle-user-status="toggleAdminUserStatus"
+        @revoke-user-sessions="revokeAdminSessions"
+        @delete-user="removeAdminUser"
       />
 
       <StatsDashboard
@@ -3132,17 +3463,55 @@ onBeforeUnmount(() => {
       </div>
     </div>
 
-    <AuthDialog
+      <div
-      :open="authDialogOpen"
+        v-if="timetableContextMenu.open"
-      :mode="authMode"
+        class="print-hidden fixed inset-0 z-40"
-      :form="authForm"
+        @click="closeTimetableContextMenu"
-      :busy="authBusy"
+        @contextmenu.prevent="closeTimetableContextMenu"
-      :message="authMessage"
+      >
-      @close="closeAuthDialog"
+        <section
-      @submit="submitAuthForm"
+          class="absolute z-50 min-w-[220px] rounded-[24px] border border-stone-200 bg-white p-3 shadow-[0_24px_80px_rgba(28,25,23,0.18)]"
-      @switch-mode="authMode = $event; authMessage = ''"
+          :style="{
-      @update:field="updateAuthField"
+            left: `${Math.min(timetableContextMenu.x, windowWidth - 236)}px`,
-    />
+            top: `${timetableContextMenu.y}px`,
+          }"
+          @click.stop
+          @contextmenu.prevent
+        >
+          <p class="px-2 pb-2 text-[10px] font-bold uppercase tracking-[0.2em] text-stone-500">Time Table Menu</p>
+          <button
+            type="button"
+            class="flex w-full items-center justify-between rounded-2xl px-3 py-3 text-left text-sm font-semibold transition"
+            :class="timetableClipboard ? 'text-stone-800 hover:bg-[#f7f2ea]' : 'cursor-not-allowed text-stone-400'"
+            :disabled="!timetableClipboard"
+            @click="pasteTimetableToContextTarget"
+          >
+            <span>현재 날짜에 붙여넣기</span>
+            <span class="text-[10px] font-bold tracking-[0.14em] text-stone-400">
+              {{ timetableClipboard ? '준비됨' : '비어 있음' }}
+            </span>
+          </button>
+          <p
+            class="mt-2 rounded-2xl bg-[#faf7f2] px-3 py-3 text-[11px] font-semibold leading-5 text-stone-500"
+          >
+            {{ timetableClipboard ? `${createDateLabel(timetableClipboard.sourceDateKey)} 타임테이블이 복사되어 있습니다.` : '먼저 다른 날짜의 TIME TABLE 라벨을 왼쪽 클릭해 복사해 주세요.' }}
+          </p>
+        </section>
+      </div>
+
+      <AuthDialog
+        :open="authDialogOpen"
+        :mode="authMode"
+        :form="authForm"
+        :busy="authBusy"
+        :message="authMessage"
+        :show-resend-verification="showVerificationResend"
+        @close="closeAuthDialog"
+        @submit="submitAuthForm"
+        @resend-verification="resendVerificationEmail"
+        @switch-mode="authMode = $event; authMessage = ''"
+        @update:field="updateAuthField"
+      />
 
     <div
       v-if="printDialogOpen"
@@ -3297,7 +3666,7 @@ onBeforeUnmount(() => {
       leave-to-class="translate-y-2 opacity-0"
     >
       <div
-        v-if="isAuthenticated && syncToastVisible"
+        v-if="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

src/components/AdminDashboard.vue

@@ -1,4 +1,6 @@
 <script setup>
+import { computed, ref } from 'vue'
+
 const props = defineProps({
   summary: {
     type: Object,
@@ -8,6 +10,14 @@ const props = defineProps({
     type: Array,
     required: true,
   },
+  selectedUserId: {
+    type: Number,
+    default: null,
+  },
+  userDetail: {
+    type: Object,
+    default: null,
+  },
   recentLogins: {
     type: Array,
     required: true,
@@ -20,8 +30,27 @@ const props = defineProps({
     type: String,
     default: '',
   },
+  actionBusyUserId: {
+    type: Number,
+    default: null,
+  },
+  detailBusy: {
+    type: Boolean,
+    default: false,
+  },
 })
 
+const emit = defineEmits([
+  'select-user',
+  'toggle-user-status',
+  'revoke-user-sessions',
+  'delete-user',
+])
+
+const userSearch = ref('')
+const userStatusFilter = ref('all')
+const userSort = ref('lastLoginDesc')
+
 function formatDate(value) {
   if (!value) {
     return '기록 없음'
@@ -41,11 +70,88 @@ function formatDate(value) {
     minute: '2-digit',
   }).format(date)
 }
+
+function getPlannerSummary(payload) {
+  if (!payload || typeof payload !== 'object') {
+    return {
+      comment: '코멘트 없음',
+      taskCount: 0,
+      completedCount: 0,
+      memoCount: 0,
+    }
+  }
+
+  const tasks = Array.isArray(payload.tasks) ? payload.tasks : []
+  const memo = Array.isArray(payload.memo) ? payload.memo : []
+  const activeTasks = tasks.filter((task) => task?.title?.trim?.())
+
+  return {
+    comment: payload.comment?.trim?.() || '코멘트 없음',
+    taskCount: activeTasks.length,
+    completedCount: activeTasks.filter((task) => task.checked).length,
+    memoCount: memo.filter((item) => item?.text?.trim?.() || item?.label?.trim?.()).length,
+  }
+}
+
+const filteredUsers = computed(() => {
+  const search = userSearch.value.trim().toLowerCase()
+  const filtered = props.users.filter((user) => {
+    const matchesSearch = !search
+      || String(user.id).includes(search)
+      || user.nickname?.toLowerCase().includes(search)
+      || user.email?.toLowerCase().includes(search)
+
+    if (!matchesSearch) {
+      return false
+    }
+
+    switch (userStatusFilter.value) {
+      case 'active':
+        return !user.disabledAt && user.isActiveRecently
+      case 'disabled':
+        return Boolean(user.disabledAt)
+      case 'unverified':
+        return !user.emailVerifiedAt
+      case 'admin':
+        return user.role === 'admin'
+      case 'member':
+        return user.role !== 'admin'
+      default:
+        return true
+    }
+  })
+
+  return [...filtered].sort((left, right) => {
+    switch (userSort.value) {
+      case 'plannerDesc':
+        return right.plannerEntryCount - left.plannerEntryCount || right.id - left.id
+      case 'goalDesc':
+        return right.goalCount - left.goalCount || right.id - left.id
+      case 'createdDesc':
+        return new Date(right.createdAt || 0).getTime() - new Date(left.createdAt || 0).getTime() || right.id - left.id
+      case 'nicknameAsc':
+        return String(left.nickname || '').localeCompare(String(right.nickname || ''), 'ko')
+      case 'lastLoginDesc':
+      default:
+        return new Date(right.lastLoginAt || right.createdAt || 0).getTime()
+          - new Date(left.lastLoginAt || left.createdAt || 0).getTime()
+          || right.id - left.id
+    }
+  })
+})
+
+const filteredUsersSummary = computed(() => {
+  const total = filteredUsers.value.length
+  const disabled = filteredUsers.value.filter((user) => user.disabledAt).length
+  const active = filteredUsers.value.filter((user) => !user.disabledAt && user.isActiveRecently).length
+
+  return { total, disabled, active }
+})
 </script>
 
 <template>
   <section class="grid gap-6">
-    <div class="grid gap-4 md:grid-cols-2 xl:grid-cols-4">
+    <div class="grid gap-4 md:grid-cols-2 xl:grid-cols-5">
       <article class="rounded-[28px] border border-white/60 bg-white/80 p-6">
         <p class="text-[11px] font-bold uppercase tracking-[0.24em] text-stone-500">Total Users</p>
         <p class="mt-4 text-4xl font-semibold tracking-[-0.06em] text-stone-900">{{ summary.totalUsers }}</p>
@@ -69,6 +175,12 @@ function formatDate(value) {
         <p class="mt-4 text-3xl font-semibold tracking-[-0.06em] text-stone-900">{{ summary.verifiedUsers }} / {{ summary.totalAdmins }}</p>
         <p class="mt-2 text-sm font-semibold text-stone-500">인증 완료 계정 수 / 관리자 수</p>
       </article>
+
+      <article class="rounded-[28px] border border-white/60 bg-white/80 p-6">
+        <p class="text-[11px] font-bold uppercase tracking-[0.24em] text-stone-500">Disabled Users</p>
+        <p class="mt-4 text-4xl font-semibold tracking-[-0.06em] text-stone-900">{{ summary.disabledUsers ?? 0 }}</p>
+        <p class="mt-2 text-sm font-semibold text-stone-500">관리자가 비활성화한 계정 수</p>
+      </article>
     </div>
 
     <div class="grid gap-6 xl:grid-cols-[320px_minmax(0,1fr)]">
@@ -127,8 +239,55 @@ function formatDate(value) {
           {{ message }}
         </p>
 
+        <div class="mt-5 grid gap-3 rounded-[24px] border border-stone-200 bg-[#fcfaf6] p-4 md:grid-cols-[minmax(0,1.2fr)_180px_180px]">
+          <label class="grid gap-2">
+            <span class="text-[10px] font-bold uppercase tracking-[0.18em] text-stone-500">검색</span>
+            <input
+              v-model="userSearch"
+              type="text"
+              placeholder="닉네임, 이메일, ID 검색"
+              class="h-11 rounded-2xl border border-stone-200 bg-white px-4 text-sm font-semibold text-stone-700 outline-none transition placeholder:text-stone-400 focus:border-stone-400"
+            />
+          </label>
+
+          <label class="grid gap-2">
+            <span class="text-[10px] font-bold uppercase tracking-[0.18em] text-stone-500">상태 필터</span>
+            <select
+              v-model="userStatusFilter"
+              class="h-11 rounded-2xl border border-stone-200 bg-white px-4 text-sm font-semibold text-stone-700 outline-none transition focus:border-stone-400"
+            >
+              <option value="all">전체 사용자</option>
+              <option value="active">최근 활동</option>
+              <option value="disabled">비활성화</option>
+              <option value="unverified">미인증</option>
+              <option value="member">일반 사용자</option>
+              <option value="admin">관리자</option>
+            </select>
+          </label>
+
+          <label class="grid gap-2">
+            <span class="text-[10px] font-bold uppercase tracking-[0.18em] text-stone-500">정렬</span>
+            <select
+              v-model="userSort"
+              class="h-11 rounded-2xl border border-stone-200 bg-white px-4 text-sm font-semibold text-stone-700 outline-none transition focus:border-stone-400"
+            >
+              <option value="lastLoginDesc">최근 접속순</option>
+              <option value="plannerDesc">문서 많은 순</option>
+              <option value="goalDesc">목표 많은 순</option>
+              <option value="createdDesc">최근 가입순</option>
+              <option value="nicknameAsc">이름순</option>
+            </select>
+          </label>
+        </div>
+
+        <div class="mt-4 flex flex-wrap items-center gap-2 text-[11px] font-bold tracking-[0.12em] text-stone-500">
+          <span class="rounded-full bg-white px-3 py-2">표시 {{ filteredUsersSummary.total }}명</span>
+          <span class="rounded-full bg-white px-3 py-2">활동 {{ filteredUsersSummary.active }}명</span>
+          <span class="rounded-full bg-white px-3 py-2">비활성 {{ filteredUsersSummary.disabled }}명</span>
+        </div>
+
         <div class="mt-5 overflow-hidden rounded-[24px] border border-stone-200 bg-white">
-          <div class="hidden grid-cols-[84px_minmax(0,1.4fr)_120px_150px_110px_100px_150px] gap-3 border-b border-stone-200 bg-[#f8f4ed] px-5 py-4 text-[10px] font-bold uppercase tracking-[0.18em] text-stone-500 xl:grid">
+          <div class="hidden grid-cols-[84px_minmax(0,1.2fr)_110px_150px_90px_90px_150px_190px] gap-3 border-b border-stone-200 bg-[#f8f4ed] px-5 py-4 text-[10px] font-bold uppercase tracking-[0.18em] text-stone-500 xl:grid">
             <span>ID</span>
             <span>사용자</span>
             <span>권한</span>
@@ -136,19 +295,27 @@ function formatDate(value) {
             <span>문서 수</span>
             <span>목표 수</span>
             <span>상태</span>
+            <span>관리</span>
           </div>
 
           <div class="divide-y divide-stone-200">
             <article
-              v-for="user in users"
+              v-for="user in filteredUsers"
               :key="user.id"
               class="px-5 py-4"
             >
-              <div class="grid gap-3 xl:grid-cols-[84px_minmax(0,1.4fr)_120px_150px_110px_100px_150px] xl:items-center">
+              <div class="grid gap-3 xl:grid-cols-[84px_minmax(0,1.2fr)_110px_150px_90px_90px_150px_190px] xl:items-center">
                 <p class="text-xs font-bold tracking-[0.14em] text-stone-500">#{{ user.id }}</p>
                 <div>
                   <p class="text-sm font-semibold text-stone-900">{{ user.nickname }}</p>
                   <p class="mt-1 text-xs font-semibold text-stone-500">{{ user.email }}</p>
+                  <button
+                    type="button"
+                    class="mt-2 text-[11px] font-bold tracking-[0.12em] text-stone-500 underline underline-offset-4 transition hover:text-stone-900"
+                    @click="emit('select-user', user)"
+                  >
+                    {{ selectedUserId === user.id ? '상세 닫기' : '상세 보기' }}
+                  </button>
                 </div>
                 <p class="text-sm font-semibold text-stone-700">{{ user.role }}</p>
                 <p class="text-sm font-semibold text-stone-700">{{ formatDate(user.lastLoginAt) }}</p>
@@ -157,9 +324,9 @@ function formatDate(value) {
                 <div class="flex flex-wrap items-center gap-2">
                   <span
                     class="rounded-full px-3 py-1 text-[10px] font-bold tracking-[0.14em]"
-                    :class="user.isActiveRecently ? 'bg-emerald-100 text-emerald-700' : 'bg-stone-100 text-stone-500'"
+                    :class="user.disabledAt ? 'bg-rose-100 text-rose-700' : user.isActiveRecently ? 'bg-emerald-100 text-emerald-700' : 'bg-stone-100 text-stone-500'"
                   >
-                    {{ user.isActiveRecently ? '활동 중' : '휴면 가능성' }}
+                    {{ user.disabledAt ? '비활성화' : user.isActiveRecently ? '활동 중' : '휴면 가능성' }}
                   </span>
                   <span
                     class="rounded-full px-3 py-1 text-[10px] font-bold tracking-[0.14em]"
@@ -167,18 +334,176 @@ function formatDate(value) {
                   >
                     {{ user.emailVerifiedAt ? '이메일 인증' : '미인증' }}
                   </span>
+                  <span
+                    class="rounded-full px-3 py-1 text-[10px] font-bold tracking-[0.14em]"
+                    :class="user.activeSessionCount > 0 ? 'bg-violet-100 text-violet-700' : 'bg-stone-100 text-stone-500'"
+                  >
+                    세션 {{ user.activeSessionCount }}개
+                  </span>
+                </div>
+                <div class="flex flex-wrap items-center gap-2 xl:justify-end">
+                  <button
+                    v-if="user.role !== 'admin'"
+                    type="button"
+                    class="rounded-full border px-3 py-2 text-[10px] font-bold tracking-[0.14em] transition"
+                    :class="user.disabledAt ? 'border-emerald-300 text-emerald-700 hover:bg-emerald-50' : 'border-amber-300 text-amber-700 hover:bg-amber-50'"
+                    :disabled="actionBusyUserId === user.id"
+                    @click="emit('toggle-user-status', user)"
+                  >
+                    {{ user.disabledAt ? '다시 허용' : '비활성화' }}
+                  </button>
+                  <button
+                    v-if="user.role !== 'admin'"
+                    type="button"
+                    class="rounded-full border border-stone-300 px-3 py-2 text-[10px] font-bold tracking-[0.14em] text-stone-700 transition hover:bg-stone-100"
+                    :disabled="actionBusyUserId === user.id"
+                    @click="emit('revoke-user-sessions', user)"
+                  >
+                    강제 로그아웃
+                  </button>
+                  <button
+                    v-if="user.role !== 'admin'"
+                    type="button"
+                    class="rounded-full border border-rose-300 px-3 py-2 text-[10px] font-bold tracking-[0.14em] text-rose-700 transition hover:bg-rose-50"
+                    :disabled="actionBusyUserId === user.id"
+                    @click="emit('delete-user', user)"
+                  >
+                    삭제
+                  </button>
+                  <span
+                    v-if="actionBusyUserId === user.id"
+                    class="text-[10px] font-bold tracking-[0.12em] text-stone-400"
+                  >
+                    처리 중...
+                  </span>
                 </div>
               </div>
             </article>
 
             <div
-              v-if="!busy && users.length === 0"
+              v-if="!busy && filteredUsers.length === 0"
               class="px-5 py-10 text-center text-sm font-semibold text-stone-500"
             >
-              표시할 사용자가 없습니다.
+              조건에 맞는 사용자가 없습니다.
             </div>
           </div>
         </div>
+
+        <section class="border-t border-stone-200 bg-[#fcfaf6] px-5 py-5">
+          <div class="flex items-center justify-between gap-4">
+            <div>
+              <p class="text-[11px] font-bold uppercase tracking-[0.24em] text-stone-500">사용자 상세</p>
+              <p class="mt-2 text-sm font-semibold text-stone-500">선택한 사용자의 최근 플래너 기록과 목표를 확인합니다.</p>
+            </div>
+            <div
+              v-if="detailBusy"
+              class="rounded-full bg-stone-900 px-4 py-2 text-[11px] font-bold tracking-[0.16em] text-white"
+            >
+              불러오는 중...
+            </div>
+          </div>
+
+          <div
+            v-if="userDetail?.user"
+            class="mt-5 grid gap-5 xl:grid-cols-[minmax(0,1.15fr)_minmax(320px,0.85fr)]"
+          >
+            <div class="rounded-[24px] border border-stone-200 bg-white p-5">
+              <div class="flex items-center justify-between gap-4">
+                <div>
+                  <p class="text-lg font-semibold text-stone-900">{{ userDetail.user.nickname }}</p>
+                  <p class="mt-1 text-sm font-semibold text-stone-500">{{ userDetail.user.email }}</p>
+                </div>
+                <div class="flex flex-wrap justify-end gap-2">
+                  <span class="rounded-full bg-stone-100 px-3 py-1 text-[10px] font-bold tracking-[0.14em] text-stone-600">{{ userDetail.user.role }}</span>
+                  <span
+                    class="rounded-full px-3 py-1 text-[10px] font-bold tracking-[0.14em]"
+                    :class="userDetail.user.disabledAt ? 'bg-rose-100 text-rose-700' : 'bg-emerald-100 text-emerald-700'"
+                  >
+                    {{ userDetail.user.disabledAt ? '비활성화' : '사용 가능' }}
+                  </span>
+                </div>
+              </div>
+
+              <div class="mt-5 grid gap-3 md:grid-cols-3">
+                <div class="rounded-2xl border border-stone-200 bg-[#fbf7f0] px-4 py-4">
+                  <p class="text-[10px] font-bold tracking-[0.16em] text-stone-500">최근 로그인</p>
+                  <p class="mt-2 text-sm font-semibold text-stone-800">{{ formatDate(userDetail.user.lastLoginAt) }}</p>
+                </div>
+                <div class="rounded-2xl border border-stone-200 bg-[#fbf7f0] px-4 py-4">
+                  <p class="text-[10px] font-bold tracking-[0.16em] text-stone-500">문서 / 목표</p>
+                  <p class="mt-2 text-sm font-semibold text-stone-800">{{ userDetail.user.plannerEntryCount }} / {{ userDetail.user.goalCount }}</p>
+                </div>
+                <div class="rounded-2xl border border-stone-200 bg-[#fbf7f0] px-4 py-4">
+                  <p class="text-[10px] font-bold tracking-[0.16em] text-stone-500">활성 세션</p>
+                  <p class="mt-2 text-sm font-semibold text-stone-800">{{ userDetail.user.activeSessionCount }}개</p>
+                </div>
+              </div>
+
+              <div class="mt-6">
+                <p class="text-[11px] font-bold uppercase tracking-[0.2em] text-stone-500">최근 플래너 기록</p>
+                <div class="mt-3 space-y-3">
+                  <article
+                    v-for="entry in userDetail.plannerEntries"
+                    :key="entry.entryDate"
+                    class="rounded-2xl border border-stone-200 bg-[#fffdfa] px-4 py-4"
+                  >
+                    <div class="flex items-center justify-between gap-3">
+                      <p class="text-sm font-semibold text-stone-900">{{ entry.entryDate }}</p>
+                      <p class="text-[11px] font-semibold text-stone-500">{{ formatDate(entry.updatedAt) }}</p>
+                    </div>
+                    <p class="mt-3 text-sm font-semibold leading-6 text-stone-700">{{ getPlannerSummary(entry.payload).comment }}</p>
+                    <div class="mt-3 flex flex-wrap gap-2 text-[11px] font-bold tracking-[0.12em] text-stone-500">
+                      <span>작업 {{ getPlannerSummary(entry.payload).taskCount }}개</span>
+                      <span>완료 {{ getPlannerSummary(entry.payload).completedCount }}개</span>
+                      <span>메모 {{ getPlannerSummary(entry.payload).memoCount }}개</span>
+                    </div>
+                  </article>
+                  <p
+                    v-if="userDetail.plannerEntries.length === 0"
+                    class="rounded-2xl border border-dashed border-stone-300 bg-white px-4 py-4 text-sm font-semibold text-stone-500"
+                  >
+                    아직 작성한 플래너 기록이 없습니다.
+                  </p>
+                </div>
+              </div>
+            </div>
+
+            <div class="rounded-[24px] border border-stone-200 bg-white p-5">
+              <p class="text-[11px] font-bold uppercase tracking-[0.2em] text-stone-500">목표 목록</p>
+              <div class="mt-3 space-y-3">
+                <article
+                  v-for="goal in userDetail.goals"
+                  :key="goal.id"
+                  class="rounded-2xl border border-stone-200 bg-[#fffdfa] px-4 py-4"
+                >
+                  <div class="flex items-center justify-between gap-3">
+                    <p class="text-sm font-semibold text-stone-900">{{ goal.title }}</p>
+                    <span class="rounded-full border border-stone-200 px-3 py-1 text-[10px] font-bold tracking-[0.12em] text-stone-500">
+                      {{ goal.targetDate }}
+                    </span>
+                  </div>
+                  <div class="mt-3 flex flex-wrap gap-2 text-[11px] font-bold tracking-[0.12em] text-stone-500">
+                    <span>표시 시작 {{ goal.activeFrom || '미설정' }}</span>
+                    <span>표시 종료 {{ goal.activeUntil || '미설정' }}</span>
+                  </div>
+                </article>
+                <p
+                  v-if="userDetail.goals.length === 0"
+                  class="rounded-2xl border border-dashed border-stone-300 bg-white px-4 py-4 text-sm font-semibold text-stone-500"
+                >
+                  등록된 목표가 없습니다.
+                </p>
+              </div>
+            </div>
+          </div>
+
+          <div
+            v-else
+            class="mt-5 rounded-[24px] border border-dashed border-stone-300 bg-white px-5 py-10 text-center text-sm font-semibold text-stone-500"
+          >
+            사용자 목록에서 `상세 보기`를 눌러 기록과 목표를 확인해 주세요.
+          </div>
+        </section>
       </section>
     </div>
   </section>

src/components/AuthDialog.vue

@@ -20,11 +20,16 @@ const props = defineProps({
     type: String,
     default: '',
   },
+  showResendVerification: {
+    type: Boolean,
+    default: false,
+  },
 })
 
 const emit = defineEmits([
   'close',
   'submit',
+  'resend-verification',
   'switch-mode',
   'update:field',
 ])
@@ -185,12 +190,25 @@ function getSubmitLabel(mode, busy) {
           <span class="text-xs font-bold tracking-[0.08em] text-stone-700">로그인 상태 유지</span>
         </label>
 
-        <p
+        <div
           v-if="message"
-          class="rounded-2xl border border-stone-300 bg-white/80 px-4 py-3 text-sm font-semibold leading-6 text-stone-700"
+          class="rounded-2xl border border-stone-300 bg-white/80 px-4 py-3"
         >
-          {{ message }}
+          <div class="flex items-start justify-between gap-4">
-        </p>
+            <p class="min-w-0 text-sm font-semibold leading-6 text-stone-700">
+              {{ message }}
+            </p>
+            <button
+              v-if="showResendVerification"
+              type="button"
+              class="shrink-0 rounded-full border border-stone-300 px-3 py-2 text-[10px] font-bold tracking-[0.14em] text-stone-600 transition hover:border-stone-500 hover:text-stone-900"
+              :disabled="busy"
+              @click="emit('resend-verification')"
+            >
+              재전송
+            </button>
+          </div>
+        </div>
 
         <button
           type="submit"

src/components/GuideTooltip.vue

@@ -1,5 +1,5 @@
 <script setup>
-import { onBeforeUnmount, ref } from 'vue'
+import { computed, nextTick, onBeforeUnmount, ref } from 'vue'
 
 const props = defineProps({
   title: {
@@ -28,17 +28,52 @@ const emit = defineEmits(['dismiss'])
 
 const open = ref(false)
 const rootRef = ref(null)
+const buttonRef = ref(null)
+const popupStyle = ref({})
+const isCompactButtonLabel = computed(() => String(props.buttonLabel || '').trim().length <= 1)
 
 function close() {
   open.value = false
 }
 
-function toggle() {
+function updatePopupPosition() {
+  if (!open.value || !buttonRef.value || typeof window === 'undefined') {
+    return
+  }
+
+  const rect = buttonRef.value.getBoundingClientRect()
+  const viewportWidth = window.innerWidth
+  const preferredWidth = Math.min(256, Math.max(196, viewportWidth - 24))
+  const horizontalPadding = 12
+  let left = rect.left
+
+  if (left + preferredWidth > viewportWidth - horizontalPadding) {
+    left = viewportWidth - preferredWidth - horizontalPadding
+  }
+
+  if (left < horizontalPadding) {
+    left = horizontalPadding
+  }
+
+  popupStyle.value = {
+    left: `${left}px`,
+    top: `${rect.bottom + 8}px`,
+    width: `${preferredWidth}px`,
+    maxWidth: `calc(100vw - ${horizontalPadding * 2}px)`,
+  }
+}
+
+async function toggle() {
   if (!props.visible) {
     return
   }
 
   open.value = !open.value
+
+  if (open.value) {
+    await nextTick()
+    updatePopupPosition()
+  }
 }
 
 function closeFromOutside(event) {
@@ -56,10 +91,14 @@ function dismiss() {
 
 if (typeof window !== 'undefined') {
   window.addEventListener('pointerdown', closeFromOutside)
+  window.addEventListener('resize', updatePopupPosition)
+  window.addEventListener('scroll', updatePopupPosition, true)
 }
 
 onBeforeUnmount(() => {
   window.removeEventListener('pointerdown', closeFromOutside)
+  window.removeEventListener('resize', updatePopupPosition)
+  window.removeEventListener('scroll', updatePopupPosition, true)
 })
 </script>
 
@@ -67,11 +106,13 @@ onBeforeUnmount(() => {
   <span
     v-if="visible"
     ref="rootRef"
-    class="relative inline-flex"
+    class="relative inline-flex print:hidden"
   >
     <button
+      ref="buttonRef"
       type="button"
-      class="flex h-5 w-5 items-center justify-center rounded-full border border-stone-300 bg-white text-[10px] font-bold text-stone-500 transition hover:border-stone-500 hover:text-stone-900 focus-visible:ring-2 focus-visible:ring-stone-900 focus-visible:ring-offset-2"
+      class="inline-flex shrink-0 items-center justify-center whitespace-nowrap border border-stone-300 bg-white text-[10px] font-bold text-stone-500 transition hover:border-stone-500 hover:text-stone-900 focus-visible:ring-2 focus-visible:ring-stone-900 focus-visible:ring-offset-2"
+      :class="isCompactButtonLabel ? 'h-5 w-5 rounded-full' : 'min-h-[22px] rounded-full px-2 py-1 leading-none'"
       aria-label="가이드 보기"
       :aria-expanded="open"
       @click.stop="toggle"
@@ -79,21 +120,24 @@ onBeforeUnmount(() => {
       {{ buttonLabel }}
     </button>
 
-    <span
+    <Teleport to="body">
-      v-if="open"
+      <span
-      class="absolute left-0 top-7 z-50 w-64 rounded-2xl border border-stone-200 bg-white p-4 text-left shadow-[0_18px_50px_rgba(28,25,23,0.16)]"
+        v-if="open"
-      @pointerdown.stop
+        class="fixed z-[120] rounded-2xl border border-stone-200 bg-white p-4 text-left shadow-[0_18px_50px_rgba(28,25,23,0.16)] print:hidden"
-    >
+        :style="popupStyle"
-      <span class="block text-[10px] font-bold uppercase tracking-[0.2em] text-stone-500">{{ title }}</span>
+        @pointerdown.stop
-      <span class="mt-2 block text-[11px] font-semibold leading-5 tracking-[0.04em] text-stone-700">{{ description }}</span>
-      <button
-        v-if="dismissible"
-        type="button"
-        class="mt-3 rounded-full border border-stone-200 px-3 py-2 text-[10px] font-bold tracking-[0.14em] text-stone-600 transition hover:border-stone-500 hover:text-stone-900"
-        @click="dismiss"
       >
-        더 이상 보지 않기
+        <span class="block text-[10px] font-bold uppercase tracking-[0.2em] text-stone-500">{{ title }}</span>
-      </button>
+        <span class="mt-2 block break-words text-[11px] font-semibold leading-5 tracking-[0.04em] text-stone-700">{{ description }}</span>
-    </span>
+        <button
+          v-if="dismissible"
+          type="button"
+          class="mt-3 rounded-full border border-stone-200 px-3 py-2 text-[10px] font-bold tracking-[0.14em] text-stone-600 transition hover:border-stone-500 hover:text-stone-900"
+          @click="dismiss"
+        >
+          더 이상 보지 않기
+        </button>
+      </span>
+    </Teleport>
   </span>
 </template>

src/components/MiniCalendar.vue

@@ -48,6 +48,7 @@ function selectYear(year) {
           <button
             type="button"
             class="flex h-9 w-9 items-center justify-center rounded-full border border-stone-200 text-xs font-bold text-stone-600 transition hover:border-stone-400 hover:text-ink sm:h-auto sm:w-auto sm:px-2 sm:py-1"
+            @mousedown.prevent
             @click="emit('shift-month', -1)"
           >
             ←
@@ -57,6 +58,7 @@ function selectYear(year) {
             <button
               type="button"
               class="rounded-full px-2 py-1 text-[10px] font-semibold tracking-[0.16em] text-stone-500 transition hover:bg-stone-100 hover:text-ink sm:text-[11px]"
+              @mousedown.prevent
               @click="isYearPickerOpen = !isYearPickerOpen"
             >
               {{ yearLabel }}
@@ -65,6 +67,7 @@ function selectYear(year) {
           <button
             type="button"
             class="flex h-9 w-9 items-center justify-center rounded-full border border-stone-200 text-xs font-bold text-stone-600 transition hover:border-stone-400 hover:text-ink sm:h-auto sm:w-auto sm:px-2 sm:py-1"
+            @mousedown.prevent
             @click="emit('shift-month', 1)"
           >
             →
@@ -74,6 +77,7 @@ function selectYear(year) {
       <button
         type="button"
         class="shrink-0 self-start rounded-full border border-stone-200 px-3 py-2 text-[10px] font-bold tracking-[0.14em] text-stone-600 transition hover:border-stone-400 hover:text-ink sm:self-auto"
+        @mousedown.prevent
         @click="emit('go-today')"
       >
         TODAY
@@ -87,6 +91,7 @@ function selectYear(year) {
           <button
             type="button"
             class="rounded-full border border-stone-200 px-2 py-1 text-xs font-bold text-stone-600 transition hover:border-stone-400 hover:text-ink"
+            @mousedown.prevent
             @click="emit('shift-year', -12)"
           >
             ←
@@ -97,6 +102,7 @@ function selectYear(year) {
           <button
             type="button"
             class="rounded-full border border-stone-200 px-2 py-1 text-xs font-bold text-stone-600 transition hover:border-stone-400 hover:text-ink"
+            @mousedown.prevent
             @click="emit('shift-year', 12)"
           >
             →
@@ -109,6 +115,7 @@ function selectYear(year) {
             type="button"
             class="rounded-xl border px-3 py-2 text-[11px] font-semibold transition"
             :class="year === currentYearNumber ? 'border-ink bg-ink text-white' : 'border-stone-200 text-stone-700 hover:border-stone-400 hover:bg-stone-50'"
+            @mousedown.prevent
             @click="selectYear(year)"
           >
             {{ year }}
@@ -139,6 +146,7 @@ function selectYear(year) {
               : 'border-stone-200 bg-stone-50 text-stone-700 hover:border-stone-400 hover:bg-white',
             day.isCurrentMonth ? '' : 'opacity-35',
           ]"
+          @mousedown.prevent
           @click="emit('select', day.date)"
         >
           <span>{{ day.label }}</span>

src/components/PlannerPage.vue

@@ -66,11 +66,18 @@ const emit = defineEmits([
   'update:memo-label',
   'update:memo',
   'update:timetable',
+  'timetable-action',
+  'timetable-contextmenu',
 ])
 
+const LONG_PRESS_DELAY_MS = 420
+const TOUCH_MOVE_CANCEL_DISTANCE = 10
+
 let dragState = null
+let timetableTouchTimer = null
 let taskSelectionDrag = null
 const selectedTaskIndexes = ref(new Set())
+const pendingTimetableTouchIndex = ref(null)
 
 function shouldShowTaskPlaceholder(index) {
   return index === 0 && props.tasks.every((task) => !task.title.trim())
@@ -88,6 +95,37 @@ function buildTimedRange(baseTimetable, startIndex, endIndex, nextValue) {
   return nextTimetable
 }
 
+function clearTimetableTouchTimer() {
+  if (timetableTouchTimer) {
+    window.clearTimeout(timetableTouchTimer)
+    timetableTouchTimer = null
+  }
+}
+
+function beginTimetableDrag(index, shouldFill) {
+  dragState = {
+    startIndex: index,
+    baseTimetable: [...props.timetable],
+    nextValue: shouldFill,
+    isActive: true,
+    isTouchPending: false,
+  }
+
+  pendingTimetableTouchIndex.value = null
+  emit('update:timetable', buildTimedRange(dragState.baseTimetable, index, index, dragState.nextValue))
+}
+
+function getTimetableCellIndexAtPoint(clientX, clientY) {
+  const cell = document.elementFromPoint(clientX, clientY)?.closest('[data-timetable-index]')
+  const index = Number(cell?.dataset.timetableIndex)
+
+  return Number.isInteger(index) ? index : null
+}
+
+function getTimetableCellIndexFromPointer(event) {
+  return getTimetableCellIndexAtPoint(event.clientX, event.clientY)
+}
+
 function startTimetableDrag(index, event) {
   if (props.readonly) {
     return
@@ -99,17 +137,41 @@ function startTimetableDrag(index, event) {
 
   const shouldFill = event.button === 2 ? false : !props.timetable[index]
 
-  dragState = {
+  if (event.pointerType === 'touch') {
-    startIndex: index,
+    clearTimetableTouchTimer()
-    baseTimetable: [...props.timetable],
+    pendingTimetableTouchIndex.value = index
-    nextValue: shouldFill,
+    dragState = {
+      startIndex: index,
+      baseTimetable: [...props.timetable],
+      nextValue: shouldFill,
+      isActive: false,
+      isTouchPending: true,
+      touchStartX: event.clientX,
+      touchStartY: event.clientY,
+      pointerId: event.pointerId,
+    }
+
+    event.currentTarget?.setPointerCapture?.(event.pointerId)
+    timetableTouchTimer = window.setTimeout(() => {
+      if (!dragState?.isTouchPending || dragState.pointerId !== event.pointerId) {
+        return
+      }
+
+      dragState.isTouchPending = false
+      dragState.isActive = true
+      pendingTimetableTouchIndex.value = null
+      emit('update:timetable', buildTimedRange(dragState.baseTimetable, index, index, dragState.nextValue))
+    }, LONG_PRESS_DELAY_MS)
+
+    return
   }
 
-  emit('update:timetable', buildTimedRange(dragState.baseTimetable, index, index, dragState.nextValue))
+  event.preventDefault()
+  beginTimetableDrag(index, shouldFill)
 }
 
 function moveTimetableDrag(index) {
-  if (props.readonly || !dragState) {
+  if (props.readonly || !dragState?.isActive) {
     return
   }
 
@@ -119,7 +181,75 @@ function moveTimetableDrag(index) {
   )
 }
 
+function moveTimetableDragFromPointer(event) {
+  if (props.readonly || !dragState) {
+    return
+  }
+
+  if (dragState.isTouchPending) {
+    const movedX = Math.abs(event.clientX - dragState.touchStartX)
+    const movedY = Math.abs(event.clientY - dragState.touchStartY)
+
+    if (movedX > TOUCH_MOVE_CANCEL_DISTANCE || movedY > TOUCH_MOVE_CANCEL_DISTANCE) {
+      stopTimetableDrag()
+    }
+
+    return
+  }
+
+  if (!dragState.isActive) {
+    return
+  }
+
+  if (event.pointerType === 'touch') {
+    event.preventDefault()
+  }
+
+  const index = getTimetableCellIndexFromPointer(event)
+
+  if (index !== null) {
+    moveTimetableDrag(index)
+  }
+}
+
+function moveTimetableDragFromTouch(event) {
+  if (props.readonly || !dragState) {
+    return
+  }
+
+  const touch = event.touches[0]
+
+  if (!touch) {
+    return
+  }
+
+  if (dragState.isTouchPending) {
+    const movedX = Math.abs(touch.clientX - dragState.touchStartX)
+    const movedY = Math.abs(touch.clientY - dragState.touchStartY)
+
+    if (movedX > TOUCH_MOVE_CANCEL_DISTANCE || movedY > TOUCH_MOVE_CANCEL_DISTANCE) {
+      stopTimetableDrag()
+    }
+
+    return
+  }
+
+  if (!dragState.isActive) {
+    return
+  }
+
+  event.preventDefault()
+
+  const index = getTimetableCellIndexAtPoint(touch.clientX, touch.clientY)
+
+  if (index !== null) {
+    moveTimetableDrag(index)
+  }
+}
+
 function stopTimetableDrag() {
+  clearTimetableTouchTimer()
+  pendingTimetableTouchIndex.value = null
   dragState = null
 }
 
@@ -230,12 +360,22 @@ function clearSelectedTasks(event) {
   clearTaskSelection()
 }
 
+window.addEventListener('pointermove', moveTimetableDragFromPointer)
 window.addEventListener('pointerup', stopTimetableDrag)
+window.addEventListener('pointercancel', stopTimetableDrag)
+window.addEventListener('touchmove', moveTimetableDragFromTouch, { passive: false })
+window.addEventListener('touchend', stopTimetableDrag)
+window.addEventListener('touchcancel', stopTimetableDrag)
 window.addEventListener('pointermove', moveTaskSelectionFromPointer)
 window.addEventListener('pointerup', stopTaskSelection)
 window.addEventListener('keydown', clearSelectedTasks)
 onBeforeUnmount(() => {
+  window.removeEventListener('pointermove', moveTimetableDragFromPointer)
   window.removeEventListener('pointerup', stopTimetableDrag)
+  window.removeEventListener('pointercancel', stopTimetableDrag)
+  window.removeEventListener('touchmove', moveTimetableDragFromTouch)
+  window.removeEventListener('touchend', stopTimetableDrag)
+  window.removeEventListener('touchcancel', stopTimetableDrag)
   window.removeEventListener('pointermove', moveTaskSelectionFromPointer)
   window.removeEventListener('pointerup', stopTaskSelection)
   window.removeEventListener('keydown', clearSelectedTasks)
@@ -304,7 +444,7 @@ onBeforeUnmount(() => {
     </div>
 
     <div class="planner-sheet__body flex flex-col gap-5 py-[10px] lg:flex-row lg:gap-4">
-      <div class="planner-sheet__lists flex w-full flex-1 flex-col gap-[21px] lg:w-[394px]">
+      <div class="planner-sheet__lists flex w-full flex-1 flex-col gap-[26px] print:gap-[21px] lg:w-[394px]">
         <section>
           <div class="flex items-center gap-2 text-muted">
             <span class="shrink-0">TASKS</span>
@@ -408,16 +548,32 @@ onBeforeUnmount(() => {
       </div>
 
       <section class="planner-sheet__timetable w-full shrink-0 lg:w-[210px]">
-        <div class="flex items-center gap-2 text-muted">
+        <div v-if="!props.readonly" class="flex items-center gap-2 text-muted">
+          <button
+            type="button"
+            class="shrink-0 text-left transition hover:text-ink"
+            @click="emit('timetable-action')"
+            @contextmenu.prevent="emit('timetable-contextmenu', $event)"
+          >
+            <span class="shrink-0">TIME TABLE</span>
+          </button>
+          <span class="h-px flex-1 bg-ink"></span>
+          <GuideTooltip
+            title="Time Table"
+            description="먼저 원하는 날짜의 TIME TABLE 제목을 클릭해 타임테이블을 저장하세요. 그다음 붙여넣을 날짜로 이동해서 TIME TABLE 제목을 마우스 오른쪽 클릭하면 손쉽게 같은 내용을 붙여넣을 수 있습니다."
+            :dismissible="false"
+          />
+        </div>
+        <div v-else class="flex items-center gap-2 text-muted">
           <span class="shrink-0">TIME TABLE</span>
           <span class="h-px flex-1 bg-ink"></span>
         </div>
         <div class="planner-sheet__timetable-scroll overflow-x-auto pb-1">
-          <div class="planner-sheet__timetable-grid min-w-[210px]">
+          <div class="planner-sheet__timetable-grid min-w-[210px] w-full">
             <div
               v-for="(hour, index) in hours"
               :key="`${hour}-${index}`"
-              class="flex h-[25px] border-b sm:h-[30px]"
+              class="grid h-[25px] grid-cols-[30px_repeat(6,minmax(0,1fr))] border-b sm:h-[30px] lg:grid-cols-[30px_repeat(6,30px)]"
               :class="index === hours.length - 1 ? 'border-ink' : 'border-line'"
             >
               <div
@@ -429,10 +585,14 @@ onBeforeUnmount(() => {
               <div
                 v-for="quarter in 6"
                 :key="quarter"
-                :class="props.timetable[index * 6 + quarter - 1] ? 'bg-stone-800/90' : 'bg-transparent'"
+                :data-timetable-index="index * 6 + quarter - 1"
-                class="h-full w-[30px] cursor-crosshair border-r border-dashed border-line transition-colors last:border-r-0 touch-none select-none"
+                :class="[
+                  props.timetable[index * 6 + quarter - 1] ? 'bg-stone-800/90' : 'bg-transparent',
+                  pendingTimetableTouchIndex === index * 6 + quarter - 1 ? 'ring-1 ring-inset ring-stone-500/70' : '',
+                ]"
+                class="h-full cursor-crosshair touch-pan-y select-none border-r border-dashed border-line transition-colors last:border-r-0"
                 @contextmenu.prevent
-                @pointerdown.prevent="startTimetableDrag(index * 6 + quarter - 1, $event)"
+                @pointerdown="startTimetableDrag(index * 6 + quarter - 1, $event)"
                 @pointerenter="moveTimetableDrag(index * 6 + quarter - 1)"
               />
             </div>

src/components/SettingsDashboard.vue

@@ -18,6 +18,10 @@ const props = defineProps({
     type: Object,
     required: true,
   },
+  authSessionInfo: {
+    type: Object,
+    required: true,
+  },
   profileBusy: {
     type: Boolean,
     default: false,
@@ -151,6 +155,28 @@ function updateAccountDeleteField(field, event) {
           </button>
         </div>
       </div>
+
+      <div class="mt-4 rounded-[24px] border border-stone-200 bg-white/80 p-4">
+        <p class="text-[10px] font-bold tracking-[0.18em] text-stone-500">LOGIN STATUS</p>
+        <div class="mt-3 space-y-3">
+          <div class="rounded-2xl border border-stone-200 bg-[#fbf7f0] 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 leading-6 text-stone-800">{{ authSessionInfo.storageLabel }}</p>
+            <p class="mt-1 text-xs font-semibold leading-5 text-stone-500">{{ authSessionInfo.storageDescription }}</p>
+          </div>
+          <div class="rounded-2xl border border-stone-200 bg-[#fbf7f0] 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 leading-6 text-stone-800">{{ authSessionInfo.lastLoginLabel }}</p>
+          </div>
+          <div
+            v-if="authSessionInfo.verificationLabel"
+            class="rounded-2xl border border-stone-200 bg-[#fbf7f0] 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 leading-6 text-stone-800">{{ authSessionInfo.verificationLabel }}</p>
+          </div>
+        </div>
+      </div>
     </aside>
 
     <div class="grid gap-6">

src/lib/adminApi.js

@@ -1,10 +1,14 @@
 import { buildApiUrl, toUserFacingApiError } from './apiBase'
 
-async function request(path, token) {
+async function request(path, token, { method = 'GET', body } = {}) {
+  const hasBody = body !== undefined
   const response = await fetch(buildApiUrl(path), {
+    method,
     headers: {
       Authorization: `Bearer ${token}`,
+      ...(hasBody ? { 'Content-Type': 'application/json' } : {}),
     },
+    body: hasBody ? JSON.stringify(body) : undefined,
   })
 
   const data = await response.json().catch(() => ({}))
@@ -19,3 +23,26 @@ async function request(path, token) {
 export async function fetchAdminOverview(token) {
   return request('/api/admin/overview', token)
 }
+
+export async function fetchAdminUserDetail(token, userId) {
+  return request(`/api/admin/users/${userId}/detail`, token)
+}
+
+export async function updateAdminUserStatus(token, userId, disabled) {
+  return request(`/api/admin/users/${userId}/status`, token, {
+    method: 'PUT',
+    body: { disabled },
+  })
+}
+
+export async function revokeAdminUserSessions(token, userId) {
+  return request(`/api/admin/users/${userId}/revoke-sessions`, token, {
+    method: 'POST',
+  })
+}
+
+export async function deleteAdminUser(token, userId) {
+  return request(`/api/admin/users/${userId}`, token, {
+    method: 'DELETE',
+  })
+}

src/lib/authClient.js

@@ -92,6 +92,13 @@ export async function fetchCurrentUser(token) {
   })
 }
 
+export async function logout(token) {
+  return request('/api/auth/logout', {
+    method: 'POST',
+    token,
+  })
+}
+
 export async function updateProfile(token, { email, nickname }) {
   return request('/api/auth/profile', {
     method: 'PUT',
@@ -136,3 +143,11 @@ export async function confirmVerification({ token }) {
     body: { token },
   })
 }
+
+export async function requestVerification({ email }, token) {
+  return request('/api/auth/verification/request', {
+    method: 'POST',
+    token,
+    body: email ? { email } : {},
+  })
+}

src/lib/plannerStorage.js

@@ -40,16 +40,8 @@ export function restorePlannerUiState({
   toDateValue,
 }) {
   const savedState = readStorageState()
-
+  selectedDate.value = toDateValue(new Date(), selectedDate.value)
-  if (savedState.selectedDate) {
+  calendarViewDate.value = new Date(selectedDate.value)
-    selectedDate.value = toDateValue(savedState.selectedDate, selectedDate.value)
-  }
-
-  if (savedState.calendarViewDate) {
-    calendarViewDate.value = toDateValue(savedState.calendarViewDate, selectedDate.value)
-  } else {
-    calendarViewDate.value = new Date(selectedDate.value)
-  }
 
   if (savedState.statsRangeStart) {
     statsRangeStart.value = savedState.statsRangeStart
@@ -75,12 +67,13 @@ export function persistPlannerState({
   const previousState = readStorageState()
   const nextState = {
     ...previousState,
-    selectedDate: selectedDate.toISOString(),
-    calendarViewDate: calendarViewDate.toISOString(),
     statsRangeStart,
     statsRangeEnd,
   }
 
+  delete nextState.selectedDate
+  delete nextState.calendarViewDate
+
   if (includeRecords) {
     nextState.records = Object.fromEntries(
       Object.entries(plannerRecords).map(([key, record]) => [