journal: multi-select emotions and per-category writing templates

- Mood switches from a single enum column to a many-to-many
  JournalEntryMood table so an entry can carry several feelings at
  once; the vocabulary is trimmed to 9 named emotions (dropped the
  overlapping satisfaction scale) with unified noun-style labels.
- Categories can define a content_template that pre-fills the "new
  entry" textarea when selected (only if the user hasn't started
  typing), seeded with a Story/Feelings/Decisions/Insights/Actions
  reflection template on the default "일상" category.
- Fixes a real attribute-injection bug found while building the
  template feature: Jinja's built-in |tojson filter doesn't escape
  double quotes, which breaks a double-quoted x-data="..." attribute
  when the JSON payload contains one; added |forceescape and a
  regression test.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

.env.example

@@ -20,3 +20,7 @@ GOOGLE_REDIRECT_URI=http://localhost:8000/auth/google/callback
 VAPID_PUBLIC_KEY=
 VAPID_PRIVATE_KEY=
 VAPID_SUBJECT=mailto:you@example.com
+
+# 저널 사진/영상 첨부 저장 경로(로컬 디스크)와 업로드 용량 제한(MB). 둘 다 기본값이 있어 생략 가능.
+# JOURNAL_MEDIA_ROOT=app/media/journal
+# JOURNAL_MAX_UPLOAD_MB=20

.gitignore

@@ -2,6 +2,7 @@ __pycache__/
 *.pyc
 .env
 .env.dev
+deploy.env
 .venv/
 venv/
 *.egg-info/
@@ -12,3 +13,4 @@ node_modules/
 logs/
 img*.png
 image.md
+app/media/

CLAUDE.md

@@ -36,8 +36,8 @@ pytest tests/test_habits.py::test_name   # 단일 테스트
 
 ### 요청 흐름 (2가지 라우터 계열이 공존)
 
-- `app/routers/habits.py`, `app/routers/logs.py`, `app/routers/push.py` — `/api/*` 하위, JSON in/out API. 라우터 레벨 `dependencies=[Depends(require_login)]`로 기본 보호되고, 유저 객체가 필요한 각 엔드포인트는 `current_user: User = Depends(require_login)`을 시그니처에 추가로 선언한다(FastAPI가 같은 요청 안에서 dependency를 캐싱하므로 DB 조회가 중복되지 않는다). 미인증 시 401 JSON을 반환.
-- `app/routers/pages.py` — SSR 페이지(`/login`, `/today`, `/habits`, `/history`)와 htmx가 폼 제출로 호출하는 액션 엔드포인트(`/habits/new`, `/habits/{id}/complete` 등). 미인증 시 401 대신 `/login`으로 303 리다이렉트한다 — `_current_user_or_redirect(request, db)`가 `User`(로그인됨) 또는 `RedirectResponse`(미인증)를 반환하고, 각 핸들러는 `isinstance(current, RedirectResponse)`로 분기한다. 폼 액션은 대부분 처리 후 `HX-Redirect` 헤더로 같은 탭을 새로고침하는 방식으로 단순화되어 있다(부분 DOM 스왑이 아님).
+- `app/routers/habits.py`, `app/routers/logs.py`, `app/routers/push.py`, `app/routers/journal.py` — `/api/*` 하위, JSON in/out API. 라우터 레벨 `dependencies=[Depends(require_login)]`로 기본 보호되고, 유저 객체가 필요한 각 엔드포인트는 `current_user: User = Depends(require_login)`을 시그니처에 추가로 선언한다(FastAPI가 같은 요청 안에서 dependency를 캐싱하므로 DB 조회가 중복되지 않는다). 미인증 시 401 JSON을 반환. `journal.py`는 현재 첨부파일 스트리밍(`GET /api/journal/media/{attachment_id}`) 하나뿐이다.
+- `app/routers/pages.py`, `app/routers/journal_pages.py` — SSR 페이지(`/login`, `/today`, `/habits`, `/history`, `/journal`)와 htmx가 폼 제출로 호출하는 액션 엔드포인트(`/habits/new`, `/habits/{id}/complete`, `/journal/new` 등). 미인증 시 401 대신 `/login`으로 303 리다이렉트한다 — `_current_user_or_redirect(request, db)`가 `User`(로그인됨) 또는 `RedirectResponse`(미인증)를 반환하고, 각 핸들러는 `isinstance(current, RedirectResponse)`로 분기한다. 폼 액션은 대부분 처리 후 `HX-Redirect` 헤더로 같은 탭을 새로고침하는 방식으로 단순화되어 있다(부분 DOM 스왑이 아님) — 단 `/today`의 체크 토글과 `/journal`의 day-detail 내부 액션(수정/삭제)처럼 이미 htmx partial 안에 있는 경우는 예외로, 그 partial을 다시 렌더링해서 돌려준다. `journal_pages.py`는 별도 파일이지만 `pages.py`의 `_current_user_or_redirect`와 `templates`(Jinja2Templates 인스턴스)를 그대로 import해서 재사용한다 — `pages.py`가 계속 비대해지는 걸 막기 위해 기능별로 페이지 라우터 파일을 분리하기 시작한 첫 사례.
 - `app/routers/auth.py` — `/auth/*`, 페이지 네비게이션(리다이렉트/폼 POST)이라 `/api/*` 프리픽스를 쓰지 않는다. `GET /auth/google/login`이 구글 동의 화면으로 리다이렉트하고, `GET /auth/google/callback`이 `authlib`로 id_token을 검증해 `User`를 조회/생성한 뒤 세션 쿠키를 발급, `POST /auth/logout`이 쿠키를 지운다. OAuth 핸드셰이크 중 state/nonce를 담는 `SessionMiddleware`(`app/main.py`)는 로그인 유지용 쿠키(`habit_session`)와 별개의 임시 쿠키(`oauth_session`)를 쓴다.
 
 두 계열이 같은 `app/services/*`, `app/schemas/*`를 공유한다 — 새 기능을 추가할 때 API와 페이지 라우터 양쪽에서 비즈니스 로직을 중복 구현하지 말고 `app/services/`에 두고 재사용할 것.
@@ -70,7 +70,7 @@ pytest tests/test_habits.py::test_name   # 단일 테스트
 1. ✅ 기반 셋업 + 습관 CRUD (`/habits` 화면, PIN 로그인 — 7단계에서 구글 OAuth로 대체됨)
 2. ✅ 데일리 체크 & `/today` 화면 — `/habits`와 달리 여기는 실제 htmx 부분 갱신을 쓴다: 체크 버튼이 `#today-content`를 통째로 `partials/today_content.html`로 교체한다(개별 아이템만 스왑하지 않는 이유: 진행률 배지도 같이 갱신해야 해서). 이 partial은 `today.html`의 최초 렌더와 토글 응답에서 동일하게 재사용된다 (`app/routers/pages.py`의 `_today_context`).
 3. ✅ 기록 확인 화면 (월별/주별) — `/history`. 두 뷰 모두 순수 SSR(링크 기반 이전/다음 네비게이션)이고 htmx 상호작용은 없다. 월별 집계와 주별 매트릭스는 모두 **현재 active 상태인 습관만** 기준으로 계산한다(`app/services/log_service.py`의 `get_monthly_summary`/`get_weekly_matrix`) — 완료 처리되었거나 삭제된 습관은 과거 날짜라도 집계에서 빠진다. 즉 "그 날 실제로 무엇이 예정되어 있었는가"를 재구성하지 않고 "지금 진행 중인 습관 기준으로 최근 기록이 어떤지"를 보여주는 단순화된 설계다. 히트맵 투명도는 `app/template_utils.py`의 `heatmap_opacity()`가 계산해 `--color-accent-rgb` CSS 변수와 조합한다.
-4. ✅ PWA 기본 (manifest, 서비스워커, 아이콘) — `manifest.json`은 `/static/manifest.json`에 있고 `base.html`이 `/static/manifest.json`으로 직접 링크한다(루트 경로 라우트 아님, manifest는 자체 `scope` 필드로 범위를 지정하므로 파일 위치가 중요하지 않음). 반면 `service-worker.js`는 앱 전체를 커버해야 해서 `app/main.py`의 `GET /service-worker.js`가 `app/static/service-worker.js`를 루트 경로로 직접 서빙한다 — 이 둘의 서빙 방식이 다른 이유이니 헷갈리지 말 것. 아이콘은 `scripts/generate_icons.py`(Pillow 필요, 런타임 의존성 아님)로 생성.
+4. ✅ PWA 기본 (manifest, 서비스워커, 아이콘) — `manifest.json`은 `/static/manifest.json`에 있고 `base.html`이 `/static/manifest.json`으로 직접 링크한다(루트 경로 라우트 아님, manifest는 자체 `scope` 필드로 범위를 지정하므로 파일 위치가 중요하지 않음). 반면 `service-worker.js`는 앱 전체를 커버해야 해서 `app/main.py`의 `GET /service-worker.js`가 `app/static/service-worker.js`를 루트 경로로 직접 서빙한다 — 이 둘의 서빙 방식이 다른 이유이니 헷갈리지 말 것. 아이콘은 `scripts/generate_icons.py`(Pillow 필요)로 생성. Pillow는 8단계(저널링)의 첨부 이미지 썸네일 생성에도 쓰이기 시작해 지금은 런타임 의존성이다(`pyproject.toml`의 `dependencies`에 있음, 예전엔 `dev` 전용이었음).
    - **캐싱 전략 (중요)**: 처음엔 모든 GET을 stale-while-revalidate로 캐싱했는데, `/habits`·`/today`처럼 사용자가 직접 데이터를 바꾸고 곧바로 재방문하는 페이지에서 "방금 저장한 게 사라진 것처럼" 보이는 실사용 버그로 이어졌다(습관 생성/수정 후 `HX-Redirect`로 재이동했을 때 캐시된 옛 페이지가 먼저 뜸). `service-worker.js`의 fetch 핸들러는 이제 `request.mode === "navigate"`(페이지 탐색)와 그 외(정적 자산)를 분리한다 — 탐색은 **네트워크 우선**(오프라인일 때만 캐시 폴백), 정적 자산만 캐시 우선 stale-while-revalidate 유지. 서비스워커 캐시 로직을 바꿀 때마다 `CACHE_NAME` 버전을 올려야 `activate` 핸들러가 구버전 캐시를 정리한다(현재 `habit-tracker-v2`).
 5. ✅ Web Push 알림 (APScheduler 매분 tick + VAPID) — VAPID 키 원시 바이트는 `py_vapid`의 `b64urlencode`로 직접 인코딩해서 `.env`에 저장한다(`Vapid02`에 `public_key_str` 같은 헬퍼가 없음, `scripts/generate_vapid_keys.py` 참고). `scheduler_service._tick()`은 습관별 job을 등록/해제하는 대신 **매분 폴링** 방식으로 전체 active 습관을 훑어 지금 시각+요일이 맞고 오늘 아직 `habit_notification_log`에 없는 것만 발송한다 — 습관 CRUD와 스케줄러 job을 동기화할 필요가 없어서 이 방식을 택함. `push_service.send_to_user(db, user_id, ...)`(멀티유저 전환 전에는 `send_to_all`이었음)는 만료된 구독(404/410)만 자동 삭제하고 다른 오류는 무시하고 다음 구독자로 넘어간다(한 구독자 오류가 전체 발송을 막지 않도록). 프론트엔드 구독 흐름은 `app/static/js/push-register.js`(`window.habitPush`), `/today` 카드에 "알림 켜기" 버튼으로 노출. **주의**: Chrome 네이티브 알림 권한 프롬프트는 브라우저 크롬 UI 영역이라 자동화 도구로 클릭할 수 없다 — 구독 저장/발송/스케줄러 로직은 curl과 직접 함수 호출로 검증했지만, 실제 브라우저 권한 승인 → 진짜 푸시 수신까지의 마지막 단계는 사람이 직접 확인해야 한다.
    - **경합 방지**: `_tick()`은 발송 전에 `habit_notification_log`에 먼저 커밋해 "선점"하고(`_claim_notification_slot`), `(habit_id, notify_date)` 유니크 제약을 경합 방지 락처럼 쓴다 — 선점에 실패(`IntegrityError`)하면 이미 다른 워커/틱이 처리한 것으로 보고 조용히 건너뛴다. 이 앱은 `uvicorn --reload`로 개발 중 실행하는 경우가 많은데, **포트가 겹친 채로 오래된 워커 프로세스가 안 죽고 새 프로세스와 동시에 떠 있으면 각자 스케줄러를 따로 띄워서 같은 알림을 동시에 두 번 기록하려다 죽는 사고**가 실제로 있었다(웹 요청도 임의로 둘 중 한 프로세스로 라우팅되어 "가끔 옛날 코드로 응답"하는 것처럼 보이는 증상과 세트로 나타남). 이상 동작이 보이면 먼저 `Get-NetTCPConnection -LocalPort 8000 -ErrorAction SilentlyContinue`(PowerShell, `netstat`보다 정확함)로 실제 리스너가 1개인지 확인하고, 여러 개면 관련 `python.exe`/`uvicorn.exe`를 모두 정리한 뒤 하나만 새로 띄울 것.
@@ -87,6 +87,15 @@ pytest tests/test_habits.py::test_name   # 단일 테스트
    - **OAuth 핸드셰이크와 로그인 세션은 별개의 쿠키**: `authlib`가 리다이렉트 도중 state/nonce를 저장하려면 `request.session`이 있어야 해서 `app/main.py`에 `SessionMiddleware`(쿠키명 `oauth_session`, `max_age=600`)를 추가했다. 로그인 유지용 쿠키(`habit_session`, `itsdangerous` 서명, 30일)와는 완전히 다른 메커니즘이니 헷갈리지 말 것 — `create_session_token(user_id)`가 담는 페이로드도 `{"authenticated": True}`에서 `{"user_id": ...}`로 바뀌었다.
    - **리디렉션 URI는 동적 추론이 아니라 `.env`에 명시**: 이 앱은 Tailscale로 리버스 프록시 없이 HTTPS를 받는 배포가 흔한데(위 6단계 HTTPS 문제 참고), `request.url_for()`로 콜백 URL을 추론하면 프록시 뒤에서 scheme이 `http`로 잘못 잡힐 위험이 있다. 그래서 `GOOGLE_REDIRECT_URI`를 `.env`에 명시적으로 두고 Google Cloud Console의 "승인된 리디렉션 URI"와 정확히 일치시키는 방식을 택했다 — 값이 하나라도 다르면 구글이 `redirect_uri_mismatch`로 콜백을 거부한다.
    - **테스트 관련 주의**: 실제 구글 계정으로 로그인/동의 화면을 클릭하는 마지막 단계는 브라우저 자동화로 재현할 수 없다(진짜 구글 계정 자격증명이 필요한 영역) — `GET /auth/google/login`이 `accounts.google.com`으로 302 리다이렉트하는지, 로그인 후 발급된 세션 쿠키로 API가 정상 동작하는지는 curl로 검증할 수 있지만, 구글 동의 화면 자체는 사람이 직접 로그인해서 `/today`까지 도달하는지 확인해야 한다.
+8. ✅ 저널링 — 습관 체크에 곁들이는 회고와, 습관과 무관한 자유 일기를 함께 지원한다. 카테고리(사용자가 자유롭게 만드는 "일상"/"투자" 같은 저널 묶음, `JournalCategory`), 태그, 사진/영상 첨부, 월별 캘린더, 고정 질문 템플릿, 기분 트래킹, "1년 전 오늘" 회상을 이번 출시에 포함했고 AI 기반 프롬프트/피드백만 후속 업데이트로 미뤘다. 별도 프로젝트로 분리하지 않고 기존 구글 OAuth/유저/DB/PWA 인프라를 재사용했다.
+   - **라우터 파일이 하나 더 늘었다**: 위 "요청 흐름" 절에서 설명한 API(`habits.py`/`logs.py`/`push.py`) vs 페이지(`pages.py`) 2계열 구조를 그대로 따르되, `pages.py`를 더 비대하게 만들지 않으려고 저널 전용 파일을 새로 뺐다 — `app/routers/journal.py`(`/api/journal/*`, 현재는 첨부파일 스트리밍 `GET /api/journal/media/{attachment_id}` 하나뿐)와 `app/routers/journal_pages.py`(`/journal` 캘린더·day-detail·엔트리/카테고리 CRUD, `pages.py`의 `_current_user_or_redirect`와 `templates`를 그대로 import해서 재사용). 앞으로 다른 기능도 규모가 커지면 `pages.py`에 계속 얹기보다 이 패턴(기능별 페이지 라우터 파일 분리)을 따를 것.
+   - **데이터 모델**: `app/models/journal.py`에 `JournalCategory`(user별 유니크 이름), `JournalEntry`(entry_date와 created_at 분리 — entry_date는 사용자가 지정 가능해 어제 일을 오늘 쓸 수 있고, 하루+카테고리당 여러 엔트리를 허용하므로 유니크 제약이 없다), `JournalTag`/`JournalEntryTag`(M:N), `JournalEntryMood`, `JournalAttachment`, `JournalPrompt`(카테고리 무관 전역 질문 뱅크, 마이그레이션에서 시드 데이터 삽입)가 있다. 카테고리 FK는 non-null이고, 대신 `journal_service.ensure_default_category`가 유저의 첫 저널 진입 시 카테고리가 하나도 없으면 "일상"을 자동 생성해 "카테고리 없음" 케이스를 아예 없앤다.
+   - **기분(mood)은 엔트리당 하나가 아니라 여러 개를 태그처럼 붙일 수 있다**: 처음엔 `JournalEntry.mood`가 단일 nullable enum 컬럼이었는데(0010 마이그레이션), 감정을 동시에 여러 개 고를 수 있어야 한다는 요구로 0011 마이그레이션에서 그 컬럼을 지우고 `JournalEntryMood(entry_id, mood)` 연결 테이블로 옮겼다 — `JournalTag`와 달리 mood는 고정된 enum 값 집합이라 별도 이름 엔티티 없이 값 자체를 복합 PK로 쓴다(`journal_tag`처럼 이름 조회/생성 로직이 필요 없음). `JournalMood`는 만족도 스케일 5종(최고/좋음/보통/별로/힘듦)에 구체적 감정 9종(아픔/성취/분노/신남/평온/행복/걱정/피곤/슬픔)을 더해 총 14종이다. 폼에서는 Alpine 배열(`moods: []`)로 다중 토글 pill을 만들고 쉼표로 join한 hidden input 하나로 제출한다(태그 입력과 동일한 패턴, `journal_pages._parse_moods`가 서버에서 다시 분해). pill 목록/이모지는 `journal_pages.py`의 `JOURNAL_MOOD_OPTIONS`에 한 곳에 정의해 `templates.env.globals`로 등록, 작성/수정 폼과 day-detail 표시 양쪽에서 재사용한다.
+   - **첨부파일은 `/static`이 아니라 인증된 라우트로 서빙한다**: 이 앱의 유일한 `StaticFiles` 마운트(`/static`)는 완전 공개라 사진/영상처럼 유저별로 비공개여야 하는 파일을 두면 안 된다. `journal_service.save_attachment`는 `settings.journal_media_root`(기본 `app/media/journal/{user_id}/{entry_id}/`, `.gitignore`에 등록됨) 아래 로컬 디스크에 저장하고, `GET /api/journal/media/{attachment_id}`가 `JournalAttachment→JournalEntry.user_id` 소유권을 확인한 뒤에만 `FileResponse`로 스트리밍한다. 이미지 첨부는 Pillow로 가로 400px 썸네일(`?thumbnail=true` 쿼리로 구분)을 만들어 목록/캘린더에서 원본 대신 가볍게 로드한다 — 영상은 썸네일을 만들지 않고 재생 링크만 보여준다(ffmpeg 등 별도 도구가 필요해 v1 범위 밖으로 미룸).
+   - **미디어 라우트를 `/api/` 밑에 둔 이유**: `service-worker.js`의 fetch 핸들러는 `/api/`로 시작하는 GET 요청을 무조건 네트워크로 그냥 통과시키고 캐싱하지 않는다(아래 4단계 캐싱 전략 참고). 저널 미디어를 `/api/journal/media/...`에 둠으로써 이 기존 규칙에 공짜로 올라타 서비스워커를 전혀 건드리지 않고도 "비공개 사진/영상이 클라이언트 캐시에 무기한 남는" 문제를 피했다 — 만약 `/journal/media/...`처럼 `/api/` 밖에 뒀다면 정적 자산과 똑같이 stale-while-revalidate로 캐싱돼버렸을 것.
+   - **캘린더/day-detail은 `/history`의 기존 패턴을 그대로 재사용했다**: `calendar.Calendar(firstweekday=6).monthdatescalendar()`로 월 그리드를 만들고, 날짜를 클릭하면 htmx로 `#day-detail`에 partial을 swap하는 구조가 동일하다. 다만 의미가 달라 `heatmap_opacity`(습관 완료율 기반 투명도)는 재사용하지 않고, 그날 등장한 카테고리 색상을 점(`.journal-day-dot`)으로 표시하는 방식을 새로 만들었다.
+   - **엔트리 수정/삭제/첨부삭제는 `HX-Redirect`가 아니라 `#day-detail` partial을 다시 렌더링해서 돌려준다**: `/today`의 체크 토글과 같은 이유 — 이미 htmx로 `#day-detail`에 로드된 상태에서 벌어지는 액션이라 전체 페이지 리다이렉트 대신 그 자리에서 갱신하는 게 자연스럽다. 검증 실패 시에도 같은 partial을 `edit_error`/`editing_entry_id` 컨텍스트와 함께 다시 렌더링해 해당 엔트리의 수정 폼이 열린 채로 에러 메시지를 보여준다(`habit_item.html`의 Alpine `editing` 토글과 같은 아이디어를 서버 렌더링 쪽에서 구현한 것).
+   - **테스트는 SQLite(단위) + 실제 MariaDB(수동 curl/httpx 스모크)로 이중 검증했다**: "1년 전 오늘" 회상과 랜덤 프롬프트 뽑기를 처음엔 각각 `MONTH()`/`DAY()`, `RANDOM()` 같은 DB 함수로 짜려고 했는데, 이 프로젝트의 pytest는 SQLite 인메모리 DB를 쓰고 운영은 MariaDB라 방언이 다르면(`RANDOM()` vs `RAND()` 등) 테스트만 통과하고 운영에서 깨질 위험이 있었다. 그래서 두 기능 다 파이썬 레벨 필터링/`random.choice()`로 바꿔 방언 종속성을 아예 없앴다 — 개인 규모 데이터라 전체 스캔 비용도 무시할 만하다. 한글 저장/조회가 실제 MariaDB(`utf8mb4`)에서도 깨지지 않는지는 `httpx`로 직접 폼을 제출해 왕복 검증했다(터미널에 출력할 때는 콘솔 코드페이지 때문에 깨져 보일 수 있어도, 문자열 비교 자체는 정상이었다 — 실제 버그가 아니라 표시상의 문제였음을 확인).
 
 ## Docker 배포
 
