fix(auth): 애플 로그인 aud 기본값 application.yml → kr.sblog.slimbudget.app

- @Value 기본값보다 application.yml 이 우선 → 실제 값이 옛 번들ID였음
- iOS 번들ID 변경(.app)에 맞춰 서버 기대 aud 정합 (유효하지 않은 애플 토큰 해결)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

.gitea/workflows/ci.yaml

@@ -0,0 +1,73 @@
+name: CI
+
+on:
+  # main 은 Deploy(clean build=테스트 포함)가 게이트 역할을 하므로 CI 중복 실행 제외(배포 시간 단축).
+  push:
+    branches: [dev]
+  pull_request:
+    branches: [main, dev]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    services:
+      mariadb:
+        image: mariadb:11
+        env:
+          MARIADB_ROOT_PASSWORD: ci_root_pw
+          MARIADB_DATABASE: sb_db
+        options: >-
+          --health-cmd="healthcheck.sh --connect --innodb_initialized"
+          --health-interval=10s
+          --health-timeout=5s
+          --health-retries=15
+      redis:
+        image: redis:7
+        options: >-
+          --health-cmd="redis-cli ping"
+          --health-interval=10s
+          --health-timeout=5s
+          --health-retries=10
+
+    env:
+      DB_URL: jdbc:mariadb://mariadb:3306/sb_db?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Seoul
+      DB_USERNAME: root
+      DB_PASSWORD: ci_root_pw
+      REDIS_HOST: redis
+      REDIS_PORT: '6379'
+      # 컨텍스트 테스트(@SpringBootTest)가 스키마를 필요로 함(시작 시 기본분류 시더가 테이블 조회) → 운영과 동일하게 스키마 초기화
+      SQL_INIT_MODE: always
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: '17'
+          # cache 제거: Gitea 캐시 서버 미연결 시 'Save cache' 후처리가 수 분 hang → '가짜 실패' 유발
+
+      # clean build 는 test 태스크를 포함 — 단위테스트 실패 시 빌드/배포 차단(게이트)
+      - name: Build & Test
+        run: |
+          chmod +x ./gradlew
+          ./gradlew --no-daemon clean build
+
+      # 테스트 결과 리포트 — 성공/실패 무관하게 항상 업로드(실패 원인 확인용)
+      - name: Upload test report
+        if: always()
+        uses: actions/upload-artifact@v3
+        with:
+          name: test-report
+          path: build/reports/tests/test
+          retention-days: 7
+
+      - name: Upload jar
+        uses: actions/upload-artifact@v3
+        with:
+          name: app-jar
+          path: build/libs/*.jar
+          retention-days: 7

.gitea/workflows/deploy.yaml

@@ -0,0 +1,73 @@
+name: Deploy
+
+# main 푸시 시 자동 배포: jar 빌드 → 서버로 scp → systemd 재시작
+#
+# 저장소 Settings > Actions > Secrets 에 등록:
+#   DEPLOY_HOST     배포 서버 호스트/IP
+#   DEPLOY_USER     SSH 계정 (systemctl 무비밀번호 sudo 필요 — deploy/README.md 참고)
+#   DEPLOY_SSH_KEY  SSH 개인키 (PEM 전체)
+#   DEPLOY_PATH     jar 배치 디렉터리 (예: /opt/sb-backend)
+#   DEPLOY_PORT     SSH 포트 (선택, 기본 22)
+#   SERVICE_NAME    systemd 유닛명 (선택, 기본 sb-backend)
+on:
+  push:
+    branches: [main]
+  workflow_dispatch: {}
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+
+    # 배포 잡은 테스트를 돌리지 않으므로 DB/Redis 서비스 컨테이너가 필요 없다.
+    # → 서비스 컨테이너 후처리(cleanup) hang 으로 "가짜 실패"가 나던 문제 회피.
+    # 품질(테스트) 게이트는 ci.yaml 이 같은 push 에서 함께 수행한다.
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: '17'
+          # cache 제거: Gitea 캐시 서버 미연결 시 'Save cache' 후처리가 수 분 hang → '가짜 실패' 유발
+
+      # 테스트 없이 jar 만 빌드(bootJar) — 서비스 컨테이너/컨텍스트 테스트가 없어 후처리 hang 이 없다.
+      # (테스트 게이트는 ci.yaml 이 담당)
+      - name: Build jar (테스트 제외, bootJar)
+        run: |
+          chmod +x ./gradlew
+          ./gradlew --no-daemon clean bootJar
+
+      - name: Deploy (SSH + systemd)
+        env:
+          DEPLOY_HOST: ${{ secrets.DEPLOY_HOST }}
+          DEPLOY_USER: ${{ secrets.DEPLOY_USER }}
+          DEPLOY_PORT: ${{ secrets.DEPLOY_PORT }}
+          DEPLOY_SSH_KEY: ${{ secrets.DEPLOY_SSH_KEY }}
+          DEPLOY_PATH: ${{ secrets.DEPLOY_PATH }}
+          SERVICE_NAME: ${{ secrets.SERVICE_NAME }}
+        run: |
+          set -euo pipefail
+          PORT="${DEPLOY_PORT:-22}"
+          SERVICE="${SERVICE_NAME:-sb-backend}"
+          DEST="${DEPLOY_PATH:-}"
+          if [ -z "$DEST" ] || [ "$DEST" = "/" ]; then
+            echo "::error::DEPLOY_PATH 시크릿이 비어 있거나 잘못되었습니다."; exit 1
+          fi
+
+          mkdir -p ~/.ssh && chmod 700 ~/.ssh
+          printf '%s\n' "$DEPLOY_SSH_KEY" | tr -d '\r' > ~/.ssh/id_deploy
+          chmod 600 ~/.ssh/id_deploy
+          ssh-keyscan -p "$PORT" "$DEPLOY_HOST" >> ~/.ssh/known_hosts 2>/dev/null
+          SSH="ssh -p $PORT -i $HOME/.ssh/id_deploy -o StrictHostKeyChecking=yes"
+
+          JAR=$(ls build/libs/*.jar | grep -v -- '-plain.jar' | head -n1)
+          echo "Deploy $JAR -> $DEPLOY_USER@$DEPLOY_HOST:$DEST/app.jar"
+
+          $SSH "$DEPLOY_USER@$DEPLOY_HOST" "mkdir -p '$DEST'"
+          scp -P "$PORT" -i "$HOME/.ssh/id_deploy" "$JAR" "$DEPLOY_USER@$DEPLOY_HOST:$DEST/app.jar"
+          $SSH "$DEPLOY_USER@$DEPLOY_HOST" "sudo systemctl restart '$SERVICE'"
+          # 기동 대기: 최대 ~40초 폴링, 안 뜨면 상태 덤프 후 실패
+          $SSH "$DEPLOY_USER@$DEPLOY_HOST" "for i in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do systemctl is-active --quiet '$SERVICE' && echo 'service active' && exit 0; sleep 2; done; echo '서비스가 active 상태가 아닙니다:'; systemctl --no-pager -l status '$SERVICE' | tail -30; exit 1"
+          echo "✅ 배포 완료"

.gitignore

@@ -2,6 +2,10 @@ HELP.md
 .gradle
 build/
 
+# 로컬 전용 테스트/시드 스크립트 (실제 이메일·프리미엄 부여 포함 — 커밋 금지)
+scripts/seed-test-*.sql
+scripts/cleanup-test-*.sql
+
 # 환경변수 / 비밀 정보 (실제 .env 는 커밋 금지, .env.example 만 추적)
 .env
 !gradle/wrapper/gradle-wrapper.jar

build.gradle

@@ -24,6 +24,8 @@ dependencies {
 	implementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter:3.0.5'
 	// 비밀번호 BCrypt 해싱 (전체 Spring Security 미도입, crypto 모듈만 사용)
 	implementation 'org.springframework.security:spring-security-crypto'
+	// Apple 로그인 ID 토큰(JWT) 서명 검증 — Apple JWKS(공개키) 기반
+	implementation 'com.nimbusds:nimbus-jose-jwt:9.40'
 	compileOnly 'org.projectlombok:lombok'
 	runtimeOnly 'org.mariadb.jdbc:mariadb-java-client'
 	annotationProcessor 'org.projectlombok:lombok'

deploy/README.md

@@ -0,0 +1,48 @@
+# 백엔드 배포 (SSH + systemd)
+
+`main` 푸시 시 [.gitea/workflows/deploy.yaml](../.gitea/workflows/deploy.yaml) 가
+jar 를 빌드해 서버로 전송하고 systemd 서비스를 재시작합니다.
+
+## 1. Gitea 저장소 시크릿 (Settings → Actions → Secrets)
+| 시크릿 | 설명 | 예시 |
+|---|---|---|
+| `DEPLOY_HOST` | 서버 호스트/IP | `10.0.0.5` |
+| `DEPLOY_USER` | SSH 계정 | `deploy` |
+| `DEPLOY_SSH_KEY` | SSH 개인키(PEM 전체) | `-----BEGIN OPENSSH PRIVATE KEY-----...` |
+| `DEPLOY_PATH` | jar 배치 경로 | `/opt/sb-backend` |
+| `DEPLOY_PORT` | SSH 포트(선택) | `22` |
+| `SERVICE_NAME` | systemd 유닛명(선택) | `sb-backend` |
+
+## 2. 서버 1회 준비
+```bash
+# 자바 17, 배포 계정/디렉터리
+sudo apt-get install -y openjdk-17-jre-headless
+sudo useradd -m -s /bin/bash deploy   # 이미 있으면 생략
+sudo mkdir -p /opt/sb-backend && sudo chown deploy:deploy /opt/sb-backend
+
+# 러너가 보낸 공개키를 deploy 계정에 등록
+sudo -u deploy mkdir -p /home/deploy/.ssh
+echo "<배포용 공개키>" | sudo -u deploy tee -a /home/deploy/.ssh/authorized_keys
+
+# 운영 환경변수 (.env, git 미추적) — DB/Redis 접속정보
+sudo -u deploy tee /opt/sb-backend/.env >/dev/null <<'EOF'
+DB_URL=jdbc:mariadb://localhost:3306/sb_db?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Seoul
+DB_USERNAME=sb
+DB_PASSWORD=changeme
+REDIS_HOST=localhost
+REDIS_PORT=6379
+EOF
+
+# systemd 유닛 설치
+sudo cp deploy/sb-backend.service /etc/systemd/system/sb-backend.service
+sudo systemctl daemon-reload
+sudo systemctl enable --now sb-backend
+
+# deploy 계정에 해당 서비스 재시작 무비밀번호 sudo 허용
+echo 'deploy ALL=(root) NOPASSWD: /bin/systemctl restart sb-backend, /bin/systemctl is-active sb-backend' \
+  | sudo tee /etc/sudoers.d/sb-backend
+```
+
+## 3. 동작
+- main 푸시 → CI(빌드·테스트) + Deploy(빌드·전송·재시작) 가 각각 실행
+- 수동 배포: 저장소 Actions → Deploy → Run workflow

deploy/sb-backend.service

@@ -0,0 +1,18 @@
+[Unit]
+Description=SB Backend (Spring Boot)
+After=network.target mariadb.service redis-server.service
+
+[Service]
+Type=simple
+User=deploy
+WorkingDirectory=/opt/sb-backend
+# WorkingDirectory 의 .env(properties 형식)를 Spring 이 자동 로드 (application.yml 의 config.import)
+# 또는 아래처럼 systemd 로 주입해도 됨:
+# EnvironmentFile=/opt/sb-backend/.env
+ExecStart=/usr/bin/java -jar /opt/sb-backend/app.jar
+SuccessExitStatus=143
+Restart=on-failure
+RestartSec=5
+
+[Install]
+WantedBy=multi-user.target

docs/BACKEND.md

@@ -1,11 +1,11 @@
-# Slim Budget — 백엔드 (sb_bt)
+# 돈돼지 가계부 — 백엔드 (sb_bt)
 
-Spring Boot 기반의 가계부·게시판 REST API 서버.
+Spring Boot 기반의 가계부·자산·게시판 REST API 서버. (구 Slim Budget)
 
 ## 기술 스택
 - **Spring Boot 3.5** / **Java 17**
 - **MyBatis** (XML 매퍼) + **MariaDB**
-- **Redis** (세션 저장)
+- **Redis** (세션 저장 — DB 이중 저장으로 유실 대비)
 - **spring-security-crypto** (BCrypt 비밀번호 해시)
 - Lombok, Bean Validation
 
@@ -13,74 +13,97 @@ Spring Boot 기반의 가계부·게시판 REST API 서버.
 ```
 com.sb.web
 ├── account     # 가계부 (controller / service / mapper / domain / dto)
-├── auth        # 인증 (로그인/세션, AuthInterceptor)
+│                 └ invest·budget·category·recurring·quick·ocr·fx·backup 포함
-├── board       # 게시판
+├── auth        # 인증 (로그인/세션/구글로그인, AuthInterceptor, 포인트)
+├── billing     # 인앱결제·구독(Google Play Billing 검증, RTDN)
+├── board       # 게시판 (글/댓글/추천/공지/이미지)
 ├── user        # 사용자
-├── admin       # 관리자 (태그 카테고리, 게시판 설정)
+├── admin       # 관리자 (기본분류·게시판/가입 설정·회원 관리)
-└── common      # 공통 (예외, 응답, 설정)
+└── common      # 공통 (예외, 응답, 헬스체크, 설정)
 ```
 
 ## 스키마 자동 초기화
-`spring.sql.init.schema-locations` 로 기동 시 적용 (멱등 — `CREATE TABLE IF NOT EXISTS`, `ALTER TABLE ... ADD COLUMN IF NOT EXISTS`):
+`spring.sql.init` 로 기동 시 적용. 기본 `mode: never`, 환경변수 **`SQL_INIT_MODE=always`** 로 켜면 실행(멱등 — `CREATE TABLE IF NOT EXISTS`, `ALTER TABLE ... ADD COLUMN IF NOT EXISTS`):
 ```
-classpath:db/member.sql, db/board.sql, db/account.sql, db/dev-seed.sql
+schema-locations: db/member.sql, db/board.sql, db/account.sql, db/dev-seed.sql
+continue-on-error: true
 ```
-주요 테이블: `member`, `wallet`, `account_entry`, `account_tag`, `account_entry_tag`,
+주요 테이블:
-`account_category`, `budget`, `recurring`, `invest_holding`, `invest_trade`,
+- **회원/인증**: `member`, `auth_session`(세션 DB 백업), `point_history`, `app_setting`(가입 허용 등), `iap_purchase`(인앱결제)
-`post`, `comment`, `tag`, `tag_category` 등.
+- **가계부**: `wallet`, `account_entry`, `account_category`(`parent_id` 대/소분류), `account_tag`, `account_entry_tag`, `budget`, `budget_income`, `recurring`, `quick_entry`, `invest_holding`, `invest_trade`
+- **게시판**: `post`, `comment`, `post_vote`, `comment_vote`, `post_tag`, `tag`, `tag_category`, `tag_category_board`, `board_image`, `report`
+- **기타**: `default_category`(기본 분류 템플릿)
 
 ## 인증 / 보안
-- 로그인 시 토큰 발급, 이후 `Authorization: Bearer <token>` 로 인증
+- 로그인/구글로그인 시 토큰 발급, 이후 `Authorization: Bearer <token>` 로 인증
+- **구글 로그인**: `POST /api/auth/google` 로 ID 토큰 수신 → **tokeninfo 검증(aud=웹 클라이언트 ID)** 후 세션 발급. 검증된 동일 이메일이면 기존 계정에 `member.google_id` 로 연결
 - `AuthInterceptor` 가 현재 사용자(`SessionUser`)를 요청 속성(`CURRENT_MEMBER`)으로 주입
+- **세션 이중 저장**: Redis 유실·재시작 시 `auth_session`(DB)에서 복원·재수화
+- **무차별 대입 방지**: 실패 시도만 카운트 — 로그인 IP당 10회/10분, 비밀번호 재인증 회원당 5회/10분 초과 시 429
+- **봇 가입 차단**: 허니팟 + IP 레이트리밋(Redis)
 - **모든 가계부 데이터는 `member_id`(소유자)로 격리** — 본인 데이터만 조회/수정
-- DB 자격증명 등은 `.env`(gitignore)로 관리, `.env.example` 템플릿 제공
+- DB/Redis 자격증명·`ACCOUNT_CRYPTO_KEY`(계좌번호 AES-256-GCM)·`GOOGLE_CLIENT_ID` 등은 `.env`(gitignore), `.env.example` 템플릿 제공
 
 ## REST API 개요
 
 ### 인증 · 사용자 · 관리자
-- `POST /api/auth/login` 외 인증 엔드포인트
+- `/api/auth` — `login`·`signup`·`logout`·`google`·`me`(GET/DELETE) / `password`·`verify-password`·`profile`·`profile-image` / `points`·`point-history` / `signup-enabled`·`google-client-id`
-- `/api/users` — 사용자 관리
+- `/api/users` — 사용자 CRUD
-- `/api/admin/**` — 태그 카테고리·게시판 설정(관리자)
+- `/api/admin` — `signup-setting`(가입 허용 토글), `default-categories`(기본 분류), `members`(회원 목록·`role`·`plan`·`status` 변경·삭제), 태그 카테고리
-- `/api/board/**` — 게시판(글/댓글/태그/열람제한)
+- `/api/billing` — `products`·`subscription`·`google/verify`·`cancel`·`resume`·`restore`·`google/rtdn`(정기 알림)
+- `/api/board` — 글/댓글 CRUD, `posts/{id}/vote`(추천), `notice`/`unnotice`(공지), `block`/`unblock`(열람제한), `my/posts`·`my/comments`, `tag-groups`, `recommenders`
+- `/api/board/images` (업로드) · `/api/images/{id}` (공개 조회) — 게시판 이미지(DB 저장, 절대 URL 반환)
 
 ### 가계부 `/api/account`
 | 메서드·경로 | 설명 |
 |---|---|
 | `GET/POST/PUT/DELETE /entries` | 내역 CRUD. 조회 필터: `year,month,type,category,walletId,keyword,tagId` |
+| `POST /entries/notification` `POST /entries/parse` | 카드/은행 알림 자동인식 등록 · 자연어 파싱 |
+| `GET /entries/pending/count` `POST /entries/{id}/confirm` | 확인 필요(pending) 건수 · 확정 |
 | `GET /summary` `GET /stats` | 월 요약 / 기간 버킷(일·주·월·년) 수입·지출 |
-| `GET /category-stats` | 분류별 합계 (파이차트) |
+| `GET /category-stats` | 분류별 합계 (파이차트, 대/소분류) |
-| `GET/POST/PUT/DELETE /wallets` | 계좌/카드/대출/투자(BANK·CARD·LOAN·INVEST) |
+| `GET/POST/PUT/DELETE /wallets` (+`/reorder`) | 계좌(BANK·CASH·CARD·LOAN·INVEST) |
-| `GET /networth` `GET /networth/trend` | 순자산 / 월별 순자산 추이 |
+| `GET /networth` `GET /networth/trend` | 순자산 / 순자산 추이(`unit=WEEK&weeks=N` 주간 지원) |
-| `GET /wallets/{id}/entries` `POST /repayment` | 계좌별 내역 / 상환·납부(원금=이체, 이자=지출) |
+| `GET /wallets/{id}/entries` `POST /repayment` | 계좌별 내역 / 상환·납부(원금=이체·이자=지출·연회비=지출) |
-| `GET/POST/PUT/DELETE /tags` | 사용자별 가계부 태그 |
+| `GET/POST/PUT/DELETE /tags` (+`/reorder`) | 사용자별 가계부 태그 |
-| `/api/account/categories` (+`/import`) | 분류 CRUD, 기존 내역에서 가져오기 |
+| `/categories` (+`/reorder`,`/import`) | 분류 CRUD, 순서변경, 기존 내역에서 가져오기 |
-| `/api/account/budgets` (+`/status`,`/period`) | 예산 CRUD, 진행률, 기간별 |
+| `/budgets` (+`/income`,`/copy`,`/status`,`/period`) | 월별 예산 CRUD, 수입, 전월 복사, 진행률, 기간별 |
-| `/api/account/recurrings` (+`/run`) | 정기 거래 규칙, 밀린 회차 자동 생성 |
+| `/recurrings` (+`/run`) | 고정지출 규칙, 밀린 회차 자동 생성 |
-| `/api/account/invest/**` | 투자 포트폴리오(아래) |
+| `/quick-entries` | 자주 쓰는 내역 |
+| `/invest/**` | 투자 포트폴리오(아래) |
+| `/ocr/receipt` | 영수증 OCR (Google Vision) |
+| `POST /restore` | 백업 데이터 복구 (엑셀·JSON) |
+
+> 환율: `GET /api/fx/rate` — 외화 입력 시 환율 자동조회(원화 환산).
 
 ### 잔액 · 순자산 모델
-- 부호 모델: 자산(+) / 부채(−)
+- 부호 모델: 자산(+) / 부채(−). 현금(CASH)은 은행(BANK)과 동일하게 자산 합산
 - 지갑 잔액 = 개시잔액 + 수입 − 지출 − 이체출금 + 이체입금 (`WalletMapper.findBalances`)
 - 순자산 = Σ자산 − Σ부채. 투자계좌는 **예수금 + 주식 평가금액**으로 반영
-- 순자산 추이: 현금흐름 누적(이체는 상쇄) + 투자 손익은 현재 시점에 가산
+- 순자산 추이: 현금흐름 누적(이체는 상쇄) + 투자 손익은 현재 시점에 가산. 주간(월요일 기준) 집계 지원
 
-### 정기 거래 (recurring)
+### 고정지출 (recurring)
 - 빈도(DAILY/WEEKLY/MONTHLY/YEARLY) + 일/요일/월 지정
-- `last_run_date` 커서로 **중복 없이** 밀린 회차를 따라잡아 `account_entry` 생성
+- `last_run_date` 커서로 **중복 없이** 밀린 회차를 따라잡아 `account_entry` 생성. 자동 생성분은 **'확인 필요'** 상태로 만들어 실제 처리 확인 후 확정
 
-### 투자 포트폴리오 (`/api/account/invest`) — 종목 단위(C)
+### 투자 포트폴리오 (`/api/account/invest`) — 종목 단위
 | 경로 | 설명 |
 |---|---|
-| `GET/POST/PUT/DELETE /holdings` | 보유 종목 (종목명·코드·현재가). 집계: 수량·평단·평가금액·평가손익·수익률·실현손익 |
+| `GET/POST/PUT/DELETE /holdings` | 보유 종목(종목명·코드·현재가). 집계: 수량·평단·평가금액·평가손익·수익률·실현손익 |
-| `GET/POST /holdings/{id}/trades`, `DELETE /trades/{id}` | 매수/매도 이력 |
+| `GET/POST /holdings/{id}/trades`, `PUT/DELETE /trades/{id}` | 매수/매도 이력 (수정 시 시점별 시뮬레이션으로 보유수량 음수 방지) |
-- 매매이력(시간순)으로 **이동평균 평단**·실현손익·평가손익 산출
+| `POST /holdings/refresh-prices`, `POST /refresh-prices` | 종목코드로 현재가 자동 갱신(네이버 금융) |
-- 매수 시 평단 재계산 `(기존수량×평단 + 매수수량×단가 + 수수료)/총수량`, 매도 시 실현손익 = (매도가 − 평단)×수량 − 수수료
+- 매매이력(시간순)으로 **이동평균 평단**·실현손익·평가손익 산출. 매도수량이 보유수량 초과 시 400
-- 매도수량이 보유수량 초과 시 400 반환
 - 투자계좌 가치 = 예수금(현금 ± 매매) + 주식평가, 순자산/추이에 연동
 - 원화·정수 수량 기준 (해외주식 소수점/환율·자동 시세는 범위 외)
+- ℹ️ 백엔드는 종목 단위 API를 유지하나, **현재 프론트 UI 는 투자금+평가액만 입력하는 단순형**으로 노출
 
 ## 개발/실행
 ```bash
-cp .env.example .env   # DB/Redis 자격증명 입력
+cp .env.example .env   # DB/Redis 자격증명 입력 (SQL_INIT_MODE=always 로 스키마 자동생성)
 ./gradlew bootRun      # http://localhost:8080
+./gradlew test         # 단위 + @WebMvcTest 통합 테스트
 ```
+
+## 배포
+- `main` 푸시 → Gitea Actions 가 CI(빌드·테스트) + Deploy(jar 전송·systemd 재시작) 실행. 테스트 실패 시 배포 중단
+- 상세: [deploy/README.md](../deploy/README.md)

src/main/java/com/sb/web/SbBtApplication.java

@@ -3,9 +3,11 @@ package com.sb.web;
 import org.mybatis.spring.annotation.MapperScan;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.scheduling.annotation.EnableScheduling;
 
 @SpringBootApplication
-@MapperScan({"com.sb.web.user.mapper", "com.sb.web.auth.mapper", "com.sb.web.board.mapper", "com.sb.web.account.mapper"})
+@EnableScheduling
+@MapperScan({"com.sb.web.user.mapper", "com.sb.web.auth.mapper", "com.sb.web.board.mapper", "com.sb.web.account.mapper", "com.sb.web.admin.mapper", "com.sb.web.point.mapper", "com.sb.web.billing.mapper"})
 public class SbBtApplication {
 
 	public static void main(String[] args) {

src/main/java/com/sb/web/account/controller/AccountController.java

@@ -3,13 +3,18 @@ package com.sb.web.account.controller;
 import com.sb.web.account.dto.AccountEntryRequest;
 import com.sb.web.account.dto.AccountEntryResponse;
 import com.sb.web.account.dto.AccountSummary;
+import com.sb.web.account.dto.ParsedEntryResponse;
 import com.sb.web.account.dto.AccountTagRequest;
 import com.sb.web.account.dto.AccountTagResponse;
 import com.sb.web.account.dto.CategoryStat;
+import com.sb.web.account.dto.ConfirmRequest;
+import com.sb.web.account.dto.NotificationRequest;
+import com.sb.web.account.dto.TagReorderRequest;
 import com.sb.web.account.dto.NetWorthPoint;
 import com.sb.web.account.dto.NetWorthResponse;
 import com.sb.web.account.dto.PeriodStat;
 import com.sb.web.account.dto.RepaymentRequest;
+import com.sb.web.account.dto.WalletReorderRequest;
 import com.sb.web.account.dto.WalletRequest;
 import com.sb.web.account.dto.WalletResponse;
 import com.sb.web.account.service.AccountService;
@@ -22,6 +27,7 @@ import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 
 import java.util.List;
+import java.util.Map;
 
 /**
  * 가계부 API. (/api/account/** — 로그인 필요, 본인 데이터만 접근)
@@ -50,7 +56,9 @@ public class AccountController {
     public ResponseEntity<WalletResponse> createWallet(
             @Valid @RequestBody WalletRequest req,
             @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
-        return ResponseEntity.status(HttpStatus.CREATED).body(accountService.createWallet(req, current.getId()));
+        boolean premium = "ADMIN".equals(current.getRole()) || "PREMIUM".equals(current.getPlan());
+        return ResponseEntity.status(HttpStatus.CREATED)
+                .body(accountService.createWallet(req, current.getId(), premium));
     }
 
     @PutMapping("/wallets/{id}")
@@ -69,6 +77,14 @@ public class AccountController {
         return ResponseEntity.noContent().build();
     }
 
+    /** 계좌/카드 순서 변경 (드래그앤드랍) */
+    @PutMapping("/wallets/reorder")
+    public List<WalletResponse> reorderWallets(
+            @RequestBody WalletReorderRequest req,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        return accountService.reorderWallets(current.getId(), req.getType(), req.getIds());
+    }
+
     @GetMapping("/networth")
     public NetWorthResponse netWorth(
             @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
@@ -123,6 +139,14 @@ public class AccountController {
         return ResponseEntity.noContent().build();
     }
 
+    /** 태그 순서 변경 */
+    @PutMapping("/tags/reorder")
+    public List<AccountTagResponse> reorderTags(
+            @RequestBody TagReorderRequest req,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        return accountService.reorderTags(current.getId(), req.getIds());
+    }
+
     @GetMapping("/entries")
     public List<AccountEntryResponse> list(
             @RequestParam(required = false) Integer year,
@@ -146,11 +170,16 @@ public class AccountController {
         return accountService.categoryStats(current.getId(), type, year, month);
     }
 
-    /** 월별 순자산 추이 */
+    /** 순자산 추이 (unit=WEEK 면 주별, weeks 개수 / 그 외 월별, months 개수) */
     @GetMapping("/networth/trend")
     public List<NetWorthPoint> netWorthTrend(
             @RequestParam(required = false) Integer months,
+            @RequestParam(required = false) Integer weeks,
+            @RequestParam(defaultValue = "MONTH") String unit,
             @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        if ("WEEK".equalsIgnoreCase(unit)) {
+            return accountService.netWorthTrendWeekly(current.getId(), weeks);
+        }
         return accountService.netWorthTrend(current.getId(), months);
     }
 
@@ -193,4 +222,50 @@ public class AccountController {
         accountService.delete(id, current.getId());
         return ResponseEntity.noContent().build();
     }
+
+    /* ===== 카드 결제 알림 자동인식 ===== */
+
+    /** 미확인(확인 필요) 내역 개수 */
+    @GetMapping("/entries/pending/count")
+    public Map<String, Integer> pendingCount(
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        return Map.of("count", accountService.countPending(current.getId()));
+    }
+
+    /** 카드 결제 푸시 알림 → 미확인 지출 내역 생성 (네이티브 알림 리스너가 호출). 생성 안 되면 204 */
+    @PostMapping("/entries/notification")
+    public ResponseEntity<AccountEntryResponse> fromNotification(
+            @RequestBody NotificationRequest req,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        AccountEntryResponse created = accountService.createFromNotification(req, current.getId());
+        if (created == null) {
+            return ResponseEntity.noContent().build();
+        }
+        return ResponseEntity.status(HttpStatus.CREATED).body(created);
+    }
+
+    /** 문자/푸시 텍스트 파싱(저장 안 함) → 추가 폼 자동채움. */
+    @PostMapping("/entries/parse")
+    public ParsedEntryResponse parseText(
+            @RequestBody NotificationRequest req,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        return accountService.parseText(req);
+    }
+
+    /** 통계 화면 집계 → AI 재무 코멘트. PREMIUM 무제한, FREE 는 크레딧 차감. */
+    @PostMapping("/ai-comment")
+    public com.sb.web.account.dto.AiCommentResponse aiComment(
+            @RequestBody com.sb.web.account.dto.AiCommentRequest req,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        return accountService.aiComment(req, current);
+    }
+
+    /** 미확인 내역 확정 (분류/계좌 보정) */
+    @PostMapping("/entries/{id}/confirm")
+    public AccountEntryResponse confirm(
+            @PathVariable Long id,
+            @RequestBody(required = false) ConfirmRequest req,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        return accountService.confirm(id, req, current.getId());
+    }
 }

src/main/java/com/sb/web/account/controller/BackupController.java

@@ -0,0 +1,41 @@
+package com.sb.web.account.controller;
+
+import com.sb.web.account.dto.RestoreRequest;
+import com.sb.web.account.service.BackupService;
+import com.sb.web.auth.dto.SessionUser;
+import com.sb.web.auth.web.AuthInterceptor;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestAttribute;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * 데이터 가져오기(복구) API. (로그인 필요 — /api/account/** 보호)
+ *   POST /api/account/restore  엑셀 백업으로 전체 데이터 복구(기존 데이터 덮어씀)
+ */
+@RestController
+@RequestMapping("/api/account")
+@RequiredArgsConstructor
+public class BackupController {
+
+    private final BackupService backupService;
+
+    @PostMapping("/restore")
+    public ResponseEntity<Void> restore(
+            @RequestBody RestoreRequest req,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        backupService.restore(current.getId(), req);
+        return ResponseEntity.noContent().build();
+    }
+
+    @DeleteMapping("/all")
+    public ResponseEntity<Void> deleteAll(
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        backupService.deleteAll(current.getId());
+        return ResponseEntity.noContent().build();
+    }
+}

src/main/java/com/sb/web/account/controller/BudgetController.java

@@ -1,9 +1,14 @@
 package com.sb.web.account.controller;
 
+import com.sb.web.account.dto.BudgetOnetimeRequest;
+import com.sb.web.account.dto.BudgetOnetimeResponse;
 import com.sb.web.account.dto.BudgetPeriodStat;
 import com.sb.web.account.dto.BudgetRequest;
 import com.sb.web.account.dto.BudgetResponse;
 import com.sb.web.account.dto.BudgetStatus;
+import com.sb.web.account.dto.ExpectedIncomeRequest;
+import com.sb.web.account.service.AccountSettingService;
+import com.sb.web.account.service.BudgetOnetimeService;
 import com.sb.web.account.service.BudgetService;
 import com.sb.web.auth.dto.SessionUser;
 import com.sb.web.auth.web.AuthInterceptor;
@@ -24,11 +29,47 @@ import java.util.List;
 public class BudgetController {
 
     private final BudgetService budgetService;
+    private final BudgetOnetimeService onetimeService;
+    private final AccountSettingService settingService;
+
+    /** 월 예상 수입 조회 (연·월별) */
+    @GetMapping("/income")
+    public ExpectedIncomeRequest getIncome(
+            @RequestParam int year,
+            @RequestParam int month,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        return new ExpectedIncomeRequest(settingService.getExpectedIncome(current.getId(), year, month));
+    }
+
+    /** 월 예상 수입 설정 (연·월별) */
+    @PutMapping("/income")
+    public ExpectedIncomeRequest setIncome(
+            @RequestParam int year,
+            @RequestParam int month,
+            @Valid @RequestBody ExpectedIncomeRequest req,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        settingService.setExpectedIncome(current.getId(), year, month, req.getExpectedIncome());
+        return req;
+    }
 
     @GetMapping
     public List<BudgetResponse> list(
+            @RequestParam int year,
+            @RequestParam int month,
             @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
-        return budgetService.list(current.getId());
+        return budgetService.list(current.getId(), year, month);
+    }
+
+    /** 다른 월의 예산을 이 달로 복사(전월 복사 등). 같은 분류는 덮어씀 */
+    @PostMapping("/copy")
+    public List<BudgetResponse> copy(
+            @RequestParam int fromYear,
+            @RequestParam int fromMonth,
+            @RequestParam int toYear,
+            @RequestParam int toMonth,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        budgetService.copy(current.getId(), fromYear, fromMonth, toYear, toMonth);
+        return budgetService.list(current.getId(), toYear, toMonth);
     }
 
     @GetMapping("/status")
@@ -51,9 +92,11 @@ public class BudgetController {
 
     @PostMapping
     public ResponseEntity<BudgetResponse> create(
+            @RequestParam int year,
+            @RequestParam int month,
             @Valid @RequestBody BudgetRequest req,
             @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
-        return ResponseEntity.status(HttpStatus.CREATED).body(budgetService.create(req, current.getId()));
+        return ResponseEntity.status(HttpStatus.CREATED).body(budgetService.create(req, current.getId(), year, month));
     }
 
     @PutMapping("/{id}")
@@ -71,4 +114,35 @@ public class BudgetController {
         budgetService.delete(id, current.getId());
         return ResponseEntity.noContent().build();
     }
+
+    // ===== 1회성 예산 =====
+
+    @GetMapping("/onetime")
+    public List<BudgetOnetimeResponse> onetimeList(
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        return onetimeService.list(current.getId());
+    }
+
+    @PostMapping("/onetime")
+    public ResponseEntity<BudgetOnetimeResponse> onetimeCreate(
+            @Valid @RequestBody BudgetOnetimeRequest req,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        return ResponseEntity.status(HttpStatus.CREATED).body(onetimeService.create(req, current.getId()));
+    }
+
+    @PutMapping("/onetime/{id}")
+    public BudgetOnetimeResponse onetimeUpdate(
+            @PathVariable Long id,
+            @Valid @RequestBody BudgetOnetimeRequest req,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        return onetimeService.update(id, req, current.getId());
+    }
+
+    @DeleteMapping("/onetime/{id}")
+    public ResponseEntity<Void> onetimeDelete(
+            @PathVariable Long id,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        onetimeService.delete(id, current.getId());
+        return ResponseEntity.noContent().build();
+    }
 }

src/main/java/com/sb/web/account/controller/CategoryController.java

@@ -1,5 +1,6 @@
 package com.sb.web.account.controller;
 
+import com.sb.web.account.dto.CategoryReorderRequest;
 import com.sb.web.account.dto.CategoryRequest;
 import com.sb.web.account.dto.CategoryResponse;
 import com.sb.web.account.service.CategoryService;
@@ -52,10 +53,18 @@ public class CategoryController {
         return ResponseEntity.noContent().build();
     }
 
-    /** 기존 내역의 분류를 목록으로 가져오기 */
+    /** 드래그앤드랍 순서 변경 */
-    @PostMapping("/import")
+    @PutMapping("/reorder")
-    public List<CategoryResponse> importFromEntries(
+    public List<CategoryResponse> reorder(
+            @RequestBody CategoryReorderRequest req,
             @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
-        return categoryService.importFromEntries(current.getId());
+        return categoryService.reorder(current.getId(), req.getType(), req.getIds());
+    }
+
+    /** 관리자가 정의한 기본 분류를 내 분류로 불러오기 */
+    @PostMapping("/import")
+    public List<CategoryResponse> importDefaults(
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        return categoryService.importDefaults(current.getId());
     }
 }

src/main/java/com/sb/web/account/controller/FxController.java

@@ -0,0 +1,40 @@
+package com.sb.web.account.controller;
+
+import com.sb.web.account.service.FxService;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.math.BigDecimal;
+import java.time.Instant;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 환율 조회 API. 외화 결제 입력 시 통화→원화 환율 자동 채움용.
+ *   GET /api/fx/rate?from=USD&to=KRW  →  { from, to, rate }
+ */
+@RestController
+@RequestMapping("/api/fx")
+public class FxController {
+
+    private final FxService fxService;
+
+    public FxController(FxService fxService) {
+        this.fxService = fxService;
+    }
+
+    @GetMapping("/rate")
+    public Map<String, Object> rate(@RequestParam String from,
+                                    @RequestParam(defaultValue = "KRW") String to) {
+        BigDecimal rate = fxService.getRate(from, to);
+        Instant updatedAt = fxService.getCachedAt(from);
+        Map<String, Object> res = new HashMap<>();
+        res.put("from", from == null ? null : from.toUpperCase());
+        res.put("to", to == null ? null : to.toUpperCase());
+        res.put("rate", rate); // 조회 실패 시 null
+        res.put("updatedAt", updatedAt != null ? updatedAt.toString() : null);
+        return res;
+    }
+}

src/main/java/com/sb/web/account/controller/InvestController.java

@@ -23,6 +23,7 @@ import java.util.List;
  *   DELETE /api/account/invest/holdings/{id}       종목 삭제(매매이력 포함)
  *   GET    /api/account/invest/holdings/{id}/trades  매매이력
  *   POST   /api/account/invest/holdings/{id}/trades  매수/매도
+ *   PUT    /api/account/invest/trades/{id}         매매 수정
  *   DELETE /api/account/invest/trades/{id}         매매 삭제
  */
 @RestController
@@ -46,6 +47,22 @@ public class InvestController {
         return ResponseEntity.status(HttpStatus.CREATED).body(investService.createHolding(req, current.getId()));
     }
 
+    /** 종목코드로 현재가 시세를 일괄 갱신 */
+    @PostMapping("/holdings/refresh-prices")
+    public List<HoldingResponse> refreshPrices(
+            @RequestParam Long walletId,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        return investService.refreshPrices(current.getId(), walletId);
+    }
+
+    /** 모든 투자계좌 보유종목 현재가 일괄 갱신(계좌 목록 평가액 반영용) */
+    @PostMapping("/refresh-prices")
+    public ResponseEntity<Void> refreshAllPrices(
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        investService.refreshAllPrices(current.getId());
+        return ResponseEntity.noContent().build();
+    }
+
     @PutMapping("/holdings/{id}")
     public HoldingResponse updateHolding(
             @PathVariable Long id,
@@ -77,6 +94,14 @@ public class InvestController {
         return ResponseEntity.status(HttpStatus.CREATED).body(investService.addTrade(id, req, current.getId()));
     }
 
+    @PutMapping("/trades/{id}")
+    public TradeResponse updateTrade(
+            @PathVariable Long id,
+            @Valid @RequestBody TradeRequest req,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        return investService.updateTrade(id, req, current.getId());
+    }
+
     @DeleteMapping("/trades/{id}")
     public ResponseEntity<Void> deleteTrade(
             @PathVariable Long id,

src/main/java/com/sb/web/account/controller/OcrController.java

@@ -0,0 +1,77 @@
+package com.sb.web.account.controller;
+
+import com.sb.web.account.dto.ParsedEntryResponse;
+import com.sb.web.account.service.AiEntryParser;
+import com.sb.web.account.service.VisionOcrService;
+import com.sb.web.auth.dto.SessionUser;
+import com.sb.web.auth.web.AuthInterceptor;
+import com.sb.web.common.exception.ApiException;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestAttribute;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.IOException;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 영수증 OCR API (/api/account/ocr/** — 로그인 필요).
+ * - /receipt   : Google Vision 텍스트 추출(프론트 규칙 파서용, 폴백)
+ * - /receipt-ai: Claude Vision 으로 영수증을 구조화(금액·상호·날짜·분류·계좌). AI 미설정/실패 시 recognized=false.
+ */
+@RestController
+@RequestMapping("/api/account/ocr")
+@RequiredArgsConstructor
+public class OcrController {
+
+    private final VisionOcrService visionOcrService;
+    private final AiEntryParser aiEntryParser;
+
+    @PostMapping("/receipt")
+    public Map<String, String> receipt(
+            @RequestParam("image") MultipartFile image,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) throws IOException {
+        if (image == null || image.isEmpty()) {
+            throw new ApiException(HttpStatus.BAD_REQUEST, "영수증 이미지를 첨부하세요.");
+        }
+        String text = visionOcrService.recognize(image.getBytes());
+        return Map.of("text", text);
+    }
+
+    /**
+     * 영수증 이미지 → AI 구조화. AI 미설정/실패/미인식이면 recognized=false 로 반환(프론트가 /receipt 폴백).
+     * 분류·계좌 후보는 멀티파트 파트 수 제한(Tomcat 기본 10개)을 피하려 '줄바꿈'으로 합친 단일 필드로 받는다.
+     */
+    @PostMapping("/receipt-ai")
+    public ParsedEntryResponse receiptAi(
+            @RequestParam("image") MultipartFile image,
+            @RequestParam(value = "categoryHints", required = false) String categoryHints,
+            @RequestParam(value = "walletHints", required = false) String walletHints,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) throws IOException {
+        if (image == null || image.isEmpty()) {
+            throw new ApiException(HttpStatus.BAD_REQUEST, "영수증 이미지를 첨부하세요.");
+        }
+        return aiEntryParser
+                .parseReceipt(image.getBytes(), image.getContentType(), LocalDate.now(),
+                        splitLines(categoryHints), splitLines(walletHints))
+                .orElseGet(() -> ParsedEntryResponse.builder().recognized(false).build());
+    }
+
+    /** 줄바꿈으로 합쳐 온 후보 문자열 → 리스트(공백 항목 제거). null/빈 값이면 빈 리스트. */
+    private static List<String> splitLines(String joined) {
+        if (joined == null || joined.isBlank()) return List.of();
+        List<String> out = new ArrayList<>();
+        for (String s : joined.split("\n")) {
+            String t = s.trim();
+            if (!t.isEmpty()) out.add(t);
+        }
+        return out;
+    }
+}

src/main/java/com/sb/web/account/controller/QuickEntryController.java

@@ -0,0 +1,46 @@
+package com.sb.web.account.controller;
+
+import com.sb.web.account.dto.QuickEntryRequest;
+import com.sb.web.account.dto.QuickEntryResponse;
+import com.sb.web.account.service.QuickEntryService;
+import com.sb.web.auth.dto.SessionUser;
+import com.sb.web.auth.web.AuthInterceptor;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+/**
+ * 자주 쓰는 내역(빠른 등록 템플릿) API. (/api/account/quick-entries — 로그인 필요, 본인 데이터만)
+ */
+@RestController
+@RequestMapping("/api/account/quick-entries")
+@RequiredArgsConstructor
+public class QuickEntryController {
+
+    private final QuickEntryService service;
+
+    @GetMapping
+    public List<QuickEntryResponse> list(
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        return service.list(current.getId());
+    }
+
+    @PostMapping
+    public ResponseEntity<QuickEntryResponse> create(
+            @Valid @RequestBody QuickEntryRequest req,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        return ResponseEntity.status(HttpStatus.CREATED).body(service.create(req, current.getId()));
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> delete(
+            @PathVariable Long id,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        service.delete(id, current.getId());
+        return ResponseEntity.noContent().build();
+    }
+}

src/main/java/com/sb/web/account/controller/RecurringController.java

@@ -34,7 +34,9 @@ public class RecurringController {
     public ResponseEntity<RecurringResponse> create(
             @Valid @RequestBody RecurringRequest req,
             @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
-        return ResponseEntity.status(HttpStatus.CREATED).body(recurringService.create(req, current.getId()));
+        boolean premium = "ADMIN".equals(current.getRole()) || "PREMIUM".equals(current.getPlan());
+        return ResponseEntity.status(HttpStatus.CREATED)
+                .body(recurringService.create(req, current.getId(), premium));
     }
 
     @PutMapping("/{id}")

src/main/java/com/sb/web/account/controller/ShopController.java

@@ -0,0 +1,37 @@
+package com.sb.web.account.controller;
+
+import com.sb.web.account.dto.ShopStatusResponse;
+import com.sb.web.account.service.ShopService;
+import com.sb.web.auth.dto.SessionUser;
+import com.sb.web.auth.web.AuthInterceptor;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.Map;
+
+@RestController
+@RequestMapping("/api/account/shop")
+@RequiredArgsConstructor
+public class ShopController {
+
+    private final ShopService shopService;
+
+    @GetMapping("/status")
+    public ShopStatusResponse status(
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        return shopService.getStatus(current.getId());
+    }
+
+    @PostMapping("/buy")
+    public ShopStatusResponse buy(
+            @RequestBody Map<String, String> body,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        String item = body.get("item");
+        return switch (item) {
+            case "WALLET_SLOT" -> shopService.buyWalletSlot(current.getId());
+            case "AI_STAT"     -> shopService.buyAiStatPack(current.getId());
+            default -> throw new org.springframework.web.server.ResponseStatusException(
+                    org.springframework.http.HttpStatus.BAD_REQUEST, "SHOP_UNKNOWN_ITEM");
+        };
+    }
+}

src/main/java/com/sb/web/account/domain/AccountCategory.java

@@ -21,6 +21,7 @@ public class AccountCategory implements Serializable {
     private Long memberId;
     private String type;   // INCOME / EXPENSE
     private String name;
+    private Long parentId; // 대분류 id (NULL=대분류, 값=소분류)
     private Integer sortOrder;
     private LocalDateTime createdAt;
 }

src/main/java/com/sb/web/account/domain/AccountEntry.java

@@ -6,6 +6,7 @@ import lombok.Data;
 import lombok.NoArgsConstructor;
 
 import java.io.Serializable;
+import java.math.BigDecimal;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 
@@ -29,6 +30,12 @@ public class AccountEntry implements Serializable {
     private String walletName;  // 조인 표시용
     private Long toWalletId;    // 이체 입금 계좌
     private String toWalletName;
+    private Integer installmentMonths; // 카드 할부 개월수(2~24, 일시불은 null)
+    private String currency;            // 외화 통화코드(USD 등). null/KRW = 원화
+    private BigDecimal originalAmount;  // 외화 원본 금액
+    private BigDecimal exchangeRate;    // 적용 환율(외화 1단위→원화)
+    private Boolean pending;     // 확인 필요(미확정) 여부 — 알림 자동인식 건
+    private String notifKey;     // 알림 자동인식 중복방지 키
     private LocalDateTime createdAt;
     private LocalDateTime updatedAt;
 }

src/main/java/com/sb/web/account/domain/AccountTag.java

@@ -20,5 +20,6 @@ public class AccountTag implements Serializable {
     private Long id;
     private Long memberId;
     private String name;
+    private Integer sortOrder;
     private LocalDateTime createdAt;
 }

src/main/java/com/sb/web/account/domain/Budget.java

@@ -28,6 +28,8 @@ public class Budget implements Serializable {
     private Long weekly;
     private Long monthly;
     private Long yearly;
+    private Integer year;      // 예산 연도(월별 예산)
+    private Integer month;     // 예산 월(1~12)
     private LocalDateTime createdAt;
     private LocalDateTime updatedAt;
 }

src/main/java/com/sb/web/account/domain/BudgetOnetime.java

@@ -0,0 +1,29 @@
+package com.sb.web.account.domain;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+
+/**
+ * 1회성 예산 — 특정 기간(start_date~end_date)에 단발 예산을 설정.
+ * category=null 이면 전체 지출 합산, 값 있으면 해당 카테고리만.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class BudgetOnetime {
+    private Long id;
+    private Long memberId;
+    private String title;
+    private String category;       // null = 전체
+    private Long amount;
+    private LocalDate startDate;
+    private LocalDate endDate;
+    private LocalDateTime createdAt;
+    private LocalDateTime updatedAt;
+}

src/main/java/com/sb/web/account/domain/DefaultCategory.java

@@ -0,0 +1,26 @@
+package com.sb.web.account.domain;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.io.Serializable;
+import java.time.LocalDateTime;
+
+/**
+ * 기본(디폴트) 분류 — 전체 사용자 공용 템플릿(관리자 관리). 사용자는 자기 분류로 복사해 사용.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class DefaultCategory implements Serializable {
+
+    private Long id;
+    private String type;   // INCOME / EXPENSE
+    private String name;
+    private Long parentId; // 대분류 id (NULL=대분류, 값=소분류)
+    private Integer sortOrder;
+    private LocalDateTime createdAt;
+}

src/main/java/com/sb/web/account/domain/InvestTrade.java

@@ -5,6 +5,7 @@ import lombok.Builder;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
+import java.math.BigDecimal;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 
@@ -22,7 +23,7 @@ public class InvestTrade {
     private Long holdingId;
     private String tradeType;   // BUY / SELL
     private LocalDate tradeDate;
-    private Long quantity;      // 수량(주)
+    private BigDecimal quantity; // 수량(주, 소수점 매매 지원)
     private Long price;         // 단가(원)
     private Long fee;           // 수수료/세금(원)
     private LocalDateTime createdAt;

src/main/java/com/sb/web/account/domain/QuickEntry.java

@@ -0,0 +1,31 @@
+package com.sb.web.account.domain;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.io.Serializable;
+import java.time.LocalDateTime;
+
+/**
+ * 자주 쓰는 내역(빠른 등록 템플릿) — 사용자별.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class QuickEntry implements Serializable {
+
+    private Long id;
+    private Long memberId;
+    private String label;
+    private String type;     // INCOME / EXPENSE
+    private String category;
+    private Long amount;
+    private String memo;
+    private Long walletId;
+    private Integer sortOrder;
+    private LocalDateTime createdAt;
+    private String walletName; // 조회 시 조인(표시용)
+}

src/main/java/com/sb/web/account/domain/Wallet.java

@@ -6,6 +6,7 @@ import lombok.Data;
 import lombok.NoArgsConstructor;
 
 import java.io.Serializable;
+import java.math.BigDecimal;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 
@@ -29,6 +30,13 @@ public class Wallet implements Serializable {
     private Long openingBalance;  // 초기 잔액(부호있음: 자산+, 부채-)
     private LocalDate openingDate;
     private Long currentValue;    // 현재 평가금액 (INVEST 전용, 수동 갱신)
+    private Long loanAmount;       // 대출 실행 금액(원금, 처음 빌린 금액) (LOAN 전용)
+    private BigDecimal loanRate;   // 연이자율(%) e.g. 5.25 (LOAN 전용)
+    private String loanMethod;     // 상환방식: EQUAL_PAYMENT / EQUAL_PRINCIPAL / BULLET (LOAN 전용)
+    private Integer loanMonths;    // 대출기간(개월) (LOAN 전용)
+    private LocalDate loanStart;   // 대출시작일 (LOAN 전용)
+    private Long loanPayment;      // 월 상환금(고정, 원리금균등) — 은행 조회액과 정확히 맞추기 위한 선택 입력 (LOAN 전용)
+    private Integer sortOrder;    // 표시 순서 (타입 내 정렬)
     private LocalDateTime createdAt;
     private LocalDateTime updatedAt;
 }

src/main/java/com/sb/web/account/dto/AccountEntryRequest.java

@@ -1,5 +1,7 @@
 package com.sb.web.account.dto;
 
+import jakarta.validation.constraints.Max;
+import jakarta.validation.constraints.Min;
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Pattern;
@@ -7,6 +9,7 @@ import jakarta.validation.constraints.PositiveOrZero;
 import jakarta.validation.constraints.Size;
 import lombok.Data;
 
+import java.math.BigDecimal;
 import java.time.LocalDate;
 import java.util.List;
 
@@ -39,6 +42,17 @@ public class AccountEntryRequest {
     /** 이체 입금 계좌 ID (TRANSFER 시 필수) */
     private Long toWalletId;
 
+    /** 카드 할부 개월수 (2~24, 일시불은 null). EXPENSE + 카드 결제에만 의미 있음 */
+    @Min(value = 2, message = "할부는 2개월 이상이어야 합니다.")
+    @Max(value = 24, message = "할부는 최대 24개월까지 가능합니다.")
+    private Integer installmentMonths;
+
     /** 선택한 태그 ID 목록 (태그 관리에 등록된 태그, 선택) */
     private List<Long> tagIds;
+
+    /** 외화 결제(선택). currency 가 있으면 amount 는 환산된 원화여야 한다. */
+    @Size(max = 3, message = "통화코드가 올바르지 않습니다.")
+    private String currency;          // USD/JPY 등. null/KRW = 원화
+    private BigDecimal originalAmount; // 외화 원본 금액
+    private BigDecimal exchangeRate;   // 적용 환율(외화 1단위→원화)
 }

src/main/java/com/sb/web/account/dto/AccountEntryResponse.java

@@ -4,6 +4,7 @@ import com.sb.web.account.domain.AccountEntry;
 import lombok.Builder;
 import lombok.Data;
 
+import java.math.BigDecimal;
 import java.time.LocalDate;
 import java.util.List;
 
@@ -24,6 +25,11 @@ public class AccountEntryResponse {
     private String walletName;
     private Long toWalletId;
     private String toWalletName;
+    private Integer installmentMonths;
+    private Boolean pending;
+    private String currency;
+    private BigDecimal originalAmount;
+    private BigDecimal exchangeRate;
     private List<String> tags;
 
     public static AccountEntryResponse from(AccountEntry e, List<String> tags) {
@@ -38,6 +44,11 @@ public class AccountEntryResponse {
                 .walletName(e.getWalletName())
                 .toWalletId(e.getToWalletId())
                 .toWalletName(e.getToWalletName())
+                .installmentMonths(e.getInstallmentMonths())
+                .pending(Boolean.TRUE.equals(e.getPending()))
+                .currency(e.getCurrency())
+                .originalAmount(e.getOriginalAmount())
+                .exchangeRate(e.getExchangeRate())
                 .tags(tags)
                 .build();
     }

src/main/java/com/sb/web/account/dto/AiCommentRequest.java

@@ -0,0 +1,27 @@
+package com.sb.web.account.dto;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * 통계 화면의 이번 달 집계(원 단위) — AI 재무 코멘트 생성용. 거래 원문은 보내지 않고 집계만 전달.
+ */
+@Data
+public class AiCommentRequest {
+
+    private int year;
+    private int month;
+    private long income;       // 이번 달 수입 합계
+    private long expense;      // 이번 달 지출 합계
+    private long prevExpense;  // 직전 달 지출 합계(대비용)
+    private long budget;       // 이번 달 예산 합계
+    private long spent;        // 이번 달 예산 대비 소비액
+    private List<CategoryAmount> categories; // 분류별 지출 상위
+
+    @Data
+    public static class CategoryAmount {
+        private String category;
+        private long total;
+    }
+}

src/main/java/com/sb/web/account/dto/AiCommentResponse.java

@@ -0,0 +1,17 @@
+package com.sb.web.account.dto;
+
+import lombok.Builder;
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * AI 재무 코멘트 결과. bullets 가 비어 있으면 통계 화면에서 카드를 숨긴다.
+ */
+@Data
+@Builder
+public class AiCommentResponse {
+
+    private List<String> bullets;  // 현황 관찰/코멘트
+    private List<String> tips;     // 절약 가이드(실행 가능한 제안)
+}

src/main/java/com/sb/web/account/dto/BudgetOnetimeRequest.java

@@ -0,0 +1,30 @@
+package com.sb.web.account.dto;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Positive;
+import jakarta.validation.constraints.Size;
+import lombok.Data;
+
+import java.time.LocalDate;
+
+@Data
+public class BudgetOnetimeRequest {
+
+    @NotBlank(message = "제목을 입력하세요.")
+    @Size(max = 100, message = "제목은 100자 이내여야 합니다.")
+    private String title;
+
+    @Size(max = 50, message = "카테고리는 50자 이내여야 합니다.")
+    private String category;   // null 또는 빈값 = 전체 지출
+
+    @NotNull(message = "금액을 입력하세요.")
+    @Positive(message = "금액은 0보다 커야 합니다.")
+    private Long amount;
+
+    @NotNull(message = "시작일을 입력하세요.")
+    private LocalDate startDate;
+
+    @NotNull(message = "종료일을 입력하세요.")
+    private LocalDate endDate;
+}

src/main/java/com/sb/web/account/dto/BudgetOnetimeResponse.java

@@ -0,0 +1,41 @@
+package com.sb.web.account.dto;
+
+import com.sb.web.account.domain.BudgetOnetime;
+import lombok.Builder;
+import lombok.Data;
+
+import java.time.LocalDate;
+
+@Data
+@Builder
+public class BudgetOnetimeResponse {
+    private Long id;
+    private String title;
+    private String category;   // null = 전체
+    private Long amount;
+    private LocalDate startDate;
+    private LocalDate endDate;
+    private long spent;
+    private long remaining;
+    private String status;     // UPCOMING / ACTIVE / ENDED
+
+    public static BudgetOnetimeResponse from(BudgetOnetime b, long spent) {
+        LocalDate today = LocalDate.now();
+        String status;
+        if (today.isBefore(b.getStartDate())) status = "UPCOMING";
+        else if (today.isAfter(b.getEndDate())) status = "ENDED";
+        else status = "ACTIVE";
+
+        return BudgetOnetimeResponse.builder()
+                .id(b.getId())
+                .title(b.getTitle())
+                .category(b.getCategory())
+                .amount(b.getAmount())
+                .startDate(b.getStartDate())
+                .endDate(b.getEndDate())
+                .spent(spent)
+                .remaining(b.getAmount() - spent)
+                .status(status)
+                .build();
+    }
+}

src/main/java/com/sb/web/account/dto/CategoryReorderRequest.java

@@ -0,0 +1,15 @@
+package com.sb.web.account.dto;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * 분류 순서 변경 요청. ids 순서대로 sort_order 를 재설정한다.
+ */
+@Data
+public class CategoryReorderRequest {
+
+    private String type;       // INCOME / EXPENSE
+    private List<Long> ids;    // 새 순서의 분류 id 목록
+}

src/main/java/com/sb/web/account/dto/CategoryRequest.java

@@ -18,4 +18,7 @@ public class CategoryRequest {
     @NotBlank(message = "분류 이름을 입력하세요.")
     @Size(max = 50, message = "분류 이름은 50자 이내여야 합니다.")
     private String name;
+
+    /** 대분류 id. null=대분류로 생성, 값=해당 대분류의 소분류로 생성/이동 */
+    private Long parentId;
 }

src/main/java/com/sb/web/account/dto/CategoryResponse.java

@@ -14,8 +14,11 @@ public class CategoryResponse {
     private Long id;
     private String type;
     private String name;
+    private Long parentId; // 대분류 id (null=대분류)
 
     public static CategoryResponse from(AccountCategory c) {
-        return CategoryResponse.builder().id(c.getId()).type(c.getType()).name(c.getName()).build();
+        return CategoryResponse.builder()
+                .id(c.getId()).type(c.getType()).name(c.getName()).parentId(c.getParentId())
+                .build();
     }
 }

src/main/java/com/sb/web/account/dto/ConfirmRequest.java

@@ -0,0 +1,13 @@
+package com.sb.web.account.dto;
+
+import lombok.Data;
+
+/**
+ * 미확인(알림 자동인식) 내역 확정 요청 — 분류·계좌 보정(선택).
+ */
+@Data
+public class ConfirmRequest {
+
+    private String category;
+    private Long walletId;
+}

src/main/java/com/sb/web/account/dto/ExpectedIncomeRequest.java

@@ -0,0 +1,18 @@
+package com.sb.web.account.dto;
+
+import jakarta.validation.constraints.PositiveOrZero;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * 월 예상 수입 요청/응답.
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class ExpectedIncomeRequest {
+
+    @PositiveOrZero(message = "예상 수입은 0 이상이어야 합니다.")
+    private Long expectedIncome;
+}

src/main/java/com/sb/web/account/dto/HoldingResponse.java

@@ -3,6 +3,8 @@ package com.sb.web.account.dto;
 import lombok.Builder;
 import lombok.Data;
 
+import java.math.BigDecimal;
+
 /**
  * 보유 종목 응답 (매매이력으로 산출한 집계 포함).
  */
@@ -16,7 +18,7 @@ public class HoldingResponse {
     private String ticker;
     private Long currentPrice;   // 현재가(수동, null 가능)
 
-    private Long quantity;       // 보유수량 (매수−매도)
+    private BigDecimal quantity; // 보유수량 (매수−매도, 소수점 가능)
     private Long avgPrice;       // 평균매입단가 (보유분, 반올림 표시값)
     private Long costBasis;      // 보유분 매입원가 합(수수료 포함)
     private Long evalValue;      // 평가금액 = 수량 × (현재가 ?? 평단)

src/main/java/com/sb/web/account/dto/NotificationRequest.java

@@ -0,0 +1,28 @@
+package com.sb.web.account.dto;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * 카드 결제 푸시 알림 원문 (네이티브 알림 리스너 → 백엔드).
+ * 빠른입력(자연어) 파싱 시에는 사용자의 분류·계좌 후보 목록을 함께 실어 AI가 그 중에서 고르게 한다.
+ */
+@Data
+public class NotificationRequest {
+
+    /** 알림을 띄운 앱 패키지명 (예: 카드사 앱) */
+    private String app;
+
+    /** 알림 제목 */
+    private String title;
+
+    /** 알림 본문 */
+    private String text;
+
+    /** (선택) AI 파싱용 분류 후보 이름 목록 — 이 중에서 카테고리를 고르게 함(없으면 미추천) */
+    private List<String> categoryHints;
+
+    /** (선택) AI 파싱용 결제수단(계좌) 후보 이름 목록 — 텍스트에 결제수단 언급 시 이 중에서 고름 */
+    private List<String> walletHints;
+}

src/main/java/com/sb/web/account/dto/ParsedEntryResponse.java

@@ -0,0 +1,23 @@
+package com.sb.web.account.dto;
+
+import lombok.Builder;
+import lombok.Data;
+
+import java.time.LocalDate;
+
+/**
+ * 문자/푸시 텍스트 파싱 결과 (내역 추가 폼 자동 채움용). 저장하지 않음.
+ */
+@Data
+@Builder
+public class ParsedEntryResponse {
+
+    private boolean recognized;  // 거래로 인식되었는가
+    private String type;         // INCOME / EXPENSE / TRANSFER
+    private long amount;
+    private String merchant;     // 가맹점/적요(메모 후보)
+    private LocalDate date;
+    private String category;     // AI 추천 분류(후보 목록 중). 없으면 빈 문자열
+    private String wallet;       // AI 추천 계좌(후보 중). 지출/수입=결제수단, 이체=보내는(출금) 계좌
+    private String toWallet;     // 이체 시 받는(입금) 계좌(후보 중). 아니면 빈 문자열
+}

src/main/java/com/sb/web/account/dto/QuickEntryRequest.java

@@ -0,0 +1,32 @@
+package com.sb.web.account.dto;
+
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Pattern;
+import jakarta.validation.constraints.Positive;
+import jakarta.validation.constraints.Size;
+import lombok.Data;
+
+/**
+ * 자주 쓰는 내역 생성 요청.
+ */
+@Data
+public class QuickEntryRequest {
+
+    @Size(max = 50, message = "이름은 50자 이내여야 합니다.")
+    private String label;
+
+    @Pattern(regexp = "INCOME|EXPENSE", message = "구분이 올바르지 않습니다.")
+    private String type;
+
+    @Size(max = 50)
+    private String category;
+
+    @NotNull(message = "금액을 입력하세요.")
+    @Positive(message = "금액은 0보다 커야 합니다.")
+    private Long amount;
+
+    @Size(max = 255)
+    private String memo;
+
+    private Long walletId;
+}

src/main/java/com/sb/web/account/dto/QuickEntryResponse.java

@@ -0,0 +1,30 @@
+package com.sb.web.account.dto;
+
+import com.sb.web.account.domain.QuickEntry;
+import lombok.Builder;
+import lombok.Data;
+
+/**
+ * 자주 쓰는 내역 응답.
+ */
+@Data
+@Builder
+public class QuickEntryResponse {
+
+    private Long id;
+    private String label;
+    private String type;
+    private String category;
+    private Long amount;
+    private String memo;
+    private Long walletId;
+    private String walletName;
+
+    public static QuickEntryResponse from(QuickEntry q) {
+        return QuickEntryResponse.builder()
+                .id(q.getId()).label(q.getLabel()).type(q.getType()).category(q.getCategory())
+                .amount(q.getAmount()).memo(q.getMemo()).walletId(q.getWalletId())
+                .walletName(q.getWalletName())
+                .build();
+    }
+}

src/main/java/com/sb/web/account/dto/RepaymentRequest.java

@@ -8,7 +8,7 @@ import lombok.Data;
 import java.time.LocalDate;
 
 /**
- * 대출/카드 상환·납부 요청. 원금은 이체, 이자는 지출로 분리 생성된다.
+ * 대출/카드 상환·납부 요청. 원금은 이체, 이자·연회비는 지출로 분리 생성된다.
  */
 @Data
 public class RepaymentRequest {
@@ -28,6 +28,9 @@ public class RepaymentRequest {
     @PositiveOrZero(message = "이자는 0 이상이어야 합니다.")
     private Long interest;
 
+    @PositiveOrZero(message = "연회비는 0 이상이어야 합니다.")
+    private Long annualFee;
+
     @Size(max = 255, message = "메모는 255자 이내여야 합니다.")
     private String memo;
 }

src/main/java/com/sb/web/account/dto/RestoreRequest.java

@@ -0,0 +1,83 @@
+package com.sb.web.account.dto;
+
+import lombok.Data;
+
+import java.time.LocalDate;
+import java.util.List;
+
+/**
+ * 데이터 복구(가져오기) 요청 — 엑셀 백업을 파싱한 결과.
+ * 계좌는 원본 ID(oldId) 기준으로 매핑(같은 이름 계좌가 있어도 정확). 분류·태그는 이름 기준(유니크).
+ */
+@Data
+public class RestoreRequest {
+
+    private List<Wal> wallets;
+    private List<Cat> categories;
+    private List<String> tags;
+    private List<Entry> entries;
+    private List<Recur> recurrings;
+    private List<BudgetRequest> budgets;
+    private List<Quick> quickEntries;
+
+    @Data
+    public static class Wal {
+        private Long oldId;          // 원본 계좌 id (매핑 키)
+        private String type;
+        private String name;
+        private String issuer;
+        private String accountNumber;
+        private String cardType;
+        private Long openingBalance;
+        private LocalDate openingDate;
+        private Long currentValue;
+    }
+
+    @Data
+    public static class Cat {
+        private String type;
+        private String name;
+        private String parent; // 대분류명 (없으면 대분류)
+    }
+
+    @Data
+    public static class Entry {
+        private LocalDate entryDate;
+        private String type;
+        private String category;
+        private Long amount;
+        private String memo;
+        private Long walletId;        // 원본 계좌 id
+        private Long toWalletId;      // 원본 입금 계좌 id(이체)
+        private Integer installmentMonths;
+        private List<String> tags;    // 태그명
+    }
+
+    @Data
+    public static class Recur {
+        private String title;
+        private String type;
+        private Long amount;
+        private String category;
+        private String memo;
+        private Long walletId;
+        private Long toWalletId;
+        private String frequency;
+        private Integer dayOfMonth;
+        private Integer dayOfWeek;
+        private Integer monthOfYear;
+        private LocalDate startDate;
+        private LocalDate endDate;
+        private Boolean active;
+    }
+
+    @Data
+    public static class Quick {
+        private String label;
+        private String type;
+        private String category;
+        private Long amount;
+        private String memo;
+        private Long walletId;
+    }
+}

src/main/java/com/sb/web/account/dto/ShopStatusResponse.java

@@ -0,0 +1,15 @@
+package com.sb.web.account.dto;
+
+import lombok.Builder;
+import lombok.Getter;
+
+@Getter
+@Builder
+public class ShopStatusResponse {
+    private int extraWalletSlots;
+    private int aiStatCredits;
+    private int maxExtraSlots;
+    private int walletSlotPrice;
+    private int aiStatPrice;
+    private int aiStatPackSize;
+}

src/main/java/com/sb/web/account/dto/TagReorderRequest.java

@@ -0,0 +1,14 @@
+package com.sb.web.account.dto;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * 태그 순서 변경 요청. ids 순서대로 sort_order 를 재설정한다.
+ */
+@Data
+public class TagReorderRequest {
+
+    private List<Long> ids; // 새 순서의 태그 id 목록
+}

src/main/java/com/sb/web/account/dto/TradeRequest.java

@@ -6,6 +6,7 @@ import jakarta.validation.constraints.Positive;
 import jakarta.validation.constraints.PositiveOrZero;
 import lombok.Data;
 
+import java.math.BigDecimal;
 import java.time.LocalDate;
 
 /**
@@ -20,8 +21,8 @@ public class TradeRequest {
     @NotNull(message = "거래일을 입력하세요.")
     private LocalDate tradeDate;
 
-    @Positive(message = "수량은 1 이상이어야 합니다.")
+    @Positive(message = "수량은 0보다 커야 합니다.")
-    private Long quantity;
+    private BigDecimal quantity;
 
     @PositiveOrZero(message = "단가는 0 이상이어야 합니다.")
     private Long price;

src/main/java/com/sb/web/account/dto/TradeResponse.java

@@ -4,6 +4,8 @@ import com.sb.web.account.domain.InvestTrade;
 import lombok.Builder;
 import lombok.Data;
 
+import java.math.BigDecimal;
+import java.math.RoundingMode;
 import java.time.LocalDate;
 
 /**
@@ -17,12 +19,16 @@ public class TradeResponse {
     private Long holdingId;
     private String tradeType;
     private LocalDate tradeDate;
-    private Long quantity;
+    private BigDecimal quantity;
     private Long price;
     private Long fee;
-    private Long amount; // 거래금액 = 수량 × 단가 (수수료 제외)
+    private Long amount; // 거래금액 = 수량 × 단가 (수수료 제외, 원 단위 반올림)
 
     public static TradeResponse from(InvestTrade t) {
+        long amount = t.getQuantity()
+                .multiply(BigDecimal.valueOf(t.getPrice()))
+                .setScale(0, RoundingMode.HALF_UP)
+                .longValue();
         return TradeResponse.builder()
                 .id(t.getId())
                 .holdingId(t.getHoldingId())
@@ -31,7 +37,7 @@ public class TradeResponse {
                 .quantity(t.getQuantity())
                 .price(t.getPrice())
                 .fee(t.getFee())
-                .amount(t.getQuantity() * t.getPrice())
+                .amount(amount)
                 .build();
     }
 }

src/main/java/com/sb/web/account/dto/WalletReorderRequest.java

@@ -0,0 +1,15 @@
+package com.sb.web.account.dto;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * 계좌/카드 순서 변경 요청. ids 순서대로 sort_order 를 재설정한다.
+ */
+@Data
+public class WalletReorderRequest {
+
+    private String type;       // BANK / CARD / LOAN / INVEST
+    private List<Long> ids;    // 새 순서의 wallet id 목록
+}

src/main/java/com/sb/web/account/dto/WalletRequest.java

@@ -1,10 +1,13 @@
 package com.sb.web.account.dto;
 
+import jakarta.validation.constraints.DecimalMax;
+import jakarta.validation.constraints.DecimalMin;
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.Pattern;
 import jakarta.validation.constraints.Size;
 import lombok.Data;
 
+import java.math.BigDecimal;
 import java.time.LocalDate;
 
 /**
@@ -14,7 +17,7 @@ import java.time.LocalDate;
 public class WalletRequest {
 
     @NotBlank(message = "유형을 선택하세요.")
-    @Pattern(regexp = "BANK|CARD|LOAN|INVEST", message = "유형이 올바르지 않습니다.")
+    @Pattern(regexp = "BANK|CASH|CARD|LOAN|INVEST|MINUS", message = "유형이 올바르지 않습니다.")
     private String type;
 
     @NotBlank(message = "이름을 입력하세요.")
@@ -37,4 +40,18 @@ public class WalletRequest {
 
     /** 현재 평가금액 (INVEST 전용, 수동 갱신) */
     private Long currentValue;
+
+    // ===== 대출(LOAN) 전용 =====
+    private Long loanAmount;       // 대출 실행 금액(원금)
+
+    @DecimalMin(value = "0.0", inclusive = true)
+    @DecimalMax(value = "100.0", message = "이자율은 100% 이하여야 합니다.")
+    private BigDecimal loanRate;   // 연이자율(%)
+
+    @Pattern(regexp = "EQUAL_PAYMENT|EQUAL_PRINCIPAL|BULLET|", message = "상환방식이 올바르지 않습니다.")
+    private String loanMethod;     // 상환방식
+
+    private Integer loanMonths;    // 대출기간(개월)
+    private LocalDate loanStart;   // 대출시작일
+    private Long loanPayment;      // 월 상환금(고정, 원리금균등) — 선택
 }

src/main/java/com/sb/web/account/dto/WalletResponse.java

@@ -4,6 +4,7 @@ import com.sb.web.account.domain.Wallet;
 import lombok.Builder;
 import lombok.Data;
 
+import java.math.BigDecimal;
 import java.time.LocalDate;
 
 /**
@@ -28,6 +29,16 @@ public class WalletResponse {
     private Long deposit;         // 예수금(미투자 현금) = 투입원금 + 매도 − 매수
     private Long stockValue;      // 주식 평가금액
     private Long valuationGain;   // 총손익(실현+평가) = 총평가 − 투입원금
+    private Long currentValue;    // 평가액 직접입력값(퇴직연금·연금 등 수동 갱신). 있으면 총평가로 사용
+    private Boolean manualValuation; // true면 평가액 직접입력형(종목 자동계산 대신)
+
+    // 대출(LOAN) 전용
+    private Long loanAmount;       // 대출 실행 금액(원금)
+    private BigDecimal loanRate;   // 연이자율(%) e.g. 5.25
+    private String loanMethod;     // EQUAL_PAYMENT / EQUAL_PRINCIPAL / BULLET
+    private Integer loanMonths;    // 대출기간(개월)
+    private LocalDate loanStart;   // 대출시작일
+    private Long loanPayment;      // 월 상환금(고정, 원리금균등) — 선택 입력
 
     public static WalletResponse from(Wallet w, long balance) {
         return WalletResponse.builder()
@@ -40,6 +51,13 @@ public class WalletResponse {
                 .openingBalance(w.getOpeningBalance())
                 .openingDate(w.getOpeningDate())
                 .balance(balance)
+                .currentValue(w.getCurrentValue())
+                .loanAmount(w.getLoanAmount())
+                .loanRate(w.getLoanRate())
+                .loanMethod(w.getLoanMethod())
+                .loanMonths(w.getLoanMonths())
+                .loanStart(w.getLoanStart())
+                .loanPayment(w.getLoanPayment())
                 .build();
     }
 }

src/main/java/com/sb/web/account/mapper/AccountEntryMapper.java

@@ -47,6 +47,9 @@ public interface AccountEntryMapper {
     /** 월별 순현금흐름(수입−지출, 계좌 지정분) — {ym, net} 행 반환 (순자산 추이용) */
     List<Map<String, Object>> monthlyWalletFlow(@Param("memberId") Long memberId);
 
+    /** 주별 순현금흐름(수입−지출, 계좌 지정분) — {wk(=주 월요일 yyyy-MM-dd), net} (주간 순자산 추이용) */
+    List<Map<String, Object>> weeklyWalletFlow(@Param("memberId") Long memberId);
+
     /** 기간 버킷(일/주/월/년)별 수입·지출 — {bucket, income, expense} (이체 제외) */
     List<Map<String, Object>> statsByPeriod(@Param("memberId") Long memberId,
                                             @Param("unit") String unit,
@@ -59,6 +62,22 @@ public interface AccountEntryMapper {
 
     int delete(@Param("id") Long id, @Param("memberId") Long memberId);
 
+    /* ----- 알림 자동인식(미확인) ----- */
+    /** 중복방지 키로 기존 알림 내역 조회 */
+    AccountEntry findByMemberAndNotifKey(@Param("memberId") Long memberId, @Param("notifKey") String notifKey);
+
+    /** 미확인(확인 필요) 내역 개수 */
+    int countPending(@Param("memberId") Long memberId);
+
+    /** 자동인식 분류 학습: 같은 메모 키워드로 과거에 가장 많이 쓴 분류 1건(없으면 null) */
+    String findLearnedCategory(@Param("memberId") Long memberId,
+                               @Param("type") String type,
+                               @Param("memo") String memo);
+
+    /** 미확인 내역 확정 (pending=0, 분류/계좌 보정) */
+    int confirm(@Param("id") Long id, @Param("memberId") Long memberId,
+                @Param("category") String category, @Param("walletId") Long walletId);
+
     /** 기존 내역의 (type별) 사용된 분류명 distinct (분류 불러오기용) */
     List<String> findDistinctCategories(@Param("memberId") Long memberId, @Param("type") String type);
 
@@ -74,4 +93,12 @@ public interface AccountEntryMapper {
     int deleteEntryTagsByEntryId(@Param("entryId") Long entryId);
 
     List<String> findTagNamesByEntryId(@Param("entryId") Long entryId);
+
+    /** 복수 항목의 태그를 한 번에 조회 — {entryId, tagName} 맵 반환 */
+    List<Map<String, Object>> findTagsByEntryIds(@Param("entryIds") List<Long> entryIds);
+
+    /** 특정 연·월에 기록이 있는 서로 다른 날짜 수 (한 달 개근 판정용) */
+    int countDistinctEntryDays(@Param("memberId") Long memberId,
+                               @Param("year") int year,
+                               @Param("month") int month);
 }

src/main/java/com/sb/web/account/mapper/AccountSettingMapper.java

@@ -0,0 +1,22 @@
+package com.sb.web.account.mapper;
+
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+/**
+ * 월 예상 수입 매퍼 (budget_income, 월별).
+ */
+@Mapper
+public interface AccountSettingMapper {
+
+    /** 해당 연·월의 예상 수입 (없으면 null) */
+    Long findExpectedIncome(@Param("memberId") Long memberId,
+                            @Param("year") int year,
+                            @Param("month") int month);
+
+    /** 해당 연·월 예상 수입 upsert */
+    int upsertExpectedIncome(@Param("memberId") Long memberId,
+                             @Param("year") int year,
+                             @Param("month") int month,
+                             @Param("expectedIncome") Long expectedIncome);
+}

src/main/java/com/sb/web/account/mapper/AccountTagMapper.java

@@ -24,6 +24,10 @@ public interface AccountTagMapper {
 
     int update(AccountTag tag);
 
+    int updateSortOrder(@Param("id") Long id, @Param("memberId") Long memberId, @Param("sortOrder") int sortOrder);
+
+    Integer maxSortOrder(@Param("memberId") Long memberId);
+
     int delete(@Param("id") Long id, @Param("memberId") Long memberId);
 
     /** 주어진 ID 중 해당 사용자 소유로 실제 존재하는 태그 ID만 반환 */

src/main/java/com/sb/web/account/mapper/BackupMapper.java

@@ -0,0 +1,24 @@
+package com.sb.web.account.mapper;
+
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+/**
+ * 데이터 복구 시 회원의 기존 가계부 데이터를 전부 삭제(트랜잭션 내에서 호출).
+ */
+@Mapper
+public interface BackupMapper {
+
+    int deleteEntryTags(@Param("memberId") Long memberId);
+    int deleteEntries(@Param("memberId") Long memberId);
+    int deleteRecurrings(@Param("memberId") Long memberId);
+    int deleteBudgets(@Param("memberId") Long memberId);
+    int deleteBudgetIncome(@Param("memberId") Long memberId);
+    int deleteBudgetOnetime(@Param("memberId") Long memberId);
+    int deleteQuickEntries(@Param("memberId") Long memberId);
+    int deleteInvestTrades(@Param("memberId") Long memberId);
+    int deleteInvestHoldings(@Param("memberId") Long memberId);
+    int deleteCategories(@Param("memberId") Long memberId);
+    int deleteTags(@Param("memberId") Long memberId);
+    int deleteWallets(@Param("memberId") Long memberId);
+}

src/main/java/com/sb/web/account/mapper/BudgetMapper.java

@@ -12,13 +12,24 @@ import java.util.List;
 @Mapper
 public interface BudgetMapper {
 
-    List<Budget> findByMember(@Param("memberId") Long memberId);
+    List<Budget> findByMember(@Param("memberId") Long memberId,
+                              @Param("year") Integer year,
+                              @Param("month") Integer month);
 
     Budget findByIdAndMember(@Param("id") Long id, @Param("memberId") Long memberId);
 
     int countByCategory(@Param("memberId") Long memberId,
                         @Param("category") String category,
-                        @Param("excludeId") Long excludeId);
+                        @Param("excludeId") Long excludeId,
+                        @Param("year") Integer year,
+                        @Param("month") Integer month);
+
+    /** fromYear/fromMonth 예산을 toYear/toMonth 로 복사(같은 분류는 덮어씀). 복사된 건수 반환 */
+    int copyMonth(@Param("memberId") Long memberId,
+                  @Param("fromYear") Integer fromYear,
+                  @Param("fromMonth") Integer fromMonth,
+                  @Param("toYear") Integer toYear,
+                  @Param("toMonth") Integer toMonth);
 
     int insert(Budget budget);
 

src/main/java/com/sb/web/account/mapper/BudgetOnetimeMapper.java

@@ -0,0 +1,27 @@
+package com.sb.web.account.mapper;
+
+import com.sb.web.account.domain.BudgetOnetime;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.time.LocalDate;
+import java.util.List;
+
+@Mapper
+public interface BudgetOnetimeMapper {
+
+    List<BudgetOnetime> findByMember(@Param("memberId") Long memberId);
+
+    BudgetOnetime findByIdAndMember(@Param("id") Long id, @Param("memberId") Long memberId);
+
+    long sumExpenseInRange(@Param("memberId") Long memberId,
+                           @Param("startDate") LocalDate startDate,
+                           @Param("endDate") LocalDate endDate,
+                           @Param("category") String category);
+
+    void insert(BudgetOnetime b);
+
+    void update(BudgetOnetime b);
+
+    void delete(@Param("id") Long id, @Param("memberId") Long memberId);
+}

src/main/java/com/sb/web/account/mapper/CategoryMapper.java

@@ -16,6 +16,14 @@ public interface CategoryMapper {
 
     AccountCategory findByIdAndMember(@Param("id") Long id, @Param("memberId") Long memberId);
 
+    /** 이름으로 조회 (기본분류 불러오기 중복 확인용) */
+    AccountCategory findByMemberTypeName(@Param("memberId") Long memberId,
+                                         @Param("type") String type,
+                                         @Param("name") String name);
+
+    /** 해당 대분류(parent_id)에 속한 소분류 개수 */
+    int countChildren(@Param("memberId") Long memberId, @Param("parentId") Long parentId);
+
     int countByName(@Param("memberId") Long memberId,
                     @Param("type") String type,
                     @Param("name") String name,
@@ -28,4 +36,10 @@ public interface CategoryMapper {
     int update(AccountCategory category);
 
     int delete(@Param("id") Long id, @Param("memberId") Long memberId);
+
+    /** 순서(sort_order) 변경 */
+    int updateSortOrder(@Param("id") Long id, @Param("memberId") Long memberId, @Param("sortOrder") int sortOrder);
+
+    /** 해당 타입의 현재 최대 sort_order (신규 분류를 맨 뒤에 배치) */
+    Integer maxSortOrder(@Param("memberId") Long memberId, @Param("type") String type);
 }

src/main/java/com/sb/web/account/mapper/DefaultCategoryMapper.java

@@ -0,0 +1,32 @@
+package com.sb.web.account.mapper;
+
+import com.sb.web.account.domain.DefaultCategory;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+/**
+ * 기본(디폴트) 분류 매퍼 — 전체 공용(소유자 격리 없음).
+ */
+@Mapper
+public interface DefaultCategoryMapper {
+
+    List<DefaultCategory> findAll();
+
+    DefaultCategory findById(@Param("id") Long id);
+
+    int countChildren(@Param("parentId") Long parentId);
+
+    int countByName(@Param("type") String type, @Param("name") String name, @Param("excludeId") Long excludeId);
+
+    int insert(DefaultCategory category);
+
+    int update(DefaultCategory category);
+
+    int delete(@Param("id") Long id);
+
+    int updateSortOrder(@Param("id") Long id, @Param("sortOrder") int sortOrder);
+
+    Integer maxSortOrder(@Param("type") String type);
+}

src/main/java/com/sb/web/account/mapper/InvestMapper.java

@@ -38,6 +38,8 @@ public interface InvestMapper {
 
     int insertTrade(InvestTrade trade);
 
+    int updateTrade(InvestTrade trade);
+
     int deleteTrade(@Param("id") Long id, @Param("memberId") Long memberId);
 
     int deleteTradesByHolding(@Param("holdingId") Long holdingId, @Param("memberId") Long memberId);

src/main/java/com/sb/web/account/mapper/QuickEntryMapper.java

@@ -0,0 +1,24 @@
+package com.sb.web.account.mapper;
+
+import com.sb.web.account.domain.QuickEntry;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+/**
+ * 자주 쓰는 내역 매퍼 — 소유자(member_id) 격리.
+ */
+@Mapper
+public interface QuickEntryMapper {
+
+    List<QuickEntry> findByMember(@Param("memberId") Long memberId);
+
+    QuickEntry findByIdAndMember(@Param("id") Long id, @Param("memberId") Long memberId);
+
+    int insert(QuickEntry e);
+
+    int delete(@Param("id") Long id, @Param("memberId") Long memberId);
+
+    Integer maxSortOrder(@Param("memberId") Long memberId);
+}

src/main/java/com/sb/web/account/mapper/RecurringMapper.java

@@ -15,6 +15,9 @@ public interface RecurringMapper {
 
     List<Recurring> findByMember(@Param("memberId") Long memberId);
 
+    /** 회원의 정기 거래 개수 (무료 회원 등록 한도 판정용) */
+    int countByMember(@Param("memberId") Long memberId);
+
     /** 활성 규칙 (자동 생성용) */
     List<Recurring> findActiveByMember(@Param("memberId") Long memberId);
 

src/main/java/com/sb/web/account/mapper/WalletMapper.java

@@ -25,4 +25,13 @@ public interface WalletMapper {
     int update(Wallet wallet);
 
     int delete(@Param("id") Long id, @Param("memberId") Long memberId);
+
+    /** 순서(sort_order) 변경 */
+    int updateSortOrder(@Param("id") Long id, @Param("memberId") Long memberId, @Param("sortOrder") int sortOrder);
+
+    /** 해당 타입의 현재 최대 sort_order (신규 계좌를 맨 뒤에 배치) */
+    Integer maxSortOrder(@Param("memberId") Long memberId, @Param("type") String type);
+
+    /** 해당 타입의 계좌 개수 (무료 회원 종류별 등록 한도 판정용) */
+    int countByType(@Param("memberId") Long memberId, @Param("type") String type);
 }

src/main/java/com/sb/web/account/service/AccountService.java

@@ -6,6 +6,9 @@ import com.sb.web.account.domain.Wallet;
 import com.sb.web.account.dto.AccountEntryRequest;
 import com.sb.web.account.dto.AccountEntryResponse;
 import com.sb.web.account.dto.AccountSummary;
+import com.sb.web.account.dto.ConfirmRequest;
+import com.sb.web.account.dto.NotificationRequest;
+import com.sb.web.account.dto.ParsedEntryResponse;
 import com.sb.web.account.dto.AccountTagRequest;
 import com.sb.web.account.dto.AccountTagResponse;
 import com.sb.web.account.dto.CategoryStat;
@@ -18,12 +21,16 @@ import com.sb.web.account.dto.WalletResponse;
 import com.sb.web.account.mapper.AccountEntryMapper;
 import com.sb.web.account.mapper.AccountTagMapper;
 import com.sb.web.account.mapper.WalletMapper;
+import com.sb.web.auth.dto.SessionUser;
+import com.sb.web.auth.mapper.MemberMapper;
 import com.sb.web.common.exception.ApiException;
+import com.sb.web.point.PointService;
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.HttpStatus;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.time.LocalDate;
 import java.time.YearMonth;
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -43,14 +50,30 @@ public class AccountService {
     private final AccountTagMapper tagMapper;
     private final WalletMapper walletMapper;
     private final InvestService investService;
+    private final CardNotificationParser notificationParser;
+    private final AiEntryParser aiEntryParser;
+    private final PointService pointService;
+    private final MemberMapper memberMapper;
 
     /* ===================== 항목 ===================== */
 
     public List<AccountEntryResponse> list(Long memberId, Integer year, Integer month,
                                            String type, String category, Long walletId, String keyword, Long tagId) {
-        return mapper.findByMember(memberId, year, month,
+        List<AccountEntry> entries = mapper.findByMember(memberId, year, month,
-                        blankToNull(type), blankToNull(category), walletId, blankToNull(keyword), tagId).stream()
+                blankToNull(type), blankToNull(category), walletId, blankToNull(keyword), tagId);
-                .map(this::toResponse)
+        if (entries.isEmpty()) return List.of();
+        // 태그 N+1 방지: 한 번에 모든 entry 의 태그를 조회 후 Map 으로 그룹화
+        List<Long> ids = entries.stream().map(AccountEntry::getId).toList();
+        Map<Long, List<String>> tagsByEntry = new HashMap<>();
+        for (Map<String, Object> row : mapper.findTagsByEntryIds(ids)) {
+            Object rawId = row.get("entry_id");
+            String name = (String) row.get("tag_name");
+            if (rawId == null || name == null) continue;
+            Long eid = ((Number) rawId).longValue();
+            tagsByEntry.computeIfAbsent(eid, k -> new ArrayList<>()).add(name);
+        }
+        return entries.stream()
+                .map(e -> AccountEntryResponse.from(e, tagsByEntry.getOrDefault(e.getId(), List.of())))
                 .toList();
     }
 
@@ -125,6 +148,66 @@ public class AccountService {
         return result;
     }
 
+    /** 주별 순자산 추이 (월요일 기준 버킷). 기본 13주(최근 약 3개월). */
+    public List<NetWorthPoint> netWorthTrendWeekly(Long memberId, Integer weeks) {
+        int n = (weeks == null || weeks <= 0 || weeks > 53) ? 13 : weeks;
+        LocalDate today = LocalDate.now();
+        LocalDate currentMon = today.minusDays(today.getDayOfWeek().getValue() - 1L); // 이번 주 월요일
+        LocalDate startMon = currentMon.minusWeeks(n - 1L);
+
+        Map<String, Long> flow = new HashMap<>();
+        for (Map<String, Object> row : mapper.weeklyWalletFlow(memberId)) {
+            Object net = row.get("net");
+            flow.put((String) row.get("wk"), net == null ? 0L : ((Number) net).longValue());
+        }
+
+        // 개시잔액: 개시주가 시작주 이전(또는 미상)이면 기준선, 범위 내면 해당 주 버킷
+        List<Wallet> ws = walletMapper.findByMember(memberId);
+        Map<String, Long> openingByWeek = new HashMap<>();
+        long baseline = 0;
+        for (Wallet w : ws) {
+            long ob = w.getOpeningBalance() == null ? 0L : w.getOpeningBalance();
+            if (ob == 0) {
+                continue;
+            }
+            LocalDate od = w.getOpeningDate();
+            LocalDate om = od == null ? null : od.minusDays(od.getDayOfWeek().getValue() - 1L);
+            if (om == null || om.isBefore(startMon)) {
+                baseline += ob;
+            } else if (!om.isAfter(currentMon)) {
+                openingByWeek.merge(om.toString(), ob, Long::sum);
+            }
+        }
+        String startKey = startMon.toString();
+        for (Map.Entry<String, Long> e : flow.entrySet()) {
+            if (e.getKey().compareTo(startKey) < 0) {
+                baseline += e.getValue();
+            }
+        }
+
+        List<NetWorthPoint> result = new ArrayList<>();
+        long running = baseline;
+        for (LocalDate m = startMon; !m.isAfter(currentMon); m = m.plusWeeks(1)) {
+            String key = m.toString();
+            running += flow.getOrDefault(key, 0L);
+            running += openingByWeek.getOrDefault(key, 0L);
+            result.add(NetWorthPoint.builder().month(key).netWorth(running).build());
+        }
+
+        // 투자 손익(실현+평가)은 과거 주별 이력이 없으므로 마지막 점에만 가산 (월간과 동일)
+        if (!result.isEmpty()) {
+            long investAdjust = 0;
+            for (InvestService.WalletInvest wi : investService.valuationByWallet(memberId).values()) {
+                investAdjust += wi.cashDelta + wi.stockEval;
+            }
+            if (investAdjust != 0) {
+                NetWorthPoint last = result.get(result.size() - 1);
+                last.setNetWorth(last.getNetWorth() + investAdjust);
+            }
+        }
+        return result;
+    }
+
     /** 기간 버킷(일/주/월/년)별 수입·지출 통계 */
     public List<PeriodStat> stats(Long memberId, String unit, Integer year, Integer month) {
         String u = switch (unit == null ? "" : unit.toUpperCase()) {
@@ -168,12 +251,36 @@ public class AccountService {
                 .memo(req.getMemo())
                 .walletId(req.getWalletId())
                 .toWalletId(transfer ? req.getToWalletId() : null)
+                .installmentMonths(installmentOf(req))
+                .currency(req.getCurrency())
+                .originalAmount(req.getOriginalAmount())
+                .exchangeRate(req.getExchangeRate())
                 .build();
         mapper.insert(entry);
         applyTags(entry.getId(), req.getTagIds(), memberId);
+        pointService.awardAccountEntry(memberId);
+        awardIfMonthComplete(entry.getEntryDate(), memberId);
         return toResponse(mapper.findByIdAndMember(entry.getId(), memberId));
     }
 
+    /**
+     * 내역의 월이 '현재 진행 중인 달'이고 그 달 모든 날에 기록이 있으면 개근 보너스(랜덤 1~100P) 지급.
+     * 지난달을 소급 입력해 채우는 파밍을 막기 위해 현재 월만 인정한다(전 월 제외). 판정 실패는 저장에 영향 없음.
+     */
+    private void awardIfMonthComplete(java.time.LocalDate entryDate, Long memberId) {
+        if (entryDate == null) return;
+        try {
+            java.time.LocalDate today = java.time.LocalDate.now();
+            if (entryDate.getYear() != today.getYear() || entryDate.getMonthValue() != today.getMonthValue()) return;
+            int recorded = mapper.countDistinctEntryDays(memberId, entryDate.getYear(), entryDate.getMonthValue());
+            if (recorded >= entryDate.lengthOfMonth()) {
+                pointService.awardMonthComplete(memberId, entryDate.getYear(), entryDate.getMonthValue());
+            }
+        } catch (Exception ignore) {
+            // 개근 판정 오류는 무시(내역 저장은 이미 완료)
+        }
+    }
+
     @Transactional
     public AccountEntryResponse update(Long id, AccountEntryRequest req, Long memberId) {
         AccountEntry entry = mustFind(id, memberId);
@@ -186,6 +293,10 @@ public class AccountService {
         entry.setMemo(req.getMemo());
         entry.setWalletId(req.getWalletId());
         entry.setToWalletId(transfer ? req.getToWalletId() : null);
+        entry.setInstallmentMonths(installmentOf(req));
+        entry.setCurrency(req.getCurrency());
+        entry.setOriginalAmount(req.getOriginalAmount());
+        entry.setExchangeRate(req.getExchangeRate());
         mapper.update(entry);
 
         mapper.deleteEntryTagsByEntryId(id);
@@ -200,15 +311,149 @@ public class AccountService {
         mapper.delete(id, memberId);
     }
 
+    /* ===================== 카드 결제 알림 자동인식 ===================== */
+
+    /** 미확인(확인 필요) 내역 개수 */
+    public int countPending(Long memberId) {
+        return mapper.countPending(memberId);
+    }
+
+    /**
+     * 카드 결제 푸시 알림 → 미확인(pending) 지출 내역 생성.
+     * 결제 알림이 아니거나 중복이면 null 반환(생성 안 함). 취소 알림도 일단 무시(v1).
+     */
+    /**
+     * 문자/푸시·자연어 한 줄 텍스트를 파싱해 폼 자동채움용 결과 반환 (저장 안 함).
+     * AI 파서(Claude Haiku)가 설정돼 있으면 우선 시도("어제 스타벅스 5천원" 같은 자유 입력 처리),
+     * 미설정/실패/미인식이면 기존 규칙기반 카드알림 파서로 폴백.
+     */
+    public ParsedEntryResponse parseText(NotificationRequest req) {
+        java.time.LocalDate today = java.time.LocalDate.now();
+        java.util.Optional<ParsedEntryResponse> ai =
+                aiEntryParser.parse(req.getText(), today, req.getCategoryHints(), req.getWalletHints());
+        if (ai.isPresent() && ai.get().isRecognized()) {
+            return ai.get();
+        }
+        CardNotificationParser.Parsed p = notificationParser.parse(req.getTitle(), req.getText(), today);
+        return ParsedEntryResponse.builder()
+                .recognized(p.isRecognized())
+                .type(p.isIncome() ? "INCOME" : "EXPENSE")
+                .amount(p.getAmount())
+                .merchant(p.getMerchant())
+                .date(p.getDate())
+                .build();
+    }
+
+    /** 통계 화면 집계 → AI 재무 코멘트.
+     *  - PREMIUM: 무제한.
+     *  - FREE + ai_stat_credits > 0: 크레딧 1 차감 후 호출.
+     *  - FREE + credits == 0: 402 에러(프론트가 상점으로 유도).
+     */
+    @Transactional
+    public com.sb.web.account.dto.AiCommentResponse aiComment(
+            com.sb.web.account.dto.AiCommentRequest req, SessionUser current) {
+        if ("FREE".equals(current.getPlan())) {
+            int credits = memberMapper.getAiStatCredits(current.getId());
+            if (credits <= 0) {
+                throw new ApiException(HttpStatus.PAYMENT_REQUIRED, "AI_STAT_CREDIT_EMPTY");
+            }
+            memberMapper.decrementAiStatCredit(current.getId());
+        }
+        try {
+            String json = new com.fasterxml.jackson.databind.ObjectMapper().writeValueAsString(req);
+            return aiEntryParser.financeComment(json);
+        } catch (ApiException e) {
+            throw e;
+        } catch (Exception e) {
+            return com.sb.web.account.dto.AiCommentResponse.builder()
+                    .bullets(java.util.List.of()).tips(java.util.List.of()).build();
+        }
+    }
+
+    @Transactional
+    public AccountEntryResponse createFromNotification(NotificationRequest req, Long memberId) {
+        CardNotificationParser.Parsed p =
+                notificationParser.parse(req.getTitle(), req.getText(), java.time.LocalDate.now());
+        if (!p.isRecognized() || p.getAmount() <= 0) {
+            return null; // 결제/이체 알림 아님 → 무시
+        }
+        // 중복방지
+        if (p.getNotifKey() != null && mapper.findByMemberAndNotifKey(memberId, p.getNotifKey()) != null) {
+            return null;
+        }
+        // 카드 결제 → 카드(CARD) 매칭 / 은행 입출금·이체 → 은행(BANK) 매칭
+        String walletType = p.isBankTransfer() ? "BANK" : "CARD";
+        Long walletId = matchWalletId(p.getIssuer(), memberId, walletType);
+
+        // 분류 자동학습: 같은 메모(가맹점) 키워드로 과거에 확정한 분류가 있으면 그대로 채워준다.
+        String type = p.isIncome() ? "INCOME" : "EXPENSE";
+        String merchant = p.getMerchant();
+        String learnedCategory = (merchant != null && !merchant.isBlank())
+                ? mapper.findLearnedCategory(memberId, type, merchant)
+                : null;
+
+        AccountEntry entry = AccountEntry.builder()
+                .memberId(memberId)
+                .entryDate(p.getDate() != null ? p.getDate() : java.time.LocalDate.now())
+                .type(type)
+                .category(learnedCategory)
+                .amount(p.getAmount())
+                .memo(merchant)
+                .walletId(walletId)
+                .toWalletId(null)
+                .installmentMonths(null)
+                .pending(true)
+                .notifKey(p.getNotifKey())
+                .build();
+        mapper.insert(entry);
+        return toResponse(mapper.findByIdAndMember(entry.getId(), memberId));
+    }
+
+    /** 미확인 내역 확정 (분류/계좌 보정 후 pending 해제) */
+    @Transactional
+    public AccountEntryResponse confirm(Long id, ConfirmRequest req, Long memberId) {
+        AccountEntry e = mustFind(id, memberId);
+        if (!Boolean.TRUE.equals(e.getPending())) {
+            return toResponse(e); // 이미 확정된 건
+        }
+        String category = req != null ? req.getCategory() : null;
+        Long walletId = req != null ? req.getWalletId() : null;
+        mapper.confirm(id, memberId, category, walletId);
+        return toResponse(mapper.findByIdAndMember(id, memberId));
+    }
+
+    /** 카드사/은행명으로 등록된 해당 type(CARD/BANK) 지갑 id 찾기 (issuer/name 유연 매칭).
+     *  미매칭이라도 그 type 지갑이 정확히 1개면 그 지갑으로 기본 매칭. */
+    private Long matchWalletId(String issuer, Long memberId, String walletType) {
+        List<Wallet> wallets = walletMapper.findByMember(memberId).stream()
+                .filter(w -> walletType.equals(w.getType()))
+                .toList();
+        if (issuer != null) {
+            Long matched = wallets.stream()
+                    .filter(w -> overlaps(w.getIssuer(), issuer) || overlaps(w.getName(), issuer))
+                    .map(Wallet::getId)
+                    .findFirst()
+                    .orElse(null);
+            if (matched != null) return matched;
+        }
+        return wallets.size() == 1 ? wallets.get(0).getId() : null;
+    }
+
+    /** 표기 차이를 흡수한 카드사 매칭 (KB국민 ↔ 국민 ↔ 국민카드 ↔ KB카드 등) */
+    private boolean overlaps(String walletField, String issuer) {
+        return CardIssuerMatcher.matches(walletField, issuer);
+    }
+
     /* ===================== 상환/납부 ===================== */
 
-    /** 대출/카드 상환·납부: 원금은 이체(부채↓), 이자는 지출로 분리해 2건 생성 */
+    /** 대출/카드 상환·납부: 원금은 이체(부채↓), 이자·연회비는 지출로 분리 생성 */
     @Transactional
     public void repay(RepaymentRequest req, Long memberId) {
         long principal = req.getPrincipal() != null ? req.getPrincipal() : 0L;
         long interest = req.getInterest() != null ? req.getInterest() : 0L;
-        if (principal <= 0 && interest <= 0) {
+        long annualFee = req.getAnnualFee() != null ? req.getAnnualFee() : 0L;
-            throw new ApiException(HttpStatus.BAD_REQUEST, "원금 또는 이자를 입력하세요.");
+        if (principal <= 0 && interest <= 0 && annualFee <= 0) {
+            throw new ApiException(HttpStatus.BAD_REQUEST, "원금·이자·연회비 중 하나는 입력하세요.");
         }
         requireOwnedWallet(req.getFromWalletId(), memberId);
         Wallet target = walletMapper.findByIdAndMember(req.getTargetWalletId(), memberId);
@@ -218,6 +463,9 @@ public class AccountService {
         if (!"LOAN".equals(target.getType()) && !"CARD".equals(target.getType())) {
             throw new ApiException(HttpStatus.BAD_REQUEST, "상환 대상은 대출/카드만 가능합니다.");
         }
+        if (annualFee > 0 && !"CARD".equals(target.getType())) {
+            throw new ApiException(HttpStatus.BAD_REQUEST, "연회비는 카드 상환에만 입력할 수 있습니다.");
+        }
         if (req.getFromWalletId().equals(req.getTargetWalletId())) {
             throw new ApiException(HttpStatus.BAD_REQUEST, "출금/대상 계좌가 같을 수 없습니다.");
         }
@@ -246,6 +494,18 @@ public class AccountService {
                     .memo(req.getMemo() != null ? req.getMemo() : "이자")
                     .build());
         }
+        // 연회비: 지출 (카드, 출금 계좌에서, 분류=연회비)
+        if (annualFee > 0) {
+            mapper.insert(AccountEntry.builder()
+                    .memberId(memberId)
+                    .entryDate(req.getEntryDate())
+                    .type("EXPENSE")
+                    .category("연회비")
+                    .amount(annualFee)
+                    .walletId(req.getFromWalletId())
+                    .memo(req.getMemo() != null ? req.getMemo() : "연회비")
+                    .build());
+        }
     }
 
     /* ===================== 계좌/카드 (사용자별) ===================== */
@@ -260,19 +520,31 @@ public class AccountService {
                     if ("INVEST".equals(w.getType())) {
                         InvestService.WalletInvest wi = inv.getOrDefault(w.getId(), new InvestService.WalletInvest());
                         long deposit = cash + wi.cashDelta;       // 예수금
-                        long total = deposit + wi.stockEval;       // 총평가
+                        if (w.getCurrentValue() != null) {
-                        r.setBalance(total);
+                            // 평가액 직접입력형(퇴직연금·연금 등): 입력한 평가액을 총평가로 사용
-                        r.setInvestedAmount(cash);                 // 순입금(투입원금)
+                            long total = w.getCurrentValue();
-                        r.setDeposit(deposit);
+                            r.setBalance(total);
-                        r.setStockValue(wi.stockEval);
+                            r.setInvestedAmount(cash);             // 누적 적립원금(순입금)
-                        r.setValuationGain(total - cash);          // 실현+평가 손익
+                            r.setDeposit(deposit);
+                            r.setStockValue(total - deposit);
+                            r.setValuationGain(total - cash);
+                            r.setManualValuation(true);
+                        } else {
+                            long total = deposit + wi.stockEval;   // 총평가
+                            r.setBalance(total);
+                            r.setInvestedAmount(cash);             // 순입금(투입원금)
+                            r.setDeposit(deposit);
+                            r.setStockValue(wi.stockEval);
+                            r.setValuationGain(total - cash);      // 실현+평가 손익
+                            r.setManualValuation(false);
+                        }
                     }
                     return r;
                 })
                 .toList();
     }
 
-    /** 순자산 = 총자산(BANK) − 총부채(CARD/LOAN) */
+    /** 순자산 = 총자산(BANK/CASH/INVEST) − 총부채(CARD/LOAN) */
     public NetWorthResponse netWorth(Long memberId) {
         Map<Long, Long> balances = balanceMap(memberId);
         Map<Long, InvestService.WalletInvest> inv = investService.valuationByWallet(memberId);
@@ -281,10 +553,15 @@ public class AccountService {
         for (Wallet w : walletMapper.findByMember(memberId)) {
             long bal = balances.getOrDefault(w.getId(), 0L);
             if ("INVEST".equals(w.getType())) {
-                // 투자: 예수금(현금+매매증감) + 주식 평가금액
+                if (w.getCurrentValue() != null) {
-                InvestService.WalletInvest wi = inv.getOrDefault(w.getId(), new InvestService.WalletInvest());
+                    // 평가액 직접입력형(퇴직연금·연금 등): 입력한 평가액을 자산으로
-                assets += bal + wi.cashDelta + wi.stockEval;
+                    assets += w.getCurrentValue();
-            } else if ("BANK".equals(w.getType())) {
+                } else {
+                    // 투자: 예수금(현금+매매증감) + 주식 평가금액
+                    InvestService.WalletInvest wi = inv.getOrDefault(w.getId(), new InvestService.WalletInvest());
+                    assets += bal + wi.cashDelta + wi.stockEval;
+                }
+            } else if ("BANK".equals(w.getType()) || "CASH".equals(w.getType())) {
                 assets += bal;
             } else {
                 liabilities += -bal; // 부채는 음수 잔액 → 양수 부채로 표시
@@ -297,25 +574,66 @@ public class AccountService {
                 .build();
     }
 
+    // 무료 회원 계좌 등록 한도: 종류(은행·현금·카드·대출·증권·마이너스)별 기본 2개.
+    // 포인트 상점(추후)에서 영구 보너스 슬롯을 구매하면 종류별 최대 5개까지 확장 가능.
+    public static final int FREE_WALLET_BASE_LIMIT = 2;
+    public static final int FREE_WALLET_MAX_LIMIT  = 5;
+
+    /** 무료 회원의 해당 타입 등록 한도 = 기본 2 + 포인트 상점 구매 슬롯, 최대 5. */
+    private int freeWalletLimit(Long memberId, String type) {
+        int bonus = memberMapper.getExtraWalletSlots(memberId);
+        return Math.min(FREE_WALLET_BASE_LIMIT + bonus, FREE_WALLET_MAX_LIMIT);
+    }
+
     @Transactional
-    public WalletResponse createWallet(WalletRequest req, Long memberId) {
+    public WalletResponse createWallet(WalletRequest req, Long memberId, boolean premium) {
+        // 유료(또는 관리자)는 무제한. 무료는 종류별 한도 검증.
+        if (!premium) {
+            int limit = freeWalletLimit(memberId, req.getType());
+            if (walletMapper.countByType(memberId, req.getType()) >= limit) {
+                throw new ApiException(HttpStatus.BAD_REQUEST,
+                        "무료 회원은 종류별 계좌를 " + limit + "개까지 등록할 수 있어요. 유료로 업그레이드하면 무제한이에요.");
+            }
+        }
         Wallet wallet = toWallet(req);
         wallet.setMemberId(memberId);
+        Integer max = walletMapper.maxSortOrder(memberId, req.getType());
+        wallet.setSortOrder(max == null ? 0 : max + 1); // 같은 타입의 맨 뒤
         walletMapper.insert(wallet);
         return WalletResponse.from(wallet, wallet.getOpeningBalance()); // 신규 → 잔액=초기잔액
     }
 
+    /** 드래그앤드랍 순서 변경: 전달된 id 순서대로 sort_order 재설정 (본인·동일 타입만) */
+    @Transactional
+    public List<WalletResponse> reorderWallets(Long memberId, String type, List<Long> ids) {
+        int i = 0;
+        for (Long id : ids) {
+            Wallet w = walletMapper.findByIdAndMember(id, memberId);
+            if (w != null && w.getType().equals(type)) {
+                walletMapper.updateSortOrder(id, memberId, i++);
+            }
+        }
+        return listWallets(memberId);
+    }
+
     @Transactional
     public WalletResponse updateWallet(Long id, WalletRequest req, Long memberId) {
         Wallet wallet = mustFindWallet(id, memberId);
         wallet.setType(req.getType());
         wallet.setName(req.getName().trim());
         wallet.setIssuer(blankToNull(req.getIssuer()));
-        wallet.setAccountNumber("BANK".equals(req.getType()) ? blankToNull(req.getAccountNumber()) : null);
+        wallet.setAccountNumber(("BANK".equals(req.getType()) || "MINUS".equals(req.getType())) ? blankToNull(req.getAccountNumber()) : null);
         wallet.setCardType("CARD".equals(req.getType()) ? blankToNull(req.getCardType()) : null);
         wallet.setOpeningBalance(req.getOpeningBalance() != null ? req.getOpeningBalance() : 0L);
         wallet.setOpeningDate(req.getOpeningDate());
         wallet.setCurrentValue("INVEST".equals(req.getType()) ? req.getCurrentValue() : null);
+        boolean isLoan = "LOAN".equals(req.getType());
+        wallet.setLoanAmount(isLoan ? req.getLoanAmount() : null);
+        wallet.setLoanRate(isLoan ? req.getLoanRate() : null);
+        wallet.setLoanMethod(isLoan ? blankToNull(req.getLoanMethod()) : null);
+        wallet.setLoanMonths(isLoan ? req.getLoanMonths() : null);
+        wallet.setLoanStart(isLoan ? req.getLoanStart() : null);
+        wallet.setLoanPayment(isLoan ? req.getLoanPayment() : null);
         walletMapper.update(wallet);
         return WalletResponse.from(wallet, balanceMap(memberId).getOrDefault(id, wallet.getOpeningBalance()));
     }
@@ -345,15 +663,22 @@ public class AccountService {
     }
 
     private Wallet toWallet(WalletRequest req) {
+        boolean isLoan = "LOAN".equals(req.getType());
         return Wallet.builder()
                 .type(req.getType())
                 .name(req.getName().trim())
                 .issuer(blankToNull(req.getIssuer()))
-                .accountNumber("BANK".equals(req.getType()) ? blankToNull(req.getAccountNumber()) : null)
+                .accountNumber(("BANK".equals(req.getType()) || "MINUS".equals(req.getType())) ? blankToNull(req.getAccountNumber()) : null)
                 .cardType("CARD".equals(req.getType()) ? blankToNull(req.getCardType()) : null)
                 .openingBalance(req.getOpeningBalance() != null ? req.getOpeningBalance() : 0L)
                 .openingDate(req.getOpeningDate())
                 .currentValue("INVEST".equals(req.getType()) ? req.getCurrentValue() : null)
+                .loanAmount(isLoan ? req.getLoanAmount() : null)
+                .loanRate(isLoan ? req.getLoanRate() : null)
+                .loanMethod(isLoan ? blankToNull(req.getLoanMethod()) : null)
+                .loanMonths(isLoan ? req.getLoanMonths() : null)
+                .loanStart(isLoan ? req.getLoanStart() : null)
+                .loanPayment(isLoan ? req.getLoanPayment() : null)
                 .build();
     }
 
@@ -403,11 +728,28 @@ public class AccountService {
         if (tagMapper.countByName(memberId, name, null) > 0) {
             throw new ApiException(HttpStatus.CONFLICT, "이미 존재하는 태그입니다.");
         }
-        AccountTag tag = AccountTag.builder().memberId(memberId).name(name).build();
+        Integer max = tagMapper.maxSortOrder(memberId);
+        AccountTag tag = AccountTag.builder()
+                .memberId(memberId)
+                .name(name)
+                .sortOrder(max == null ? 0 : max + 1)
+                .build();
         tagMapper.insert(tag);
         return AccountTagResponse.from(tag);
     }
 
+    /** 태그 순서 변경 — ids 순서대로 sort_order 재설정 */
+    @Transactional
+    public List<AccountTagResponse> reorderTags(Long memberId, List<Long> ids) {
+        int i = 0;
+        for (Long id : ids) {
+            if (tagMapper.findByIdAndMember(id, memberId) != null) {
+                tagMapper.updateSortOrder(id, memberId, i++);
+            }
+        }
+        return listTags(memberId);
+    }
+
     @Transactional
     public AccountTagResponse updateTag(Long id, AccountTagRequest req, Long memberId) {
         AccountTag tag = mustFindTag(id, memberId);
@@ -433,6 +775,15 @@ public class AccountService {
         return AccountEntryResponse.from(entry, mapper.findTagNamesByEntryId(entry.getId()));
     }
 
+    /** 할부 개월수 정규화: 지출(EXPENSE)이고 2개월 이상일 때만 저장, 그 외(일시불·수입·이체)는 null */
+    private Integer installmentOf(AccountEntryRequest req) {
+        Integer m = req.getInstallmentMonths();
+        if (!"EXPENSE".equals(req.getType()) || m == null || m < 2) {
+            return null;
+        }
+        return m;
+    }
+
     /** 선택된 태그 ID 중 해당 사용자 소유로 존재하는 것만 연결 */
     private void applyTags(Long entryId, List<Long> tagIds, Long memberId) {
         if (tagIds == null || tagIds.isEmpty()) {

src/main/java/com/sb/web/account/service/AccountSettingService.java

@@ -0,0 +1,25 @@
+package com.sb.web.account.service;
+
+import com.sb.web.account.mapper.AccountSettingMapper;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * 월 예상 수입 설정 서비스 (월별).
+ */
+@Service
+@RequiredArgsConstructor
+public class AccountSettingService {
+
+    private final AccountSettingMapper settingMapper;
+
+    public Long getExpectedIncome(Long memberId, int year, int month) {
+        return settingMapper.findExpectedIncome(memberId, year, month);
+    }
+
+    @Transactional
+    public void setExpectedIncome(Long memberId, int year, int month, Long expectedIncome) {
+        settingMapper.upsertExpectedIncome(memberId, year, month, expectedIncome);
+    }
+}

src/main/java/com/sb/web/account/service/AiEntryParser.java

@@ -0,0 +1,270 @@
+package com.sb.web.account.service;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.sb.web.account.dto.AiCommentResponse;
+import com.sb.web.account.dto.ParsedEntryResponse;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.MediaType;
+import org.springframework.stereotype.Component;
+import org.springframework.web.client.RestClient;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * 자연어 한 줄 입력("어제 스타벅스 5천원")을 Claude(Haiku)로 파싱해 폼 자동채움 필드로 변환한다.
+ * 키(app.anthropic-api-key) 미설정이거나 호출 실패 시 Optional.empty() → 호출부가 규칙기반 파서로 폴백.
+ * AI는 폼 prefill 용도이며 저장은 사용자 확인 후.
+ */
+@Slf4j
+@Component
+public class AiEntryParser {
+
+    /** Anthropic API 키. 미설정 시 AI 파싱 비활성(규칙기반으로 폴백). */
+    @Value("${app.anthropic-api-key:}")
+    private String apiKey;
+
+    /** 사용 모델. 저렴·빠른 Haiku 권장(학습 미사용). */
+    @Value("${app.anthropic-model:claude-haiku-4-5}")
+    private String model;
+
+    private final ObjectMapper om = new ObjectMapper();
+    private final RestClient rest = RestClient.builder().baseUrl("https://api.anthropic.com").build();
+
+    public boolean enabled() {
+        return apiKey != null && !apiKey.isBlank();
+    }
+
+    /** 시작 시 AI 파서 활성 여부·키 로딩 상태를 로그로 남겨 진단을 쉽게 한다(키는 앞부분만 마스킹). */
+    @jakarta.annotation.PostConstruct
+    void logConfig() {
+        if (enabled()) {
+            String masked = apiKey.length() > 14 ? apiKey.substring(0, 14) + "…(len=" + apiKey.length() + ")" : "(len=" + apiKey.length() + ")";
+            log.info("[ai-parse] 활성화됨 — model={}, key={}", model, masked);
+        } else {
+            log.warn("[ai-parse] 비활성(ANTHROPIC_API_KEY 미설정) — 규칙기반 파서만 사용");
+        }
+    }
+
+    /** 자유 텍스트 → 파싱 결과. 실패/미설정 시 empty. 분류·계좌 후보를 주면 AI가 그 중에서 골라 채운다. */
+    public Optional<ParsedEntryResponse> parse(String text, LocalDate today,
+                                               List<String> categoryHints, List<String> walletHints) {
+        if (!enabled() || text == null || text.isBlank()) {
+            log.info("[ai-parse] 건너뜀 — enabled={}, textBlank={}", enabled(), (text == null || text.isBlank()));
+            return Optional.empty();
+        }
+        log.info("[ai-parse] 요청 수신 — text='{}'", text);
+        String system = withHints("""
+            너는 한국어 가계부 입력 도우미다. 사용자가 자연어로 쓴 한 줄 지출/수입/이체 메모를 구조화한다.
+            반드시 아래 JSON 객체 '하나만' 출력한다(마크다운/설명 금지):
+            {"recognized":boolean,"type":"INCOME"|"EXPENSE"|"TRANSFER","amount":정수(원),"merchant":"문자열","date":"YYYY-MM-DD","category":"문자열","wallet":"문자열","toWallet":"문자열"}
+            규칙:
+            - amount: 원 단위 정수. 아라비아 숫자·한글 수 모두 해석한다.
+              예) "5천원"=5000, "1만2천"=12000, "3만5천원"=35000, "천원"=1000,
+                  "오만원"=50000, "삼만원"=30000, "십만원"=100000, "오천원"=5000, "만원"=10000, "이만오천원"=25000.
+            - type: 이체/송금/옮김/입출금 간 이동은 TRANSFER. 급여/월급/수입/입금/환불/이자/용돈 등은 INCOME. 그 외 소비는 EXPENSE(기본).
+            - TRANSFER 판단: "A에서 B로 5만원", "A→B 이체", "카드값 냈어(계좌→카드)" 처럼 내 계좌 사이 이동. 이때 category는 빈 문자열.
+            - merchant: 가맹점/항목명(예: 스타벅스, 점심, 택시). 이체면 메모(예: 카드대금)나 빈 문자열.
+            - date: 오늘=__TODAY__ 기준 상대표현 해석(오늘/어제/그저께/엊그제 등). 명시 없으면 오늘.
+            - category: 지출/수입일 때만. 거래 내용에 알맞은 분류를 아래 '분류 후보'에서 정확히 하나(예: 라면→식비, 택시→교통). 없거나 이체면 빈 문자열. 후보에 없는 값 지어내지 말 것.
+            - wallet: 지출/수입이면 결제수단(출금 계좌). 이체면 '보내는(출금)' 계좌. 아래 '계좌 후보'에 있는 이름만, 언급 없으면 빈 문자열.
+            - toWallet: 이체일 때 '받는(입금)' 계좌. '계좌 후보'에 있는 이름만. 이체가 아니거나 언급 없으면 빈 문자열.
+            - 금액을 못 찾거나 거래가 아니면 recognized=false.
+            분류 후보: __CATS__
+            계좌 후보: __WALLETS__
+            """, today, categoryHints, walletHints);
+        return callClaude(system, text, 300, today, categoryHints, walletHints);
+    }
+
+    /** 영수증 이미지 → 구조화(Claude Vision). 실패/미설정 시 empty → 호출부가 기존 OCR 로 폴백. */
+    public Optional<ParsedEntryResponse> parseReceipt(byte[] image, String mediaType, LocalDate today,
+                                                      List<String> categoryHints, List<String> walletHints) {
+        if (!enabled() || image == null || image.length == 0) {
+            log.info("[ai-parse] 영수증 건너뜀 — enabled={}, empty={}", enabled(), (image == null || image.length == 0));
+            return Optional.empty();
+        }
+        log.info("[ai-parse] 영수증 수신 — {} bytes, media={}", image.length, mediaType);
+        String system = withHints("""
+            너는 한국어 영수증 판독기다. 첨부된 영수증 이미지를 보고 거래 하나로 구조화한다.
+            반드시 아래 JSON 객체 '하나만' 출력한다(마크다운/설명 금지):
+            {"recognized":boolean,"type":"INCOME"|"EXPENSE","amount":정수(원),"merchant":"문자열","date":"YYYY-MM-DD","category":"문자열","wallet":"문자열"}
+            규칙:
+            - amount: 최종 결제/합계 금액(원 단위 정수, 부가세 포함 총액).
+            - type: 영수증은 대부분 EXPENSE. 환불 영수증이면 INCOME.
+            - merchant: 상호명(가맹점).
+            - date: 영수증의 거래일(YYYY-MM-DD). 안 보이면 오늘=__TODAY__.
+            - category: 품목/업종에 가장 알맞은 분류를 아래 '분류 후보'에서 정확히 하나 고른다. 없으면 빈 문자열. 후보에 없는 값 지어내지 말 것.
+            - wallet: 영수증에 카드사/결제수단이 보이고 아래 '결제수단 후보'에 있으면 그 이름. 아니면 빈 문자열.
+            - 영수증이 아니거나 금액을 못 읽으면 recognized=false.
+            분류 후보: __CATS__
+            결제수단 후보: __WALLETS__
+            """, today, categoryHints, walletHints);
+        String base64 = Base64.getEncoder().encodeToString(image);
+        String mt = (mediaType == null || mediaType.isBlank()) ? "image/jpeg" : mediaType;
+        List<Object> content = List.of(
+                Map.of("type", "image", "source", Map.of("type", "base64", "media_type", mt, "data", base64)),
+                Map.of("type", "text", "text", "이 영수증을 위 스키마로 구조화해줘."));
+        return callClaude(system, content, 400, today, categoryHints, walletHints);
+    }
+
+    /** 이번 달 집계(JSON) → 현황 코멘트 + 절약 가이드. 미설정/실패 시 빈 응답. */
+    public AiCommentResponse financeComment(String summaryJson) {
+        if (!enabled() || summaryJson == null || summaryJson.isBlank()) return emptyComment();
+        try {
+            String system = """
+                너는 한국어 개인 가계부 코치다. 아래 사용자의 이번 달 집계(JSON, 금액 단위 원)를 보고 두 가지를 만든다.
+                1) bullets: 현황 관찰 2~3개. 각 한 문장, 구체적 숫자 인용, 잔소리·과장 없이 담백하게.
+                   (예: 전월 대비 지출 증감, 예산 대비 소비 속도, 특정 분류 과다, 수입 대비 지출 비율)
+                2) tips: 이 사용자의 지출 패턴에 딱 맞춘 '실행 가능한' 절약 제안 2~3개. 두루뭉술한 원칙 금지,
+                   구체적 분류·습관을 지목. 각 한 문장.
+                   단, 교통·버스·지하철·대중교통 관련 분류는 이미 정기권으로 최저 비용을 사용 중이므로 tips에서 제외한다.
+                말투: 모든 문장을 정중한 종결어미로 끝낸다. 예) "~입니다", "~합니다", "~할 수 있습니다", "~하는 것이 좋습니다".
+                     반말·음슴체(예: "~함", "~줄이자") 금지.
+                예시 — bullet: "식비가 이번 달 지출의 42%로 가장 큰 비중을 차지하고 있습니다."
+                       tip: "카페 지출 8만원을 주 2회로 줄이면 약 3만원을 절약할 수 있습니다."
+                반드시 아래 JSON '하나만' 출력한다(마크다운/설명 금지):
+                {"bullets":["관찰1","관찰2"],"tips":["절약제안1","절약제안2"]}
+                데이터가 빈약하면 해당 배열을 빈 배열로.
+                """;
+            Map<String, Object> reqBody = Map.of(
+                    "model", model,
+                    "max_tokens", 600,
+                    "system", system,
+                    "messages", List.of(Map.of("role", "user", "content", summaryJson)));
+            JsonNode resp = rest.post()
+                    .uri("/v1/messages")
+                    .header("x-api-key", apiKey)
+                    .header("anthropic-version", "2023-06-01")
+                    .contentType(MediaType.APPLICATION_JSON)
+                    .body(reqBody)
+                    .retrieve()
+                    .body(JsonNode.class);
+            String out = stripFences(resp.path("content").path(0).path("text").asText("")).trim();
+            log.info("[ai-comment] 원문='{}'", out);
+            String json = extractJson(out);
+            if (json == null) return emptyComment();
+            JsonNode root = om.readTree(json);
+            List<String> bullets = strArray(root.path("bullets"));
+            List<String> tips = strArray(root.path("tips"));
+            log.info("[ai-comment] 결과 — 코멘트 {}개, 절약팁 {}개", bullets.size(), tips.size());
+            return AiCommentResponse.builder().bullets(bullets).tips(tips).build();
+        } catch (Exception e) {
+            log.warn("[ai-comment] 실패: {}", e.toString());
+            return emptyComment();
+        }
+    }
+
+    private AiCommentResponse emptyComment() {
+        return AiCommentResponse.builder().bullets(List.of()).tips(List.of()).build();
+    }
+
+    /** JsonNode 배열 → 공백 제거한 문자열 리스트. */
+    private List<String> strArray(JsonNode arr) {
+        List<String> out = new ArrayList<>();
+        if (arr != null && arr.isArray()) {
+            for (JsonNode n : arr) {
+                String s = n.asText("").trim();
+                if (!s.isEmpty()) out.add(s);
+            }
+        }
+        return out;
+    }
+
+    /** 분류·계좌 후보와 오늘 날짜를 시스템 프롬프트 템플릿에 주입. */
+    private String withHints(String body, LocalDate today, List<String> categoryHints, List<String> walletHints) {
+        String catList = (categoryHints == null || categoryHints.isEmpty()) ? "(없음)" : String.join(", ", categoryHints);
+        String walletList = (walletHints == null || walletHints.isEmpty()) ? "(없음)" : String.join(", ", walletHints);
+        return body.replace("__TODAY__", today.toString()).replace("__CATS__", catList).replace("__WALLETS__", walletList);
+    }
+
+    /** Claude Messages 호출 → 응답 JSON 파싱 → 결과. 후보에 없는 분류·계좌는 버림. 실패/미인식 시 empty. */
+    private Optional<ParsedEntryResponse> callClaude(String system, Object userContent, int maxTokens,
+                                                     LocalDate today, List<String> categoryHints, List<String> walletHints) {
+        try {
+            Map<String, Object> reqBody = Map.of(
+                    "model", model,
+                    "max_tokens", maxTokens,
+                    "system", system,
+                    "messages", List.of(Map.of("role", "user", "content", userContent)));
+            JsonNode resp = rest.post()
+                    .uri("/v1/messages")
+                    .header("x-api-key", apiKey)
+                    .header("anthropic-version", "2023-06-01")
+                    .contentType(MediaType.APPLICATION_JSON)
+                    .body(reqBody)
+                    .retrieve()
+                    .body(JsonNode.class);
+            String out = stripFences(resp.path("content").path(0).path("text").asText("")).trim();
+            log.info("[ai-parse] 모델 원문='{}'", out);
+            // 모델이 설명문을 섞어 보내도 첫 '{'~마지막 '}' 만 추출해 JSON 파싱(견고성).
+            String json = extractJson(out);
+            if (json == null) {
+                log.info("[ai-parse] JSON 없음 — 미인식으로 간주");
+                return Optional.empty();
+            }
+            JsonNode j = om.readTree(json);
+            String rawType = j.path("type").asText("EXPENSE").toUpperCase();
+            String type = ("INCOME".equals(rawType) || "TRANSFER".equals(rawType)) ? rawType : "EXPENSE";
+            LocalDate date;
+            try {
+                date = LocalDate.parse(j.path("date").asText());
+            } catch (Exception e) {
+                date = today;
+            }
+            boolean transfer = "TRANSFER".equals(type);
+            ParsedEntryResponse result = ParsedEntryResponse.builder()
+                    .recognized(j.path("recognized").asBoolean(false))
+                    .type(type)
+                    .amount(Math.max(0, j.path("amount").asLong(0)))
+                    .merchant(j.path("merchant").asText(""))
+                    .date(date)
+                    // 이체는 분류 없음
+                    .category(transfer ? "" : pickFromHints(j.path("category").asText(""), categoryHints))
+                    .wallet(pickFromHints(j.path("wallet").asText(""), walletHints))
+                    .toWallet(transfer ? pickFromHints(j.path("toWallet").asText(""), walletHints) : "")
+                    .build();
+            log.info("[ai-parse] 결과 — recognized={}, type={}, amount={}, merchant={}, date={}, category={}, wallet={}, toWallet={}",
+                    result.isRecognized(), result.getType(), result.getAmount(), result.getMerchant(), result.getDate(),
+                    result.getCategory(), result.getWallet(), result.getToWallet());
+            return Optional.of(result);
+        } catch (Exception e) {
+            log.warn("[ai-parse] 실패 → 폴백: {}", e.toString());
+            return Optional.empty();
+        }
+    }
+
+    /** 모델이 반환한 값이 후보 목록에 실제 존재할 때만 채택(대소문자·공백 무시). 없으면 빈 문자열. */
+    private String pickFromHints(String value, List<String> hints) {
+        if (value == null || value.isBlank() || hints == null) return "";
+        String v = value.trim();
+        for (String h : hints) {
+            if (h != null && h.trim().equalsIgnoreCase(v)) return h;
+        }
+        return "";
+    }
+
+    /** 설명문이 앞뒤로 붙어도 첫 '{'~마지막 '}' 구간만 잘라 JSON 만 추출. 중괄호 없으면 null. */
+    private String extractJson(String s) {
+        int a = s.indexOf('{');
+        int b = s.lastIndexOf('}');
+        if (a >= 0 && b > a) return s.substring(a, b + 1);
+        return null;
+    }
+
+    /** 모델이 ```json ... ``` 로 감쌌을 때 코드펜스 제거. */
+    private String stripFences(String s) {
+        String t = s.trim();
+        if (t.startsWith("```")) {
+            int nl = t.indexOf('\n');
+            if (nl >= 0) t = t.substring(nl + 1);
+            if (t.endsWith("```")) t = t.substring(0, t.length() - 3);
+        }
+        return t;
+    }
+}

src/main/java/com/sb/web/account/service/BackupService.java

@@ -0,0 +1,225 @@
+package com.sb.web.account.service;
+
+import com.sb.web.account.dto.AccountEntryRequest;
+import com.sb.web.account.dto.AccountTagRequest;
+import com.sb.web.account.dto.BudgetRequest;
+import com.sb.web.account.dto.CategoryRequest;
+import com.sb.web.account.dto.QuickEntryRequest;
+import com.sb.web.account.dto.RecurringRequest;
+import com.sb.web.account.dto.RestoreRequest;
+import com.sb.web.account.dto.WalletRequest;
+import com.sb.web.account.mapper.BackupMapper;
+import com.sb.web.common.exception.ApiException;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * 데이터 가져오기(복구) — 기존 데이터를 전부 삭제하고 백업(이름 기준)을 새로 재생성한다.
+ * 전체를 한 트랜잭션으로 처리해 중간 실패 시 롤백(기존 데이터 보존)된다.
+ * ※ 투자 종목/매매내역은 백업에 포함되지 않아 복구 시 삭제된다(평가액 계좌 자체는 복원).
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class BackupService {
+
+    private final BackupMapper backupMapper;
+    private final AccountService accountService;
+    private final CategoryService categoryService;
+    private final RecurringService recurringService;
+    private final BudgetService budgetService;
+    private final QuickEntryService quickEntryService;
+
+    @Transactional
+    public void deleteAll(Long memberId) {
+        backupMapper.deleteEntryTags(memberId);
+        backupMapper.deleteEntries(memberId);
+        backupMapper.deleteRecurrings(memberId);
+        backupMapper.deleteBudgets(memberId);
+        backupMapper.deleteBudgetIncome(memberId);
+        backupMapper.deleteBudgetOnetime(memberId);
+        backupMapper.deleteQuickEntries(memberId);
+        backupMapper.deleteInvestTrades(memberId);
+        backupMapper.deleteInvestHoldings(memberId);
+        backupMapper.deleteCategories(memberId);
+        backupMapper.deleteTags(memberId);
+        backupMapper.deleteWallets(memberId);
+        log.info("[deleteAll] member={} — all account data deleted", memberId);
+    }
+
+    @Transactional
+    public void restore(Long memberId, RestoreRequest req) {
+        if (isEmpty(req)) {
+            throw new ApiException(HttpStatus.BAD_REQUEST, "복구할 데이터가 비어 있습니다. 백업 파일을 확인해주세요.");
+        }
+
+        // 1) 기존 데이터 전부 삭제 (FK 안전 순서)
+        backupMapper.deleteEntryTags(memberId);
+        backupMapper.deleteEntries(memberId);
+        backupMapper.deleteRecurrings(memberId);
+        backupMapper.deleteBudgets(memberId);
+        backupMapper.deleteBudgetIncome(memberId);
+        backupMapper.deleteBudgetOnetime(memberId);
+        backupMapper.deleteQuickEntries(memberId);
+        backupMapper.deleteInvestTrades(memberId);
+        backupMapper.deleteInvestHoldings(memberId);
+        backupMapper.deleteCategories(memberId);
+        backupMapper.deleteTags(memberId);
+        backupMapper.deleteWallets(memberId);
+
+        // 2) 계좌 → 원본 id(oldId) → 새 id (같은 이름 계좌가 있어도 정확)
+        Map<Long, Long> walletMap = new HashMap<>();
+        if (req.getWallets() != null) {
+            for (RestoreRequest.Wal w : req.getWallets()) {
+                if (w == null || w.getName() == null) continue;
+                WalletRequest wr = new WalletRequest();
+                wr.setType(w.getType());
+                wr.setName(w.getName());
+                wr.setIssuer(w.getIssuer());
+                wr.setAccountNumber(w.getAccountNumber());
+                wr.setCardType(w.getCardType());
+                wr.setOpeningBalance(w.getOpeningBalance());
+                wr.setOpeningDate(w.getOpeningDate());
+                wr.setCurrentValue(w.getCurrentValue());
+                // 복원은 사용자 본인 데이터 복구이므로 무료 한도(종류별 2개)를 적용하지 않는다.
+                Long newId = accountService.createWallet(wr, memberId, true).getId();
+                if (w.getOldId() != null) walletMap.put(w.getOldId(), newId);
+            }
+        }
+
+        // 3) 태그 → 이름→새 ID
+        Map<String, Long> tagMap = new HashMap<>();
+        if (req.getTags() != null) {
+            for (String name : req.getTags()) {
+                if (name == null || name.isBlank()) continue;
+                AccountTagRequest tr = new AccountTagRequest();
+                tr.setName(name.trim());
+                tagMap.put(name.trim(), accountService.createTag(tr, memberId).getId());
+            }
+        }
+
+        // 4) 분류 — 대분류 먼저, 소분류는 부모 이름으로 매핑 ("TYPE|name" → id)
+        Map<String, Long> catMap = new HashMap<>();
+        if (req.getCategories() != null) {
+            for (RestoreRequest.Cat c : req.getCategories()) {
+                if (c.getName() == null || (c.getParent() != null && !c.getParent().isBlank())) continue;
+                CategoryRequest cr = new CategoryRequest();
+                cr.setType(c.getType());
+                cr.setName(c.getName());
+                catMap.put(key(c.getType(), c.getName()), categoryService.create(cr, memberId).getId());
+            }
+            for (RestoreRequest.Cat c : req.getCategories()) {
+                if (c.getName() == null || c.getParent() == null || c.getParent().isBlank()) continue;
+                CategoryRequest cr = new CategoryRequest();
+                cr.setType(c.getType());
+                cr.setName(c.getName());
+                cr.setParentId(catMap.get(key(c.getType(), c.getParent())));
+                categoryService.create(cr, memberId);
+            }
+        }
+
+        // 5) 내역
+        if (req.getEntries() != null) {
+            for (RestoreRequest.Entry e : req.getEntries()) {
+                if (e.getEntryDate() == null || e.getType() == null) continue;
+                Long wid = walletMap.get(e.getWalletId());
+                Long twid = walletMap.get(e.getToWalletId());
+                if (badTransfer(e.getType(), wid, twid)) continue; // 이체 계좌가 없거나 같으면 건너뜀
+                AccountEntryRequest er = new AccountEntryRequest();
+                er.setEntryDate(e.getEntryDate());
+                er.setType(e.getType());
+                er.setCategory(e.getCategory());
+                er.setAmount(e.getAmount());
+                er.setMemo(e.getMemo());
+                er.setWalletId(wid);
+                er.setToWalletId(twid);
+                er.setInstallmentMonths(e.getInstallmentMonths());
+                if (e.getTags() != null) {
+                    er.setTagIds(e.getTags().stream().map(tagMap::get).filter(Objects::nonNull).toList());
+                }
+                accountService.create(er, memberId);
+            }
+        }
+
+        // 6) 고정지출
+        if (req.getRecurrings() != null) {
+            for (RestoreRequest.Recur r : req.getRecurrings()) {
+                if (r.getTitle() == null) continue;
+                Long wid = walletMap.get(r.getWalletId());
+                Long twid = walletMap.get(r.getToWalletId());
+                if (badTransfer(r.getType(), wid, twid)) continue;
+                RecurringRequest rr = new RecurringRequest();
+                rr.setTitle(r.getTitle());
+                rr.setType(r.getType());
+                rr.setAmount(r.getAmount());
+                rr.setCategory(r.getCategory());
+                rr.setMemo(r.getMemo());
+                rr.setWalletId(wid);
+                rr.setToWalletId(twid);
+                rr.setFrequency(r.getFrequency());
+                rr.setDayOfMonth(r.getDayOfMonth());
+                rr.setDayOfWeek(r.getDayOfWeek());
+                rr.setMonthOfYear(r.getMonthOfYear());
+                rr.setStartDate(r.getStartDate());
+                rr.setEndDate(r.getEndDate());
+                rr.setActive(r.getActive() == null || r.getActive());
+                // 복원은 본인 데이터 복구이므로 무료 한도 미적용
+                recurringService.create(rr, memberId, true);
+            }
+        }
+
+        // 7) 예산 — 복구 시 현재 월 예산으로 등록(백업엔 월 정보 없음)
+        if (req.getBudgets() != null) {
+            java.time.LocalDate today = java.time.LocalDate.now();
+            for (BudgetRequest b : req.getBudgets()) {
+                if (b == null || b.getCategory() == null) continue;
+                budgetService.create(b, memberId, today.getYear(), today.getMonthValue());
+            }
+        }
+
+        // 8) 자주 쓰는 내역
+        if (req.getQuickEntries() != null) {
+            for (RestoreRequest.Quick q : req.getQuickEntries()) {
+                if (q.getType() == null) continue;
+                QuickEntryRequest qr = new QuickEntryRequest();
+                qr.setLabel(q.getLabel());
+                qr.setType(q.getType());
+                qr.setCategory(q.getCategory());
+                qr.setAmount(q.getAmount());
+                qr.setMemo(q.getMemo());
+                qr.setWalletId(walletMap.get(q.getWalletId()));
+                quickEntryService.create(qr, memberId);
+            }
+        }
+
+        log.info("[restore] member={} wallets={} entries={} restored",
+                memberId, walletMap.size(), req.getEntries() == null ? 0 : req.getEntries().size());
+    }
+
+    private static String key(String type, String name) {
+        return type + "|" + name;
+    }
+
+    /** 이체인데 출금/입금 계좌가 없거나 같으면 복구에서 제외(검증 오류로 전체 롤백 방지) */
+    private static boolean badTransfer(String type, Long walletId, Long toWalletId) {
+        return "TRANSFER".equals(type) && (walletId == null || toWalletId == null || walletId.equals(toWalletId));
+    }
+
+    private boolean isEmpty(RestoreRequest r) {
+        return empty(r.getWallets()) && empty(r.getCategories()) && empty(r.getTags())
+                && empty(r.getEntries()) && empty(r.getRecurrings()) && empty(r.getBudgets())
+                && empty(r.getQuickEntries());
+    }
+
+    private boolean empty(List<?> l) {
+        return l == null || l.isEmpty();
+    }
+}

src/main/java/com/sb/web/account/service/BudgetOnetimeService.java

@@ -0,0 +1,82 @@
+package com.sb.web.account.service;
+
+import com.sb.web.account.domain.BudgetOnetime;
+import com.sb.web.account.dto.BudgetOnetimeRequest;
+import com.sb.web.account.dto.BudgetOnetimeResponse;
+import com.sb.web.account.mapper.BudgetOnetimeMapper;
+import com.sb.web.common.exception.ApiException;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+@Service
+@RequiredArgsConstructor
+public class BudgetOnetimeService {
+
+    private final BudgetOnetimeMapper mapper;
+
+    public List<BudgetOnetimeResponse> list(Long memberId) {
+        return mapper.findByMember(memberId).stream()
+                .map(b -> {
+                    long spent = mapper.sumExpenseInRange(
+                            memberId, b.getStartDate(), b.getEndDate(), b.getCategory());
+                    return BudgetOnetimeResponse.from(b, spent);
+                })
+                .toList();
+    }
+
+    @Transactional
+    public BudgetOnetimeResponse create(BudgetOnetimeRequest req, Long memberId) {
+        validate(req);
+        BudgetOnetime b = BudgetOnetime.builder()
+                .memberId(memberId)
+                .title(req.getTitle().trim())
+                .category(blankToNull(req.getCategory()))
+                .amount(req.getAmount())
+                .startDate(req.getStartDate())
+                .endDate(req.getEndDate())
+                .build();
+        mapper.insert(b);
+        long spent = mapper.sumExpenseInRange(memberId, b.getStartDate(), b.getEndDate(), b.getCategory());
+        return BudgetOnetimeResponse.from(b, spent);
+    }
+
+    @Transactional
+    public BudgetOnetimeResponse update(Long id, BudgetOnetimeRequest req, Long memberId) {
+        validate(req);
+        BudgetOnetime b = mustFind(id, memberId);
+        b.setTitle(req.getTitle().trim());
+        b.setCategory(blankToNull(req.getCategory()));
+        b.setAmount(req.getAmount());
+        b.setStartDate(req.getStartDate());
+        b.setEndDate(req.getEndDate());
+        mapper.update(b);
+        long spent = mapper.sumExpenseInRange(memberId, b.getStartDate(), b.getEndDate(), b.getCategory());
+        return BudgetOnetimeResponse.from(b, spent);
+    }
+
+    @Transactional
+    public void delete(Long id, Long memberId) {
+        mustFind(id, memberId);
+        mapper.delete(id, memberId);
+    }
+
+    private void validate(BudgetOnetimeRequest req) {
+        if (req.getEndDate().isBefore(req.getStartDate())) {
+            throw new ApiException(HttpStatus.BAD_REQUEST, "종료일이 시작일보다 빠를 수 없습니다.");
+        }
+    }
+
+    private BudgetOnetime mustFind(Long id, Long memberId) {
+        BudgetOnetime b = mapper.findByIdAndMember(id, memberId);
+        if (b == null) throw new ApiException(HttpStatus.NOT_FOUND, "1회성 예산을 찾을 수 없습니다.");
+        return b;
+    }
+
+    private String blankToNull(String s) {
+        return (s == null || s.isBlank()) ? null : s.trim();
+    }
+}

src/main/java/com/sb/web/account/service/BudgetService.java

@@ -31,36 +31,46 @@ public class BudgetService {
     private final BudgetMapper budgetMapper;
     private final AccountEntryMapper entryMapper;
 
-    public List<BudgetResponse> list(Long memberId) {
+    public List<BudgetResponse> list(Long memberId, int year, int month) {
-        return budgetMapper.findByMember(memberId).stream().map(BudgetResponse::from).toList();
+        return budgetMapper.findByMember(memberId, year, month).stream().map(BudgetResponse::from).toList();
     }
 
     @Transactional
-    public BudgetResponse create(BudgetRequest req, Long memberId) {
+    public BudgetResponse create(BudgetRequest req, Long memberId, int year, int month) {
         String category = req.getCategory().trim();
-        if (budgetMapper.countByCategory(memberId, category, null) > 0) {
+        if (budgetMapper.countByCategory(memberId, category, null, year, month) > 0) {
             throw new ApiException(HttpStatus.CONFLICT, "이미 예산이 설정된 카테고리입니다.");
         }
         Budget budget = toBudget(req, category);
         budget.setMemberId(memberId);
+        budget.setYear(year);
+        budget.setMonth(month);
         budgetMapper.insert(budget);
         return BudgetResponse.from(budget);
     }
 
     @Transactional
     public BudgetResponse update(Long id, BudgetRequest req, Long memberId) {
-        mustFind(id, memberId);
+        Budget existing = mustFind(id, memberId);
         String category = req.getCategory().trim();
-        if (budgetMapper.countByCategory(memberId, category, id) > 0) {
+        if (budgetMapper.countByCategory(memberId, category, id, existing.getYear(), existing.getMonth()) > 0) {
             throw new ApiException(HttpStatus.CONFLICT, "이미 예산이 설정된 카테고리입니다.");
         }
         Budget budget = toBudget(req, category);
         budget.setId(id);
         budget.setMemberId(memberId);
+        budget.setYear(existing.getYear());
+        budget.setMonth(existing.getMonth());
         budgetMapper.update(budget);
         return BudgetResponse.from(budget);
     }
 
+    /** fromYear/fromMonth 예산을 toYear/toMonth 로 복사(같은 분류 덮어씀). 복사된 건수 반환 */
+    @Transactional
+    public int copy(Long memberId, int fromYear, int fromMonth, int toYear, int toMonth) {
+        return budgetMapper.copyMonth(memberId, fromYear, fromMonth, toYear, toMonth);
+    }
+
     @Transactional
     public void delete(Long id, Long memberId) {
         mustFind(id, memberId);
@@ -79,7 +89,7 @@ public class BudgetService {
         }
 
         List<BudgetStatus> result = new ArrayList<>();
-        for (Budget b : budgetMapper.findByMember(memberId)) {
+        for (Budget b : budgetMapper.findByMember(memberId, year, month)) {
             long monthlyBudget = monthlyBudget(b, daysInMonth);
             long spent = spentByCategory.getOrDefault(b.getCategory(), 0L);
             result.add(BudgetStatus.builder()
@@ -103,7 +113,8 @@ public class BudgetService {
         int y = year != null ? year : Year.now().getValue();
         int m = month != null ? month : 1;
 
-        List<Budget> budgets = budgetMapper.findByMember(memberId);
+        // 기간 차트는 선택 월의 예산을 기준으로 각 버킷에 적용(월별 예산 도입 전 동작과 동일)
+        List<Budget> budgets = budgetMapper.findByMember(memberId, y, m);
         Map<String, Long> expense = new HashMap<>();
         for (Map<String, Object> row : entryMapper.statsByPeriod(memberId, unit, year, month)) {
             expense.put(String.valueOf(((Number) row.get("bucket")).longValue()),

src/main/java/com/sb/web/account/service/CardIssuerMatcher.java

@@ -0,0 +1,44 @@
+package com.sb.web.account.service;
+
+/**
+ * 카드사명 유연 매칭.
+ * 알림에서 감지한 카드사와 사용자가 등록한 카드의 「카드사/이름」을, 표기 차이
+ * (KB / 국민 / 국민카드 / KB카드, 농협 / NH, 비씨 / BC 등)에 관계없이 같은 카드사로 인식한다.
+ */
+public final class CardIssuerMatcher {
+
+    private CardIssuerMatcher() {
+    }
+
+    /** 두 표기가 같은 카드사를 가리키면 true */
+    public static boolean matches(String walletField, String issuer) {
+        String a = canon(walletField);
+        String b = canon(issuer);
+        if (a.isEmpty() || b.isEmpty()) {
+            return false;
+        }
+        return a.equals(b) || a.contains(b) || b.contains(a);
+    }
+
+    /** 공백·접미사(카드/은행/페이/뱅크) 제거 + 동일 카드사 별칭 통합 후 소문자 키 */
+    static String canon(String s) {
+        if (s == null) {
+            return "";
+        }
+        String x = s.replaceAll("\\s+", "").toLowerCase()
+                .replace("카드", "").replace("은행", "").replace("페이", "").replace("뱅크", "");
+        if (x.contains("kb") || x.contains("국민")) {
+            return "국민";
+        }
+        if (x.contains("nh") || x.contains("농협")) {
+            return "농협";
+        }
+        if (x.equals("bc") || x.contains("비씨")) {
+            return "비씨";
+        }
+        if (x.contains("씨티") || x.contains("시티") || x.contains("citi")) {
+            return "씨티";
+        }
+        return x;
+    }
+}

src/main/java/com/sb/web/account/service/CardNotificationParser.java

@@ -0,0 +1,166 @@
+package com.sb.web.account.service;
+
+import lombok.Builder;
+import lombok.Getter;
+import org.springframework.stereotype.Component;
+
+import java.time.LocalDate;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * 결제/이체 푸시 알림 텍스트 파싱.
+ * - 카드: 승인 → 지출, 취소/환불 → 수입(환불)
+ * - 은행: 입금 → 수입, 출금/이체 → 지출
+ * 문구가 제각각이라 휴리스틱으로 종류·수입/지출·카드사(은행)·금액·가맹점·날짜를 추출한다.
+ * (서버에 두어 APK 재빌드 없이 규칙 보강 가능)
+ */
+@Component
+public class CardNotificationParser {
+
+    // 감지할 카드사/은행 (긴 이름 우선)
+    private static final List<String> ISSUERS = List.of(
+            "KB국민", "국민", "삼성", "신한", "현대", "롯데", "하나", "우리", "비씨", "BC",
+            "농협", "NH", "씨티", "카카오뱅크", "카카오", "토스", "수협", "광주", "전북", "제주",
+            "기업", "산업", "새마을", "신협", "우체국", "케이뱅크", "K뱅크"
+    );
+
+    private static final Pattern AMOUNT = Pattern.compile("([0-9]{1,3}(?:,[0-9]{3})+|[0-9]{4,})\\s*원");
+    private static final Pattern DATE_MD = Pattern.compile("(\\d{1,2})[./](\\d{1,2})");
+
+    // 명백한 광고/이벤트 표현 — 거래신호(승인/입출금/취소)가 있어도 무조건 광고로 보고 제외.
+    // (실제 카드 승인/은행 입출금 알림에는 거의 등장하지 않는 표현들)
+    private static final Pattern AD_BLOCK = Pattern.compile(
+            "이벤트|광고|쿠폰|당첨|응모|추첨|프로모션|배너|모집|혜택|초대|수신거부|마케팅|사은품|경품|세일|"
+                    + "바로가기|자세히\\s*보기|클릭|구독|뉴스레터|안내문자|광고성");
+    // 약한 광고 표현 — 명확한 거래신호 없이 '결제'만 있을 때만 광고로 간주.
+    // (실거래 영수증/알림에도 '포인트 적립' 등이 붙는 경우가 있어 무조건 차단하지 않음)
+    private static final Pattern AD_WEAK = Pattern.compile(
+            "적립|포인트|캐시백|마일리지|리워드|무료|증정|할인");
+
+    @Getter
+    @Builder
+    public static class Parsed {
+        private boolean recognized;    // 가계부에 넣을 알림으로 인식되었는가
+        private boolean income;        // true=수입(입금/환불), false=지출(승인/출금/이체)
+        private boolean bankTransfer;  // true=은행 입출금/이체, false=카드 결제
+        private String issuer;         // 감지된 카드사/은행 (없으면 null)
+        private long amount;           // 금액(원)
+        private String merchant;       // 카드:가맹점 / 은행:적요(추정)
+        private LocalDate date;        // 거래일(추정, 없으면 오늘)
+        private String notifKey;       // 중복방지 키
+    }
+
+    /** 알림 파싱. recognized=false 면 가계부 대상 아님(무시). */
+    public Parsed parse(String title, String text, LocalDate today) {
+        String raw = ((title == null ? "" : title) + "\n" + (text == null ? "" : text)).trim();
+        if (raw.isBlank()) return notRecognized();
+
+        boolean deposit = raw.contains("입금");
+        boolean withdraw = raw.contains("출금") || raw.contains("이체") || raw.contains("송금");
+        boolean refund = raw.contains("취소") || raw.contains("환불");
+        boolean approval = raw.contains("승인") || raw.contains("일시불") || raw.contains("할부");
+        // '결제'는 광고 문구("결제하고 적립")에도 흔해 약신호로만 취급(단독으론 광고 의심)
+        boolean weakApproval = raw.contains("결제");
+
+        Matcher am = AMOUNT.matcher(raw);
+        boolean realSignal = approval || deposit || withdraw || refund;  // 명확한 거래신호
+        boolean anySignal = realSignal || weakApproval;
+        if (!am.find() || !anySignal) {
+            return notRecognized();
+        }
+        // 1) 명백한 광고/이벤트 표현이면 거래신호가 있어도 무시(광고 푸시·문자 오등록 방지)
+        if (AD_BLOCK.matcher(raw).find()) {
+            return notRecognized();
+        }
+        // 2) 약한 광고 표현(적립/포인트/할인 등)은 명확한 거래신호 없이 '결제'만 있으면 광고로 간주
+        if (!realSignal && AD_WEAK.matcher(raw).find()) {
+            return notRecognized();
+        }
+        long amount = Long.parseLong(am.group(1).replace(",", ""));
+
+        // 수입/지출: 입금·취소·환불 = 수입, 그 외(승인/결제/출금/이체) = 지출
+        boolean income = deposit || refund;
+        // 은행 이체성: 카드 승인 신호 없이 입금/출금/이체 → 은행 거래(카드사 대신 은행 계좌에 매칭)
+        boolean bankTransfer = (deposit || withdraw) && !approval;
+
+        String issuer = detectIssuer(raw);
+        String merchant = guessMerchant(raw);
+        LocalDate date = guessDate(raw, today);
+
+        String notifKey = (issuer == null ? "?" : issuer) + "|" + amount + "|"
+                + (merchant == null ? "" : merchant) + "|" + date + "|"
+                + (income ? "I" : "E") + (bankTransfer ? "B" : "C");
+
+        return Parsed.builder()
+                .recognized(true)
+                .income(income)
+                .bankTransfer(bankTransfer)
+                .issuer(issuer)
+                .amount(amount)
+                .merchant(merchant)
+                .date(date)
+                .notifKey(notifKey)
+                .build();
+    }
+
+    private Parsed notRecognized() {
+        return Parsed.builder().recognized(false).build();
+    }
+
+    private String detectIssuer(String raw) {
+        for (String c : ISSUERS) {
+            if (raw.contains(c)) return c;
+        }
+        return null;
+    }
+
+    private LocalDate guessDate(String raw, LocalDate today) {
+        Matcher m = DATE_MD.matcher(raw);
+        while (m.find()) {
+            int mo = Integer.parseInt(m.group(1));
+            int d = Integer.parseInt(m.group(2));
+            if (mo >= 1 && mo <= 12 && d >= 1 && d <= 31) {
+                try {
+                    LocalDate cand = LocalDate.of(today.getYear(), mo, d);
+                    // 미래 날짜(연말연초 경계)면 작년으로
+                    return cand.isAfter(today.plusDays(1)) ? cand.minusYears(1) : cand;
+                } catch (Exception ignore) {
+                    // 다음 후보
+                }
+            }
+        }
+        return today;
+    }
+
+    /**
+     * 가맹점/적요 추정: 잡음(카드사·문구·금액·날짜·시간·마스킹 이름 등)을 제거한 뒤
+     * 남은 한글/영문 토큰 중 가장 그럴듯한 것을 고른다. (완벽하지 않음 — 사용자가 확정 시 수정)
+     */
+    private String guessMerchant(String raw) {
+        String s = raw
+                .replaceAll("\\[?\\s*Web발신\\s*]?", " ")
+                .replaceAll("[0-9]{1,3}(?:,[0-9]{3})+\\s*원|[0-9]{4,}\\s*원", " ") // 금액
+                .replaceAll("\\d{1,2}[:시]\\d{2}분?", " ")                          // 시간
+                .replaceAll("\\d{1,2}[./]\\d{1,2}", " ")                              // 날짜
+                .replaceAll("\\([^)]*\\)", " ")                                        // 괄호(카드 끝번호 등)
+                .replaceAll("승인취소|취소승인|승인|결제|취소|환불|일시불|할부|누적|잔액|출금|입금|이체|송금|체크|신용", " ")
+                .replaceAll("[가-힣]\\*+[가-힣]?", " ");                               // 마스킹 이름(홍*동)
+        for (String c : ISSUERS) {
+            s = s.replace(c, " ");
+        }
+        s = s.replace("카드", " ").replace("은행", " ");
+        String[] tokens = s.trim().split("\\s+");
+        String best = null;
+        for (String t : tokens) {
+            String tok = t.replaceAll("[^0-9A-Za-z가-힣]", "").trim();
+            if (tok.length() < 2 || tok.length() > 20) continue;
+            if (tok.matches("\\d+")) continue;
+            if (!tok.matches(".*[가-힣A-Za-z].*")) continue;
+            // 더 긴(구체적인) 토큰을 가맹점으로 선호
+            if (best == null || tok.length() > best.length()) best = tok;
+        }
+        return best;
+    }
+}

src/main/java/com/sb/web/account/service/CategoryService.java

@@ -1,21 +1,24 @@
 package com.sb.web.account.service;
 
 import com.sb.web.account.domain.AccountCategory;
+import com.sb.web.account.domain.DefaultCategory;
 import com.sb.web.account.dto.CategoryRequest;
 import com.sb.web.account.dto.CategoryResponse;
 import com.sb.web.account.mapper.AccountEntryMapper;
 import com.sb.web.account.mapper.BudgetMapper;
 import com.sb.web.account.mapper.CategoryMapper;
+import com.sb.web.account.mapper.DefaultCategoryMapper;
 import com.sb.web.common.exception.ApiException;
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.HttpStatus;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.util.HashMap;
 import java.util.List;
-
+import java.util.Map;
 /**
- * 분류(카테고리) 서비스. 사용자별 CRUD, 이름 변경 시 내역·예산 전파, 기존 분류 불러오기.
+ * 분류(카테고리) 서비스. 사용자별 CRUD, 이름 변경 시 내역·예산 전파, 기본분류 불러오기.
  */
 @Service
 @RequiredArgsConstructor
@@ -24,6 +27,7 @@ public class CategoryService {
     private final CategoryMapper categoryMapper;
     private final AccountEntryMapper entryMapper;
     private final BudgetMapper budgetMapper;
+    private final DefaultCategoryMapper defaultCategoryMapper;
 
     public List<CategoryResponse> list(Long memberId) {
         return categoryMapper.findByMember(memberId).stream().map(CategoryResponse::from).toList();
@@ -35,13 +39,45 @@ public class CategoryService {
         if (categoryMapper.countByName(memberId, req.getType(), name, null) > 0) {
             throw new ApiException(HttpStatus.CONFLICT, "이미 존재하는 분류입니다.");
         }
+        validateParent(req.getParentId(), req.getType(), memberId);
+        Integer max = categoryMapper.maxSortOrder(memberId, req.getType());
+        int order = (max == null ? 0 : max + 1);
         AccountCategory c = AccountCategory.builder()
-                .memberId(memberId).type(req.getType()).name(name).sortOrder(0).build();
+                .memberId(memberId).type(req.getType()).name(name)
+                .parentId(req.getParentId()).sortOrder(order).build();
         categoryMapper.insert(c);
         return CategoryResponse.from(c);
     }
 
-    /** 이름만 변경 가능. 변경 시 기존 내역·예산의 분류명도 함께 갱신 */
+    /** 대분류 지정 검증: null=대분류 / 값=대분류여야(2단계 제한·동일타입·본인) */
+    private void validateParent(Long parentId, String type, Long memberId) {
+        if (parentId == null) {
+            return;
+        }
+        AccountCategory parent = categoryMapper.findByIdAndMember(parentId, memberId);
+        if (parent == null || !parent.getType().equals(type)) {
+            throw new ApiException(HttpStatus.BAD_REQUEST, "대분류가 올바르지 않습니다.");
+        }
+        if (parent.getParentId() != null) {
+            throw new ApiException(HttpStatus.BAD_REQUEST, "대분류 아래에만 소분류를 둘 수 있습니다(2단계).");
+        }
+    }
+
+    /** 드래그앤드랍 순서 변경: 전달된 id 순서대로 sort_order 재설정 (본인·동일 타입만) */
+    @Transactional
+    public List<CategoryResponse> reorder(Long memberId, String type, List<Long> ids) {
+        int i = 0;
+        for (Long id : ids) {
+            AccountCategory c = categoryMapper.findByIdAndMember(id, memberId);
+            if (c != null && c.getType().equals(type)) {
+                categoryMapper.updateSortOrder(id, memberId, i++);
+            }
+        }
+        return list(memberId);
+    }
+
+    /** 이름 변경 + 대분류 이동. 이름 변경 시 기존 내역·예산의 분류명도 함께 갱신.
+     *  주의: parentId 는 항상 현재값(또는 새 대분류)을 보내야 한다(미전송 시 대분류로 풀림). */
     @Transactional
     public CategoryResponse update(Long id, CategoryRequest req, Long memberId) {
         AccountCategory c = mustFind(id, memberId);
@@ -49,8 +85,20 @@ public class CategoryService {
         if (categoryMapper.countByName(memberId, c.getType(), newName, id) > 0) {
             throw new ApiException(HttpStatus.CONFLICT, "이미 존재하는 분류입니다.");
         }
+        Long newParent = req.getParentId();
+        if (newParent != null) {
+            if (newParent.equals(id)) {
+                throw new ApiException(HttpStatus.BAD_REQUEST, "자기 자신을 대분류로 지정할 수 없습니다.");
+            }
+            // 소분류를 가진 대분류는 소분류로 바꿀 수 없음(3단계 방지)
+            if (categoryMapper.countChildren(memberId, id) > 0) {
+                throw new ApiException(HttpStatus.BAD_REQUEST, "소분류가 있는 대분류는 소분류로 바꿀 수 없습니다.");
+            }
+        }
+        validateParent(newParent, c.getType(), memberId);
         String oldName = c.getName();
         c.setName(newName);
+        c.setParentId(newParent);
         categoryMapper.update(c);
         if (!oldName.equals(newName)) {
             entryMapper.renameCategory(memberId, c.getType(), oldName, newName);
@@ -64,21 +112,48 @@ public class CategoryService {
     @Transactional
     public void delete(Long id, Long memberId) {
         mustFind(id, memberId);
+        if (categoryMapper.countChildren(memberId, id) > 0) {
+            throw new ApiException(HttpStatus.BAD_REQUEST, "소분류가 있는 대분류는 삭제할 수 없습니다. 소분류를 먼저 옮기거나 삭제하세요.");
+        }
         categoryMapper.delete(id, memberId);
     }
 
-    /** 기존 내역에 쓰인 분류명을 분류 목록으로 가져오기 (중복 무시) */
+    /** 관리자가 정의한 기본(디폴트) 분류를 내 분류로 복사 (대/소분류 계층 유지, 같은 이름은 건너뜀) */
     @Transactional
-    public List<CategoryResponse> importFromEntries(Long memberId) {
+    public List<CategoryResponse> importDefaults(Long memberId) {
-        for (String type : new String[]{"INCOME", "EXPENSE"}) {
+        List<DefaultCategory> defaults = defaultCategoryMapper.findAll();
-            for (String name : entryMapper.findDistinctCategories(memberId, type)) {
+        // 1) 대분류 먼저 생성/확보 → default.id → 내 분류.id 매핑
-                categoryMapper.insertIgnore(AccountCategory.builder()
+        Map<Long, Long> majorMap = new HashMap<>();
-                        .memberId(memberId).type(type).name(name).sortOrder(0).build());
+        for (DefaultCategory d : defaults) {
+            if (d.getParentId() != null) {
+                continue;
             }
+            majorMap.put(d.getId(), ensureCategory(memberId, d.getType(), d.getName(), null));
+        }
+        // 2) 소분류 생성 (매핑된 대분류 아래; 부모 매핑이 없으면 대분류로 취급)
+        for (DefaultCategory d : defaults) {
+            if (d.getParentId() == null) {
+                continue;
+            }
+            ensureCategory(memberId, d.getType(), d.getName(), majorMap.get(d.getParentId()));
         }
         return list(memberId);
     }
 
+    /** 같은 이름 분류가 있으면 그 id, 없으면 생성해서 id 반환 */
+    private Long ensureCategory(Long memberId, String type, String name, Long parentId) {
+        AccountCategory existing = categoryMapper.findByMemberTypeName(memberId, type, name);
+        if (existing != null) {
+            return existing.getId();
+        }
+        Integer max = categoryMapper.maxSortOrder(memberId, type);
+        AccountCategory c = AccountCategory.builder()
+                .memberId(memberId).type(type).name(name).parentId(parentId)
+                .sortOrder(max == null ? 0 : max + 1).build();
+        categoryMapper.insert(c);
+        return c.getId();
+    }
+
     private AccountCategory mustFind(Long id, Long memberId) {
         AccountCategory c = categoryMapper.findByIdAndMember(id, memberId);
         if (c == null) {

src/main/java/com/sb/web/account/service/DefaultCategorySeeder.java

@@ -0,0 +1,75 @@
+package com.sb.web.account.service;
+
+import com.sb.web.account.domain.DefaultCategory;
+import com.sb.web.account.mapper.DefaultCategoryMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.boot.ApplicationArguments;
+import org.springframework.boot.ApplicationRunner;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 기본(디폴트) 분류 초기 시드. default_category 가 비어 있을 때만 한 번 생성한다.
+ * (관리자가 이후 자유롭게 수정/삭제 가능 — 비어 있을 때만 채우므로 운영 데이터를 덮어쓰지 않음)
+ */
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class DefaultCategorySeeder implements ApplicationRunner {
+
+    private final DefaultCategoryMapper mapper;
+
+    // 대분류 → 소분류 목록 (입력 순서 유지)
+    private static final Map<String, List<String>> EXPENSE = new LinkedHashMap<>();
+    private static final Map<String, List<String>> INCOME = new LinkedHashMap<>();
+
+    static {
+        EXPENSE.put("식비", List.of("외식", "식료품", "카페/간식", "배달"));
+        EXPENSE.put("교통", List.of("대중교통", "택시", "주유", "주차/통행료"));
+        EXPENSE.put("주거/통신", List.of("월세/관리비", "공과금", "통신비", "인터넷"));
+        EXPENSE.put("생활", List.of("생필품", "의류/미용", "가구/가전"));
+        EXPENSE.put("건강/의료", List.of("병원", "약국", "운동"));
+        EXPENSE.put("문화/여가", List.of("영화/공연", "여행", "취미", "구독서비스"));
+        EXPENSE.put("교육", List.of("학원", "도서", "강의"));
+        EXPENSE.put("경조사", List.of("축의금", "부의금", "선물"));
+        EXPENSE.put("금융", List.of("보험", "대출이자", "수수료"));
+        EXPENSE.put("기타", List.of());
+
+        INCOME.put("급여", List.of("월급", "상여금"));
+        INCOME.put("부수입", List.of("용돈", "이자/배당", "환급"));
+        INCOME.put("기타수입", List.of("중고판매", "기타"));
+    }
+
+    @Override
+    @Transactional
+    public void run(ApplicationArguments args) {
+        if (!mapper.findAll().isEmpty()) {
+            return; // 이미 데이터가 있으면 시드하지 않음
+        }
+        int n = seed("EXPENSE", EXPENSE) + seed("INCOME", INCOME);
+        log.info("[default-category] 기본 분류 시드 생성: {}건", n);
+    }
+
+    private int seed(String type, Map<String, List<String>> tree) {
+        int count = 0;
+        int majorOrder = 0;
+        for (Map.Entry<String, List<String>> e : tree.entrySet()) {
+            DefaultCategory major = DefaultCategory.builder()
+                    .type(type).name(e.getKey()).parentId(null).sortOrder(majorOrder++).build();
+            mapper.insert(major); // 생성키(id) 채워짐
+            count++;
+            int subOrder = 0;
+            for (String child : e.getValue()) {
+                mapper.insert(DefaultCategory.builder()
+                        .type(type).name(child).parentId(major.getId()).sortOrder(subOrder++).build());
+                count++;
+            }
+        }
+        return count;
+    }
+}

src/main/java/com/sb/web/account/service/DefaultCategoryService.java

@@ -0,0 +1,114 @@
+package com.sb.web.account.service;
+
+import com.sb.web.account.domain.DefaultCategory;
+import com.sb.web.account.dto.CategoryReorderRequest;
+import com.sb.web.account.dto.CategoryRequest;
+import com.sb.web.account.dto.CategoryResponse;
+import com.sb.web.account.mapper.DefaultCategoryMapper;
+import com.sb.web.common.exception.ApiException;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+/**
+ * 기본(디폴트) 분류 서비스 — 전체 공용 템플릿(관리자 전용 CRUD). 2단계(대/소분류) 제한.
+ */
+@Service
+@RequiredArgsConstructor
+public class DefaultCategoryService {
+
+    private final DefaultCategoryMapper mapper;
+
+    public List<CategoryResponse> list() {
+        return mapper.findAll().stream().map(this::toResponse).toList();
+    }
+
+    @Transactional
+    public CategoryResponse create(CategoryRequest req) {
+        String name = req.getName().trim();
+        if (mapper.countByName(req.getType(), name, null) > 0) {
+            throw new ApiException(HttpStatus.CONFLICT, "이미 존재하는 분류입니다.");
+        }
+        validateParent(req.getParentId(), req.getType());
+        Integer max = mapper.maxSortOrder(req.getType());
+        DefaultCategory c = DefaultCategory.builder()
+                .type(req.getType()).name(name).parentId(req.getParentId())
+                .sortOrder(max == null ? 0 : max + 1).build();
+        mapper.insert(c);
+        return toResponse(c);
+    }
+
+    @Transactional
+    public CategoryResponse update(Long id, CategoryRequest req) {
+        DefaultCategory c = mustFind(id);
+        String newName = req.getName().trim();
+        if (mapper.countByName(c.getType(), newName, id) > 0) {
+            throw new ApiException(HttpStatus.CONFLICT, "이미 존재하는 분류입니다.");
+        }
+        Long newParent = req.getParentId();
+        if (newParent != null) {
+            if (newParent.equals(id)) {
+                throw new ApiException(HttpStatus.BAD_REQUEST, "자기 자신을 대분류로 지정할 수 없습니다.");
+            }
+            if (mapper.countChildren(id) > 0) {
+                throw new ApiException(HttpStatus.BAD_REQUEST, "소분류가 있는 대분류는 소분류로 바꿀 수 없습니다.");
+            }
+        }
+        validateParent(newParent, c.getType());
+        c.setName(newName);
+        c.setParentId(newParent);
+        mapper.update(c);
+        return toResponse(c);
+    }
+
+    @Transactional
+    public void delete(Long id) {
+        mustFind(id);
+        if (mapper.countChildren(id) > 0) {
+            throw new ApiException(HttpStatus.BAD_REQUEST, "소분류가 있는 대분류는 삭제할 수 없습니다. 소분류를 먼저 옮기거나 삭제하세요.");
+        }
+        mapper.delete(id);
+    }
+
+    @Transactional
+    public List<CategoryResponse> reorder(CategoryReorderRequest req) {
+        int i = 0;
+        for (Long id : req.getIds()) {
+            DefaultCategory c = mapper.findById(id);
+            if (c != null && c.getType().equals(req.getType())) {
+                mapper.updateSortOrder(id, i++);
+            }
+        }
+        return list();
+    }
+
+    private void validateParent(Long parentId, String type) {
+        if (parentId == null) {
+            return;
+        }
+        DefaultCategory parent = mapper.findById(parentId);
+        if (parent == null || !parent.getType().equals(type)) {
+            throw new ApiException(HttpStatus.BAD_REQUEST, "대분류가 올바르지 않습니다.");
+        }
+        if (parent.getParentId() != null) {
+            throw new ApiException(HttpStatus.BAD_REQUEST, "대분류 아래에만 소분류를 둘 수 있습니다(2단계).");
+        }
+    }
+
+    private DefaultCategory mustFind(Long id) {
+        DefaultCategory c = mapper.findById(id);
+        if (c == null) {
+            throw new ApiException(HttpStatus.NOT_FOUND, "기본 분류를 찾을 수 없습니다.");
+        }
+        return c;
+    }
+
+    private CategoryResponse toResponse(DefaultCategory c) {
+        return CategoryResponse.builder()
+                .id(c.getId()).type(c.getType()).name(c.getName()).parentId(c.getParentId())
+                .build();
+    }
+}

src/main/java/com/sb/web/account/service/FxService.java

@@ -0,0 +1,73 @@
+package com.sb.web.account.service;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.web.client.RestClient;
+
+import java.math.BigDecimal;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * 환율 조회. open.er-api.com(무료·무인증) 사용. 통화(base)별로 하루 1회만 호출하고 캐시.
+ * 실패해도 예외를 던지지 않고 null(또는 직전 캐시) 반환.
+ */
+@Slf4j
+@Service
+public class FxService {
+
+    private static final String URL = "https://open.er-api.com/v6/latest/{base}";
+    private final RestClient restClient = RestClient.builder().build();
+
+    private record Cached(LocalDate date, Instant fetchedAt, JsonNode rates) {}
+    private final Map<String, Cached> cache = new ConcurrentHashMap<>();
+
+    /** from 통화 1단위 → to 통화 환율. 조회 실패 시 null. */
+    /** 해당 통화 환율이 마지막으로 캐시된 시각. 캐시 없으면 null. */
+    public Instant getCachedAt(String from) {
+        if (from == null) return null;
+        Cached c = cache.get(from.trim().toUpperCase());
+        return c != null ? c.fetchedAt() : null;
+    }
+
+    /** from 통화 1단위 → to 통화 환율. 조회 실패 시 null. */
+    public BigDecimal getRate(String from, String to) {
+        if (from == null || to == null) return null;
+        String base = from.trim().toUpperCase();
+        String target = to.trim().toUpperCase();
+        if (base.isEmpty() || target.isEmpty()) return null;
+        if (base.equals(target)) return BigDecimal.ONE;
+        JsonNode rates = ratesFor(base);
+        if (rates == null) return null;
+        JsonNode r = rates.get(target);
+        return (r != null && r.isNumber()) ? r.decimalValue() : null;
+    }
+
+    private JsonNode ratesFor(String base) {
+        Cached c = cache.get(base);
+        LocalDate today = LocalDate.now();
+        if (c != null && c.date().equals(today)) return c.rates();
+        try {
+            JsonNode root = restClient.get()
+                    .uri(URL, base)
+                    .header("User-Agent", "Mozilla/5.0")
+                    .retrieve()
+                    .body(JsonNode.class);
+            if (root == null || !"success".equals(root.path("result").asText())) {
+                return c != null ? c.rates() : null;
+            }
+            JsonNode rates = root.path("rates");
+            if (rates.isMissingNode() || !rates.isObject()) {
+                return c != null ? c.rates() : null;
+            }
+            cache.put(base, new Cached(today, Instant.now(), rates));
+            return rates;
+        } catch (Exception e) {
+            log.warn("환율 조회 실패 base={}: {}", base, e.toString());
+            return c != null ? c.rates() : null; // 실패 시 직전 캐시라도
+        }
+    }
+}

src/main/java/com/sb/web/account/service/InvestService.java

@@ -15,6 +15,8 @@ import org.springframework.http.HttpStatus;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.math.BigDecimal;
+import java.math.RoundingMode;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -29,6 +31,7 @@ public class InvestService {
 
     private final InvestMapper investMapper;
     private final WalletMapper walletMapper;
+    private final StockQuoteService stockQuoteService;
 
     /* ===================== 보유 종목 ===================== */
 
@@ -71,6 +74,37 @@ public class InvestService {
         investMapper.deleteHolding(id, memberId);
     }
 
+    /** 종목코드가 있는 보유종목의 현재가를 시세 조회로 갱신. 조회 성공한 종목만 반영 */
+    @Transactional
+    public List<HoldingResponse> refreshPrices(Long memberId, Long walletId) {
+        requireInvestWallet(walletId, memberId);
+        Map<String, Long> cache = new HashMap<>();
+        for (InvestHolding h : investMapper.findHoldingsByWallet(memberId, walletId)) {
+            applyQuote(h, cache);
+        }
+        return listHoldings(memberId, walletId);
+    }
+
+    /** 회원의 모든 투자계좌 보유종목 현재가를 일괄 갱신(계좌 목록 평가액 반영용) */
+    @Transactional
+    public void refreshAllPrices(Long memberId) {
+        Map<String, Long> cache = new HashMap<>();
+        for (InvestHolding h : investMapper.findHoldingsByMember(memberId)) {
+            applyQuote(h, cache);
+        }
+    }
+
+    /** 종목코드로 시세를 받아 현재가 갱신(동일 종목코드는 호출당 1회만 조회) */
+    private void applyQuote(InvestHolding h, Map<String, Long> cache) {
+        String ticker = h.getTicker();
+        if (ticker == null || ticker.isBlank()) return;
+        Long price = cache.computeIfAbsent(ticker.trim(), stockQuoteService::getDomesticPrice);
+        if (price != null && price > 0) {
+            h.setCurrentPrice(price);
+            investMapper.updateHolding(h);
+        }
+    }
+
     /* ===================== 매매 ===================== */
 
     public List<TradeResponse> listTrades(Long holdingId, Long memberId) {
@@ -86,9 +120,9 @@ public class InvestService {
         String type = "SELL".equals(req.getTradeType()) ? "SELL" : "BUY";
         if ("SELL".equals(type)) {
             Calc c = calc(investMapper.findTradesByHolding(holdingId, memberId));
-            if (req.getQuantity() > c.quantity()) {
+            if (req.getQuantity().compareTo(c.quantity()) > 0) {
                 throw new ApiException(HttpStatus.BAD_REQUEST,
-                        "매도 수량이 보유수량(" + c.quantity() + ")을 초과합니다.");
+                        "매도 수량이 보유수량(" + c.quantity().stripTrailingZeros().toPlainString() + ")을 초과합니다.");
             }
         }
         InvestTrade t = InvestTrade.builder()
@@ -104,6 +138,50 @@ public class InvestService {
         return TradeResponse.from(t);
     }
 
+    @Transactional
+    public TradeResponse updateTrade(Long id, TradeRequest req, Long memberId) {
+        InvestTrade existing = investMapper.findTradeByIdAndMember(id, memberId);
+        if (existing == null) {
+            throw new ApiException(HttpStatus.NOT_FOUND, "매매 내역을 찾을 수 없습니다.");
+        }
+        Long holdingId = existing.getHoldingId();
+        String type = "SELL".equals(req.getTradeType()) ? "SELL" : "BUY";
+        long fee = req.getFee() != null ? req.getFee() : 0L;
+
+        // 편집을 반영한 시점별 시뮬레이션 — 어느 시점에도 보유수량이 음수가 되면 거부
+        java.util.List<InvestTrade> sim = new java.util.ArrayList<>();
+        for (InvestTrade t : investMapper.findTradesByHolding(holdingId, memberId)) {
+            if (t.getId().equals(id)) {
+                sim.add(InvestTrade.builder().id(id).tradeType(type).tradeDate(req.getTradeDate())
+                        .quantity(req.getQuantity()).price(req.getPrice()).fee(fee).build());
+            } else {
+                sim.add(t);
+            }
+        }
+        sim.sort(java.util.Comparator.comparing(InvestTrade::getTradeDate)
+                .thenComparing(InvestTrade::getId));
+        BigDecimal running = BigDecimal.ZERO;
+        for (InvestTrade t : sim) {
+            if ("BUY".equals(t.getTradeType())) {
+                running = running.add(t.getQuantity());
+            } else {
+                running = running.subtract(t.getQuantity());
+                if (running.signum() < 0) {
+                    throw new ApiException(HttpStatus.BAD_REQUEST,
+                            "수정하면 보유수량이 음수가 됩니다. 매도 수량/순서를 확인하세요.");
+                }
+            }
+        }
+
+        existing.setTradeType(type);
+        existing.setTradeDate(req.getTradeDate());
+        existing.setQuantity(req.getQuantity());
+        existing.setPrice(req.getPrice());
+        existing.setFee(fee);
+        investMapper.updateTrade(existing);
+        return TradeResponse.from(existing);
+    }
+
     @Transactional
     public void deleteTrade(Long id, Long memberId) {
         if (investMapper.findTradeByIdAndMember(id, memberId) == null) {
@@ -124,7 +202,7 @@ public class InvestService {
             long evalPrice = h.getCurrentPrice() != null ? h.getCurrentPrice() : c.avgPrice();
             WalletInvest wi = result.computeIfAbsent(h.getWalletId(), k -> new WalletInvest());
             wi.cashDelta += cashDelta(trades);
-            wi.stockEval += c.quantity() * evalPrice;
+            wi.stockEval += amountOf(c.quantity(), evalPrice);
         }
         return result;
     }
@@ -145,25 +223,28 @@ public class InvestService {
         return map;
     }
 
-    /** 매매이력(시간순)으로 보유수량·원가·실현손익 산출 */
+    /** 매매이력(시간순)으로 보유수량·원가·실현손익 산출. 수량은 소수점, 금액은 원 단위 정수. */
     private Calc calc(List<InvestTrade> trades) {
-        long qty = 0, costBasis = 0, realized = 0;
+        BigDecimal qty = BigDecimal.ZERO;
+        long costBasis = 0, realized = 0;
         for (InvestTrade t : trades) {
-            long amount = t.getQuantity() * t.getPrice();
+            long amount = amountOf(t.getQuantity(), t.getPrice());
             long fee = t.getFee() != null ? t.getFee() : 0L;
             if ("BUY".equals(t.getTradeType())) {
-                qty += t.getQuantity();
+                qty = qty.add(t.getQuantity());
                 costBasis += amount + fee;
             } else { // SELL
-                long costRemoved = (qty > 0 && t.getQuantity() < qty)
+                // 부분 매도 시 보유원가를 수량 비율로 제거, 전량 매도 시 잔여 원가 전부 제거(반올림 잔차 방지)
-                        ? Math.round(costBasis * (double) t.getQuantity() / qty)
+                boolean partial = qty.signum() > 0 && t.getQuantity().compareTo(qty) < 0;
-                        : costBasis; // 전량 매도 시 잔여 원가 전부 제거(반올림 잔차 방지)
+                long costRemoved = partial
+                        ? Math.round(costBasis * t.getQuantity().doubleValue() / qty.doubleValue())
+                        : costBasis;
                 long proceeds = amount - fee;
                 realized += proceeds - costRemoved;
                 costBasis -= costRemoved;
-                qty -= t.getQuantity();
+                qty = qty.subtract(t.getQuantity());
-                if (qty <= 0) {
+                if (qty.signum() <= 0) {
-                    qty = 0;
+                    qty = BigDecimal.ZERO;
                     costBasis = 0;
                 }
             }
@@ -171,17 +252,24 @@ public class InvestService {
         return new Calc(qty, costBasis, realized);
     }
 
-    private record Calc(long quantity, long costBasis, long realized) {
+    private record Calc(BigDecimal quantity, long costBasis, long realized) {
         long avgPrice() {
-            return quantity > 0 ? Math.round(costBasis / (double) quantity) : 0;
+            return quantity.signum() > 0 ? Math.round(costBasis / quantity.doubleValue()) : 0;
         }
     }
 
+    /** 거래금액(원) = 수량 × 단가, 원 단위 반올림 */
+    private static long amountOf(BigDecimal quantity, long price) {
+        return quantity.multiply(BigDecimal.valueOf(price))
+                .setScale(0, RoundingMode.HALF_UP)
+                .longValue();
+    }
+
     /** 매매로 인한 예수금 증감 = −Σ매수(금액+수수료) + Σ매도(금액−수수료) */
     private long cashDelta(List<InvestTrade> trades) {
         long cashDelta = 0;
         for (InvestTrade t : trades) {
-            long amount = t.getQuantity() * t.getPrice();
+            long amount = amountOf(t.getQuantity(), t.getPrice());
             long fee = t.getFee() != null ? t.getFee() : 0L;
             cashDelta += "BUY".equals(t.getTradeType()) ? -(amount + fee) : (amount - fee);
         }
@@ -192,7 +280,7 @@ public class InvestService {
         Calc c = calc(trades);
         long avgPrice = c.avgPrice();
         long evalPrice = h.getCurrentPrice() != null ? h.getCurrentPrice() : avgPrice;
-        long evalValue = c.quantity() * evalPrice;
+        long evalValue = amountOf(c.quantity(), evalPrice);
         long evalGain = evalValue - c.costBasis();
         Double returnPct = c.costBasis() > 0 ? Math.round(evalGain * 1000.0 / c.costBasis()) / 10.0 : null;
         return HoldingResponse.builder()

src/main/java/com/sb/web/account/service/QuickEntryService.java

@@ -0,0 +1,56 @@
+package com.sb.web.account.service;
+
+import com.sb.web.account.domain.QuickEntry;
+import com.sb.web.account.dto.QuickEntryRequest;
+import com.sb.web.account.dto.QuickEntryResponse;
+import com.sb.web.account.mapper.QuickEntryMapper;
+import com.sb.web.common.exception.ApiException;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+/**
+ * 자주 쓰는 내역(빠른 등록 템플릿) 서비스 — 사용자별.
+ */
+@Service
+@RequiredArgsConstructor
+public class QuickEntryService {
+
+    private final QuickEntryMapper mapper;
+
+    public List<QuickEntryResponse> list(Long memberId) {
+        return mapper.findByMember(memberId).stream().map(QuickEntryResponse::from).toList();
+    }
+
+    @Transactional
+    public QuickEntryResponse create(QuickEntryRequest req, Long memberId) {
+        Integer max = mapper.maxSortOrder(memberId);
+        QuickEntry e = QuickEntry.builder()
+                .memberId(memberId)
+                .label(blankToNull(req.getLabel()))
+                .type(req.getType())
+                .category("EXPENSE".equals(req.getType()) || "INCOME".equals(req.getType()) ? blankToNull(req.getCategory()) : null)
+                .amount(req.getAmount())
+                .memo(blankToNull(req.getMemo()))
+                .walletId(req.getWalletId())
+                .sortOrder(max == null ? 0 : max + 1)
+                .build();
+        mapper.insert(e);
+        return QuickEntryResponse.from(mapper.findByIdAndMember(e.getId(), memberId));
+    }
+
+    @Transactional
+    public void delete(Long id, Long memberId) {
+        if (mapper.findByIdAndMember(id, memberId) == null) {
+            throw new ApiException(HttpStatus.NOT_FOUND, "자주 쓰는 내역을 찾을 수 없습니다.");
+        }
+        mapper.delete(id, memberId);
+    }
+
+    private String blankToNull(String s) {
+        return (s == null || s.isBlank()) ? null : s.trim();
+    }
+}

src/main/java/com/sb/web/account/service/RecurringService.java

@@ -30,8 +30,15 @@ public class RecurringService {
         return recurringMapper.findByMember(memberId).stream().map(this::toResponse).toList();
     }
 
+    // 무료 회원 고정지출 등록 한도(써보고 → 결제 유도). 유료·관리자는 무제한.
+    public static final int FREE_RECURRING_LIMIT = 2;
+
     @Transactional
-    public RecurringResponse create(RecurringRequest req, Long memberId) {
+    public RecurringResponse create(RecurringRequest req, Long memberId, boolean premium) {
+        if (!premium && recurringMapper.countByMember(memberId) >= FREE_RECURRING_LIMIT) {
+            throw new ApiException(HttpStatus.BAD_REQUEST,
+                    "무료 회원은 고정 지출을 " + FREE_RECURRING_LIMIT + "개까지 등록할 수 있어요. 유료로 업그레이드하면 무제한이에요.");
+        }
         Recurring r = toEntity(req);
         r.setMemberId(memberId);
         recurringMapper.insert(r);
@@ -83,15 +90,19 @@ public class RecurringService {
 
     private AccountEntry buildEntry(Recurring r, LocalDate date, Long memberId) {
         boolean transfer = "TRANSFER".equals(r.getType());
+        // 메모가 없으면 제목으로 채워 '확인 필요' 목록에서 알아보기 쉽게 한다.
+        String memo = (r.getMemo() != null && !r.getMemo().isBlank()) ? r.getMemo() : r.getTitle();
         return AccountEntry.builder()
                 .memberId(memberId)
                 .entryDate(date)
                 .type(r.getType())
                 .category(transfer ? null : r.getCategory())
                 .amount(r.getAmount())
-                .memo(r.getMemo())
+                .memo(memo)
                 .walletId(r.getWalletId())
                 .toWalletId(transfer ? r.getToWalletId() : null)
+                // 실제 결제/이체가 일어났는지 사용자가 확인하도록 '확인 필요'로 생성
+                .pending(true)
                 .build();
     }
 

src/main/java/com/sb/web/account/service/ShopService.java

@@ -0,0 +1,71 @@
+package com.sb.web.account.service;
+
+import com.sb.web.account.dto.ShopStatusResponse;
+import com.sb.web.auth.mapper.MemberMapper;
+import com.sb.web.point.PointService;
+import com.sb.web.point.mapper.PointMapper;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.server.ResponseStatusException;
+
+@Service
+@RequiredArgsConstructor
+public class ShopService {
+
+    static final int MAX_EXTRA_SLOTS   = 3;
+    static final int WALLET_SLOT_PRICE = 500;
+    static final int AI_STAT_PRICE     = 1000;
+    static final int AI_STAT_PACK_SIZE = 10;
+
+    private static final String REASON_SHOP_WALLET_SLOT = "SHOP_WALLET_SLOT";
+    private static final String REASON_SHOP_AI_STAT     = "SHOP_AI_STAT";
+
+    private final MemberMapper memberMapper;
+    private final PointMapper  pointMapper;
+
+    public ShopStatusResponse getStatus(Long memberId) {
+        return ShopStatusResponse.builder()
+                .extraWalletSlots(memberMapper.getExtraWalletSlots(memberId))
+                .aiStatCredits(memberMapper.getAiStatCredits(memberId))
+                .maxExtraSlots(MAX_EXTRA_SLOTS)
+                .walletSlotPrice(WALLET_SLOT_PRICE)
+                .aiStatPrice(AI_STAT_PRICE)
+                .aiStatPackSize(AI_STAT_PACK_SIZE)
+                .build();
+    }
+
+    @Transactional
+    public ShopStatusResponse buyWalletSlot(Long memberId) {
+        int slots = memberMapper.getExtraWalletSlots(memberId);
+        if (slots >= MAX_EXTRA_SLOTS) {
+            throw new ResponseStatusException(HttpStatus.CONFLICT, "SHOP_WALLET_SLOT_MAX");
+        }
+        long points = pointService(memberId);
+        if (points < WALLET_SLOT_PRICE) {
+            throw new ResponseStatusException(HttpStatus.PAYMENT_REQUIRED, "SHOP_NOT_ENOUGH_POINTS");
+        }
+        pointMapper.insertHistory(memberId, -WALLET_SLOT_PRICE, REASON_SHOP_WALLET_SLOT);
+        pointMapper.addPoints(memberId, -WALLET_SLOT_PRICE);
+        memberMapper.incrementExtraWalletSlots(memberId);
+        return getStatus(memberId);
+    }
+
+    @Transactional
+    public ShopStatusResponse buyAiStatPack(Long memberId) {
+        long points = pointService(memberId);
+        if (points < AI_STAT_PRICE) {
+            throw new ResponseStatusException(HttpStatus.PAYMENT_REQUIRED, "SHOP_NOT_ENOUGH_POINTS");
+        }
+        pointMapper.insertHistory(memberId, -AI_STAT_PRICE, REASON_SHOP_AI_STAT);
+        pointMapper.addPoints(memberId, -AI_STAT_PRICE);
+        memberMapper.addAiStatCredits(memberId, AI_STAT_PACK_SIZE);
+        return getStatus(memberId);
+    }
+
+    private long pointService(Long memberId) {
+        Long p = pointMapper.getPoints(memberId);
+        return p == null ? 0L : p;
+    }
+}

src/main/java/com/sb/web/account/service/StockQuoteService.java

@@ -0,0 +1,43 @@
+package com.sb.web.account.service;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.web.client.RestClient;
+
+/**
+ * 국내 상장 종목 현재가(시세) 조회. 네이버 금융 폴링 API 사용(무인증).
+ * 종목코드(6자리)로 현재가를 가져온다. 실패해도 예외를 던지지 않고 null 반환.
+ */
+@Slf4j
+@Service
+public class StockQuoteService {
+
+    private static final String URL =
+            "https://polling.finance.naver.com/api/realtime/domestic/stock/{code}";
+
+    private final RestClient restClient = RestClient.builder().build();
+
+    /** 국내 상장 종목 현재가(원). 조회 실패/미상장/코드없음이면 null */
+    public Long getDomesticPrice(String ticker) {
+        if (ticker == null || ticker.isBlank()) return null;
+        String code = ticker.trim();
+        try {
+            JsonNode root = restClient.get()
+                    .uri(URL, code)
+                    .header("User-Agent", "Mozilla/5.0")
+                    .retrieve()
+                    .body(JsonNode.class);
+            if (root == null) return null;
+            JsonNode datas = root.path("datas");
+            if (!datas.isArray() || datas.isEmpty()) return null;
+            String priceStr = datas.get(0).path("closePrice").asText(null);
+            if (priceStr == null || priceStr.isBlank()) return null;
+            String digits = priceStr.replaceAll("[^0-9]", "");
+            return digits.isEmpty() ? null : Long.parseLong(digits);
+        } catch (Exception e) {
+            log.warn("시세 조회 실패 ticker={}: {}", code, e.toString());
+            return null;
+        }
+    }
+}

src/main/java/com/sb/web/account/service/VisionOcrService.java

@@ -0,0 +1,82 @@
+package com.sb.web.account.service;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.sb.web.common.exception.ApiException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.stereotype.Service;
+import org.springframework.web.client.RestClient;
+
+import java.util.Base64;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Google Cloud Vision 영수증 OCR. 이미지(byte) → 전체 텍스트.
+ * API 키는 환경변수(GOOGLE_VISION_API_KEY)로만 주입하며, 프론트엔드엔 노출하지 않는다.
+ */
+@Slf4j
+@Service
+public class VisionOcrService {
+
+    private static final String ENDPOINT = "https://vision.googleapis.com/v1/images:annotate";
+
+    private final RestClient restClient = RestClient.builder().build();
+    private final ObjectMapper objectMapper;
+    private final String apiKey;
+
+    public VisionOcrService(ObjectMapper objectMapper,
+                            @Value("${google.vision.api-key:}") String apiKey) {
+        this.objectMapper = objectMapper;
+        this.apiKey = apiKey;
+    }
+
+    public boolean isEnabled() {
+        return apiKey != null && !apiKey.isBlank();
+    }
+
+    /** 영수증 이미지에서 전체 텍스트 추출 */
+    public String recognize(byte[] image) {
+        if (!isEnabled()) {
+            throw new ApiException(HttpStatus.SERVICE_UNAVAILABLE, "영수증 OCR이 설정되지 않았습니다.");
+        }
+        String content = Base64.getEncoder().encodeToString(image);
+        Map<String, Object> body = Map.of(
+                "requests", List.of(Map.of(
+                        "image", Map.of("content", content),
+                        "features", List.of(Map.of("type", "DOCUMENT_TEXT_DETECTION")),
+                        "imageContext", Map.of("languageHints", List.of("ko"))
+                ))
+        );
+
+        String responseJson;
+        try {
+            responseJson = restClient.post()
+                    .uri(ENDPOINT + "?key=" + apiKey)
+                    .contentType(MediaType.APPLICATION_JSON)
+                    .body(body)
+                    .retrieve()
+                    .body(String.class);
+        } catch (Exception e) {
+            log.warn("Vision OCR 호출 실패: {}", e.getMessage());
+            throw new ApiException(HttpStatus.BAD_GATEWAY, "영수증 인식 서버 호출에 실패했습니다.");
+        }
+
+        try {
+            JsonNode r0 = objectMapper.readTree(responseJson).path("responses").path(0);
+            if (r0.has("error")) {
+                log.warn("Vision OCR 오류 응답: {}", r0.path("error").path("message").asText());
+                throw new ApiException(HttpStatus.BAD_GATEWAY, "영수증 인식에 실패했습니다.");
+            }
+            return r0.path("fullTextAnnotation").path("text").asText("");
+        } catch (ApiException e) {
+            throw e;
+        } catch (Exception e) {
+            log.warn("Vision OCR 응답 파싱 실패: {}", e.getMessage());
+            throw new ApiException(HttpStatus.BAD_GATEWAY, "영수증 인식 결과를 처리하지 못했습니다.");
+        }
+    }
+}

src/main/java/com/sb/web/admin/controller/AdminCategoryController.java

@@ -0,0 +1,55 @@
+package com.sb.web.admin.controller;
+
+import com.sb.web.account.dto.CategoryReorderRequest;
+import com.sb.web.account.dto.CategoryRequest;
+import com.sb.web.account.dto.CategoryResponse;
+import com.sb.web.account.service.DefaultCategoryService;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+/**
+ * 관리자 기본(디폴트) 분류 관리 API. (/api/admin/** — AdminInterceptor 로 ADMIN 권한 필요)
+ *   GET    /default-categories          기본 분류 목록
+ *   POST   /default-categories          생성(대/소분류)
+ *   PUT    /default-categories/{id}     수정(이름·대분류)
+ *   DELETE /default-categories/{id}     삭제
+ *   PUT    /default-categories/reorder  순서 변경
+ */
+@RestController
+@RequestMapping("/api/admin/default-categories")
+@RequiredArgsConstructor
+public class AdminCategoryController {
+
+    private final DefaultCategoryService service;
+
+    @GetMapping
+    public List<CategoryResponse> list() {
+        return service.list();
+    }
+
+    @PostMapping
+    public ResponseEntity<CategoryResponse> create(@Valid @RequestBody CategoryRequest req) {
+        return ResponseEntity.status(HttpStatus.CREATED).body(service.create(req));
+    }
+
+    @PutMapping("/{id}")
+    public CategoryResponse update(@PathVariable Long id, @Valid @RequestBody CategoryRequest req) {
+        return service.update(id, req);
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> delete(@PathVariable Long id) {
+        service.delete(id);
+        return ResponseEntity.noContent().build();
+    }
+
+    @PutMapping("/reorder")
+    public List<CategoryResponse> reorder(@RequestBody CategoryReorderRequest req) {
+        return service.reorder(req);
+    }
+}

src/main/java/com/sb/web/admin/controller/AdminSettingsController.java

@@ -0,0 +1,31 @@
+package com.sb.web.admin.controller;
+
+import com.sb.web.admin.dto.SignupSettingRequest;
+import com.sb.web.admin.service.AppSettingService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.Map;
+
+/**
+ * 관리자용 앱 설정 API. (/api/admin — AdminInterceptor 로 관리자만 접근)
+ *   GET /signup-setting   회원가입 허용 여부 조회
+ *   PUT /signup-setting   회원가입 허용 여부 변경
+ */
+@RestController
+@RequestMapping("/api/admin")
+@RequiredArgsConstructor
+public class AdminSettingsController {
+
+    private final AppSettingService appSettingService;
+
+    @GetMapping("/signup-setting")
+    public Map<String, Boolean> getSignupSetting() {
+        return Map.of("enabled", appSettingService.isSignupEnabled());
+    }
+
+    @PutMapping("/signup-setting")
+    public Map<String, Boolean> updateSignupSetting(@RequestBody SignupSettingRequest req) {
+        return Map.of("enabled", appSettingService.setSignupEnabled(req.isEnabled()));
+    }
+}

src/main/java/com/sb/web/admin/controller/AdminTagController.java

@@ -1,7 +1,5 @@
 package com.sb.web.admin.controller;
 
-import com.sb.web.board.dto.BoardSettingRequest;
-import com.sb.web.board.dto.BoardSettingResponse;
 import com.sb.web.board.dto.TagCategoryRequest;
 import com.sb.web.board.dto.TagCategoryResponse;
 import com.sb.web.board.dto.TagRequest;
@@ -68,16 +66,4 @@ public class AdminTagController {
         tagService.deleteTag(id);
         return ResponseEntity.noContent().build();
     }
-
-    /* ===== 게시판 설정 (사용할 태그 카테고리) ===== */
-
-    @GetMapping("/board-setting")
-    public BoardSettingResponse boardSetting() {
-        return tagService.getBoardSetting();
-    }
-
-    @PutMapping("/board-setting")
-    public BoardSettingResponse updateBoardSetting(@RequestBody BoardSettingRequest req) {
-        return tagService.setBoardSetting(req.getTagCategoryId());
-    }
 }

src/main/java/com/sb/web/admin/controller/MemberAdminController.java

@@ -0,0 +1,63 @@
+package com.sb.web.admin.controller;
+
+import com.sb.web.admin.dto.PlanUpdateRequest;
+import com.sb.web.admin.dto.RoleUpdateRequest;
+import com.sb.web.admin.dto.StatusUpdateRequest;
+import com.sb.web.admin.service.MemberAdminService;
+import com.sb.web.auth.dto.MemberAdminResponse;
+import com.sb.web.auth.dto.SessionUser;
+import com.sb.web.auth.web.AuthInterceptor;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+/**
+ * 관리자용 회원 관리 API. (/api/admin/members — AdminInterceptor 로 관리자만 접근)
+ */
+@RestController
+@RequestMapping("/api/admin/members")
+@RequiredArgsConstructor
+public class MemberAdminController {
+
+    private final MemberAdminService memberAdminService;
+
+    @GetMapping
+    public List<MemberAdminResponse> list() {
+        return memberAdminService.list();
+    }
+
+    @PutMapping("/{id}/role")
+    public MemberAdminResponse updateRole(
+            @PathVariable Long id,
+            @Valid @RequestBody RoleUpdateRequest req,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        return memberAdminService.updateRole(id, req.getRole(), current.getId());
+    }
+
+    @PutMapping("/{id}/plan")
+    public MemberAdminResponse updatePlan(
+            @PathVariable Long id,
+            @Valid @RequestBody PlanUpdateRequest req,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        return memberAdminService.updatePlan(id, req.getPlan(), current.getId());
+    }
+
+    @PutMapping("/{id}/status")
+    public MemberAdminResponse updateStatus(
+            @PathVariable Long id,
+            @Valid @RequestBody StatusUpdateRequest req,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        return memberAdminService.updateStatus(id, req.getStatus(), current.getId());
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> delete(
+            @PathVariable Long id,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        memberAdminService.delete(id, current.getId());
+        return ResponseEntity.noContent().build();
+    }
+}

src/main/java/com/sb/web/admin/dto/PlanUpdateRequest.java

@@ -0,0 +1,14 @@
+package com.sb.web.admin.dto;
+
+import jakarta.validation.constraints.Pattern;
+import lombok.Data;
+
+/**
+ * 회원 멤버십 플랜 변경 요청.
+ */
+@Data
+public class PlanUpdateRequest {
+
+    @Pattern(regexp = "FREE|PREMIUM", message = "플랜은 FREE 또는 PREMIUM 이어야 합니다.")
+    private String plan;
+}

src/main/java/com/sb/web/admin/dto/RoleUpdateRequest.java

@@ -0,0 +1,14 @@
+package com.sb.web.admin.dto;
+
+import jakarta.validation.constraints.Pattern;
+import lombok.Data;
+
+/**
+ * 회원 역할 변경 요청.
+ */
+@Data
+public class RoleUpdateRequest {
+
+    @Pattern(regexp = "USER|ADMIN", message = "역할은 USER 또는 ADMIN 이어야 합니다.")
+    private String role;
+}

src/main/java/com/sb/web/admin/dto/SignupSettingRequest.java

@@ -0,0 +1,12 @@
+package com.sb.web.admin.dto;
+
+import lombok.Data;
+
+/**
+ * 회원가입 허용 설정 변경 요청.
+ */
+@Data
+public class SignupSettingRequest {
+
+    private boolean enabled;
+}

src/main/java/com/sb/web/admin/dto/StatusUpdateRequest.java

@@ -0,0 +1,14 @@
+package com.sb.web.admin.dto;
+
+import jakarta.validation.constraints.Pattern;
+import lombok.Data;
+
+/**
+ * 회원 상태 변경 요청.
+ */
+@Data
+public class StatusUpdateRequest {
+
+    @Pattern(regexp = "ACTIVE|SUSPENDED|WITHDRAWN", message = "상태 값이 올바르지 않습니다.")
+    private String status;
+}

src/main/java/com/sb/web/admin/mapper/AppSettingMapper.java

@@ -0,0 +1,16 @@
+package com.sb.web.admin.mapper;
+
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+/**
+ * 앱 전역 설정(app_setting, 단일 행 id=1) 접근.
+ */
+@Mapper
+public interface AppSettingMapper {
+
+    /** 회원가입 허용 여부 (true=허용) */
+    Boolean isSignupEnabled();
+
+    int updateSignupEnabled(@Param("enabled") boolean enabled);
+}

src/main/java/com/sb/web/admin/service/AppSettingService.java

@@ -0,0 +1,28 @@
+package com.sb.web.admin.service;
+
+import com.sb.web.admin.mapper.AppSettingMapper;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * 앱 전역 설정 서비스. 현재는 회원가입 허용 여부.
+ */
+@Service
+@RequiredArgsConstructor
+public class AppSettingService {
+
+    private final AppSettingMapper appSettingMapper;
+
+    /** 회원가입 허용 여부. 설정 행이 없으면 기본 허용(true). */
+    public boolean isSignupEnabled() {
+        Boolean v = appSettingMapper.isSignupEnabled();
+        return v == null || v;
+    }
+
+    @Transactional
+    public boolean setSignupEnabled(boolean enabled) {
+        appSettingMapper.updateSignupEnabled(enabled);
+        return enabled;
+    }
+}

src/main/java/com/sb/web/admin/service/MemberAdminService.java

@@ -0,0 +1,74 @@
+package com.sb.web.admin.service;
+
+import com.sb.web.auth.domain.Member;
+import com.sb.web.auth.dto.MemberAdminResponse;
+import com.sb.web.auth.mapper.MemberMapper;
+import com.sb.web.common.exception.ApiException;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+/**
+ * 관리자용 회원 관리 서비스. (목록/역할/상태/삭제)
+ * 본인 계정에 대한 역할·상태·삭제는 잠금 방지를 위해 차단한다.
+ */
+@Service
+@RequiredArgsConstructor
+public class MemberAdminService {
+
+    private final MemberMapper memberMapper;
+
+    public List<MemberAdminResponse> list() {
+        return memberMapper.findAll().stream().map(MemberAdminResponse::from).toList();
+    }
+
+    @Transactional
+    public MemberAdminResponse updateRole(Long targetId, String role, Long currentAdminId) {
+        Member target = mustFind(targetId);
+        if (targetId.equals(currentAdminId)) {
+            throw new ApiException(HttpStatus.BAD_REQUEST, "본인의 역할은 변경할 수 없습니다.");
+        }
+        memberMapper.updateRole(targetId, role);
+        target.setRole(role);
+        return MemberAdminResponse.from(target);
+    }
+
+    @Transactional
+    public MemberAdminResponse updatePlan(Long targetId, String plan, Long currentAdminId) {
+        Member target = mustFind(targetId);
+        memberMapper.updatePlan(targetId, plan);
+        target.setPlan(plan);
+        return MemberAdminResponse.from(target);
+    }
+
+    @Transactional
+    public MemberAdminResponse updateStatus(Long targetId, String status, Long currentAdminId) {
+        Member target = mustFind(targetId);
+        if (targetId.equals(currentAdminId)) {
+            throw new ApiException(HttpStatus.BAD_REQUEST, "본인의 상태는 변경할 수 없습니다.");
+        }
+        memberMapper.updateStatus(targetId, status);
+        target.setStatus(status);
+        return MemberAdminResponse.from(target);
+    }
+
+    @Transactional
+    public void delete(Long targetId, Long currentAdminId) {
+        mustFind(targetId);
+        if (targetId.equals(currentAdminId)) {
+            throw new ApiException(HttpStatus.BAD_REQUEST, "본인 계정은 삭제할 수 없습니다.");
+        }
+        memberMapper.deleteById(targetId);
+    }
+
+    private Member mustFind(Long id) {
+        Member m = memberMapper.findById(id);
+        if (m == null) {
+            throw new ApiException(HttpStatus.NOT_FOUND, "회원을 찾을 수 없습니다.");
+        }
+        return m;
+    }
+}

src/main/java/com/sb/web/auth/controller/AuthController.java

@@ -3,6 +3,7 @@ package com.sb.web.auth.controller;
 import com.sb.web.auth.dto.LoginRequest;
 import com.sb.web.auth.dto.LoginResponse;
 import com.sb.web.auth.dto.MemberResponse;
+import com.sb.web.auth.dto.PasswordChangeRequest;
 import com.sb.web.auth.dto.SessionUser;
 import com.sb.web.auth.dto.SignupRequest;
 import com.sb.web.auth.service.AuthService;
@@ -27,15 +28,51 @@ import org.springframework.web.bind.annotation.*;
 public class AuthController {
 
     private final AuthService authService;
+    private final com.sb.web.admin.service.AppSettingService appSettingService;
+    private final com.sb.web.point.PointService pointService;
+
+    /** 회원가입 허용 여부 (비보호) — 프론트가 가입 진입 전에 차단 표시용 */
+    @GetMapping("/signup-enabled")
+    public java.util.Map<String, Boolean> signupEnabled() {
+        return java.util.Map.of("enabled", appSettingService.isSignupEnabled());
+    }
 
     @PostMapping("/signup")
-    public ResponseEntity<MemberResponse> signup(@Valid @RequestBody SignupRequest req) {
+    public ResponseEntity<MemberResponse> signup(@Valid @RequestBody SignupRequest req,
-        return ResponseEntity.status(HttpStatus.CREATED).body(authService.signup(req));
+            HttpServletRequest request) {
+        return ResponseEntity.status(HttpStatus.CREATED).body(authService.signup(req, clientIp(request)));
+    }
+
+    /** 클라이언트 IP (nginx 프록시 뒤 → X-Forwarded-For 우선) */
+    private String clientIp(HttpServletRequest request) {
+        String xff = request.getHeader("X-Forwarded-For");
+        if (xff != null && !xff.isBlank()) {
+            return xff.split(",")[0].trim();
+        }
+        return request.getRemoteAddr();
     }
 
     @PostMapping("/login")
-    public LoginResponse login(@Valid @RequestBody LoginRequest req) {
+    public LoginResponse login(@Valid @RequestBody LoginRequest req, HttpServletRequest request) {
-        return authService.login(req);
+        return authService.login(req, clientIp(request));
+    }
+
+    /** 구글 OAuth 클라이언트 ID (비보호) — 프론트가 구글 버튼 노출/초기화에 사용. 미설정 시 빈 문자열 */
+    @GetMapping("/google-client-id")
+    public java.util.Map<String, String> googleClientId() {
+        return java.util.Map.of("clientId", authService.googleClientId());
+    }
+
+    /** 구글 로그인/가입 (비보호) — ID 토큰 검증 후 세션 발급 */
+    @PostMapping("/google")
+    public LoginResponse googleLogin(@Valid @RequestBody com.sb.web.auth.dto.GoogleLoginRequest req) {
+        return authService.googleLogin(req.getIdToken(), req.isRememberMe());
+    }
+
+    /** 애플 로그인/가입 (비보호) — Sign in with Apple identity token 검증 후 세션 발급 */
+    @PostMapping("/apple")
+    public LoginResponse appleLogin(@Valid @RequestBody com.sb.web.auth.dto.AppleLoginRequest req) {
+        return authService.appleLogin(req.getIdentityToken(), req.getName(), req.isRememberMe());
     }
 
     @PostMapping("/logout")
@@ -48,4 +85,72 @@ public class AuthController {
     public SessionUser me(@RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
         return current;
     }
+
+    /** 회원 탈퇴 — 본인 계정과 모든 데이터 삭제 */
+    @DeleteMapping("/me")
+    public ResponseEntity<Void> withdraw(
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current,
+            HttpServletRequest request) {
+        authService.withdraw(current.getId(), AuthInterceptor.resolveToken(request));
+        return ResponseEntity.noContent().build();
+    }
+
+    /** 현재 사용자 활동 포인트 (최신값 — 게시판 작성으로 수시 변동) */
+    @GetMapping("/points")
+    public java.util.Map<String, Long> points(
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        return java.util.Map.of("points", pointService.getPoints(current.getId()));
+    }
+
+    /** 포인트 적립/차감 내역 — year+month 지정 시 해당 월 전건, 미지정 시 최근 100건 */
+    @GetMapping("/point-history")
+    public java.util.List<com.sb.web.point.PointHistoryResponse> pointHistory(
+            @RequestParam(required = false) Integer year,
+            @RequestParam(required = false) Integer month,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        if (year != null && month != null) {
+            return pointService.getHistory(current.getId(), year, month);
+        }
+        return pointService.getHistory(current.getId());
+    }
+
+    @PutMapping("/password")
+    public ResponseEntity<Void> changePassword(
+            @Valid @RequestBody PasswordChangeRequest req,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        authService.changePassword(current.getId(), req);
+        return ResponseEntity.noContent().build();
+    }
+
+    /** 가입정보 변경 진입 전 비밀번호 재인증 */
+    @PostMapping("/verify-password")
+    public ResponseEntity<Void> verifyPassword(
+            @Valid @RequestBody com.sb.web.auth.dto.PasswordVerifyRequest req,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        authService.verifyPassword(current.getId(), req.getPassword());
+        return ResponseEntity.noContent().build();
+    }
+
+    /** 현재 회원 전체 프로필 (아바타·포인트 포함) — 재로그인 없이 최신값 동기화 */
+    @GetMapping("/profile")
+    public MemberResponse profile(@RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        return authService.getProfile(current.getId());
+    }
+
+    /** 가입정보(이름/이메일) 변경 */
+    @PutMapping("/profile")
+    public MemberResponse updateProfile(
+            @Valid @RequestBody com.sb.web.auth.dto.ProfileUpdateRequest req,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current,
+            HttpServletRequest request) {
+        return authService.updateProfile(current.getId(), AuthInterceptor.resolveToken(request), req);
+    }
+
+    /** 프로필 사진(사용자 지정) 변경/해제 — image 가 비면 해제(구글 사진으로 폴백) */
+    @PutMapping("/profile-image")
+    public MemberResponse updateProfileImage(
+            @RequestBody com.sb.web.auth.dto.ProfileImageRequest req,
+            @RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
+        return authService.updateProfileImage(current.getId(), req.getImage());
+    }
 }

src/main/java/com/sb/web/auth/domain/AuthSession.java

@@ -0,0 +1,56 @@
+package com.sb.web.auth.domain;
+
+import com.sb.web.auth.dto.SessionUser;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;
+
+/**
+ * 세션 영속 백업(auth_session). Redis 유실 시 여기서 SessionUser 를 복원한다.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class AuthSession {
+
+    private String token;
+    private Long memberId;
+    private String loginId;
+    private String name;
+    private String role;
+    private String plan;
+    private String provider;
+    private boolean rememberMe;
+    private LocalDateTime expiresAt;
+    private LocalDateTime createdAt;
+
+    public static AuthSession of(String token, SessionUser u, LocalDateTime expiresAt) {
+        return AuthSession.builder()
+                .token(token)
+                .memberId(u.getId())
+                .loginId(u.getLoginId())
+                .name(u.getName())
+                .role(u.getRole())
+                .plan(u.getPlan())
+                .provider(u.getProvider())
+                .rememberMe(u.isRememberMe())
+                .expiresAt(expiresAt)
+                .build();
+    }
+
+    public SessionUser toSessionUser() {
+        return SessionUser.builder()
+                .id(memberId)
+                .loginId(loginId)
+                .name(name)
+                .role(role)
+                .plan(plan)
+                .provider(provider)
+                .rememberMe(rememberMe)
+                .build();
+    }
+}

src/main/java/com/sb/web/auth/domain/Member.java

@@ -23,9 +23,18 @@ public class Member implements Serializable {
     private String password;     // BCrypt 해시 (소셜 전용은 null)
     private String name;
     private String email;
-    private String provider;     // LOCAL / NAVER
+    private String provider;     // LOCAL / NAVER / GOOGLE
     private String providerId;   // 소셜 제공자 측 고유 ID
+    private String googleId;     // 구글 sub (계정 연결용 — LOCAL 계정에 구글을 연결해도 provider 는 유지)
+    private String appleId;      // 애플 sub (계정 연결용 — 구글과 동일)
+    private String googlePicture; // 구글 아바타 URL (로그인 시 동기화)
+    private String profileImage;  // 사용자 지정 프로필 이미지(data URL). 우선순위: profileImage > googlePicture > 이니셜
     private String role;         // USER / ADMIN
+    private String plan;         // FREE / PREMIUM (멤버십)
+    private LocalDateTime planExpiresAt; // 유료 멤버십 만료일 (NULL=만료없음/무료)
+    private String planProduct;  // 구독 상품 ID (premium_monthly 등)
+    private Boolean planAutoRenew; // 자동 갱신 여부 (해지 시 false)
+    private Long points;         // 활동 포인트 (게시판 글/댓글 작성 보상)
     private String status;       // ACTIVE / SUSPENDED / WITHDRAWN
     private LocalDateTime createdAt;
     private LocalDateTime updatedAt;

src/main/java/com/sb/web/auth/dto/AppleLoginRequest.java

@@ -0,0 +1,19 @@
+package com.sb.web.auth.dto;
+
+import jakarta.validation.constraints.NotBlank;
+import lombok.Data;
+
+/**
+ * 애플 로그인 요청 — 프론트(Sign in with Apple)에서 받은 identity token(JWT).
+ * 이름은 애플이 <b>최초 인증 시에만</b> 클라이언트에 주므로, 신규 가입 시 채우도록 함께 전달받는다.
+ */
+@Data
+public class AppleLoginRequest {
+
+    @NotBlank(message = "토큰이 없습니다.")
+    private String identityToken;
+
+    private String name; // 최초 로그인 시에만 제공될 수 있음(이후 null)
+
+    private boolean rememberMe;
+}

src/main/java/com/sb/web/auth/dto/GoogleLoginRequest.java

@@ -0,0 +1,16 @@
+package com.sb.web.auth.dto;
+
+import jakarta.validation.constraints.NotBlank;
+import lombok.Data;
+
+/**
+ * 구글 로그인 요청 — 프론트(Google Identity Services)에서 받은 ID 토큰.
+ */
+@Data
+public class GoogleLoginRequest {
+
+    @NotBlank(message = "토큰이 없습니다.")
+    private String idToken;
+
+    private boolean rememberMe;
+}

src/main/java/com/sb/web/auth/dto/LoginRequest.java

@@ -14,4 +14,7 @@ public class LoginRequest {
 
     @NotBlank(message = "비밀번호를 입력하세요.")
     private String password;
+
+    /** 로그인 상태 유지(자동 로그인). true 면 세션을 길게(30일) 유지 */
+    private boolean rememberMe;
 }

src/main/java/com/sb/web/auth/dto/MemberAdminResponse.java

@@ -0,0 +1,39 @@
+package com.sb.web.auth.dto;
+
+import com.sb.web.auth.domain.Member;
+import lombok.Builder;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * 관리자용 회원 정보 응답 (비밀번호 제외).
+ */
+@Data
+@Builder
+public class MemberAdminResponse {
+
+    private Long id;
+    private String loginId;
+    private String name;
+    private String email;
+    private String role;     // USER / ADMIN
+    private String plan;     // FREE / PREMIUM
+    private String status;   // ACTIVE / SUSPENDED / WITHDRAWN
+    private String provider; // LOCAL / 소셜
+    private LocalDateTime createdAt;
+
+    public static MemberAdminResponse from(Member m) {
+        return MemberAdminResponse.builder()
+                .id(m.getId())
+                .loginId(m.getLoginId())
+                .name(m.getName())
+                .email(m.getEmail())
+                .role(m.getRole())
+                .plan(m.getPlan())
+                .status(m.getStatus())
+                .provider(m.getProvider())
+                .createdAt(m.getCreatedAt())
+                .build();
+    }
+}