@@ -97,4 +106,4 @@ pytest tests/test_habits.py::test_name   # 단일 테스트
 - `.env`는 이미지에 COPY하지 않고(`.dockerignore`) `docker-compose.yml`의 `env_file`로 런타임에 주입한다 — 이미지 레이어에 비밀번호가 남지 않게 하기 위함.
 - **컨테이너는 반드시 1개만 실행**해야 한다 — `scheduler_service`가 프로세스 안에서 APScheduler를 직접 돌리므로, replica를 늘리면 각자 스케줄러를 따로 띄워 같은 알림을 중복 처리하려 든다(`_claim_notification_slot`의 유니크 제약 경합 방지 덕에 죽지는 않지만 애초에 여러 개 띄울 이유가 없다).
 - **타임존**: `date.today()`(`/today`, 완료율/스트릭 계산 등 날짜 관련 로직 전반)는 컨테이너의 시스템 로컬 타임존을 그대로 쓴다. `python:3.13-slim` 베이스 이미지는 기본 타임존이 UTC라서, `Dockerfile`에 `TZ=Asia/Seoul` + `tzdata` 설치 + `/etc/localtime` 심볼릭 링크를 명시하지 않으면 자정~오전 9시(KST) 사이에 서버가 "아직 어제"로 날짜를 계산한다 — 실제로 이 때문에 매일 아침 `/today`가 전날 체크 상태 그대로 보이고 날짜가 안 넘어가는 버그가 있었다. 코드 로직(`date.today()`) 자체는 문제가 아니라 컨테이너 타임존 설정 누락이 원인이었으니, 비슷한 날짜 관련 이상 증상이 배포 환경에서만 재현되면 먼저 컨테이너 타임존을 의심할 것.
-- **HTTPS는 배포 대상에 따라 둘 중 하나**: (1) 집 PC를 직접 서버로 쓰는 경우 → Tailscale(`tailscale serve --bg 8000`), 컨테이너 8000번이 호스트 8000번에 그대로 매핑되므로(`ports: ["8000:8000"]`) 프로세스로 직접 띄우든 컨테이너로 띄우든 Tailscale 입장에서 차이 없음. (2) **이미 리버스 프록시(nginx 등)가 앞단에 있는 서버에 배포하는 경우 → Tailscale 불필요**, 프록시가 도메인의 TLS를 처리하고 컨테이너의 8000번으로 평문 HTTP 프록시하면 된다. 이 앱 자체는 어느 쪽이든 코드 변경 없이 평문 HTTP로만 응답하면 되므로(`app/main.py`에 HTTPS 강제/리다이렉트 로직 없음), 배포 방식은 순전히 인프라 레이어에서 결정된다. 프록시가 컨테이너와 같은 호스트에서 돈다면 `docker-compose.yml`의 포트 매핑을 `"127.0.0.1:8000:8000"`으로 좁혀서 컨테이너가 프록시를 우회해 외부에 직접 노출되지 않게 하는 걸 권장.
+- **HTTPS는 배포 대상에 따라 둘 중 하나**: (1) 집 PC를 직접 서버로 쓰는 경우 → Tailscale(`tailscale serve --bg 8000`), 컨테이너 8000번이 호스트 8000번에 그대로 매핑되므로(`ports: ["8000:8000"]`) 프로세스로 직접 띄우든 컨테이너로 띄우든 Tailscale 입장에서 차이 없음. (2) **이미 리버스 프록시(nginx 등)가 앞단에 있는 서버에 배포하는 경우 → Tailscale 불필요**, 프록시가 도메인의 TLS를 처리하고 컨테이너의 8000번으로 평문 HTTP 프록시하면 된다. 이 앱은 리버스 프록시가 보내주는 `X-Forwarded-Proto` 헤더를 보고 `http`면 301로 `https`로 리다이렉트한다(`app/main.py`의 `redirect_http_to_https` 미들웨어) — 프록시가 이 헤더를 안 보내주면(로컬 `uvicorn` 직접 실행 등) 그냥 통과하므로 로컬 개발엔 영향 없다. 이 미들웨어가 실제로 동작하려면 **프록시가 HTTP(80)와 HTTPS(443) 요청을 모두 앱까지 전달하면서 각각 `X-Forwarded-Proto: http`/`https`를 명시적으로 설정**해야 한다 — 시놀로지 NAS 역방향 프록시처럼 리다이렉트 기능 자체가 없는 프록시 뒤에 배포할 때 특히 이 헤더 설정을 빠뜨리기 쉽다(80번 포트에 대한 프록시 규칙 자체가 없으면 트래픽이 앱에 도달하지도 못하고 NAS 자체 관리 페이지 등 엉뚱한 곳으로 샐 수 있음 — 실제로 이 문제가 있었음). 프록시가 컨테이너와 같은 호스트에서 돈다면 `docker-compose.yml`의 포트 매핑을 `"127.0.0.1:8000:8000"`으로 좁혀서 컨테이너가 프록시를 우회해 외부에 직접 노출되지 않게 하는 걸 권장.

README.md

@@ -1,4 +1,4 @@
-# 습관 트래커
+# 해빗랩
 
 개인용 습관 관리 PWA. 아이폰과 PC에서 같은 서버(MariaDB)에 접속해 습관을 관리합니다.
 

app/config.py

@@ -18,5 +18,8 @@ class Settings(BaseSettings):
     session_cookie_name: str = "habit_session"
     timezone: str = "Asia/Seoul"
 
+    journal_media_root: str = "app/media/journal"
+    journal_max_upload_mb: int = 20
+
 
 settings = Settings()

app/main.py

@@ -1,15 +1,16 @@
 import logging
 from contextlib import asynccontextmanager
+from pathlib import Path
 
 from fastapi import FastAPI, Request
-from fastapi.responses import FileResponse, JSONResponse
+from fastapi.responses import FileResponse, JSONResponse, RedirectResponse
 from fastapi.staticfiles import StaticFiles
 from starlette.exceptions import HTTPException as StarletteHTTPException
 from starlette.middleware.sessions import SessionMiddleware
 
 from app.config import settings
 from app.database import SessionLocal
-from app.routers import auth, habits, logs, pages, push
+from app.routers import auth, habits, journal, journal_pages, logs, pages, push
 from app.routers.pages import templates
 from app.security import get_current_user_optional
 from app.services import scheduler_service
@@ -19,23 +20,36 @@ logger = logging.getLogger(__name__)
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
+    Path(settings.journal_media_root).mkdir(parents=True, exist_ok=True)
     scheduler_service.start_scheduler()
     yield
     scheduler_service.shutdown_scheduler()
 
 
-app = FastAPI(title="습관 트래커", lifespan=lifespan)
+app = FastAPI(title="해빗랩", lifespan=lifespan)
 
 # 구글 OAuth 핸드셰이크 중 state/nonce를 임시로 저장하는 데만 쓰는 세션이다.
 # 로그인 유지용 쿠키(habit_session)와는 별개.
 app.add_middleware(SessionMiddleware, secret_key=settings.secret_key, session_cookie="oauth_session", max_age=600)
 
+
+@app.middleware("http")
+async def redirect_http_to_https(request: Request, call_next):
+    # 리버스 프록시가 X-Forwarded-Proto로 원래 스킴을 알려줄 때만 동작한다
+    # (로컬 uvicorn 직접 실행 시에는 이 헤더가 없어 그냥 통과).
+    if request.headers.get("x-forwarded-proto") == "http":
+        return RedirectResponse(str(request.url.replace(scheme="https")), status_code=301)
+    return await call_next(request)
+
+
 app.mount("/static", StaticFiles(directory="app/static"), name="static")
 
 app.include_router(auth.router)
 app.include_router(habits.router)
+app.include_router(journal.router)
 app.include_router(logs.router)
 app.include_router(push.router)
+app.include_router(journal_pages.router)
 app.include_router(pages.router)
 
 
@@ -75,3 +89,9 @@ async def unhandled_exception_handler(request: Request, exc: Exception):
 def service_worker():
     # 서비스워커 scope가 앱 전체를 커버하려면 /static/ 하위가 아닌 루트 경로로 서빙해야 한다.
     return FileResponse("app/static/service-worker.js", media_type="application/javascript")
+
+
+@app.get("/.well-known/assetlinks.json")
+def assetlinks():
+    # Android TWA(kr.co.alphalok.habit.twa)의 도메인 소유권 증명용 — 반드시 /.well-known/ 루트 경로여야 한다.
+    return FileResponse("app/static/.well-known/assetlinks.json", media_type="application/json")

app/models/__init__.py

@@ -1,5 +1,15 @@
 from app.models.habit import Habit, HabitStatus, HabitType
 from app.models.habit_log import HabitLog
+from app.models.journal import (
+    JournalAttachment,
+    JournalAttachmentType,
+    JournalCategory,
+    JournalEntry,
+    JournalEntryMood,
+    JournalMood,
+    JournalPrompt,
+    JournalTag,
+)
 from app.models.notification_log import HabitNotificationLog, SummaryNotificationLog
 from app.models.push_subscription import PushSubscription
 from app.models.user import User
@@ -9,6 +19,14 @@ __all__ = [
     "HabitStatus",
     "HabitType",
     "HabitLog",
+    "JournalAttachment",
+    "JournalAttachmentType",
+    "JournalCategory",
+    "JournalEntry",
+    "JournalEntryMood",
+    "JournalMood",
+    "JournalPrompt",
+    "JournalTag",
     "HabitNotificationLog",
     "SummaryNotificationLog",
     "PushSubscription",

app/models/journal.py

@@ -0,0 +1,134 @@
+import enum
+from datetime import date, datetime
+
+from sqlalchemy import Column, Date, Enum, ForeignKey, Integer, String, Table, Text, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.sql import func
+
+from app.database import Base
+from app.models.habit import _by_value
+
+
+class JournalMood(str, enum.Enum):
+    PAIN = "pain"  # 아픔
+    ACHIEVEMENT = "achievement"  # 성취
+    ANGER = "anger"  # 분노
+    EXCITED = "excited"  # 신남
+    CALM = "calm"  # 평온
+    HAPPY = "happy"  # 행복
+    WORRY = "worry"  # 걱정
+    TIRED = "tired"  # 피곤
+    SAD = "sad"  # 슬픔
+
+
+class JournalAttachmentType(str, enum.Enum):
+    IMAGE = "image"
+    VIDEO = "video"
+
+
+journal_entry_tag = Table(
+    "journal_entry_tag",
+    Base.metadata,
+    Column("entry_id", ForeignKey("journal_entry.id", ondelete="CASCADE"), primary_key=True),
+    Column("tag_id", ForeignKey("journal_tag.id", ondelete="CASCADE"), primary_key=True),
+)
+
+
+class JournalCategory(Base):
+    __tablename__ = "journal_category"
+    __table_args__ = (UniqueConstraint("user_id", "name", name="uq_journal_category_user_name"),)
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    user_id: Mapped[int] = mapped_column(ForeignKey("user.id", ondelete="CASCADE"), nullable=False)
+    name: Mapped[str] = mapped_column(String(50), nullable=False)
+    color: Mapped[str | None] = mapped_column(String(20), nullable=True)
+    sort_order: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    # 이 카테고리로 새 기록을 쓸 때 내용칸에 미리 채워주는 틀(예: Story/Feelings/Decisions/... 회고 양식).
+    # 사용자가 직접 타이핑을 시작하면 더 이상 덮어쓰지 않는다(프론트에서 처리).
+    content_template: Mapped[str | None] = mapped_column(Text, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(server_default=func.now(), nullable=False)
+
+    entries: Mapped[list["JournalEntry"]] = relationship(
+        back_populates="category", cascade="all, delete-orphan", passive_deletes=True
+    )
+
+
+class JournalEntry(Base):
+    __tablename__ = "journal_entry"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    user_id: Mapped[int] = mapped_column(ForeignKey("user.id", ondelete="CASCADE"), nullable=False)
+    category_id: Mapped[int] = mapped_column(
+        ForeignKey("journal_category.id", ondelete="CASCADE"), nullable=False
+    )
+    entry_date: Mapped[date] = mapped_column(Date, nullable=False)
+    title: Mapped[str | None] = mapped_column(String(200), nullable=True)
+    content: Mapped[str] = mapped_column(Text, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(server_default=func.now(), nullable=False)
+    updated_at: Mapped[datetime] = mapped_column(
+        server_default=func.now(), onupdate=func.now(), nullable=False
+    )
+
+    category: Mapped["JournalCategory"] = relationship(back_populates="entries")
+    tags: Mapped[list["JournalTag"]] = relationship(
+        secondary=journal_entry_tag, back_populates="entries"
+    )
+    moods: Mapped[list["JournalEntryMood"]] = relationship(
+        back_populates="entry", cascade="all, delete-orphan", passive_deletes=True
+    )
+    attachments: Mapped[list["JournalAttachment"]] = relationship(
+        back_populates="entry", cascade="all, delete-orphan", passive_deletes=True
+    )
+
+
+class JournalEntryMood(Base):
+    """엔트리 하나에 여러 감정을 태그처럼 붙일 수 있게 하는 연결 테이블. mood 자체가 고정 enum이라
+    JournalTag처럼 별도 엔티티(이름 등)를 둘 필요가 없어 journal_entry_tag와 달리 값 자체를 PK로 쓴다."""
+
+    __tablename__ = "journal_entry_mood"
+
+    entry_id: Mapped[int] = mapped_column(ForeignKey("journal_entry.id", ondelete="CASCADE"), primary_key=True)
+    mood: Mapped[JournalMood] = mapped_column(
+        Enum(JournalMood, native_enum=False, length=20, values_callable=_by_value), primary_key=True
+    )
+
+    entry: Mapped["JournalEntry"] = relationship(back_populates="moods")
+
+
+class JournalTag(Base):
+    __tablename__ = "journal_tag"
+    __table_args__ = (UniqueConstraint("user_id", "name", name="uq_journal_tag_user_name"),)
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    user_id: Mapped[int] = mapped_column(ForeignKey("user.id", ondelete="CASCADE"), nullable=False)
+    name: Mapped[str] = mapped_column(String(50), nullable=False)
+
+    entries: Mapped[list["JournalEntry"]] = relationship(
+        secondary=journal_entry_tag, back_populates="tags"
+    )
+
+
+class JournalAttachment(Base):
+    __tablename__ = "journal_attachment"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    entry_id: Mapped[int] = mapped_column(ForeignKey("journal_entry.id", ondelete="CASCADE"), nullable=False)
+    media_type: Mapped[JournalAttachmentType] = mapped_column(
+        Enum(JournalAttachmentType, native_enum=False, length=10, values_callable=_by_value), nullable=False
+    )
+    file_path: Mapped[str] = mapped_column(String(500), nullable=False)
+    thumbnail_path: Mapped[str | None] = mapped_column(String(500), nullable=True)
+    original_filename: Mapped[str] = mapped_column(String(255), nullable=False)
+    file_size: Mapped[int] = mapped_column(Integer, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(server_default=func.now(), nullable=False)
+
+    entry: Mapped["JournalEntry"] = relationship(back_populates="attachments")
+
+
+class JournalPrompt(Base):
+    """카테고리 무관 전역 질문 뱅크. 특정 카테고리 전용 프롬프트는 v1 범위 밖(향후 확장 여지)."""
+
+    __tablename__ = "journal_prompt"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    question_text: Mapped[str] = mapped_column(String(300), nullable=False)

app/routers/journal.py

@@ -0,0 +1,36 @@
+from fastapi import APIRouter, Depends, HTTPException, Query
+from fastapi.responses import FileResponse
+from sqlalchemy.orm import Session
+
+from app.database import get_db
+from app.models.user import User
+from app.schemas.journal import JournalCategoryReorderRequest
+from app.security import require_login
+from app.services import journal_service
+
+router = APIRouter(prefix="/api/journal", tags=["journal"], dependencies=[Depends(require_login)])
+
+
+@router.get("/media/{attachment_id}")
+def get_media(
+    attachment_id: int,
+    thumbnail: bool = Query(False),
+    db: Session = Depends(get_db),
+    current_user: User = Depends(require_login),
+):
+    attachment = journal_service.get_attachment(db, attachment_id, current_user.id)
+    if attachment is None:
+        raise HTTPException(status_code=404, detail="첨부파일을 찾을 수 없습니다")
+
+    path = attachment.thumbnail_path if (thumbnail and attachment.thumbnail_path) else attachment.file_path
+    return FileResponse(path, filename=attachment.original_filename)
+
+
+@router.post("/categories/reorder")
+def reorder_categories(
+    data: JournalCategoryReorderRequest,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(require_login),
+):
+    journal_service.reorder_categories(db, current_user.id, data.category_ids)
+    return {"ok": True}

app/routers/journal_pages.py

@@ -0,0 +1,355 @@
+import calendar
+from datetime import date
+
+from fastapi import APIRouter, Depends, File, Form, Request, Response, UploadFile
+from fastapi.responses import HTMLResponse, RedirectResponse
+from pydantic import ValidationError
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.orm import Session
+
+from app.database import get_db
+from app.models.journal import JournalMood
+from app.routers.pages import _current_user_or_redirect, templates
+from app.schemas.journal import JournalCategoryCreate, JournalEntryCreate, JournalEntryUpdate
+from app.services import journal_service
+
+router = APIRouter()
+
+# (enum 값, 이모지, 한글 라벨). 기분 선택 pill(작성/수정 폼)과 표시(day-detail)에서 공유해서 쓴다.
+# 여러 개를 동시에 고를 수 있어서(다중 선택) 라벨은 전부 명사형으로 통일한다.
+JOURNAL_MOOD_OPTIONS = [
+    (JournalMood.PAIN, "🤕", "아픔"),
+    (JournalMood.ACHIEVEMENT, "🏆", "성취"),
+    (JournalMood.ANGER, "😠", "분노"),
+    (JournalMood.EXCITED, "🤩", "신남"),
+    (JournalMood.CALM, "😌", "평온"),
+    (JournalMood.HAPPY, "😊", "행복"),
+    (JournalMood.WORRY, "😟", "걱정"),
+    (JournalMood.TIRED, "😪", "피곤"),
+    (JournalMood.SAD, "😢", "슬픔"),
+]
+templates.env.globals["journal_mood_options"] = JOURNAL_MOOD_OPTIONS
+templates.env.globals["journal_mood_emoji"] = {m.value: emoji for m, emoji, _ in JOURNAL_MOOD_OPTIONS}
+# Jinja2 내장 |tojson 필터가 이 policy를 읽어서 json.dumps에 넘긴다 — 기본값(ensure_ascii=True)이면
+# 한글이 \uXXXX로 이스케이프돼 응답 본문에서 읽기 힘들어진다.
+templates.env.policies["json.dumps_kwargs"] = {"ensure_ascii": False}
+
+
+def _parse_moods(raw: str) -> list[JournalMood]:
+    moods = []
+    for v in raw.split(","):
+        v = v.strip()
+        if not v:
+            continue
+        try:
+            moods.append(JournalMood(v))
+        except ValueError:
+            continue
+    return moods
+
+
+def _parse_tags(raw: str) -> list[str]:
+    return [t for t in raw.split(",")]
+
+
+def _month_context(db: Session, user_id: int, year: int, month: int, category_id: int | None) -> dict:
+    summary_map = journal_service.get_monthly_journal_summary(db, user_id, year, month, category_id)
+    weeks = calendar.Calendar(firstweekday=6).monthdatescalendar(year, month)
+
+    prev_year, prev_month = (year - 1, 12) if month == 1 else (year, month - 1)
+    next_year, next_month = (year + 1, 1) if month == 12 else (year, month + 1)
+
+    return {
+        "year": year,
+        "month": month,
+        "weeks": weeks,
+        "summary_map": summary_map,
+        "prev_year": prev_year,
+        "prev_month": prev_month,
+        "next_year": next_year,
+        "next_month": next_month,
+    }
+
+
+def _render_day_detail(request: Request, db: Session, user_id: int, entry_date: date, **extra):
+    return templates.TemplateResponse(
+        request,
+        "partials/journal_day_detail.html",
+        {
+            "entry_date": entry_date,
+            "items": journal_service.get_day_entries(db, user_id, entry_date),
+            "categories": journal_service.list_categories(db, user_id),
+            **extra,
+        },
+    )
+
+
+@router.get("/journal")
+def journal_page(
+    request: Request,
+    tab: str = "calendar",
+    year: int | None = None,
+    month: int | None = None,
+    category_id: int | None = None,
+    db: Session = Depends(get_db),
+):
+    current = _current_user_or_redirect(request, db)
+    if isinstance(current, RedirectResponse):
+        return current
+
+    journal_service.ensure_default_category(db, current.id)
+    categories = journal_service.list_categories(db, current.id)
+
+    today = date.today()
+    year = year or today.year
+    month = month or today.month
+    tab = "manage" if tab == "manage" else "calendar"
+
+    return templates.TemplateResponse(
+        request,
+        "journal.html",
+        {
+            "logged_in": True,
+            "current_user": current,
+            "tab": tab,
+            "categories": categories,
+            "category_id": category_id,
+            "category_templates": {str(c.id): c.content_template or "" for c in categories},
+            "entry_counts": journal_service.count_entries_by_category(db, current.id) if tab == "manage" else {},
+            "on_this_day": journal_service.get_on_this_day(db, current.id, today),
+            "prompt": journal_service.get_random_prompt(db),
+            "today_iso": today.isoformat(),
+            **_month_context(db, current.id, year, month, category_id),
+        },
+    )
+
+
+@router.get("/journal/day/{entry_date}")
+def journal_day_detail(request: Request, entry_date: date, db: Session = Depends(get_db)):
+    current = _current_user_or_redirect(request, db)
+    if isinstance(current, RedirectResponse):
+        return current
+
+    return _render_day_detail(request, db, current.id, entry_date)
+
+
+@router.post("/journal/new")
+def create_entry_page(
+    request: Request,
+    category_id: int = Form(...),
+    entry_date: str = Form(...),
+    title: str | None = Form(None),
+    content: str = Form(""),
+    moods: str = Form(""),
+    tags: str = Form(""),
+    files: list[UploadFile] = File(default=[]),
+    db: Session = Depends(get_db),
+):
+    current = _current_user_or_redirect(request, db)
+    if isinstance(current, RedirectResponse):
+        return current
+
+    try:
+        parsed_date = date.fromisoformat(entry_date)
+        data = JournalEntryCreate(
+            category_id=category_id,
+            entry_date=parsed_date,
+            title=title,
+            content=content,
+            moods=_parse_moods(moods),
+            tags=_parse_tags(tags),
+        )
+    except ValidationError as exc:
+        message = exc.errors()[0]["msg"].removeprefix("Value error, ")
+        return HTMLResponse(message)
+    except ValueError:
+        return HTMLResponse("입력값을 확인해주세요")
+
+    entry = journal_service.create_entry(db, current.id, data)
+    for upload in files:
+        if not upload.filename:
+            continue
+        try:
+            journal_service.save_attachment(db, entry, upload)
+        except ValueError as exc:
+            return HTMLResponse(str(exc))
+
+    response = Response(status_code=200)
+    response.headers["HX-Redirect"] = f"/journal?year={parsed_date.year}&month={parsed_date.month}"
+    return response
+
+
+@router.post("/journal/{entry_id}/edit")
+def edit_entry_page(
+    request: Request,
+    entry_id: int,
+    category_id: int = Form(...),
+    entry_date: str = Form(...),
+    title: str | None = Form(None),
+    content: str = Form(""),
+    moods: str = Form(""),
+    tags: str = Form(""),
+    files: list[UploadFile] = File(default=[]),
+    db: Session = Depends(get_db),
+):
+    current = _current_user_or_redirect(request, db)
+    if isinstance(current, RedirectResponse):
+        return current
+
+    entry = journal_service.get_entry(db, entry_id, current.id)
+    if entry is None:
+        return Response(status_code=404)
+
+    original_date = entry.entry_date
+
+    try:
+        parsed_date = date.fromisoformat(entry_date)
+        data = JournalEntryUpdate(
+            category_id=category_id,
+            entry_date=parsed_date,
+            title=title,
+            content=content,
+            moods=_parse_moods(moods),
+            tags=_parse_tags(tags),
+        )
+    except ValidationError as exc:
+        message = exc.errors()[0]["msg"].removeprefix("Value error, ")
+        return _render_day_detail(
+            request, db, current.id, original_date, edit_error=message, editing_entry_id=entry_id
+        )
+    except ValueError:
+        return _render_day_detail(
+            request,
+            db,
+            current.id,
+            original_date,
+            edit_error="입력값을 확인해주세요",
+            editing_entry_id=entry_id,
+        )
+
+    journal_service.update_entry(db, entry, data)
+    for upload in files:
+        if not upload.filename:
+            continue
+        try:
+            journal_service.save_attachment(db, entry, upload)
+        except ValueError:
+            pass  # 첨부 실패는 조용히 넘어간다 — 본문 수정은 이미 반영됐다
+
+    return _render_day_detail(request, db, current.id, parsed_date)
+
+
+@router.post("/journal/{entry_id}/delete")
+def delete_entry_page(request: Request, entry_id: int, db: Session = Depends(get_db)):
+    current = _current_user_or_redirect(request, db)
+    if isinstance(current, RedirectResponse):
+        return current
+
+    entry = journal_service.get_entry(db, entry_id, current.id)
+    if entry is None:
+        return Response(status_code=404)
+
+    entry_date_value = entry.entry_date
+    journal_service.delete_entry(db, entry)
+
+    return _render_day_detail(request, db, current.id, entry_date_value)
+
+
+@router.post("/journal/{entry_id}/attachments/{attachment_id}/delete")
+def delete_attachment_page(
+    request: Request, entry_id: int, attachment_id: int, db: Session = Depends(get_db)
+):
+    current = _current_user_or_redirect(request, db)
+    if isinstance(current, RedirectResponse):
+        return current
+
+    entry = journal_service.get_entry(db, entry_id, current.id)
+    if entry is None:
+        return Response(status_code=404)
+    attachment = journal_service.get_attachment(db, attachment_id, current.id)
+    if attachment is None or attachment.entry_id != entry.id:
+        return Response(status_code=404)
+
+    entry_date_value = entry.entry_date
+    journal_service.delete_attachment(db, attachment)
+
+    return _render_day_detail(request, db, current.id, entry_date_value)
+
+
+@router.post("/journal/categories/new")
+def create_category_page(
+    request: Request,
+    name: str = Form(""),
+    color: str | None = Form(None),
+    content_template: str | None = Form(None),
+    db: Session = Depends(get_db),
+):
+    current = _current_user_or_redirect(request, db)
+    if isinstance(current, RedirectResponse):
+        return current
+
+    try:
+        data = JournalCategoryCreate(name=name, color=color, content_template=content_template)
+    except ValidationError as exc:
+        message = exc.errors()[0]["msg"].removeprefix("Value error, ")
+        return HTMLResponse(message)
+
+    try:
+        journal_service.create_category(db, current.id, data)
+    except IntegrityError:
+        db.rollback()
+        return HTMLResponse("이미 같은 이름의 카테고리가 있어요")
+
+    response = Response(status_code=200)
+    response.headers["HX-Redirect"] = "/journal?tab=manage"
+    return response
+
+
+@router.post("/journal/categories/{category_id}/edit")
+def edit_category_page(
+    request: Request,
+    category_id: int,
+    name: str = Form(""),
+    color: str | None = Form(None),
+    content_template: str | None = Form(None),
+    db: Session = Depends(get_db),
+):
+    current = _current_user_or_redirect(request, db)
+    if isinstance(current, RedirectResponse):
+        return current
+
+    category = journal_service.get_category(db, category_id, current.id)
+    if category is None:
+        return Response(status_code=404)
+
+    try:
+        data = JournalCategoryCreate(name=name, color=color, content_template=content_template)
+    except ValidationError as exc:
+        message = exc.errors()[0]["msg"].removeprefix("Value error, ")
+        return HTMLResponse(message)
+
+    try:
+        journal_service.update_category(db, category, data)
+    except IntegrityError:
+        db.rollback()
+        return HTMLResponse("이미 같은 이름의 카테고리가 있어요")
+
+    response = Response(status_code=200)
+    response.headers["HX-Redirect"] = "/journal?tab=manage"
+    return response
+
+
+@router.post("/journal/categories/{category_id}/delete")
+def delete_category_page(request: Request, category_id: int, db: Session = Depends(get_db)):
+    current = _current_user_or_redirect(request, db)
+    if isinstance(current, RedirectResponse):
+        return current
+
+    category = journal_service.get_category(db, category_id, current.id)
+    if category is None:
+        return Response(status_code=404)
+
+    journal_service.delete_category(db, category)
+    response = Response(status_code=200)
+    response.headers["HX-Redirect"] = "/journal?tab=manage"
+    return response

app/routers/pages.py

@@ -8,12 +8,13 @@ from fastapi.templating import Jinja2Templates
 from pydantic import ValidationError
 from sqlalchemy.orm import Session
 
+from app.config import settings
 from app.database import get_db
 from app.models.habit import HabitDifficulty, HabitStatus, HabitType
 from app.models.user import User
 from app.schemas.habit import HabitCreate, HabitUpdate
 from app.security import get_current_user_optional
-from app.services import habit_service, log_service
+from app.services import habit_service, log_service, user_service
 from app.template_utils import (
     difficulty_label,
     goal_progress,
@@ -46,14 +47,57 @@ def _current_user_or_redirect(request: Request, db: Session) -> User | RedirectR
 def index(request: Request, db: Session = Depends(get_db)):
     if get_current_user_optional(request, db) is not None:
         return RedirectResponse(url="/today", status_code=303)
-    return RedirectResponse(url="/login", status_code=303)
+    # 로그인 없이도 앱 목적을 설명하는 페이지가 있어야 한다(구글 OAuth 동의 화면 "홈페이지" 요건).
+    return templates.TemplateResponse(request, "home.html", {"logged_in": False, "current_user": None})
 
 
 @router.get("/login")
-def login_page(request: Request, db: Session = Depends(get_db)):
+def login_page(request: Request, deleted: bool = False, db: Session = Depends(get_db)):
     if get_current_user_optional(request, db) is not None:
         return RedirectResponse(url="/today", status_code=303)
-    return templates.TemplateResponse(request, "login.html", {"logged_in": False, "current_user": None})
+    return templates.TemplateResponse(
+        request, "login.html", {"logged_in": False, "current_user": None, "deleted": deleted}
+    )
+
+
+@router.get("/privacy")
+def privacy_page(request: Request, db: Session = Depends(get_db)):
+    user = get_current_user_optional(request, db)
+    return templates.TemplateResponse(
+        request, "privacy.html", {"logged_in": user is not None, "current_user": user}
+    )
+
+
+@router.get("/account")
+def account_page(request: Request, db: Session = Depends(get_db)):
+    current = _current_user_or_redirect(request, db)
+    if isinstance(current, RedirectResponse):
+        return current
+    return templates.TemplateResponse(request, "account.html", {"logged_in": True, "current_user": current})
+
+
+@router.post("/account/delete")
+def delete_account_page(request: Request, confirm_email: str = Form(""), db: Session = Depends(get_db)):
+    current = _current_user_or_redirect(request, db)
+    if isinstance(current, RedirectResponse):
+        return current
+
+    if confirm_email.strip().lower() != current.email.lower():
+        return templates.TemplateResponse(
+            request,
+            "account.html",
+            {
+                "logged_in": True,
+                "current_user": current,
+                "delete_error": "입력한 이메일이 계정 이메일과 일치하지 않습니다.",
+            },
+            status_code=400,
+        )
+
+    user_service.delete_account(db, current)
+    response = RedirectResponse(url="/login?deleted=1", status_code=303)
+    response.delete_cookie(settings.session_cookie_name)
+    return response
 
 
 def _today_context(db: Session, user_id: int, **extra) -> dict:

app/routers/push.py

@@ -42,5 +42,5 @@ def unsubscribe(
 
 @router.post("/test")
 def send_test(db: Session = Depends(get_db), current_user: User = Depends(require_login)):
-    sent = push_service.send_to_user(db, current_user.id, title="습관 트래커", body="테스트 알림입니다.")
+    sent = push_service.send_to_user(db, current_user.id, title="해빗랩", body="테스트 알림입니다.")
     return {"sent": sent}

app/schemas/journal.py

@@ -0,0 +1,136 @@
+from datetime import date, datetime
+
+from pydantic import BaseModel, ConfigDict, field_validator
+
+from app.models.journal import JournalAttachmentType, JournalMood
+
+
+class JournalCategoryBase(BaseModel):
+    name: str
+    color: str | None = None
+    content_template: str | None = None
+
+    @field_validator("name")
+    @classmethod
+    def name_not_blank(cls, v: str) -> str:
+        v = v.strip()
+        if not v:
+            raise ValueError("카테고리 이름을 입력해주세요")
+        return v
+
+    @field_validator("color")
+    @classmethod
+    def blank_color_to_none(cls, v: str | None) -> str | None:
+        if v is None:
+            return None
+        v = v.strip()
+        return v or None
+
+    @field_validator("content_template")
+    @classmethod
+    def blank_template_to_none(cls, v: str | None) -> str | None:
+        if v is None:
+            return None
+        v = v.strip()
+        return v or None
+
+
+class JournalCategoryCreate(JournalCategoryBase):
+    pass
+
+
+class JournalCategoryOut(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
+    id: int
+    name: str
+    color: str | None
+    content_template: str | None
+    sort_order: int | None
+    created_at: datetime
+
+
+class JournalCategoryReorderRequest(BaseModel):
+    category_ids: list[int]
+
+
+class JournalEntryBase(BaseModel):
+    category_id: int
+    entry_date: date
+    title: str | None = None
+    content: str
+    moods: list[JournalMood] = []
+    tags: list[str] = []
+
+    @field_validator("content")
+    @classmethod
+    def content_not_blank(cls, v: str) -> str:
+        v = v.strip()
+        if not v:
+            raise ValueError("내용을 입력해주세요")
+        return v
+
+    @field_validator("title")
+    @classmethod
+    def blank_title_to_none(cls, v: str | None) -> str | None:
+        if v is None:
+            return None
+        v = v.strip()
+        return v or None
+
+    @field_validator("moods")
+    @classmethod
+    def dedupe_moods(cls, v: list[JournalMood]) -> list[JournalMood]:
+        cleaned: list[JournalMood] = []
+        for mood in v:
+            if mood not in cleaned:
+                cleaned.append(mood)
+        return cleaned
+
+    @field_validator("tags")
+    @classmethod
+    def clean_tags(cls, v: list[str]) -> list[str]:
+        cleaned: list[str] = []
+        for raw in v:
+            name = raw.strip()
+            if name and name not in cleaned:
+                cleaned.append(name)
+        return cleaned
+
+
+class JournalEntryCreate(JournalEntryBase):
+    pass
+
+
+class JournalEntryUpdate(JournalEntryBase):
+    pass
+
+
+class JournalAttachmentOut(BaseModel):
+    id: int
+    media_type: JournalAttachmentType
+    original_filename: str
+    has_thumbnail: bool
+
+
+class JournalCalendarDay(BaseModel):
+    entry_date: date
+    total_count: int
+    category_colors: list[str]  # 그 날 엔트리가 있는 카테고리들의 색상(점 표시용, 중복 제거)
+
+
+class JournalDayDetailItem(BaseModel):
+    id: int
+    category_id: int
+    category_name: str
+    category_color: str | None
+    title: str | None
+    content: str
+    moods: list[JournalMood]
+    tags: list[str]
+    attachments: list[JournalAttachmentOut]
+
+
+class JournalOnThisDayItem(JournalDayDetailItem):
+    entry_date: date
+    years_ago: int

app/services/journal_service.py

@@ -0,0 +1,398 @@
+import calendar
+import mimetypes
+import random
+import uuid
+from datetime import date
+from pathlib import Path
+
+from fastapi import UploadFile
+from PIL import Image
+from sqlalchemy import func, select
+from sqlalchemy.orm import Session
+
+from app.config import settings
+from app.models.journal import (
+    JournalAttachment,
+    JournalAttachmentType,
+    JournalCategory,
+    JournalEntry,
+    JournalEntryMood,
+    JournalPrompt,
+    JournalTag,
+)
+from app.schemas.journal import (
+    JournalAttachmentOut,
+    JournalCalendarDay,
+    JournalCategoryCreate,
+    JournalDayDetailItem,
+    JournalEntryCreate,
+    JournalEntryUpdate,
+    JournalOnThisDayItem,
+)
+
+ALLOWED_IMAGE_TYPES = {"image/jpeg", "image/png", "image/webp", "image/gif"}
+ALLOWED_VIDEO_TYPES = {"video/mp4", "video/quicktime"}
+THUMBNAIL_WIDTH = 400
+DEFAULT_CATEGORY_NAME = "일상"
+DEFAULT_CATEGORY_TEMPLATE = """**1. Story : 오늘 무슨 일이 있었나요?**
+
+-
+
+**2. Feelings : 오늘 들었던 생각과 나의 감정은?**
+
+-
+
+**3. Decisions : 오늘 내가 내린 결정이 있나요?**
+
+-
+
+**4. Insights : 나에 대해 새롭게 알게된 사실이 있나요?**
+
+-
+
+→ 나에 대한 인사이트는 메타인지를 키워주는 **소중한 기록**입니다. 꼭 보관하세요.
+
+**5. Actions : 내가 다음에 할 행동은 무엇인가요?**
+
+- """
+
+
+# ---- 카테고리 ----
+
+
+def list_categories(db: Session, user_id: int) -> list[JournalCategory]:
+    stmt = select(JournalCategory).where(JournalCategory.user_id == user_id)
+    stmt = stmt.order_by(
+        JournalCategory.sort_order.is_(None), JournalCategory.sort_order, JournalCategory.created_at
+    )
+    return list(db.scalars(stmt))
+
+
+def get_category(db: Session, category_id: int, user_id: int) -> JournalCategory | None:
+    return db.scalar(
+        select(JournalCategory).where(JournalCategory.id == category_id, JournalCategory.user_id == user_id)
+    )
+
+
+def create_category(db: Session, user_id: int, data: JournalCategoryCreate) -> JournalCategory:
+    category = JournalCategory(
+        user_id=user_id, name=data.name, color=data.color, content_template=data.content_template
+    )
+    db.add(category)
+    db.commit()
+    db.refresh(category)
+    return category
+
+
+def update_category(db: Session, category: JournalCategory, data: JournalCategoryCreate) -> JournalCategory:
+    category.name = data.name
+    category.color = data.color
+    category.content_template = data.content_template
+    db.commit()
+    db.refresh(category)
+    return category
+
+
+def ensure_default_category(db: Session, user_id: int) -> JournalCategory:
+    """유저가 카테고리를 하나도 만든 적 없으면 기본 카테고리를 자동 생성한다."""
+    existing = db.scalar(
+        select(JournalCategory)
+        .where(JournalCategory.user_id == user_id)
+        .order_by(JournalCategory.sort_order.is_(None), JournalCategory.sort_order, JournalCategory.created_at)
+        .limit(1)
+    )
+    if existing is not None:
+        return existing
+    return create_category(
+        db, user_id, JournalCategoryCreate(name=DEFAULT_CATEGORY_NAME, content_template=DEFAULT_CATEGORY_TEMPLATE)
+    )
+
+
+def reorder_categories(db: Session, user_id: int, ordered_ids: list[int]) -> None:
+    categories = db.scalars(
+        select(JournalCategory).where(JournalCategory.id.in_(ordered_ids), JournalCategory.user_id == user_id)
+    ).all()
+    category_map = {c.id: c for c in categories}
+    for index, category_id in enumerate(ordered_ids):
+        category = category_map.get(category_id)
+        if category is not None:
+            category.sort_order = index
+    db.commit()
+
+
+def count_entries_by_category(db: Session, user_id: int) -> dict[int, int]:
+    rows = db.execute(
+        select(JournalEntry.category_id, func.count(JournalEntry.id))
+        .where(JournalEntry.user_id == user_id)
+        .group_by(JournalEntry.category_id)
+    ).all()
+    return {row[0]: row[1] for row in rows}
+
+
+def delete_category(db: Session, category: JournalCategory) -> None:
+    """카테고리를 지우면 안의 엔트리도 함께 지워진다 — 첨부파일 디스크 삭제까지 하려면
+    ORM cascade에만 맡기지 않고 delete_entry를 하나씩 거쳐야 한다."""
+    entries = list(db.scalars(select(JournalEntry).where(JournalEntry.category_id == category.id)))
+    for entry in entries:
+        delete_entry(db, entry)
+    db.delete(category)
+    db.commit()
+
+
+# ---- 태그 ----
+
+
+def get_or_create_tags(db: Session, user_id: int, names: list[str]) -> list[JournalTag]:
+    tags = []
+    for name in names:
+        tag = db.scalar(select(JournalTag).where(JournalTag.user_id == user_id, JournalTag.name == name))
+        if tag is None:
+            tag = JournalTag(user_id=user_id, name=name)
+            db.add(tag)
+            db.flush()
+        tags.append(tag)
+    return tags
+
+
+# ---- 엔트리 ----
+
+
+def list_entries(
+    db: Session,
+    user_id: int,
+    category_id: int | None = None,
+    start: date | None = None,
+    end: date | None = None,
+) -> list[JournalEntry]:
+    stmt = select(JournalEntry).where(JournalEntry.user_id == user_id)
+    if category_id is not None:
+        stmt = stmt.where(JournalEntry.category_id == category_id)
+    if start is not None:
+        stmt = stmt.where(JournalEntry.entry_date >= start)
+    if end is not None:
+        stmt = stmt.where(JournalEntry.entry_date <= end)
+    stmt = stmt.order_by(JournalEntry.entry_date.desc(), JournalEntry.created_at.desc())
+    return list(db.scalars(stmt))
+
+
+def get_entry(db: Session, entry_id: int, user_id: int) -> JournalEntry | None:
+    return db.scalar(select(JournalEntry).where(JournalEntry.id == entry_id, JournalEntry.user_id == user_id))
+
+
+def create_entry(db: Session, user_id: int, data: JournalEntryCreate) -> JournalEntry:
+    tags = get_or_create_tags(db, user_id, data.tags)
+    entry = JournalEntry(
+        user_id=user_id,
+        category_id=data.category_id,
+        entry_date=data.entry_date,
+        title=data.title,
+        content=data.content,
+        tags=tags,
+        moods=[JournalEntryMood(mood=m) for m in data.moods],
+    )
+    db.add(entry)
+    db.commit()
+    db.refresh(entry)
+    return entry
+
+
+def update_entry(db: Session, entry: JournalEntry, data: JournalEntryUpdate) -> JournalEntry:
+    tags = get_or_create_tags(db, entry.user_id, data.tags)
+    entry.category_id = data.category_id
+    entry.entry_date = data.entry_date
+    entry.title = data.title
+    entry.content = data.content
+    entry.tags = tags
+    entry.moods = [JournalEntryMood(mood=m) for m in data.moods]
+    db.commit()
+    db.refresh(entry)
+    return entry
+
+
+def delete_entry(db: Session, entry: JournalEntry) -> None:
+    for attachment in list(entry.attachments):
+        _delete_attachment_files(attachment)
+    db.delete(entry)
+    db.commit()
+
+
+# ---- 첨부파일 ----
+
+
+def _media_dir(user_id: int, entry_id: int) -> Path:
+    return Path(settings.journal_media_root) / str(user_id) / str(entry_id)
+
+
+def _delete_attachment_files(attachment: JournalAttachment) -> None:
+    for path_str in (attachment.file_path, attachment.thumbnail_path):
+        if path_str:
+            Path(path_str).unlink(missing_ok=True)
+
+
+def save_attachment(db: Session, entry: JournalEntry, upload_file: UploadFile) -> JournalAttachment:
+    content_type = upload_file.content_type or ""
+    if content_type in ALLOWED_IMAGE_TYPES:
+        media_type = JournalAttachmentType.IMAGE
+    elif content_type in ALLOWED_VIDEO_TYPES:
+        media_type = JournalAttachmentType.VIDEO
+    else:
+        raise ValueError("지원하지 않는 파일 형식이에요 (사진: jpg/png/webp/gif, 영상: mp4/mov)")
+
+    data = upload_file.file.read()
+    max_bytes = settings.journal_max_upload_mb * 1024 * 1024
+    if len(data) > max_bytes:
+        raise ValueError(f"파일 용량은 {settings.journal_max_upload_mb}MB를 넘을 수 없어요")
+
+    target_dir = _media_dir(entry.user_id, entry.id)
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    ext = mimetypes.guess_extension(content_type) or Path(upload_file.filename or "").suffix or ""
+    stored_name = f"{uuid.uuid4().hex}{ext}"
+    file_path = target_dir / stored_name
+    file_path.write_bytes(data)
+
+    thumbnail_path: Path | None = None
+    if media_type == JournalAttachmentType.IMAGE:
+        thumbnail_path = target_dir / f"{uuid.uuid4().hex}_thumb.jpg"
+        try:
+            with Image.open(file_path) as img:
+                img = img.convert("RGB")
+                w, h = img.size
+                if w > THUMBNAIL_WIDTH:
+                    img = img.resize((THUMBNAIL_WIDTH, round(h * THUMBNAIL_WIDTH / w)))
+                img.save(thumbnail_path, "JPEG", quality=85)
+        except Exception:
+            # 손상되었거나 Pillow가 못 읽는 이미지여도 원본 업로드 자체는 실패시키지 않는다.
+            thumbnail_path.unlink(missing_ok=True)
+            thumbnail_path = None
+
+    attachment = JournalAttachment(
+        entry_id=entry.id,
+        media_type=media_type,
+        file_path=str(file_path),
+        thumbnail_path=str(thumbnail_path) if thumbnail_path else None,
+        original_filename=upload_file.filename or stored_name,
+        file_size=len(data),
+    )
+    db.add(attachment)
+    db.commit()
+    db.refresh(attachment)
+    return attachment
+
+
+def get_attachment(db: Session, attachment_id: int, user_id: int) -> JournalAttachment | None:
+    return db.scalar(
+        select(JournalAttachment)
+        .join(JournalEntry, JournalAttachment.entry_id == JournalEntry.id)
+        .where(JournalAttachment.id == attachment_id, JournalEntry.user_id == user_id)
+    )
+
+
+def delete_attachment(db: Session, attachment: JournalAttachment) -> None:
+    _delete_attachment_files(attachment)
+    db.delete(attachment)
+    db.commit()
+
+
+# ---- 캘린더 / day-detail / 회상 ----
+
+
+def _to_day_detail_item(entry: JournalEntry) -> JournalDayDetailItem:
+    return JournalDayDetailItem(
+        id=entry.id,
+        category_id=entry.category_id,
+        category_name=entry.category.name,
+        category_color=entry.category.color,
+        title=entry.title,
+        content=entry.content,
+        moods=[m.mood for m in entry.moods],
+        tags=[t.name for t in entry.tags],
+        attachments=[
+            JournalAttachmentOut(
+                id=a.id,
+                media_type=a.media_type,
+                original_filename=a.original_filename,
+                has_thumbnail=a.thumbnail_path is not None,
+            )
+            for a in entry.attachments
+        ],
+    )
+
+
+def get_monthly_journal_summary(
+    db: Session, user_id: int, year: int, month: int, category_id: int | None = None
+) -> dict[date, JournalCalendarDay]:
+    """해당 월의 날짜별 엔트리 개수와, 그날 등장한 카테고리 색상 목록(점 표시용)을 집계한다."""
+    days_in_month = calendar.monthrange(year, month)[1]
+    first_day = date(year, month, 1)
+    last_day = date(year, month, days_in_month)
+
+    stmt = (
+        select(JournalEntry.entry_date, JournalCategory.color)
+        .join(JournalCategory, JournalEntry.category_id == JournalCategory.id)
+        .where(JournalEntry.user_id == user_id, JournalEntry.entry_date.between(first_day, last_day))
+    )
+    if category_id is not None:
+        stmt = stmt.where(JournalEntry.category_id == category_id)
+    rows = db.execute(stmt).all()
+
+    counts: dict[date, int] = {}
+    colors_by_date: dict[date, list[str]] = {}
+    for entry_date, color in rows:
+        counts[entry_date] = counts.get(entry_date, 0) + 1
+        colors = colors_by_date.setdefault(entry_date, [])
+        color = color or "var(--color-accent)"
+        if color not in colors:
+            colors.append(color)
+
+    return {
+        d: JournalCalendarDay(entry_date=d, total_count=counts[d], category_colors=colors_by_date[d])
+        for d in counts
+    }
+
+
+def get_day_entries(
+    db: Session, user_id: int, target_date: date, category_id: int | None = None
+) -> list[JournalDayDetailItem]:
+    stmt = select(JournalEntry).where(
+        JournalEntry.user_id == user_id, JournalEntry.entry_date == target_date
+    )
+    if category_id is not None:
+        stmt = stmt.where(JournalEntry.category_id == category_id)
+    stmt = stmt.order_by(JournalEntry.created_at)
+    return [_to_day_detail_item(e) for e in db.scalars(stmt)]
+
+
+def get_on_this_day(db: Session, user_id: int, today: date) -> list[JournalOnThisDayItem]:
+    """오늘과 월/일이 같은 과거 연도의 엔트리를 반환한다("1년 전 오늘" 회상 카드).
+
+    MONTH()/DAY() 같은 DB 종속 함수 대신 파이썬에서 필터링해 SQLite(테스트)/MariaDB(운영)
+    양쪽에서 동일하게 동작하게 한다 — 개인 규모 데이터라 전체 스캔 비용도 무시할 만하다.
+    """
+    stmt = select(JournalEntry).where(JournalEntry.user_id == user_id).order_by(JournalEntry.entry_date.desc())
+    matches = [
+        e
+        for e in db.scalars(stmt)
+        if e.entry_date.month == today.month
+        and e.entry_date.day == today.day
+        and e.entry_date.year != today.year
+    ]
+    items = []
+    for e in matches:
+        base = _to_day_detail_item(e)
+        items.append(
+            JournalOnThisDayItem(
+                **base.model_dump(),
+                entry_date=e.entry_date,
+                years_ago=today.year - e.entry_date.year,
+            )
+        )
+    return items
+
+
+# ---- 프롬프트 ----
+
+
+def get_random_prompt(db: Session) -> JournalPrompt | None:
+    prompts = list(db.scalars(select(JournalPrompt)))
+    return random.choice(prompts) if prompts else None

app/services/user_service.py

@@ -0,0 +1,14 @@
+from sqlalchemy.orm import Session
+
+from app.models.user import User
+
+
+def delete_account(db: Session, user: User) -> None:
+    """계정과 그에 딸린 모든 데이터를 삭제한다.
+
+    Habit/PushSubscription/HabitLog/HabitNotificationLog/SummaryNotificationLog는 전부
+    user.id 기준 DB 레벨 ON DELETE CASCADE로 연결돼 있어(마이그레이션 0004/0005 참고),
+    User 행만 지우면 나머지는 MariaDB가 알아서 정리한다.
+    """
+    db.delete(user)
+    db.commit()

app/static/.well-known/assetlinks.json

@@ -0,0 +1,8 @@
+[{
+      "relation": ["delegate_permission/common.handle_all_urls"],
+      "target": {
+        "namespace": "android_app",
+        "package_name": "kr.co.alphalok.habit.twa",
+        "sha256_cert_fingerprints": ["2A:BC:19:7D:91:65:3A:88:68:02:8C:3B:1D:58:42:C7:17:02:FA:B9:C9:4F:01:02:3D:60:B7:C9:CE:6F:05:20"]
+      }
+    }]

app/static/css/style.css

@@ -111,6 +111,16 @@ p {
   color: var(--color-text-muted);
 }
 
+.app-footer {
+  text-align: center;
+  padding: var(--space-4) 0 var(--space-2);
+  font-size: 13px;
+}
+
+.app-footer a {
+  color: var(--color-text-muted);
+}
+
 /* iOS 홈 화면 추가 안내 배너 */
 .ios-install-banner {
   display: none;
@@ -315,7 +325,10 @@ p {
 /* 입력 */
 input[type="text"],
 input[type="time"],
-input[type="password"] {
+input[type="date"],
+input[type="password"],
+select,
+textarea {
   width: 100%;
   font-family: inherit;
   font-size: 15px;
@@ -326,6 +339,33 @@ input[type="password"] {
   color: var(--color-text);
 }
 
+textarea {
+  resize: vertical;
+  min-height: 90px;
+  line-height: 1.5;
+}
+
+select {
+  cursor: pointer;
+}
+
+input[type="file"] {
+  width: 100%;
+  font-family: inherit;
+  font-size: 14px;
+  color: var(--color-text-muted);
+}
+
+input[type="color"] {
+  width: 56px;
+  height: 40px;
+  padding: 2px;
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-control);
+  background: var(--color-bg);
+  cursor: pointer;
+}
+
 label {
   display: block;
   font-size: 13px;
@@ -456,6 +496,32 @@ label {
   color: #fff;
 }
 
+/* 저널 기분 선택 pill */
+.mood-picker {
+  display: flex;
+  gap: 6px;
+  flex-wrap: wrap;
+}
+
+.mood-pill {
+  border-radius: 999px;
+  border: 1px solid var(--color-border);
+  background: transparent;
+  color: var(--color-text-muted);
+  font-size: 14px;
+  padding: 8px 12px;
+  cursor: pointer;
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+}
+
+.mood-pill.selected {
+  background: var(--color-accent);
+  border-color: var(--color-accent);
+  color: #fff;
+}
+
 .difficulty-hint {
   font-size: 12px;
   color: var(--color-text-muted);
@@ -799,3 +865,263 @@ label {
 .wm-dash {
   color: var(--color-border);
 }
+
+/* 저널링 */
+.journal-day-dots {
+  display: flex;
+  gap: 2px;
+}
+
+.journal-day-dot {
+  width: 5px;
+  height: 5px;
+  border-radius: 50%;
+}
+
+.journal-prompt-card,
+.on-this-day-card {
+  margin-top: var(--space-2);
+  padding: var(--space-2);
+  border-radius: var(--radius-control);
+  background: var(--color-success-tint);
+  font-size: 14px;
+}
+
+.journal-entry-item {
+  padding: 10px 0;
+  border-bottom: 1px solid var(--color-border);
+}
+
+.journal-entry-item:last-child {
+  border-bottom: none;
+}
+
+.journal-entry-title {
+  font-weight: 600;
+  margin-top: 6px;
+}
+
+.journal-entry-content {
+  white-space: pre-wrap;
+  margin-top: 4px;
+}
+
+.journal-entry-tags {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+  margin-top: 8px;
+}
+
+.tag-chip {
+  font-size: 12px;
+  color: var(--color-text-muted);
+  background: var(--color-surface);
+  border: 1px solid var(--color-border);
+  border-radius: 999px;
+  padding: 2px 8px;
+}
+
+.mood-icon {
+  font-size: 18px;
+}
+
+.attachment-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(90px, 1fr));
+  gap: 8px;
+  margin-top: 8px;
+}
+
+.attachment-thumb {
+  position: relative;
+  aspect-ratio: 1;
+  border-radius: var(--radius-control);
+  overflow: hidden;
+  border: 1px solid var(--color-border);
+}
+
+.attachment-thumb img {
+  width: 100%;
+  height: 100%;
+  object-fit: cover;
+  display: block;
+}
+
+.attachment-video-link {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  height: 100%;
+  font-size: 12px;
+  text-align: center;
+  color: var(--color-text-muted);
+  text-decoration: none;
+  padding: 4px;
+}
+
+.attachment-delete-btn {
+  position: absolute;
+  top: 2px;
+  right: 2px;
+  width: 20px;
+  height: 20px;
+  border-radius: 50%;
+  border: none;
+  background: rgba(0, 0, 0, 0.6);
+  color: #fff;
+  font-size: 14px;
+  line-height: 1;
+  cursor: pointer;
+}
+
+/* 랜딩 페이지 (/) */
+.landing {
+  max-width: 480px;
+  margin: 0 auto;
+  padding: var(--space-4) var(--space-2) var(--space-4);
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-4);
+}
+
+.landing-hero {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: var(--space-3);
+  text-align: center;
+}
+
+.landing-brand {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  font-size: 15px;
+  font-weight: 700;
+  color: var(--color-accent);
+  letter-spacing: -0.01em;
+}
+
+.landing-brand img {
+  width: 24px;
+  height: 24px;
+  border-radius: 6px;
+}
+
+.landing-hero h1 {
+  font-size: 32px;
+  font-weight: 700;
+  letter-spacing: -0.02em;
+  text-wrap: balance;
+  margin: 0;
+}
+
+.landing-tagline {
+  font-size: 16px;
+  color: var(--color-text-muted);
+  margin: 0;
+}
+
+/* 요일 스트릭 시연: 실제 습관 체크 인터랙션을 그대로 축소해 보여준다 */
+.landing-streak {
+  display: flex;
+  gap: 8px;
+}
+
+.landing-day {
+  width: 34px;
+  height: 34px;
+  border-radius: 999px;
+  border: 1px solid var(--color-border);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 12px;
+  color: var(--color-text-muted);
+  background: var(--color-surface);
+}
+
+.landing-day.done {
+  background: var(--color-accent);
+  border-color: var(--color-accent);
+  color: #fff;
+  opacity: 0;
+  animation: landing-day-in 0.35s ease-out forwards;
+}
+
+.landing-day.done svg {
+  width: 16px;
+  height: 16px;
+}
+
+.landing-day:nth-of-type(1).done { animation-delay: 0.1s; }
+.landing-day:nth-of-type(2).done { animation-delay: 0.25s; }
+.landing-day:nth-of-type(3).done { animation-delay: 0.4s; }
+.landing-day:nth-of-type(4).done { animation-delay: 0.55s; }
+.landing-day:nth-of-type(5).done { animation-delay: 0.7s; }
+
+@keyframes landing-day-in {
+  from {
+    opacity: 0;
+    transform: scale(0.6);
+  }
+  to {
+    opacity: 1;
+    transform: scale(1);
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .landing-day.done {
+    opacity: 1;
+    animation: none;
+  }
+}
+
+.landing-copy {
+  font-size: 15.5px;
+  line-height: 1.75;
+  color: var(--color-text);
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-2);
+}
+
+.landing-copy strong {
+  color: var(--color-accent);
+}
+
+.landing-features {
+  display: grid;
+  gap: var(--space-2);
+}
+
+.landing-feature {
+  display: flex;
+  align-items: center;
+  gap: var(--space-2);
+  padding: var(--space-2);
+  background: var(--color-surface);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-card);
+}
+
+.landing-feature svg {
+  flex-shrink: 0;
+  width: 20px;
+  height: 20px;
+  color: var(--color-accent);
+}
+
+.landing-feature p {
+  margin: 0;
+  font-size: 14px;
+  color: var(--color-text);
+}
+
+.landing-feature p strong {
+  display: block;
+  font-size: 14.5px;
+  margin-bottom: 2px;
+}

app/static/js/journal-category-reorder.js

@@ -0,0 +1,27 @@
+(function () {
+  function initSortable() {
+    var list = document.getElementById("journal-category-list");
+    if (!list || typeof Sortable === "undefined") return;
+
+    Sortable.create(list, {
+      handle: ".drag-handle",
+      animation: 150,
+      forceFallback: true, // iOS Safari는 네이티브 HTML5 D&D 터치 지원이 불안정해서 자체 포인터 시뮬레이션을 강제한다
+      fallbackTolerance: 3,
+      onEnd: function () {
+        var ids = Array.from(list.children)
+          .map(function (el) { return el.getAttribute("data-category-id"); })
+          .filter(Boolean)
+          .map(Number);
+
+        fetch("/api/journal/categories/reorder", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ category_ids: ids }),
+        });
+      },
+    });
+  }
+
+  document.addEventListener("DOMContentLoaded", initSortable);
+})();

app/static/manifest.json

@@ -1,6 +1,6 @@
 {
-  "name": "습관 트래커",
-  "short_name": "습관 트래커",
+  "name": "해빗랩",
+  "short_name": "해빗랩",
   "description": "형성하고 싶은 습관과 끊고 싶은 습관을 요일별로 관리하고 매일 체크하는 개인용 습관 관리 앱",
   "start_url": "/today",
   "scope": "/",

app/static/offline.html

@@ -3,7 +3,7 @@
 <head>
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover" />
-  <title>오프라인 - 습관 트래커</title>
+  <title>오프라인 - 해빗랩</title>
   <link rel="icon" href="/static/icons/icon-192.png" />
   <link rel="stylesheet" href="/static/css/style.css" />
 </head>

app/static/service-worker.js

@@ -1,9 +1,10 @@
-const CACHE_NAME = "habit-tracker-v4";
+const CACHE_NAME = "habit-tracker-v5";
 const APP_SHELL = [
   "/static/css/style.css",
   "/static/js/app.js",
   "/static/js/push-register.js",
   "/static/js/habit-reorder.js",
+  "/static/js/journal-category-reorder.js",
   "/static/js/vendor/htmx.min.js",
   "/static/js/vendor/alpine.min.js",
   "/static/js/vendor/sortable.min.js",
@@ -78,7 +79,7 @@ self.addEventListener("push", (event) => {
   if (!event.data) return;
   const data = event.data.json();
   event.waitUntil(
-    self.registration.showNotification(data.title || "습관 트래커", {
+    self.registration.showNotification(data.title || "해빗랩", {
       body: data.body || "",
       icon: "/static/icons/icon-192.png",
       badge: "/static/icons/icon-192.png",

app/templates/404.html

@@ -1,5 +1,5 @@
 {% extends "base.html" %}
-{% block title %}페이지를 찾을 수 없어요 · 습관 트래커{% endblock %}
+{% block title %}페이지를 찾을 수 없어요 · 해빗랩{% endblock %}
 {% block content %}
 <div style="min-height: 60vh; display:flex; align-items:center; justify-content:center; text-align:center;">
   <div>

app/templates/500.html

@@ -1,5 +1,5 @@
 {% extends "base.html" %}
-{% block title %}오류가 발생했어요 · 습관 트래커{% endblock %}
+{% block title %}오류가 발생했어요 · 해빗랩{% endblock %}
 {% block content %}
 <div style="min-height: 60vh; display:flex; align-items:center; justify-content:center; text-align:center;">
   <div>

app/templates/account.html

@@ -0,0 +1,24 @@
+{% extends "base.html" %}
+{% block title %}계정 · 해빗랩{% endblock %}
+{% block content %}
+<h1>계정</h1>
+
+<div class="card">
+  <p><strong>이메일</strong><br />{{ current_user.email }}</p>
+  {% if current_user.name %}<p><strong>이름</strong><br />{{ current_user.name }}</p>{% endif %}
+  <p><strong>가입일</strong><br />{{ current_user.created_at.strftime('%Y-%m-%d') }}</p>
+</div>
+
+<div class="card">
+  <h2>계정 삭제</h2>
+  <p>
+    계정을 삭제하면 등록한 모든 습관, 체크 기록, 알림 구독 정보가 즉시 영구적으로 삭제되며 되돌릴 수 없습니다.
+  </p>
+  {% if delete_error %}<p style="color: var(--color-danger);">{{ delete_error }}</p>{% endif %}
+  <form method="post" action="/account/delete">
+    <label for="confirm_email">확인을 위해 본인 이메일({{ current_user.email }})을 입력하세요</label>
+    <input type="text" id="confirm_email" name="confirm_email" autocomplete="off" />
+    <button type="submit" class="btn btn-danger-ghost btn-block" style="margin-top: var(--space-2);">계정 영구 삭제</button>
+  </form>
+</div>
+{% endblock %}

app/templates/base.html

@@ -3,14 +3,14 @@
 <head>
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover" />
-  <title>{% block title %}습관 트래커{% endblock %}</title>
+  <title>{% block title %}해빗랩{% endblock %}</title>
 
   <link rel="manifest" href="/static/manifest.json" />
   <meta name="theme-color" content="#d97757" media="(prefers-color-scheme: light)" />
   <meta name="theme-color" content="#e08962" media="(prefers-color-scheme: dark)" />
   <meta name="apple-mobile-web-app-capable" content="yes" />
   <meta name="apple-mobile-web-app-status-bar-style" content="default" />
-  <meta name="apple-mobile-web-app-title" content="습관 트래커" />
+  <meta name="apple-mobile-web-app-title" content="해빗랩" />
   <link rel="apple-touch-icon" sizes="180x180" href="/static/icons/icon-apple-180.png" />
   <link rel="apple-touch-icon" href="/static/icons/icon-192.png" />
   <link rel="icon" href="/static/icons/icon-192.png" />
@@ -20,6 +20,7 @@
   <script src="/static/js/push-register.js" defer></script>
   <script src="/static/js/vendor/sortable.min.js" defer></script>
   <script src="/static/js/habit-reorder.js" defer></script>
+  <script src="/static/js/journal-category-reorder.js" defer></script>
   <script src="/static/js/vendor/alpine.min.js" defer></script>
   <script src="/static/js/app.js" defer></script>
 </head>
@@ -31,16 +32,17 @@
       <button type="button" onclick="dismissIosInstallBanner()" aria-label="닫기">&times;</button>
     </div>
     <nav class="top-nav">
-      <span class="brand">습관 트래커</span>
+      <span class="brand">해빗랩</span>
       <div class="nav-links">
         <a href="/today" class="{% block nav_today %}{% endblock %}">오늘</a>
         <a href="/habits" class="{% block nav_habits %}{% endblock %}">습관 관리</a>
         <a href="/history" class="{% block nav_history %}{% endblock %}">기록</a>
+        <a href="/journal" class="{% block nav_journal %}{% endblock %}">일기</a>
       </div>
       {% if current_user %}
       <div class="nav-user">
         {% if account_level %}<span class="nav-level-pill">Lv.{{ account_level.level }}</span>{% endif %}
-        <span>{{ current_user.name or current_user.email }}</span>
+        <a href="/account">{{ current_user.name or current_user.email }}</a>
         <form method="post" action="/auth/logout">
           <button type="submit" class="btn-link">로그아웃</button>
         </form>
@@ -60,9 +62,16 @@
         <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="5" width="18" height="16" rx="2" /><line x1="3" y1="10" x2="21" y2="10" /><line x1="8" y1="3" x2="8" y2="7" /><line x1="16" y1="3" x2="16" y2="7" /></svg>
         <span>기록</span>
       </a>
+      <a href="/journal" class="tab-item {{ self.nav_journal() }}">
+        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M4 19.5A2.5 2.5 0 0 1 6.5 17H20" /><path d="M6.5 2H20v20H6.5A2.5 2.5 0 0 1 4 19.5v-15A2.5 2.5 0 0 1 6.5 2z" /></svg>
+        <span>일기</span>
+      </a>
     </nav>
     {% endif %}
     {% block content %}{% endblock %}
+    <footer class="app-footer">
+      <a href="/privacy">개인정보처리방침</a>
+    </footer>
   </div>
 </body>
 </html>

app/templates/habits.html

@@ -1,5 +1,5 @@
 {% extends "base.html" %}
-{% block title %}습관 관리 · 습관 트래커{% endblock %}
+{% block title %}습관 관리 · 해빗랩{% endblock %}
 {% block nav_habits %}active{% endblock %}
 {% block content %}
 <h1>습관 관리</h1>

app/templates/history.html

@@ -1,5 +1,5 @@
 {% extends "base.html" %}
-{% block title %}기록 · 습관 트래커{% endblock %}
+{% block title %}기록 · 해빗랩{% endblock %}
 {% block nav_history %}active{% endblock %}
 {% block shell_class %} wide{% endblock %}
 {% block content %}

app/templates/home.html

@@ -0,0 +1,60 @@
+{% extends "base.html" %}
+{% block title %}해빗랩 · 습관이 만들어지는 진짜 시간{% endblock %}
+{% block content %}
+<div class="landing">
+  <div class="landing-hero">
+    <div class="landing-brand"><img src="/static/icons/icon-192.png" alt="" /> 해빗랩</div>
+    <h1>습관이 만들어지는<br />진짜 시간</h1>
+    <p class="landing-tagline">21일의 법칙 대신, 습관마다 다른 진짜 목표 기간을 알려드려요</p>
+
+    <div class="landing-streak" aria-hidden="true">
+      <div class="landing-day done">
+        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"><path d="M5 12l5 5 9-9" /></svg>
+      </div>
+      <div class="landing-day done">
+        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"><path d="M5 12l5 5 9-9" /></svg>
+      </div>
+      <div class="landing-day done">
+        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"><path d="M5 12l5 5 9-9" /></svg>
+      </div>
+      <div class="landing-day done">
+        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"><path d="M5 12l5 5 9-9" /></svg>
+      </div>
+      <div class="landing-day done">
+        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"><path d="M5 12l5 5 9-9" /></svg>
+      </div>
+      <div class="landing-day">토</div>
+      <div class="landing-day">일</div>
+    </div>
+  </div>
+
+  <div class="landing-copy">
+    <p>
+      "습관은 21일이면 만들어진다"는 말, 많이 들어보셨을 거예요. 사실 근거가 약한 통설이에요.
+      실증 연구(<strong>Lally et al., 2010, UCL</strong>)에 따르면 습관이 몸에 붙기까지 걸리는 시간은
+      사람마다, 습관마다 달라서 짧게는 3주, 길게는 8개월 넘게 걸리기도 해요.
+    </p>
+    <p>
+      <strong>해빗랩</strong>은 여러분이 만들고 싶은 습관도, 멈추고 싶은 습관도 함께 만들어가는 동반자예요.
+      검증된 연구를 시스템에 그대로 담아 목표 기간과 진행 상황을 짚어드리고, 그 여정을 끝까지 응원할게요.
+    </p>
+  </div>
+
+  <div class="landing-features">
+    <div class="landing-feature">
+      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="9" /><circle cx="12" cy="12" r="5" /><circle cx="12" cy="12" r="1" /></svg>
+      <p><strong>연구 기반 목표 기간</strong>속설이 아니라 실제 연구값(21·66·254일)으로 목표를 잡아요</p>
+    </div>
+    <div class="landing-feature">
+      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="8" cy="12" r="6" /><line x1="8" y1="9" x2="8" y2="15" /><line x1="5" y1="12" x2="11" y2="12" /><circle cx="17" cy="12" r="6" /><line x1="14" y1="12" x2="20" y2="12" /></svg>
+      <p><strong>만들기와 끊기, 동시에</strong>새 습관을 만드는 것과 나쁜 습관을 끊는 것을 똑같은 무게로 다뤄요</p>
+    </div>
+    <div class="landing-feature">
+      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="9" /><line x1="6" y1="6" x2="18" y2="18" /></svg>
+      <p><strong>광고·구독 없음</strong>습관관리에만 집중해요, 그 외엔 아무것도 없어요</p>
+    </div>
+  </div>
+
+  <a href="/auth/google/login" class="btn btn-primary btn-block">Google로 시작하기</a>
+</div>
+{% endblock %}

app/templates/journal.html

@@ -0,0 +1,249 @@
+{% extends "base.html" %}
+{% block title %}일기 · 해빗랩{% endblock %}
+{% block nav_journal %}active{% endblock %}
+{% block shell_class %} wide{% endblock %}
+{% block content %}
+<h1>일기</h1>
+
+<div style="display:flex; align-items:center; gap: var(--space-1);">
+  <div class="tabs" style="flex:1; min-width:0;">
+    <a href="/journal?year={{ year }}&month={{ month }}" class="{{ 'active' if tab != 'manage' and not category_id }}">전체</a>
+    {% for category in categories %}
+    <a
+      href="/journal?year={{ year }}&month={{ month }}&category_id={{ category.id }}"
+      class="{{ 'active' if tab != 'manage' and category_id == category.id }}"
+    >{{ category.name }}</a>
+    {% endfor %}
+  </div>
+  <a href="/journal?tab=manage" class="btn btn-secondary{{ ' active' if tab == 'manage' }}" style="flex-shrink:0; margin-bottom: var(--space-2); text-decoration:none;">⚙ 관리</a>
+</div>
+
+{% if tab == "manage" %}
+{% if categories %}
+<div class="card">
+  <div class="day-detail-list" id="journal-category-list">
+    {% for category in categories %}
+    <div class="journal-entry-item" data-category-id="{{ category.id }}" x-data="{ editing: false }">
+      <div class="day-detail-item" x-show="!editing">
+        <span style="display:flex; align-items:center; gap: 8px;">
+          <span class="drag-handle" aria-hidden="true">⠿</span>
+          <span class="badge" style="border-color: {{ category.color or 'var(--color-accent)' }};">{{ category.name }}</span>
+          <span class="badge">기록 {{ entry_counts.get(category.id, 0) }}개</span>
+        </span>
+        <span style="display:flex; gap:8px;">
+          <button type="button" class="btn btn-secondary" @click="editing = true">수정</button>
+          <button
+            type="button"
+            class="btn btn-danger-ghost"
+            hx-post="/journal/categories/{{ category.id }}/delete"
+            hx-target="body"
+            hx-swap="none"
+            hx-confirm="'{{ category.name }}' 카테고리를 삭제할까요? 이 카테고리의 모든 기록({{ entry_counts.get(category.id, 0) }}개)과 첨부파일도 함께 삭제됩니다."
+          >삭제</button>
+        </span>
+      </div>
+
+      <form
+        x-show="editing"
+        x-cloak
+        style="padding: 8px 0;"
+        hx-post="/journal/categories/{{ category.id }}/edit"
+        hx-target="#journal-category-edit-error-{{ category.id }}"
+        hx-swap="innerHTML"
+      >
+        <div class="field">
+          <label for="edit-category-name-{{ category.id }}">카테고리 이름</label>
+          <input type="text" id="edit-category-name-{{ category.id }}" name="name" required value="{{ category.name }}" />
+        </div>
+        <div class="field">
+          <label for="edit-category-color-{{ category.id }}">색상</label>
+          <input type="color" id="edit-category-color-{{ category.id }}" name="color" value="{{ category.color or '#d97757' }}" />
+        </div>
+        <div class="field">
+          <label for="edit-category-template-{{ category.id }}">기본 작성 틀 (선택)</label>
+          <textarea id="edit-category-template-{{ category.id }}" name="content_template" rows="4" placeholder="이 카테고리로 새 기록을 쓸 때 내용칸에 미리 채워줄 틀을 입력하세요">{{ category.content_template or '' }}</textarea>
+        </div>
+        <div id="journal-category-edit-error-{{ category.id }}" class="form-error-text"></div>
+        <div style="display:flex; gap:8px;">
+          <button type="submit" class="btn btn-primary" style="flex:1;">저장</button>
+          <button type="button" class="btn btn-secondary" @click="editing = false">취소</button>
+        </div>
+      </form>
+    </div>
+    {% endfor %}
+  </div>
+</div>
+{% endif %}
+
+<div class="card" x-data="{ open: false }">
+  <button type="button" class="btn btn-secondary btn-block" @click="open = !open">
+    <span x-show="!open">+ 카테고리 추가</span>
+    <span x-show="open" x-cloak>닫기</span>
+  </button>
+  <form x-show="open" x-cloak style="margin-top: var(--space-2);" hx-post="/journal/categories/new" hx-target="#journal-category-error" hx-swap="innerHTML">
+    <div class="field">
+      <label for="new-category-name">카테고리 이름</label>
+      <input type="text" id="new-category-name" name="name" required placeholder="예: 투자" />
+    </div>
+    <div class="field">
+      <label for="new-category-color">색상 (선택)</label>
+      <input type="color" id="new-category-color" name="color" value="#d97757" />
+    </div>
+    <div class="field">
+      <label for="new-category-template">기본 작성 틀 (선택)</label>
+      <textarea id="new-category-template" name="content_template" rows="4" placeholder="이 카테고리로 새 기록을 쓸 때 내용칸에 미리 채워줄 틀을 입력하세요"></textarea>
+    </div>
+    <div id="journal-category-error" class="form-error-text"></div>
+    <button type="submit" class="btn btn-primary btn-block">추가하기</button>
+  </form>
+</div>
+
+{% else %}
+
+{% if on_this_day %}
+<div class="card on-this-day-card">
+  <h3 style="margin-top:0;">📅 {{ on_this_day|length }}개의 지난 오늘</h3>
+  {% for item in on_this_day %}
+  <div class="day-detail-item">
+    <span>
+      <span class="badge" style="border-color: {{ item.category_color or 'var(--color-accent)' }};">{{ item.category_name }}</span>
+      {{ item.entry_date.year }}년 · {{ item.years_ago }}년 전
+    </span>
+    <span>{{ item.title or (item.content[:30] ~ ('…' if item.content|length > 30 else '')) }}</span>
+  </div>
+  {% endfor %}
+</div>
+{% endif %}
+
+<div
+  class="card"
+  x-data="{
+    open: false,
+    moods: [],
+    toggleMood(v) { this.moods.includes(v) ? this.moods = this.moods.filter(m => m !== v) : this.moods.push(v) },
+    categoryTemplates: {{ category_templates|tojson|forceescape }},
+    content: '',
+    lastAutoFilled: '',
+    onCategoryChange(categoryId) {
+      const tmpl = this.categoryTemplates[categoryId] || '';
+      if (this.content === this.lastAutoFilled) {
+        this.content = tmpl;
+        this.lastAutoFilled = tmpl;
+      }
+    },
+    init() { this.onCategoryChange(this.$refs.categorySelect.value); },
+  }"
+>
+  <button type="button" class="btn btn-primary btn-block" @click="open = !open">
+    <span x-show="!open">+ 새 기록 쓰기</span>
+    <span x-show="open" x-cloak>닫기</span>
+  </button>
+
+  {% if prompt %}
+  <div class="journal-prompt-card">💭 {{ prompt.question_text }}</div>
+  {% endif %}
+
+  <form
+    x-show="open"
+    x-cloak
+    style="margin-top: var(--space-2);"
+    hx-post="/journal/new"
+    hx-target="#journal-form-error"
+    hx-swap="innerHTML"
+    hx-encoding="multipart/form-data"
+  >
+    <div class="field">
+      <label for="new-entry-category">카테고리</label>
+      <select id="new-entry-category" name="category_id" x-ref="categorySelect" @change="onCategoryChange($event.target.value)">
+        {% for category in categories %}
+        <option value="{{ category.id }}" {{ 'selected' if category_id == category.id }}>{{ category.name }}</option>
+        {% endfor %}
+      </select>
+    </div>
+
+    <div class="field">
+      <label for="new-entry-date">날짜</label>
+      <input type="date" id="new-entry-date" name="entry_date" value="{{ today_iso }}" required />
+    </div>
+
+    <div class="field">
+      <label for="new-entry-title">제목 (선택)</label>
+      <input type="text" id="new-entry-title" name="title" placeholder="제목을 입력하세요" />
+    </div>
+
+    <div class="field">
+      <label for="new-entry-content">내용</label>
+      <textarea id="new-entry-content" name="content" rows="8" required placeholder="오늘 하루는 어땠나요?" x-model="content"></textarea>
+    </div>
+
+    <div class="field">
+      <label>기분 (선택, 여러 개 선택 가능)</label>
+      <input type="hidden" name="moods" :value="moods.join(',')" />
+      <div class="mood-picker">
+        {% for value, emoji, label in journal_mood_options %}
+        <button
+          type="button"
+          class="mood-pill"
+          :class="{ selected: moods.includes('{{ value.value }}') }"
+          @click="toggleMood('{{ value.value }}')"
+        >{{ emoji }} {{ label }}</button>
+        {% endfor %}
+      </div>
+    </div>
+
+    <div class="field">
+      <label for="new-entry-tags">태그 (선택, 쉼표로 구분)</label>
+      <input type="text" id="new-entry-tags" name="tags" placeholder="예: 투자, 회고" />
+    </div>
+
+    <div class="field">
+      <label for="new-entry-files">사진/영상 첨부 (선택)</label>
+      <input type="file" id="new-entry-files" name="files" accept="image/*,video/*" multiple />
+    </div>
+
+    <div id="journal-form-error" class="form-error-text"></div>
+
+    <button type="submit" class="btn btn-primary btn-block">기록 저장</button>
+  </form>
+</div>
+
+<div class="card">
+  <div style="display:flex; align-items:center; justify-content:space-between; margin-bottom: var(--space-2);">
+    <a href="/journal?year={{ prev_year }}&month={{ prev_month }}{{ '&category_id=' ~ category_id if category_id }}" class="btn btn-secondary">‹</a>
+    <h2 style="margin:0;">{{ year }}년 {{ month }}월</h2>
+    <a href="/journal?year={{ next_year }}&month={{ next_month }}{{ '&category_id=' ~ category_id if category_id }}" class="btn btn-secondary">›</a>
+  </div>
+
+  <div class="calendar-grid calendar-grid-header">
+    {% for wd in ["일", "월", "화", "수", "목", "금", "토"] %}
+    <div class="calendar-weekday">{{ wd }}</div>
+    {% endfor %}
+  </div>
+
+  {% for week in weeks %}
+  <div class="calendar-grid">
+    {% for d in week %}
+    {% set day_summary = summary_map.get(d) %}
+    <div
+      class="calendar-cell clickable{{ '' if d.month == month else ' muted' }}"
+      hx-get="/journal/day/{{ d.isoformat() }}"
+      hx-target="#day-detail"
+      hx-swap="innerHTML"
+    >
+      <span class="calendar-date">{{ d.day }}</span>
+      {% if day_summary %}
+      <span class="journal-day-dots">
+        {% for color in day_summary.category_colors %}
+        <span class="journal-day-dot" style="background: {{ color }};"></span>
+        {% endfor %}
+      </span>
+      {% endif %}
+    </div>
+    {% endfor %}
+  </div>
+  {% endfor %}
+</div>
+
+<div id="day-detail"></div>
+{% endif %}
+{% endblock %}

app/templates/login.html

@@ -1,9 +1,10 @@
 {% extends "base.html" %}
-{% block title %}로그인 · 습관 트래커{% endblock %}
+{% block title %}로그인 · 해빗랩{% endblock %}
 {% block content %}
 <div style="min-height: 70vh; display: flex; align-items: center; justify-content: center;">
   <div class="card" style="width: 100%; max-width: 320px;">
-    <h1 style="text-align:center;">습관 트래커</h1>
+    <h1 style="text-align:center;">해빗랩</h1>
+    {% if deleted %}<p style="text-align:center; color: var(--color-success);">계정이 삭제되었습니다.</p>{% endif %}
     <p style="text-align:center;">구글 계정으로 로그인하세요</p>
     <a href="/auth/google/login" class="btn btn-primary btn-block">Google로 로그인</a>
   </div>

app/templates/partials/journal_day_detail.html

@@ -0,0 +1,135 @@
+{% set weekday_names = ["월", "화", "수", "목", "금", "토", "일"] %}
+<div class="card day-detail-card">
+  <div style="display:flex; align-items:center; justify-content:space-between; margin-bottom: var(--space-2);">
+    <h3 style="margin:0;">{{ entry_date.strftime("%Y.%m.%d") }} ({{ weekday_names[entry_date.weekday()] }})</h3>
+    <button type="button" class="btn btn-secondary" onclick="document.getElementById('day-detail').innerHTML=''">닫기</button>
+  </div>
+
+  {% if items %}
+  <div class="day-detail-list">
+    {% for item in items %}
+    <div
+      class="journal-entry-item"
+      x-data="{
+        editing: {{ 'true' if editing_entry_id == item.id else 'false' }},
+        moods: [{% for m in item.moods %}'{{ m.value }}'{{ ',' if not loop.last }}{% endfor %}],
+        toggleMood(v) { this.moods.includes(v) ? this.moods = this.moods.filter(m => m !== v) : this.moods.push(v) },
+      }"
+    >
+      <div x-show="!editing">
+        <div style="display:flex; align-items:center; justify-content:space-between;">
+          <span class="badge" style="border-color: {{ item.category_color or 'var(--color-accent)' }};">{{ item.category_name }}</span>
+          {% if item.moods %}
+          <span class="mood-icon">{% for m in item.moods %}{{ journal_mood_emoji[m.value] }}{% endfor %}</span>
+          {% endif %}
+        </div>
+        {% if item.title %}<div class="journal-entry-title">{{ item.title }}</div>{% endif %}
+        <div class="journal-entry-content">{{ item.content }}</div>
+        {% if item.tags %}
+        <div class="journal-entry-tags">
+          {% for tag in item.tags %}<span class="tag-chip">#{{ tag }}</span>{% endfor %}
+        </div>
+        {% endif %}
+        {% if item.attachments %}
+        <div class="attachment-grid">
+          {% for attachment in item.attachments %}
+          <div class="attachment-thumb">
+            {% if attachment.media_type.value == "image" %}
+            <a href="/api/journal/media/{{ attachment.id }}" target="_blank">
+              <img src="/api/journal/media/{{ attachment.id }}?thumbnail=true" alt="{{ attachment.original_filename }}" />
+            </a>
+            {% else %}
+            <a href="/api/journal/media/{{ attachment.id }}" target="_blank" class="attachment-video-link">▶ {{ attachment.original_filename }}</a>
+            {% endif %}
+            <button
+              type="button"
+              class="attachment-delete-btn"
+              hx-post="/journal/{{ item.id }}/attachments/{{ attachment.id }}/delete"
+              hx-target="#day-detail"
+              hx-swap="innerHTML"
+              hx-confirm="이 첨부파일을 삭제할까요?"
+              aria-label="첨부파일 삭제"
+            >&times;</button>
+          </div>
+          {% endfor %}
+        </div>
+        {% endif %}
+        <div class="habit-item-actions" style="margin-top: 8px;">
+          <button type="button" class="btn btn-secondary" @click="editing = true">수정</button>
+          <button
+            type="button"
+            class="btn btn-danger-ghost"
+            hx-post="/journal/{{ item.id }}/delete"
+            hx-target="#day-detail"
+            hx-swap="innerHTML"
+            hx-confirm="이 기록을 삭제할까요?"
+          >삭제</button>
+        </div>
+      </div>
+
+      <form
+        x-show="editing"
+        x-cloak
+        style="padding: 12px 4px; border-bottom: 1px solid var(--color-border);"
+        hx-post="/journal/{{ item.id }}/edit"
+        hx-target="#day-detail"
+        hx-swap="innerHTML"
+        hx-encoding="multipart/form-data"
+      >
+        <div class="field">
+          <label>카테고리</label>
+          <select name="category_id">
+            {% for category in categories %}
+            <option value="{{ category.id }}" {{ 'selected' if category.id == item.category_id }}>{{ category.name }}</option>
+            {% endfor %}
+          </select>
+        </div>
+        <div class="field">
+          <label>날짜</label>
+          <input type="date" name="entry_date" value="{{ entry_date.isoformat() }}" required />
+        </div>
+        <div class="field">
+          <label>제목</label>
+          <input type="text" name="title" value="{{ item.title or '' }}" />
+        </div>
+        <div class="field">
+          <label>내용</label>
+          <textarea name="content" rows="4" required>{{ item.content }}</textarea>
+        </div>
+        <div class="field">
+          <label>기분 (여러 개 선택 가능)</label>
+          <input type="hidden" name="moods" :value="moods.join(',')" />
+          <div class="mood-picker">
+            {% for value, emoji, label in journal_mood_options %}
+            <button
+              type="button"
+              class="mood-pill"
+              :class="{ selected: moods.includes('{{ value.value }}') }"
+              @click="toggleMood('{{ value.value }}')"
+            >{{ emoji }} {{ label }}</button>
+            {% endfor %}
+          </div>
+        </div>
+        <div class="field">
+          <label>태그 (쉼표로 구분)</label>
+          <input type="text" name="tags" value="{{ item.tags|join(', ') }}" />
+        </div>
+        <div class="field">
+          <label>사진/영상 추가</label>
+          <input type="file" name="files" accept="image/*,video/*" multiple />
+        </div>
+        {% if edit_error and editing_entry_id == item.id %}
+        <div class="form-error-text">{{ edit_error }}</div>
+        {% endif %}
+        <div style="display:flex; gap:8px;">
+          <button type="submit" class="btn btn-primary" style="flex:1;">저장</button>
+          <button type="button" class="btn btn-secondary" @click="editing = false">취소</button>
+        </div>
+      </form>
+    </div>
+    {% endfor %}
+  </div>
+  {% else %}
+  <div class="empty-state">이 날 작성한 기록이 없어요.</div>
+  {% endif %}
+</div>

app/templates/partials/today_item.html

@@ -14,13 +14,13 @@
       {% if item.reminder_time %}<div class="habit-item-meta">알람 {{ item.reminder_time }}</div>{% endif %}
       {% if item.scheduled_days > 0 %}
       <div class="habit-item-stats">
+        <span class="badge level-badge">{{ level_tier_emoji(item.level_info.level) }} Lv.{{ item.level_info.level }}</span>
         <span class="badge">완료율 {{ item.completion_rate }}%</span>
         {% if item.current_streak > 0 %}
         <span class="badge{{ ' badge-milestone' if is_milestone_streak(item.current_streak) }}">
           {{ '🏆' if is_milestone_streak(item.current_streak) else '🔥' }} 연속 {{ item.current_streak }}일
         </span>
         {% endif %}
-        <span class="badge level-badge">{{ level_tier_emoji(item.level_info.level) }} Lv.{{ item.level_info.level }}</span>
       </div>
       <div class="xp-bar-wrap">
         <div class="xp-bar"><div class="xp-bar-fill" style="width: {{ item.level_info.progress_pct }}%;"></div></div>

app/templates/privacy.html

@@ -0,0 +1,45 @@
+{% extends "base.html" %}
+{% block title %}개인정보처리방침 · 해빗랩{% endblock %}
+{% block content %}
+<div style="max-width: 640px; margin: 0 auto; padding: 24px 16px 48px;">
+  <div class="card">
+    <h1>개인정보처리방침</h1>
+    <p>시행일자: 2026년 7월 22일</p>
+
+    <p>해빗랩(이하 "서비스")는 이용자의 개인정보를 소중히 다루며, 아래와 같이 개인정보를 수집·이용·보관합니다.</p>
+
+    <h2>1. 수집하는 개인정보 항목</h2>
+    <p><strong>가. 구글 로그인 시 (필수)</strong><br />
+    이메일 주소, 이름, 프로필 사진 URL, 구글 계정 고유 식별자(sub). 서비스는 구글 계정 정보를 이용해 자동으로 계정을 생성하며, 비밀번호는 별도로 수집·저장하지 않습니다.</p>
+    <p><strong>나. 서비스 이용 중 직접 입력하는 정보</strong><br />
+    등록한 습관의 이름, 유형(만들기/끊기), 요일 스케줄, 목표 난이도, 달성 조건, 알림 시각, 날짜별 체크·실패 기록.</p>
+    <p><strong>다. 알림(Web Push)을 켠 경우에만</strong><br />
+    브라우저가 발급하는 푸시 구독 정보(endpoint, 암호화 키)와 브라우저 종류(User-Agent). 알림 중복 발송을 막기 위한 발송 이력도 함께 기록됩니다.</p>
+    <p><strong>라. 자동 수집 정보</strong><br />
+    로그인 유지를 위한 서명된 세션 쿠키. 별도의 광고·분석·트래킹 쿠키는 사용하지 않습니다.</p>
+
+    <h2>2. 개인정보의 수집 및 이용 목적</h2>
+    <p>구글 계정 인증 및 로그인 유지, 습관 등록·체크·통계(완료율, 연속 달성일 등) 제공, 설정한 시각에 맞춘 습관 알림(Web Push) 발송을 위해서만 이용합니다. 광고, 마케팅, 프로필링 목적으로는 이용하지 않습니다.</p>
+
+    <h2>3. 개인정보의 보유 및 이용 기간</h2>
+    <p>회원 탈퇴 시까지 보관하며, 탈퇴 시 계정 정보와 습관·체크 기록, 푸시 구독 정보를 지체 없이 삭제합니다. 관계 법령에 따라 보존이 필요한 경우가 아니면 별도 보관하지 않습니다.</p>
+
+    <h2>4. 개인정보의 제3자 제공</h2>
+    <p>서비스는 이용자의 개인정보를 원칙적으로 외부에 제공하지 않습니다. 다만 구글 로그인 인증 과정에서 구글(Google LLC)과 통신이 발생하며, 이는 이용자 인증을 위한 목적에 한정됩니다.</p>
+
+    <h2>5. 이용자의 권리와 행사 방법</h2>
+    <p>이용자는 언제든지 자신의 개인정보 열람·정정·삭제를 요청할 수 있습니다. 로그인 후 <a href="/account">계정</a> 페이지에서 본인 이메일 확인 후 즉시 계정과 모든 데이터를 직접 삭제할 수 있으며, 앱을 이용하기 어려운 경우 아래 문의처로 요청하셔도 확인 후 지체 없이 처리해드립니다.</p>
+
+    <h2>6. 보안을 위한 조치</h2>
+    <p>비밀번호를 직접 저장하지 않는 구글 OAuth 인증 방식을 사용하며, 로그인 세션은 서명된 쿠키로 관리합니다. 모든 통신은 HTTPS로 암호화되며, 각 이용자의 데이터는 계정 단위로 분리되어 다른 이용자가 접근할 수 없습니다.</p>
+
+    <h2>7. 문의처</h2>
+    <p>개인정보 관련 문의, 열람·정정·삭제 요청은 아래로 연락해주세요.</p>
+    <p>해빗랩 운영자<br />
+    이메일: <a href="mailto:shinalok357@gmail.com">shinalok357@gmail.com</a></p>
+
+    <h2>8. 고지의 의무</h2>
+    <p>이 개인정보처리방침은 법령이나 서비스 변경사항을 반영하기 위해 수정될 수 있으며, 변경 시 이 페이지를 통해 고지합니다.</p>
+  </div>
+</div>
+{% endblock %}

app/templates/today.html

@@ -1,5 +1,5 @@
 {% extends "base.html" %}
-{% block title %}오늘 · 습관 트래커{% endblock %}
+{% block title %}오늘 · 해빗랩{% endblock %}
 {% block nav_today %}active{% endblock %}
 {% block content %}
 <div id="today-content">

deploy.env.example

@@ -0,0 +1,9 @@
+# 이 파일을 복사해 deploy.env로 저장한 뒤 값을 채워넣으세요. deploy.env는 git에 커밋되지 않습니다.
+# scripts/deploy_sftp.py가 이 값들로 SFTP 접속해 시놀로지 NAS에 소스를 동기화합니다.
+
+SFTP_HOST=your-domain-or-ip
+SFTP_PORT=22
+SFTP_USERNAME=
+SFTP_PASSWORD=
+# 시놀로지 SFTP는 보통 /volume1을 세션 루트("/")로 보여주므로 /volume1 접두어 없이 적는다
+SFTP_REMOTE_PATH=/docker/habit-tracker

migrations/versions/0010_add_journal_tables.py

@@ -0,0 +1,143 @@
+"""add journal tables (category, entry, tag, attachment, prompt)
+
+Revision ID: 0010_add_journal_tables
+Revises: 0009_add_habit_log_status
+Create Date: 2026-08-04
+
+습관 체크에 곁들이는 회고 + 독립적인 자유 일기를 함께 지원하는 저널링 기능을 위한 테이블.
+카테고리(예: "일상", "투자")는 사용자별로 자유롭게 만들 수 있고, 하루에 같은 카테고리로
+여러 엔트리를 쓸 수 있어 (habit_id, log_date) 같은 유니크 제약은 두지 않는다. journal_prompt는
+카테고리 무관 전역 질문 뱅크로, 최소한의 한국어 질문 시드 데이터를 함께 넣는다(AI 기반 프롬프트는
+후속 업데이트로 미룸).
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "0010_add_journal_tables"
+down_revision: Union[str, None] = "0009_add_habit_log_status"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.create_table(
+        "journal_category",
+        sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True),
+        sa.Column("user_id", sa.Integer(), sa.ForeignKey("user.id", ondelete="CASCADE"), nullable=False),
+        sa.Column("name", sa.String(length=50), nullable=False),
+        sa.Column("color", sa.String(length=20), nullable=True),
+        sa.Column("sort_order", sa.Integer(), nullable=True),
+        sa.Column("created_at", sa.DateTime(), nullable=False, server_default=sa.func.now()),
+        sa.UniqueConstraint("user_id", "name", name="uq_journal_category_user_name"),
+        mysql_engine="InnoDB",
+        mysql_charset="utf8mb4",
+    )
+
+    op.create_table(
+        "journal_entry",
+        sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True),
+        sa.Column("user_id", sa.Integer(), sa.ForeignKey("user.id", ondelete="CASCADE"), nullable=False),
+        sa.Column(
+            "category_id",
+            sa.Integer(),
+            sa.ForeignKey("journal_category.id", ondelete="CASCADE"),
+            nullable=False,
+        ),
+        sa.Column("entry_date", sa.Date(), nullable=False),
+        sa.Column("title", sa.String(length=200), nullable=True),
+        sa.Column("content", sa.Text(), nullable=False),
+        sa.Column("mood", sa.String(length=20), nullable=True),
+        sa.Column("created_at", sa.DateTime(), nullable=False, server_default=sa.func.now()),
+        sa.Column(
+            "updated_at",
+            sa.DateTime(),
+            nullable=False,
+            server_default=sa.func.now(),
+            server_onupdate=sa.func.now(),
+        ),
+        sa.CheckConstraint(
+            "mood in ('great','good','neutral','bad','awful')", name="ck_journal_entry_mood"
+        ),
+        mysql_engine="InnoDB",
+        mysql_charset="utf8mb4",
+    )
+
+    op.create_table(
+        "journal_tag",
+        sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True),
+        sa.Column("user_id", sa.Integer(), sa.ForeignKey("user.id", ondelete="CASCADE"), nullable=False),
+        sa.Column("name", sa.String(length=50), nullable=False),
+        sa.UniqueConstraint("user_id", "name", name="uq_journal_tag_user_name"),
+        mysql_engine="InnoDB",
+        mysql_charset="utf8mb4",
+    )
+
+    op.create_table(
+        "journal_entry_tag",
+        sa.Column(
+            "entry_id", sa.Integer(), sa.ForeignKey("journal_entry.id", ondelete="CASCADE"), primary_key=True
+        ),
+        sa.Column(
+            "tag_id", sa.Integer(), sa.ForeignKey("journal_tag.id", ondelete="CASCADE"), primary_key=True
+        ),
+        mysql_engine="InnoDB",
+        mysql_charset="utf8mb4",
+    )
+
+    op.create_table(
+        "journal_attachment",
+        sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True),
+        sa.Column(
+            "entry_id", sa.Integer(), sa.ForeignKey("journal_entry.id", ondelete="CASCADE"), nullable=False
+        ),
+        sa.Column("media_type", sa.String(length=10), nullable=False),
+        sa.Column("file_path", sa.String(length=500), nullable=False),
+        sa.Column("thumbnail_path", sa.String(length=500), nullable=True),
+        sa.Column("original_filename", sa.String(length=255), nullable=False),
+        sa.Column("file_size", sa.Integer(), nullable=False),
+        sa.Column("created_at", sa.DateTime(), nullable=False, server_default=sa.func.now()),
+        sa.CheckConstraint("media_type in ('image','video')", name="ck_journal_attachment_media_type"),
+        mysql_engine="InnoDB",
+        mysql_charset="utf8mb4",
+    )
+
+    op.create_table(
+        "journal_prompt",
+        sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True),
+        sa.Column("question_text", sa.String(length=300), nullable=False),
+        mysql_engine="InnoDB",
+        mysql_charset="utf8mb4",
+    )
+
+    journal_prompt = sa.table(
+        "journal_prompt",
+        sa.column("question_text", sa.String),
+    )
+    op.bulk_insert(
+        journal_prompt,
+        [
+            {"question_text": "오늘 가장 기억에 남는 순간은 언제였나요?"},
+            {"question_text": "오늘 감사했던 일은 무엇인가요?"},
+            {"question_text": "오늘 나를 힘들게 한 건 무엇이었고, 어떻게 다뤘나요?"},
+            {"question_text": "오늘 배운 것이 있다면 무엇인가요?"},
+            {"question_text": "내일의 나에게 해주고 싶은 말은?"},
+            {"question_text": "오늘 스스로를 칭찬하고 싶은 부분은?"},
+            {"question_text": "오늘 놓쳤지만 다음엔 다르게 해보고 싶은 것은?"},
+            {"question_text": "오늘 누군가에게 도움을 받았거나 준 적이 있나요?"},
+            {"question_text": "지금 가장 신경 쓰이는 고민은 무엇인가요?"},
+            {"question_text": "오늘 하루를 한 문장으로 요약한다면?"},
+            {"question_text": "요즘 내가 놓치고 있는 것은 없을까요?"},
+            {"question_text": "이번 주 목표에 얼마나 가까워졌나요?"},
+        ],
+    )
+
+
+def downgrade() -> None:
+    op.drop_table("journal_prompt")
+    op.drop_table("journal_attachment")
+    op.drop_table("journal_entry_tag")
+    op.drop_table("journal_tag")
+    op.drop_table("journal_entry")
+    op.drop_table("journal_category")

migrations/versions/0011_journal_entry_multi_mood.py

@@ -0,0 +1,51 @@
+"""allow journal entries to have multiple moods, and expand the mood vocabulary
+
+Revision ID: 0011_journal_entry_multi_mood
+Revises: 0010_add_journal_tables
+Create Date: 2026-08-04
+
+기분을 하나만 고를 수 있던 journal_entry.mood(단일 컬럼)를, 태그처럼 여러 개를 붙일 수 있는
+journal_entry_mood 연결 테이블로 바꾼다. mood 자체가 고정된 값 집합(enum)이라 journal_tag처럼
+별도 이름 엔티티를 둘 필요 없이 값 자체를 PK로 쓴다. 동시에 기존 5종(만족도 스케일)에
+구체적인 감정 9종을 추가한다.
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "0011_journal_entry_multi_mood"
+down_revision: Union[str, None] = "0010_add_journal_tables"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+MOOD_VALUES = (
+    "great", "good", "neutral", "bad", "awful",
+    "pain", "achievement", "anger", "excited", "calm", "happy", "worry", "tired", "sad",
+)
+
+
+def upgrade() -> None:
+    op.drop_constraint("ck_journal_entry_mood", "journal_entry", type_="check")
+    op.drop_column("journal_entry", "mood")
+
+    op.create_table(
+        "journal_entry_mood",
+        sa.Column(
+            "entry_id", sa.Integer(), sa.ForeignKey("journal_entry.id", ondelete="CASCADE"), primary_key=True
+        ),
+        sa.Column("mood", sa.String(length=20), primary_key=True),
+        sa.CheckConstraint(
+            "mood in (" + ",".join(f"'{v}'" for v in MOOD_VALUES) + ")", name="ck_journal_entry_mood_mood"
+        ),
+        mysql_engine="InnoDB",
+        mysql_charset="utf8mb4",
+    )
+
+
+def downgrade() -> None:
+    op.drop_table("journal_entry_mood")
+    op.add_column("journal_entry", sa.Column("mood", sa.String(length=20), nullable=True))
+    op.create_check_constraint(
+        "ck_journal_entry_mood", "journal_entry", "mood in ('great','good','neutral','bad','awful')"
+    )

migrations/versions/0012_remove_satisfaction_moods.py

@@ -0,0 +1,45 @@
+"""remove the 5 satisfaction-scale moods, keep only the 9 named emotions
+
+Revision ID: 0012_remove_satisfaction_moods
+Revises: 0011_journal_entry_multi_mood
+Create Date: 2026-08-04
+
+기분 선택을 다중 선택으로 바꾼 뒤(0011) 만족도 스케일 5종(최고/좋음/보통/별로/힘듦)과 구체적 감정 9종을
+같이 뒀는데, 다중 선택에서는 "행복"과 "좋음"처럼 겹치는 느낌을 주는 항목이 섞여 있으면 혼란스러워서
+만족도 스케일 5종을 아예 없애고 구체적 감정 9종만 남긴다. 혹시 그 사이 저장된 행이 있으면(이 저장소
+개발 환경에서는 없었음) 지워야 새 CHECK 제약을 걸 수 있다.
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "0012_remove_satisfaction_moods"
+down_revision: Union[str, None] = "0011_journal_entry_multi_mood"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+REMOVED_MOODS = ("great", "good", "neutral", "bad", "awful")
+REMAINING_MOODS = ("pain", "achievement", "anger", "excited", "calm", "happy", "worry", "tired", "sad")
+
+
+def upgrade() -> None:
+    journal_entry_mood = sa.table("journal_entry_mood", sa.column("mood", sa.String))
+    op.execute(journal_entry_mood.delete().where(journal_entry_mood.c.mood.in_(REMOVED_MOODS)))
+
+    op.drop_constraint("ck_journal_entry_mood_mood", "journal_entry_mood", type_="check")
+    op.create_check_constraint(
+        "ck_journal_entry_mood_mood",
+        "journal_entry_mood",
+        "mood in (" + ",".join(f"'{v}'" for v in REMAINING_MOODS) + ")",
+    )
+
+
+def downgrade() -> None:
+    op.drop_constraint("ck_journal_entry_mood_mood", "journal_entry_mood", type_="check")
+    op.create_check_constraint(
+        "ck_journal_entry_mood_mood",
+        "journal_entry_mood",
+        "mood in (" + ",".join(f"'{v}'" for v in REMAINING_MOODS + REMOVED_MOODS) + ")",
+    )
+    # 삭제된 행 자체는 복구하지 않는다(내용을 알 수 없음) — 제약만 원상복구.

migrations/versions/0013_journal_category_template.py

@@ -0,0 +1,58 @@
+"""add content_template to journal_category, seed the default 일상 category's template
+
+Revision ID: 0013_journal_category_template
+Revises: 0012_remove_satisfaction_moods
+Create Date: 2026-08-04
+
+카테고리별로 "새 기록 쓰기" 폼의 내용칸을 미리 채워주는 틀(예: Story/Feelings/Decisions/
+Insights/Actions 회고 양식)을 지정할 수 있게 한다. 이미 존재하는 "일상" 카테고리에는 이 틀을
+바로 채워 넣는다(새로 자동 생성되는 "일상"은 ensure_default_category가 채운다).
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "0013_journal_category_template"
+down_revision: Union[str, None] = "0012_remove_satisfaction_moods"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+DAILY_TEMPLATE = """**1. Story : 오늘 무슨 일이 있었나요?**
+
+-
+
+**2. Feelings : 오늘 들었던 생각과 나의 감정은?**
+
+-
+
+**3. Decisions : 오늘 내가 내린 결정이 있나요?**
+
+-
+
+**4. Insights : 나에 대해 새롭게 알게된 사실이 있나요?**
+
+-
+
+→ 나에 대한 인사이트는 메타인지를 키워주는 **소중한 기록**입니다. 꼭 보관하세요.
+
+**5. Actions : 내가 다음에 할 행동은 무엇인가요?**
+
+- """
+
+
+def upgrade() -> None:
+    op.add_column("journal_category", sa.Column("content_template", sa.Text(), nullable=True))
+
+    journal_category = sa.table(
+        "journal_category", sa.column("name", sa.String), sa.column("content_template", sa.Text)
+    )
+    op.execute(
+        journal_category.update()
+        .where(journal_category.c.name == "일상")
+        .values(content_template=DAILY_TEMPLATE)
+    )
+
+
+def downgrade() -> None:
+    op.drop_column("journal_category", "content_template")

pyproject.toml

@@ -19,12 +19,13 @@ dependencies = [
     "py-vapid>=1.9",
     "authlib>=1.3",
     "httpx>=0.27",
+    "pillow>=10.0",  # scripts/generate_icons.py 아이콘 재생성 + 저널 첨부 이미지 썸네일 생성(런타임)
 ]
 
 [project.optional-dependencies]
 dev = [
     "pytest>=8.0",
-    "pillow>=10.0",  # scripts/generate_icons.py 아이콘 재생성용 (런타임 미사용)
+    "paramiko>=3.4",  # scripts/deploy_sftp.py SFTP 배포용 (런타임 미사용)
 ]
 
 [tool.setuptools.packages.find]

scripts/deploy_sftp.py

@@ -0,0 +1,122 @@
+"""SFTP로 시놀로지 NAS에 소스를 동기화하는 배포 스크립트.
+
+deploy.env(git 미포함, deploy.env.example 참고)의 접속 정보를 읽어, Dockerfile이 COPY하는
+파일/디렉터리(pyproject.toml, alembic.ini, app/, migrations/, scripts/)와 Dockerfile,
+docker-compose.yml을 원격 경로로 동기화한다. 로컬 mtime이 원격보다 최신인 파일만 올리고,
+원격에만 있는 파일은 건드리지 않는다(단방향 추가/갱신, 삭제 없음). .env는 절대 동기화하지 않는다
+(원격 프로덕션 .env를 덮어쓰면 안 되므로).
+
+컨테이너 재시작/재빌드는 이 스크립트가 하지 않는다 — 파일을 올린 뒤 직접 재시작할 것.
+
+사용법: python scripts/deploy_sftp.py [--dry-run]
+"""
+
+import sys
+from pathlib import Path
+
+import paramiko
+
+sys.stdout.reconfigure(encoding="utf-8")
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+DEPLOY_ENV_PATH = PROJECT_ROOT / "deploy.env"
+
+# Dockerfile이 COPY하는 것과 동일한 목록 + 컨테이너 정의 파일
+SYNC_TARGETS = ["pyproject.toml", "alembic.ini", "Dockerfile", "docker-compose.yml", "app", "migrations", "scripts"]
+SKIP_NAMES = {"__pycache__"}
+SKIP_SUFFIXES = {".pyc"}
+
+
+def load_deploy_env(path: Path) -> dict[str, str]:
+    if not path.exists():
+        print(f"{path}가 없습니다. deploy.env.example을 복사해 값을 채워주세요.")
+        sys.exit(1)
+    values = {}
+    for line in path.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, _, value = line.partition("=")
+        values[key.strip()] = value.strip()
+    return values
+
+
+def iter_local_files(target: Path):
+    if target.is_file():
+        yield target
+        return
+    for path in target.rglob("*"):
+        if path.is_dir():
+            continue
+        if any(part in SKIP_NAMES for part in path.parts):
+            continue
+        if path.suffix in SKIP_SUFFIXES:
+            continue
+        yield path
+
+
+def ensure_remote_dir(sftp: paramiko.SFTPClient, remote_dir: str) -> None:
+    parts = remote_dir.strip("/").split("/")
+    current = ""
+    for part in parts:
+        current += "/" + part
+        try:
+            sftp.stat(current)
+        except FileNotFoundError:
+            sftp.mkdir(current)
+
+
+def remote_mtime(sftp: paramiko.SFTPClient, remote_path: str) -> float | None:
+    try:
+        return sftp.stat(remote_path).st_mtime
+    except FileNotFoundError:
+        return None
+
+
+def main() -> None:
+    dry_run = "--dry-run" in sys.argv
+    env = load_deploy_env(DEPLOY_ENV_PATH)
+
+    host = env["SFTP_HOST"]
+    port = int(env.get("SFTP_PORT", "22"))
+    username = env["SFTP_USERNAME"]
+    password = env["SFTP_PASSWORD"]
+    remote_root = env["SFTP_REMOTE_PATH"].rstrip("/")
+
+    print(f"{host}:{port} ({username}) -> {remote_root} 로 동기화{'(dry-run)' if dry_run else ''}")
+
+    transport = paramiko.Transport((host, port))
+    transport.connect(username=username, password=password)
+    sftp = paramiko.SFTPClient.from_transport(transport)
+    assert sftp is not None
+
+    uploaded, skipped = 0, 0
+    try:
+        for target_name in SYNC_TARGETS:
+            local_target = PROJECT_ROOT / target_name
+            if not local_target.exists():
+                continue
+            for local_file in iter_local_files(local_target):
+                rel_path = local_file.relative_to(PROJECT_ROOT).as_posix()
+                remote_path = f"{remote_root}/{rel_path}"
+                local_mtime = local_file.stat().st_mtime
+                existing_mtime = remote_mtime(sftp, remote_path)
+
+                if existing_mtime is not None and existing_mtime >= local_mtime:
+                    skipped += 1
+                    continue
+
+                print(f"  업로드: {rel_path}")
+                if not dry_run:
+                    ensure_remote_dir(sftp, str(Path(remote_path).parent.as_posix()))
+                    sftp.put(str(local_file), remote_path)
+                uploaded += 1
+    finally:
+        sftp.close()
+        transport.close()
+
+    print(f"완료: {uploaded}개 업로드, {skipped}개 변경 없음. 컨테이너 재시작/재빌드는 직접 해주세요.")
+
+
+if __name__ == "__main__":
+    main()

scripts/run_server.ps1

@@ -1,4 +1,4 @@
-# 습관 트래커 서버를 상시 실행하기 위한 스크립트.
+# 해빗랩 서버를 상시 실행하기 위한 스크립트.
 # Windows 작업 스케줄러 등록 시 이 스크립트를 대상으로 지정한다 (--reload 없이, conda activate 없이
 # 대상 conda 환경의 python.exe를 직접 호출해 셸 활성화 없는 예약 작업에서도 안정적으로 동작하게 한다).
 

tests/test_api_journal.py

@@ -0,0 +1,83 @@
+from datetime import date
+from io import BytesIO
+
+from PIL import Image
+from starlette.datastructures import Headers, UploadFile
+
+from app.schemas.journal import JournalCategoryCreate, JournalEntryCreate
+from app.services import journal_service
+
+
+def _make_entry_with_attachment(db_session, user_id, tmp_path, monkeypatch):
+    monkeypatch.setattr(journal_service.settings, "journal_media_root", str(tmp_path))
+    category = journal_service.create_category(db_session, user_id, JournalCategoryCreate(name="일상"))
+    entry = journal_service.create_entry(
+        db_session,
+        user_id,
+        JournalEntryCreate(category_id=category.id, entry_date=date.today(), content="기록"),
+    )
+    buf = BytesIO()
+    Image.new("RGB", (800, 600), "blue").save(buf, format="PNG")
+    upload = UploadFile(file=BytesIO(buf.getvalue()), filename="photo.png", headers=Headers({"content-type": "image/png"}))
+    attachment = journal_service.save_attachment(db_session, entry, upload)
+    return attachment
+
+
+def test_get_media_requires_login(client):
+    response = client.get("/api/journal/media/1")
+    assert response.status_code == 401
+
+
+def test_get_media_returns_file_for_owner(auth_client, db_session, test_user, tmp_path, monkeypatch):
+    attachment = _make_entry_with_attachment(db_session, test_user.id, tmp_path, monkeypatch)
+
+    response = auth_client.get(f"/api/journal/media/{attachment.id}")
+    assert response.status_code == 200
+    assert response.content[:8] == b"\x89PNG\r\n\x1a\n"
+
+
+def test_get_media_thumbnail_variant(auth_client, db_session, test_user, tmp_path, monkeypatch):
+    attachment = _make_entry_with_attachment(db_session, test_user.id, tmp_path, monkeypatch)
+
+    response = auth_client.get(f"/api/journal/media/{attachment.id}?thumbnail=true")
+    assert response.status_code == 200
+
+
+def test_get_media_returns_404_for_missing_attachment(auth_client):
+    response = auth_client.get("/api/journal/media/9999")
+    assert response.status_code == 404
+
+
+def test_get_media_returns_404_for_other_users_attachment(auth_client, db_session, other_user, tmp_path, monkeypatch):
+    attachment = _make_entry_with_attachment(db_session, other_user.id, tmp_path, monkeypatch)
+
+    response = auth_client.get(f"/api/journal/media/{attachment.id}")
+    assert response.status_code == 404
+
+
+def test_reorder_categories_requires_login(client):
+    response = client.post("/api/journal/categories/reorder", json={"category_ids": [1, 2]})
+    assert response.status_code == 401
+
+
+def test_reorder_categories_updates_sort_order(auth_client, db_session, test_user):
+    a = journal_service.create_category(db_session, test_user.id, JournalCategoryCreate(name="A"))
+    b = journal_service.create_category(db_session, test_user.id, JournalCategoryCreate(name="B"))
+
+    response = auth_client.post("/api/journal/categories/reorder", json={"category_ids": [b.id, a.id]})
+    assert response.status_code == 200
+
+    db_session.refresh(a)
+    db_session.refresh(b)
+    assert b.sort_order == 0
+    assert a.sort_order == 1
+
+
+def test_reorder_categories_ignores_other_users_ids(auth_client, db_session, other_user):
+    other_category = journal_service.create_category(db_session, other_user.id, JournalCategoryCreate(name="남의 것"))
+
+    response = auth_client.post("/api/journal/categories/reorder", json={"category_ids": [other_category.id]})
+    assert response.status_code == 200
+
+    db_session.refresh(other_category)
+    assert other_category.sort_order is None

tests/test_journal_service.py

@@ -0,0 +1,298 @@
+from datetime import date, timedelta
+from io import BytesIO
+from pathlib import Path
+
+from PIL import Image
+from starlette.datastructures import Headers, UploadFile
+
+from app.schemas.journal import JournalCategoryCreate, JournalEntryCreate, JournalEntryUpdate
+from app.services import journal_service
+
+
+def _make_category(db_session, user_id, name="일상", color=None):
+    return journal_service.create_category(db_session, user_id, JournalCategoryCreate(name=name, color=color))
+
+
+def _make_entry(db_session, user_id, category_id, entry_date=None, content="오늘의 기록", tags=None, **overrides):
+    data = JournalEntryCreate(
+        category_id=category_id,
+        entry_date=entry_date or date.today(),
+        title=overrides.pop("title", None),
+        content=content,
+        moods=overrides.pop("moods", []),
+        tags=tags or [],
+    )
+    return journal_service.create_entry(db_session, user_id, data)
+
+
+def _png_bytes(size=(800, 600)) -> bytes:
+    buf = BytesIO()
+    Image.new("RGB", size, "red").save(buf, format="PNG")
+    return buf.getvalue()
+
+
+def _upload(filename: str, content_type: str, data: bytes) -> UploadFile:
+    return UploadFile(file=BytesIO(data), filename=filename, headers=Headers({"content-type": content_type}))
+
+
+# ---- 카테고리 ----
+
+
+def test_ensure_default_category_creates_once(db_session, test_user):
+    first = journal_service.ensure_default_category(db_session, test_user.id)
+    assert first.name == journal_service.DEFAULT_CATEGORY_NAME
+    assert first.content_template == journal_service.DEFAULT_CATEGORY_TEMPLATE.strip()
+
+    second = journal_service.ensure_default_category(db_session, test_user.id)
+    assert second.id == first.id
+    assert len(journal_service.list_categories(db_session, test_user.id)) == 1
+
+
+def test_category_content_template_persists_and_updates(db_session, test_user):
+    category = journal_service.create_category(
+        db_session, test_user.id, JournalCategoryCreate(name="회고", content_template="질문 1\n\n질문 2")
+    )
+    assert category.content_template == "질문 1\n\n질문 2"
+
+    updated = journal_service.update_category(
+        db_session, category, JournalCategoryCreate(name="회고", content_template="  ")
+    )
+    assert updated.content_template is None
+
+
+def test_list_categories_scoped_to_user(db_session, test_user, other_user):
+    _make_category(db_session, test_user.id, name="일상")
+    _make_category(db_session, other_user.id, name="남의 카테고리")
+
+    mine = journal_service.list_categories(db_session, test_user.id)
+    assert [c.name for c in mine] == ["일상"]
+
+
+def test_reorder_categories_ignores_foreign_and_unknown_ids(db_session, test_user, other_user):
+    a = _make_category(db_session, test_user.id, name="A")
+    b = _make_category(db_session, test_user.id, name="B")
+    other = _make_category(db_session, other_user.id, name="남의 것")
+
+    journal_service.reorder_categories(db_session, test_user.id, [b.id, a.id, other.id, 9999])
+
+    db_session.refresh(a)
+    db_session.refresh(b)
+    db_session.refresh(other)
+    assert b.sort_order == 0
+    assert a.sort_order == 1
+    assert other.sort_order is None
+
+
+def test_count_entries_by_category(db_session, test_user, other_user):
+    a = _make_category(db_session, test_user.id, name="A")
+    b = _make_category(db_session, test_user.id, name="B")
+    other_category = _make_category(db_session, other_user.id, name="남의 카테고리")
+    _make_entry(db_session, test_user.id, a.id, content="1")
+    _make_entry(db_session, test_user.id, a.id, content="2")
+    _make_entry(db_session, test_user.id, b.id, content="3")
+    _make_entry(db_session, other_user.id, other_category.id, content="다른 유저 기록")
+
+    counts = journal_service.count_entries_by_category(db_session, test_user.id)
+    assert counts == {a.id: 2, b.id: 1}
+
+
+def test_delete_category_cascades_entries_and_attachment_files(db_session, test_user, tmp_path, monkeypatch):
+    monkeypatch.setattr(journal_service.settings, "journal_media_root", str(tmp_path))
+    category = _make_category(db_session, test_user.id, name="지울 카테고리")
+    entry = _make_entry(db_session, test_user.id, category.id)
+    attachment = journal_service.save_attachment(
+        db_session, entry, _upload("photo.png", "image/png", _png_bytes())
+    )
+    file_path = attachment.file_path
+
+    journal_service.delete_category(db_session, category)
+
+    assert journal_service.get_entry(db_session, entry.id, test_user.id) is None
+    assert not Path(file_path).exists()
+
+
+# ---- 태그 ----
+
+
+def test_get_or_create_tags_reuses_existing_by_name(db_session, test_user):
+    first = journal_service.get_or_create_tags(db_session, test_user.id, ["투자", "재테크"])
+    second = journal_service.get_or_create_tags(db_session, test_user.id, ["투자", "새태그"])
+
+    assert {t.name for t in first} == {"투자", "재테크"}
+    investment_id = next(t.id for t in first if t.name == "투자")
+    assert next(t.id for t in second if t.name == "투자") == investment_id
+    assert {t.name for t in second} == {"투자", "새태그"}
+
+
+# ---- 엔트리 ----
+
+
+def test_multiple_entries_per_day_same_category_allowed(db_session, test_user):
+    category = _make_category(db_session, test_user.id)
+    today = date.today()
+    morning = _make_entry(db_session, test_user.id, category.id, entry_date=today, content="아침 기록")
+    evening = _make_entry(db_session, test_user.id, category.id, entry_date=today, content="저녁 기록")
+
+    entries = journal_service.list_entries(db_session, test_user.id, category_id=category.id)
+    assert {e.id for e in entries} == {morning.id, evening.id}
+
+
+def test_get_entry_returns_none_for_other_users_entry(db_session, test_user, other_user):
+    category = _make_category(db_session, other_user.id)
+    other_entry = _make_entry(db_session, other_user.id, category.id)
+
+    assert journal_service.get_entry(db_session, other_entry.id, test_user.id) is None
+    assert journal_service.get_entry(db_session, other_entry.id, other_user.id) is not None
+
+
+def test_create_entry_attaches_tags(db_session, test_user):
+    category = _make_category(db_session, test_user.id)
+    entry = _make_entry(db_session, test_user.id, category.id, tags=["투자", "회고"])
+    assert {t.name for t in entry.tags} == {"투자", "회고"}
+
+
+def test_update_entry_replaces_tags(db_session, test_user):
+    category = _make_category(db_session, test_user.id)
+    entry = _make_entry(db_session, test_user.id, category.id, tags=["투자"])
+
+    updated = journal_service.update_entry(
+        db_session,
+        entry,
+        JournalEntryUpdate(category_id=category.id, entry_date=entry.entry_date, content="수정된 내용", tags=["새태그"]),
+    )
+    assert {t.name for t in updated.tags} == {"새태그"}
+    assert updated.content == "수정된 내용"
+
+
+def test_create_entry_supports_multiple_moods(db_session, test_user):
+    category = _make_category(db_session, test_user.id)
+    entry = _make_entry(db_session, test_user.id, category.id, moods=["happy", "tired"])
+    assert {m.mood.value for m in entry.moods} == {"happy", "tired"}
+
+
+def test_update_entry_replaces_moods(db_session, test_user):
+    category = _make_category(db_session, test_user.id)
+    entry = _make_entry(db_session, test_user.id, category.id, moods=["sad"])
+
+    updated = journal_service.update_entry(
+        db_session,
+        entry,
+        JournalEntryUpdate(
+            category_id=category.id, entry_date=entry.entry_date, content="내용", moods=["happy", "calm"]
+        ),
+    )
+    assert {m.mood.value for m in updated.moods} == {"happy", "calm"}
+
+
+def test_delete_entry_removes_attachment_files(db_session, test_user, tmp_path, monkeypatch):
+    monkeypatch.setattr(journal_service.settings, "journal_media_root", str(tmp_path))
+    category = _make_category(db_session, test_user.id)
+    entry = _make_entry(db_session, test_user.id, category.id)
+    attachment = journal_service.save_attachment(
+        db_session, entry, _upload("photo.png", "image/png", _png_bytes())
+    )
+    file_path = Path(attachment.file_path)
+    thumb_path = Path(attachment.thumbnail_path)
+    assert file_path.exists()
+    assert thumb_path.exists()
+
+    journal_service.delete_entry(db_session, entry)
+
+    assert not file_path.exists()
+    assert not thumb_path.exists()
+
+
+# ---- 첨부파일 ----
+
+
+def test_save_attachment_generates_thumbnail_for_image(db_session, test_user, tmp_path, monkeypatch):
+    monkeypatch.setattr(journal_service.settings, "journal_media_root", str(tmp_path))
+    category = _make_category(db_session, test_user.id)
+    entry = _make_entry(db_session, test_user.id, category.id)
+
+    attachment = journal_service.save_attachment(
+        db_session, entry, _upload("photo.png", "image/png", _png_bytes())
+    )
+
+    assert attachment.thumbnail_path is not None
+    with Image.open(attachment.thumbnail_path) as thumb:
+        assert thumb.width <= journal_service.THUMBNAIL_WIDTH
+    assert Path(attachment.file_path).exists()
+
+
+def test_save_attachment_rejects_unsupported_type(db_session, test_user, tmp_path, monkeypatch):
+    monkeypatch.setattr(journal_service.settings, "journal_media_root", str(tmp_path))
+    category = _make_category(db_session, test_user.id)
+    entry = _make_entry(db_session, test_user.id, category.id)
+
+    try:
+        journal_service.save_attachment(db_session, entry, _upload("doc.pdf", "application/pdf", b"%PDF-1.4"))
+        assert False, "should have raised"
+    except ValueError as exc:
+        assert "지원하지 않는" in str(exc)
+
+
+def test_save_attachment_rejects_oversized_file(db_session, test_user, tmp_path, monkeypatch):
+    monkeypatch.setattr(journal_service.settings, "journal_media_root", str(tmp_path))
+    monkeypatch.setattr(journal_service.settings, "journal_max_upload_mb", 0)
+    category = _make_category(db_session, test_user.id)
+    entry = _make_entry(db_session, test_user.id, category.id)
+
+    try:
+        journal_service.save_attachment(db_session, entry, _upload("photo.png", "image/png", _png_bytes()))
+        assert False, "should have raised"
+    except ValueError as exc:
+        assert "용량" in str(exc)
+
+
+def test_get_attachment_scoped_to_owner(db_session, test_user, other_user, tmp_path, monkeypatch):
+    monkeypatch.setattr(journal_service.settings, "journal_media_root", str(tmp_path))
+    category = _make_category(db_session, other_user.id)
+    entry = _make_entry(db_session, other_user.id, category.id)
+    attachment = journal_service.save_attachment(
+        db_session, entry, _upload("photo.png", "image/png", _png_bytes())
+    )
+
+    assert journal_service.get_attachment(db_session, attachment.id, test_user.id) is None
+    assert journal_service.get_attachment(db_session, attachment.id, other_user.id) is not None
+
+
+# ---- 캘린더 / day-detail / 회상 ----
+
+
+def test_get_monthly_journal_summary_counts_entries_per_day(db_session, test_user):
+    category = _make_category(db_session, test_user.id, color="#ff0000")
+    today = date.today()
+    _make_entry(db_session, test_user.id, category.id, entry_date=today, content="1")
+    _make_entry(db_session, test_user.id, category.id, entry_date=today, content="2")
+
+    summary = journal_service.get_monthly_journal_summary(db_session, test_user.id, today.year, today.month)
+    assert summary[today].total_count == 2
+    assert summary[today].category_colors == ["#ff0000"]
+
+
+def test_get_day_entries_returns_entries_for_that_date(db_session, test_user):
+    category = _make_category(db_session, test_user.id)
+    today = date.today()
+    yesterday = today - timedelta(days=1)
+    _make_entry(db_session, test_user.id, category.id, entry_date=today, content="오늘 거")
+    _make_entry(db_session, test_user.id, category.id, entry_date=yesterday, content="어제 거")
+
+    items = journal_service.get_day_entries(db_session, test_user.id, today)
+    assert [i.content for i in items] == ["오늘 거"]
+
+
+def test_get_on_this_day_matches_month_day_different_year(db_session, test_user):
+    category = _make_category(db_session, test_user.id)
+    today = date.today()
+    last_year = today.replace(year=today.year - 1)
+    _make_entry(db_session, test_user.id, category.id, entry_date=last_year, content="작년 오늘")
+    _make_entry(db_session, test_user.id, category.id, entry_date=today, content="올해 오늘")
+
+    items = journal_service.get_on_this_day(db_session, test_user.id, today)
+    assert [i.content for i in items] == ["작년 오늘"]
+    assert items[0].years_ago == 1
+
+
+def test_get_random_prompt_returns_none_when_empty(db_session):
+    assert journal_service.get_random_prompt(db_session) is None

tests/test_pages_journal.py

@@ -0,0 +1,282 @@
+from datetime import date
+from io import BytesIO
+
+from PIL import Image
+from starlette.datastructures import Headers, UploadFile
+
+from app.schemas.journal import JournalCategoryCreate, JournalEntryCreate
+from app.services import journal_service
+
+
+def _make_category(db_session, user_id, name="일상", content_template=None):
+    return journal_service.create_category(
+        db_session, user_id, JournalCategoryCreate(name=name, content_template=content_template)
+    )
+
+
+def _make_entry(db_session, user_id, category_id, entry_date=None, content="기록"):
+    data = JournalEntryCreate(category_id=category_id, entry_date=entry_date or date.today(), content=content)
+    return journal_service.create_entry(db_session, user_id, data)
+
+
+def _png_file():
+    buf = BytesIO()
+    Image.new("RGB", (400, 300), "green").save(buf, format="PNG")
+    buf.seek(0)
+    return buf
+
+
+def test_journal_page_requires_login(client):
+    response = client.get("/journal", follow_redirects=False)
+    assert response.status_code == 303
+    assert response.headers["location"] == "/login"
+
+
+def test_journal_page_creates_default_category_and_renders(auth_client):
+    response = auth_client.get("/journal")
+    assert response.status_code == 200
+    assert journal_service.DEFAULT_CATEGORY_NAME in response.text
+
+
+def test_journal_page_embeds_category_content_template(auth_client):
+    response = auth_client.get("/journal")
+    assert response.status_code == 200
+    assert "Story" in response.text
+    assert "메타인지" in response.text
+
+
+def test_journal_page_template_with_double_quotes_does_not_break_x_data_attribute(
+    auth_client, db_session, test_user
+):
+    baseline_form_count = auth_client.get("/journal").text.count("<form")
+
+    _make_category(db_session, test_user.id, name="따옴표카테고리", content_template='내용에 "큰따옴표"가 있어요')
+
+    response = auth_client.get("/journal")
+    assert response.status_code == 200
+    # x-data="..." 속성 안에 이스케이프 안 된 "가 섞이면 속성이 거기서 끊겨 뒤 마크업이 전부
+    # 속성값으로 흡수되는데, 그러면 폼의 <form 태그들이 열린 속성값 텍스트에 파묻혀 개수가
+    # 줄어든다 — 카테고리 하나 늘었다고 <form 개수가 그대로인지로 attribute-injection 여부를 검증한다.
+    assert response.text.count("<form") == baseline_form_count
+    assert "\\&#34;큰따옴표\\&#34;" in response.text
+
+
+def test_create_entry_via_multipart_form(auth_client, db_session, test_user, tmp_path, monkeypatch):
+    monkeypatch.setattr(journal_service.settings, "journal_media_root", str(tmp_path))
+    category = _make_category(db_session, test_user.id, name="투자")
+    today = date.today()
+
+    response = auth_client.post(
+        "/journal/new",
+        data={
+            "category_id": str(category.id),
+            "entry_date": today.isoformat(),
+            "title": "첫 기록",
+            "content": "오늘의 투자 회고",
+            "moods": "happy,tired",
+            "tags": "투자, 회고",
+        },
+        files={"files": ("photo.png", _png_file(), "image/png")},
+        follow_redirects=False,
+    )
+    assert response.status_code == 200
+    assert response.headers["hx-redirect"] == f"/journal?year={today.year}&month={today.month}"
+
+    entries = journal_service.list_entries(db_session, test_user.id)
+    assert len(entries) == 1
+    assert entries[0].title == "첫 기록"
+    assert {t.name for t in entries[0].tags} == {"투자", "회고"}
+    assert {m.mood.value for m in entries[0].moods} == {"happy", "tired"}
+    assert len(entries[0].attachments) == 1
+
+
+def test_create_entry_rejects_blank_content(auth_client, db_session, test_user):
+    category = _make_category(db_session, test_user.id)
+    response = auth_client.post(
+        "/journal/new",
+        data={"category_id": str(category.id), "entry_date": date.today().isoformat(), "content": "   "},
+    )
+    assert response.status_code == 200
+    assert "내용을 입력해주세요" in response.text
+    assert journal_service.list_entries(db_session, test_user.id) == []
+
+
+def test_journal_day_detail_shows_entry(auth_client, db_session, test_user):
+    category = _make_category(db_session, test_user.id)
+    today = date.today()
+    _make_entry(db_session, test_user.id, category.id, entry_date=today, content="오늘의 기록")
+
+    response = auth_client.get(f"/journal/day/{today.isoformat()}")
+    assert response.status_code == 200
+    assert "오늘의 기록" in response.text
+
+
+def test_journal_day_detail_requires_login(client):
+    response = client.get(f"/journal/day/{date.today().isoformat()}", follow_redirects=False)
+    assert response.status_code == 303
+    assert response.headers["location"] == "/login"
+
+
+def test_edit_entry_updates_content(auth_client, db_session, test_user):
+    category = _make_category(db_session, test_user.id)
+    entry = _make_entry(db_session, test_user.id, category.id, content="원래 내용")
+
+    response = auth_client.post(
+        f"/journal/{entry.id}/edit",
+        data={
+            "category_id": str(category.id),
+            "entry_date": entry.entry_date.isoformat(),
+            "content": "수정된 내용",
+            "tags": "",
+        },
+    )
+    assert response.status_code == 200
+    assert "수정된 내용" in response.text
+
+    db_session.refresh(entry)
+    assert entry.content == "수정된 내용"
+
+
+def test_edit_entry_blank_content_keeps_form_open_with_error(auth_client, db_session, test_user):
+    category = _make_category(db_session, test_user.id)
+    entry = _make_entry(db_session, test_user.id, category.id, content="원래 내용")
+
+    response = auth_client.post(
+        f"/journal/{entry.id}/edit",
+        data={"category_id": str(category.id), "entry_date": entry.entry_date.isoformat(), "content": "  "},
+    )
+    assert response.status_code == 200
+    assert "내용을 입력해주세요" in response.text
+
+    db_session.refresh(entry)
+    assert entry.content == "원래 내용"
+
+
+def test_edit_other_users_entry_returns_404(auth_client, db_session, other_user):
+    category = _make_category(db_session, other_user.id)
+    entry = _make_entry(db_session, other_user.id, category.id)
+
+    response = auth_client.post(
+        f"/journal/{entry.id}/edit",
+        data={"category_id": str(category.id), "entry_date": entry.entry_date.isoformat(), "content": "해킹 시도"},
+    )
+    assert response.status_code == 404
+
+
+def test_delete_entry_removes_it(auth_client, db_session, test_user):
+    category = _make_category(db_session, test_user.id)
+    entry = _make_entry(db_session, test_user.id, category.id, content="지울 기록")
+
+    response = auth_client.post(f"/journal/{entry.id}/delete")
+    assert response.status_code == 200
+    assert "지울 기록" not in response.text
+    assert journal_service.get_entry(db_session, entry.id, test_user.id) is None
+
+
+def test_delete_other_users_entry_returns_404(auth_client, db_session, other_user):
+    category = _make_category(db_session, other_user.id)
+    entry = _make_entry(db_session, other_user.id, category.id)
+
+    response = auth_client.post(f"/journal/{entry.id}/delete")
+    assert response.status_code == 404
+    assert journal_service.get_entry(db_session, entry.id, other_user.id) is not None
+
+
+def test_delete_attachment_removes_it(auth_client, db_session, test_user, tmp_path, monkeypatch):
+    monkeypatch.setattr(journal_service.settings, "journal_media_root", str(tmp_path))
+    category = _make_category(db_session, test_user.id)
+    entry = _make_entry(db_session, test_user.id, category.id)
+    upload = UploadFile(file=_png_file(), filename="a.png", headers=Headers({"content-type": "image/png"}))
+    attachment = journal_service.save_attachment(db_session, entry, upload)
+
+    response = auth_client.post(f"/journal/{entry.id}/attachments/{attachment.id}/delete")
+    assert response.status_code == 200
+    assert journal_service.get_attachment(db_session, attachment.id, test_user.id) is None
+
+
+def test_create_category_and_reject_duplicate(auth_client):
+    response = auth_client.post("/journal/categories/new", data={"name": "투자"}, follow_redirects=False)
+    assert response.status_code == 200
+    assert response.headers["hx-redirect"] == "/journal?tab=manage"
+
+    dup_response = auth_client.post("/journal/categories/new", data={"name": "투자"})
+    assert dup_response.status_code == 200
+    assert "이미 같은 이름" in dup_response.text
+
+
+def test_journal_page_manage_tab_shows_delete_button_for_categories(auth_client, db_session, test_user):
+    _make_category(db_session, test_user.id, name="투자")
+
+    response = auth_client.get("/journal?tab=manage")
+    assert response.status_code == 200
+    assert "/journal/categories/" in response.text
+    assert "/delete" in response.text
+
+
+def test_journal_page_default_tab_hides_category_management(auth_client, db_session, test_user):
+    _make_category(db_session, test_user.id, name="투자")
+
+    response = auth_client.get("/journal")
+    assert response.status_code == 200
+    assert "/journal/categories/" not in response.text
+
+
+def test_delete_category_removes_it_and_its_entries(auth_client, db_session, test_user):
+    category = _make_category(db_session, test_user.id, name="지울 카테고리")
+    entry = _make_entry(db_session, test_user.id, category.id, content="딸려서 지워질 기록")
+
+    response = auth_client.post(f"/journal/categories/{category.id}/delete", follow_redirects=False)
+    assert response.status_code == 200
+    assert response.headers["hx-redirect"] == "/journal?tab=manage"
+
+    assert journal_service.get_category(db_session, category.id, test_user.id) is None
+    assert journal_service.get_entry(db_session, entry.id, test_user.id) is None
+
+
+def test_delete_other_users_category_returns_404(auth_client, db_session, other_user):
+    category = _make_category(db_session, other_user.id, name="남의 카테고리")
+
+    response = auth_client.post(f"/journal/categories/{category.id}/delete")
+    assert response.status_code == 404
+    assert journal_service.get_category(db_session, category.id, other_user.id) is not None
+
+
+def test_edit_category_updates_name_and_color(auth_client, db_session, test_user):
+    category = _make_category(db_session, test_user.id, name="원래 이름")
+
+    response = auth_client.post(
+        f"/journal/categories/{category.id}/edit",
+        data={"name": "바뀐 이름", "color": "#123456"},
+        follow_redirects=False,
+    )
+    assert response.status_code == 200
+    assert response.headers["hx-redirect"] == "/journal?tab=manage"
+
+    db_session.refresh(category)
+    assert category.name == "바뀐 이름"
+    assert category.color == "#123456"
+
+
+def test_edit_category_rejects_duplicate_name(auth_client, db_session, test_user):
+    _make_category(db_session, test_user.id, name="투자")
+    category = _make_category(db_session, test_user.id, name="일기")
+
+    response = auth_client.post(f"/journal/categories/{category.id}/edit", data={"name": "투자"})
+    assert response.status_code == 200
+    assert "이미 같은 이름" in response.text
+
+
+def test_edit_other_users_category_returns_404(auth_client, db_session, other_user):
+    category = _make_category(db_session, other_user.id, name="남의 카테고리")
+
+    response = auth_client.post(f"/journal/categories/{category.id}/edit", data={"name": "가로채기"})
+    assert response.status_code == 404
+
+
+def test_manage_tab_shows_entry_count_per_category(auth_client, db_session, test_user):
+    category = _make_category(db_session, test_user.id, name="투자")
+    _make_entry(db_session, test_user.id, category.id, content="1")
+    _make_entry(db_session, test_user.id, category.id, content="2")
+
+    response = auth_client.get("/journal?tab=manage")
+    assert "기록 2개" in response.text