diff --git a/README.md b/README.md
index 8e3e4ce8..0ac83b82 100644
--- a/README.md
+++ b/README.md
@@ -1,39 +1,168 @@
-# 🚀 STARLIGHT_BE Server
+# Starlight Server
+대학생 IT경영학회 큐시즘 32기 밋업 프로젝트 4조 Starlight 백엔드 레포지토리
+<img width="1920" height="1080" alt="1" src="https://github.com/user-attachments/assets/92433169-8775-4808-b787-6c534a25cae9" />
 
-[![Java](https://img.shields.io/badge/Java-21-ED8B00?style=flat-square&logo=openjdk&logoColor=white)](https://openjdk.java.net/)
-[![Spring Boot](https://img.shields.io/badge/Spring%20Boot-3.4.9-6DB33F?style=flat-square&logo=spring&logoColor=white)](https://spring.io/projects/spring-boot)
+<br></br>
 
-> **STARLIGHT 서비스 백엔드 API 서버**
+## 👬 Member
+|      정성호     |         이호근         |                                                                                                   
+| :------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------: | 
+|   <img src="https://avatars.githubusercontent.com/SeongHo5356?v=4" width=120px alt="정성호"/>       |   <img src="https://avatars.githubusercontent.com/2ghrms?v=4" width=120px alt="이호근"/>                       |
+|   [@SeongHo5356](https://github.com/SeongHo5356)   |    [@2ghrms](https://github.com/2ghrms)  | 
 
-## 🎯 프로젝트 소개
+<br></br>
 
-Spring Boot로 만든 REST API 서버입니다. 
+## 📝 Technology Stack
+| Category             | Technology                                                                 |
+|----------------------|---------------------------------------------------------------------------|
+| **Language**         | Java 21                                                                 |
+| **Framework**        | Spring Boot 3.3.10                                                        |
+| **Databases**        | Postgresql, Redis                                                             |
+| **Authentication**   | JWT, Spring Security, OAuth2.0                                           |
+| **Development Tools**| Lombok                                                   |
+| **API Documentation**| Swagger UI (SpringDoc)                                                   |
+| **Storage**          | AWS S3, Naver Object Storage                                                                   |
+| **Infrastructure**   | Terraform, NCP Server, HashiCorp Vault  |
+| **Build Tools**      | Gradle    |
+| **Monitoring** | Prometheus, Grafana, Loki, Promtail |
 
-## 👥 팀 작업 방식
+<br></br>
 
-> **Issue 기반 개발 워크플로우**를 따릅니다. 모든 작업은 Issue에서 시작하여 PR로 완료됩니다.
+## 📅 ERD
+https://www.erdcloud.com/d/bEeEkcvDoau3kf7W5
+<img width="4240" height="1582" alt="스타라이트 ERD 제출본 (1)" src="https://github.com/user-attachments/assets/d90f822b-0df4-42fd-8f83-25e849e4e629" />
 
-### 🌳 브랜치 사용법
-> JIRA를 통해서 자동생성
+<br></br>
 
-### 💬 커밋 메시지 (Issue 번호 포함)
-> Docs: (SRLT-25) README 업데이트  
-> Feat: (SRLT-12) 로그인 기능을 추가한다  
-> Fix: (SRLT-23) 회원가입 오류를 수정한다
+## 🔨 Project Architecture
+<img width="5480" height="3640" alt="image (2)" src="https://github.com/user-attachments/assets/3af67db9-c1d1-4dec-9817-a39d0f57dc9e" />
 
+<br></br>
 
-### 💬 PR 및 ISSUE 제목
-> [SRLT-25] 로그인 기능을 추가한다  
-> [SRLT-23] 회원가입 오류를 수정한다  
-> [SRLT-12] README 업데이트
+## ⭐️ 기술스택/선정이유
 
-## 🔄 개발 흐름 (Issue → Branch → PR)
+**1️⃣ Java 21**
 
-> 1. **Issue 생성/확인** → GitHub Issues에서 작업할 이슈 생성 또는 할당받기
-> 2. **브랜치 생성** → `feat/이슈번호-기능명` 으로 Issue 기반 브랜치 만들기
-> 3. **코딩** → Issue 요구사항에 맞는 기능 개발
-> 4. **테스트** → 로컬에서 잘 돌아가는지 확인
-> 5. **PR 생성** → Pull Request 올리기 (Issue 번호 연결)
-> 6. **코드 리뷰** → 팀원들이 코드 확인
-> 7. **머지** → dev 브랜치에 합치기 -> main 브랜치에 배포
+- Java 21은 최신 언어 기능(예: 패턴 매칭, 레코드, 가상 스레드 등)을 제공하여 코드의 가독성과 유지보수성을 높이며, 개발 생산성을 향상시킵니다.
+- 최신 버전의 자바는 성능 최적화와 효율적인 메모리 관리 기능이 개선되어, 대규모 애플리케이션에서도 안정적이고 빠른 실행이 가능합니다.
+- 장기 지원 버전이므로, 앞으로의 유지보수와 안정성 측면에서 신뢰할 수 있는 기반을 제공합니다.
 
+**2️⃣ SpringBoot 3.4.9**
+- 클라우드 네이티브 최적화: Jakarta EE 기반의 높은 성숙도를 갖추고 있으며, 헬스체크·Actuator·Micrometer 등 컨테이너 및 클라우드 운영에 필수적인 관측성 기능을 기본으로 제공합니다.
+- 성능 및 보안 강화: 개선된 AOT/Native 이미지 지원을 통해 콜드스타트를 최적화할 수 있으며, 신속한 보안 패치로 안정적인 서비스 운영을 돕습니다.
+- 생산성 및 유지보수: 표준화된 스타터와 강력한 자동 설정(Auto Configuration)으로 개발 복잡도를 낮추고, 팀 온보딩 및 유지보수 비용을 최소화합니다.
+
+**3️⃣ SpringData JPA**
+
+- Spring Data JPA는 데이터베이스와의 인터랙션을 단순화하고, 불필요한 보일러플레이트 코드를 줄여 개발 효율성을 높여줍니다.
+
+**4️⃣ Spring AI**
+- LLM 통합 단순화: Spring 생태계에 통합된 AI 프레임워크로, 복잡한 LLM 연동 과정을 간소화합니다.
+- 유연한 추상화 레이어: OpenAI, Pinecone 등 다양한 제공업체에 대한 추상화 레이어를 제공하여 벤더 교체가 용이합니다.
+- 높은 생산성: Spring Boot 자동 설정 및 WebFlux를 지원하며, 벡터 검색·프롬프트 템플릿·체이닝 등 RAG 패턴을 쉽게 구현할 수 있습니다.
+
+**5️⃣ MySQL**
+- 검증된 안정성: 성숙한 InnoDB 엔진과 풍부한 운영 레퍼런스를 보유하고 있으며, TCO(총 소유 비용)가 낮습니다.
+- 기능 및 생태계: 8.x 버전의 CTE와 윈도우 함수로 복잡한 쿼리에 대응 가능하며, 리플리케이션·백업·모니터링 도구가 잘 갖춰져 있습니다.
+- OLTP 최적화: HikariCP 커넥션 풀과 적절한 인덱싱을 통해 대규모 트래픽에서도 안정적인 운영이 가능합니다.
+
+**6️⃣ NCP (CLOVA Studio, Server, Object Storage)**
+- 안정적 인프라: 네이버 클라우드 플랫폼(NCP)의 서버 인프라와 Object Storage를 활용하여 안정적이고 보안성이 뛰어난 클라우드 환경을 제공합니다.
+- AI 서비스 연동: CLOVA Studio와의 연동을 통해 프로젝트의 AI 기능을 효율적으로 지원하고 운영 효율성을 높입니다.
+
+**7️⃣ ArgoCD, K3s**
+- ArgoCD (GitOps): Pull 기반 배포로 'Git 상태=배포 상태'를 보장하며, 자동 동기화 및 자가 치유(Self-healing)로 운영 복잡도를 줄입니다.
+- K3s (경량 K8s): 리소스가 제한된 환경이나 스테이징/소규모 서비스에 최적화된 가벼운 쿠버네티스입니다.
+- 표준 호환성: Helm, Ingress 등 표준 K8s 도구를 그대로 사용할 수 있어 진입 장벽이 낮고, 추후 매니지드 서비스로의 확장이 쉽습니다.
+
+**8️⃣ Promtail, Loki, Prometheus, Grafana**
+- 로그 수집 및 검색 (Loki): Promtail이 수집한 애플리케이션 및 시스템 로그를 Loki로 전송하여 대용량 로그를 효율적으로 인덱싱하고 검색합니다.
+- 메트릭 모니터링 (Prometheus): Pull 방식을 통해 API 응답 시간, CPU, 메모리 등의 시계열 데이터를 수집합니다.
+- 데이터 시각화 (Grafana): 수집된 로그와 메트릭 데이터를 통합 대시보드로 시각화하여 시스템 상태를 한눈에 파악합니다.
+
+**9️⃣ Flannel + WireGuard VPN**
+- 네트워크 연결성: 서로 다른 네트워크(VPC, IDC, 공인망)에 분산된 노드 간의 통신을 지원합니다.
+- 보안 통신 보장: K3s 클러스터 내에서 WireGuard VPN을 통해 빠르고 안전한 Pod-to-Pod 보안 통신을 보장합니다.
+
+**🔟 Nginx**
+- 고성능 리버스 프록시: 경량화된 구조로 TLS 종료, 정적 자산 서빙, 라우팅 및 리라이트 처리에 강점을 가집니다.
+- 백엔드 보호: 헬스체크, 타임아웃, 버퍼링 등의 세밀한 튜닝을 통해 백엔드 애플리케이션의 부하를 줄이고 성능을 보장합니다.
+- 유연한 배치: 쿠버네티스 환경에서 Ingress Controller 또는 엣지 프록시로 활용하여 트래픽을 효율적으로 관리합니다.
+
+**1️⃣1️⃣ K6**
+- 사용자 흐름 테스트: JavaScript를 사용하여 실제 사용자 행동(로그인 → API 호출 → 스케줄링)을 스크립트화하고 REST API 성능을 측정합니다.
+- 커스텀 시나리오: vus(가상 사용자), stages 등의 옵션으로 스파이크 테스트나 지속성 테스트 등 다양한 부하 시나리오를 검증합니다.
+- 결과 시각화: 응답 시간, 처리량, 에러율 등의 메트릭을 수집하고 Grafana와 연동하여 테스트 결과를 시각적으로 분석합니다.
+
+
+<br></br>
+
+## 💬 Convention
+
+**commit convention** <br>
+`#이슈번호 conventionType: 구현한 내용` <br><br>
+
+
+**convention Type** <br>
+| convention type | description |
+| --- | --- |
+| `feat` | 새로운 기능 구현 |
+| `chore` | 부수적인 코드 수정 및 기타 변경사항 |
+| `docs` | 문서 추가 및 수정, 삭제 |
+| `fix` | 버그 수정 |
+| `test` | 테스트 코드 추가 및 수정, 삭제 |
+| `refactor` | 코드 리팩토링 |
+
+<br></br>
+
+## 🪵 Branch
+### 
+- `컨벤션명/#이슈번호-작업내용`
+- pull request를 통해 develop branch에 merge 후, branch delete
+- 부득이하게 develop branch에 직접 commit 해야 할 경우, `!hotfix:` 사용
+
+<br></br>
+
+## 📁 Directory
+
+```PlainText
+src/
+├── main/
+│   ├── domain/
+│   │   ├── entity/
+│   │   ├── controller/
+│   │   ├── service/
+│   │   ├── repository/
+│   │   └── dto/
+            ├── request/
+            └── response/
+│   ├── global/
+│   │   ├── apiPayload/
+│   │   ├── config/
+│   │   ├── security/
+		 
+```
+
+<br></br>
+
+## 📈  부하테스트
+각 플랫폼(Instagram, Facebook, Threads) API에는 계정/시간 당 발행 가능한 게시물 수에 제한이 있어, 부하 테스트에는 제약이 존재합니다. 이에 따라 저희는 즉시 발행이 아닌 **"예약 발행" API**를 활용한 부하 시뮬레이션 방식을 구성하였습니다.
+
+|시나리오 ① 10명이 1초 동안 최대한의 요청을 보낸다.| 시나리오 ② 2000명이 1초 동안 최대한의 요청을 보낸다.|
+| :-------| :-------|
+|![image](https://github.com/user-attachments/assets/026eb04b-4aa3-4e23-8820-5d22f1d94d12)|![image](https://github.com/user-attachments/assets/b73b7838-48e6-4392-99cd-c6497a4958d1)|
+|✅ 총 120개의 요청이 문제없이 처리됨 <br>  - 평균 요청 처리 시간 : 82.09 ms <br>  - 최소 요청 처리 시간 : 22.52ms <br>  - 최대 요청 처리 시간 : 164.64ms |✅ 총 4002개의 요청이 문제없이 처리됨<br> - 평균 요청 처리 시간 : 7.74s <br>  - 최소 요청 처리 시간 : 21.9s <br>  - 최대 요청 처리 시간 : 18.28s <br> - 95th 퍼센타일 : 14.95s|
+
+<br>
+
+| 시나리오 ③ 사용자 수 변동 시나리오 | 시나리오 ④ 응답 시간이 5초 이내인 최대 요청 수 파악|
+| :-------|:----|
+|![image](https://github.com/user-attachments/assets/c77e54f8-765f-4ef5-a79b-f8896eb761a7)|![image](https://github.com/user-attachments/assets/a856af66-9d1b-47df-b287-156c125bd9b3)|
+|0초 ~ 2초 : `50명`, 2초 ~ 12초 : `300명`, 12초 ~ 17초 : `1000명`, 17초 ~ 18초 : `500명`| 5초가 지날 경우 사용자 이탈이 늘어날 것이라고 판단하여 1초 동안 `1000명`의 사용자가 요청을 보내 `요청 처리 시간이 5초 이내`인 요청 개수를 파악 |
+|✅ 총 3789개의 요청이 문제없이 처리됨 <br>  - 평균 요청 처리 시간 : 1.94s <br>  - 최소 요청 처리 시간 : 20.53ms <br>  - 최대 요청 처리 시간 : 7.88s |✅ 총 2002개의 요청이 시간 내 처리됨 |
+
+### 테스트 결과 분석
+- 현재 시스템은 동시 약 `1,000건` 수준까지는 안정적으로 요청을 처리할 수 있는 것으로 보입니다. **시나리오 ③**처럼 사용자 수가 점차 증가하는 상황에서도 평균 응답 시간은 `1.94초`, 최대 응답 시간은 `7.88초`로, 대부분의 요청이 정상적으로 처리되었습니다.
+- 하지만 **시나리오 ②**처럼 `2,000명`의 동시 요청이 들어오면 평균 응답 시간이 `7.74초`, 최대 `18.28초`까지 증가하면서 응답 지연이 발생하였습니다. 이 결과는 대규모 트래픽에 대한 성능 한계가 있음을 보여주며, 추후 이를 개선할 필요가 있습니다.
+- **시나리오 ④**에서는 `1000명`의 사용자가 동시에 요청을 보낸 경우, 총 `2,002건`의 요청이 `5초` 이내에 처리되었습니다. 이는 현재 시스템이 실시간 대응보다는 예약 처리에 더 적합한 구조임을 보여줍니다.
+- 일반적으로 사용자 이탈이 늘기 시작하는 5초 이내 응답을 기준으로 예상 접속자 수 약 `1,000명` 정도에 대해서는 충분히 안정적인 성능을 제공할 수 있다고 판단됩니다.
diff --git a/build.gradle b/build.gradle
index 10bb23b1..d8afb991 100644
--- a/build.gradle
+++ b/build.gradle
@@ -19,6 +19,7 @@ java {
 
 repositories {
 	mavenCentral()
+	maven { url 'https://jitpack.io' }
 }
 
 apply from: 'gradle/config.gradle'
diff --git a/config b/config
index 03c0037b..3a581e52 160000
--- a/config
+++ b/config
@@ -1 +1 @@
-Subproject commit 03c0037bd23ba12e28ca71e922f0e1fe525f9714
+Subproject commit 3a581e527b6117d5929ba57a0e2c8c8b90d9d14a
diff --git a/src/main/java/starlight/adapter/ai/infra/OpenAiGenerator.java b/src/main/java/starlight/adapter/ai/infra/OpenAiGenerator.java
index 62b52455..c90ffb21 100644
--- a/src/main/java/starlight/adapter/ai/infra/OpenAiGenerator.java
+++ b/src/main/java/starlight/adapter/ai/infra/OpenAiGenerator.java
@@ -70,7 +70,7 @@ public String generateReport(String content) {
         return chatClient
                 .prompt(prompt)
                 .options(ChatOptions.builder()
-                        .temperature(0.1)
+                        .temperature(0.0)
                         .topP(0.1)
                         .build())
                 .advisors(qaAdvisor, slAdvisor)
diff --git a/src/main/java/starlight/adapter/aireport/persistence/AiReportRepository.java b/src/main/java/starlight/adapter/aireport/persistence/AiReportRepository.java
index db3826b1..31c245e4 100644
--- a/src/main/java/starlight/adapter/aireport/persistence/AiReportRepository.java
+++ b/src/main/java/starlight/adapter/aireport/persistence/AiReportRepository.java
@@ -6,6 +6,7 @@
 import java.util.Optional;
 
 public interface AiReportRepository extends JpaRepository<AiReport, Long> {
+
     Optional<AiReport> findByBusinessPlanId(Long businessPlanId);
 }
 
diff --git a/src/main/java/starlight/adapter/businessplan/webapi/dto/SubSectionCreateRequest.java b/src/main/java/starlight/adapter/businessplan/webapi/dto/SubSectionCreateRequest.java
index baf05c77..6c6ba559 100644
--- a/src/main/java/starlight/adapter/businessplan/webapi/dto/SubSectionCreateRequest.java
+++ b/src/main/java/starlight/adapter/businessplan/webapi/dto/SubSectionCreateRequest.java
@@ -1,6 +1,7 @@
 package starlight.adapter.businessplan.webapi.dto;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.annotation.JsonSubTypes;
 import com.fasterxml.jackson.annotation.JsonTypeInfo;
@@ -22,27 +23,39 @@ public record Meta(
 
         public record Block(
                         @Valid @NotNull BlockMeta meta,
-                        @Valid List<@Valid Content> content) {
+                        @Valid List<@Valid GeneralContent> content) {
         }
 
         public record BlockMeta(
                         @NotBlank String title) {
         }
 
+        // 테이블 셀 내부에서 사용하는 기본 콘텐츠 (TextItem, ImageItem만)
+        @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.EXISTING_PROPERTY, property = "type", visible = true)
+        @JsonSubTypes({
+                        @JsonSubTypes.Type(value = TextItem.class, name = "text"),
+                        @JsonSubTypes.Type(value = ImageItem.class, name = "image")
+        })
+        public sealed interface BasicContent
+                        permits TextItem, ImageItem {
+                String type();
+        }
+
+        // 블록의 content에서 사용하는 일반 콘텐츠 (BasicContent + TableItem)
         @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.EXISTING_PROPERTY, property = "type", visible = true)
         @JsonSubTypes({
                         @JsonSubTypes.Type(value = TextItem.class, name = "text"),
                         @JsonSubTypes.Type(value = ImageItem.class, name = "image"),
                         @JsonSubTypes.Type(value = TableItem.class, name = "table")
         })
-        public sealed interface Content
+        public sealed interface GeneralContent
                         permits TextItem, ImageItem, TableItem {
                 String type();
         }
 
         public record TextItem(
                         @NotBlank String type,
-                        @NotBlank String value) implements Content {
+                        String value) implements BasicContent, GeneralContent {
         }
 
         public record ImageItem(
@@ -50,27 +63,125 @@ public record ImageItem(
                         @NotBlank @Size(max = 1024) String src,
                         @JsonProperty(defaultValue = "400") Integer width,
                         @JsonProperty(defaultValue = "400") Integer height,
-                        @Size(max = 255) String caption) implements Content {
+                        @Size(max = 255) String caption) implements BasicContent, GeneralContent {
                 public ImageItem {
                         width = width != null ? width : 400;
                         height = height != null ? height : 400;
                 }
         }
 
+        // 컬럼 정보 (헤더 제거, 개수와 너비만)
+        public record TableColumn(
+                        Integer width) {
+        }
+
+        // 셀 데이터
+        @JsonInclude(JsonInclude.Include.NON_DEFAULT)
+        public record TableCell(
+                        @NotEmpty List<@Valid BasicContent> content,
+                        @Min(1) Integer rowspan,
+                        @Min(1) Integer colspan) {
+                public TableCell {
+                        rowspan = rowspan != null ? rowspan : 1;
+                        colspan = colspan != null ? colspan : 1;
+                }
+        }
+
         public record TableItem(
                         @NotBlank String type,
-                        @NotEmpty List<@NotBlank String> columns,
-                        @NotEmpty List<@NotEmpty List<Object>> rows) implements Content {
+                        @NotEmpty List<@Valid TableColumn> columns,
+                        @NotEmpty List<List<@Valid TableCell>> rows) implements GeneralContent {
 
-                @AssertTrue(message = "table rows must match columns length")
+                @AssertTrue(message = "table rows must match columns length considering cell spans")
                 @JsonIgnore
-                public boolean isRectangular() {
-                        int w = (columns == null) ? -1 : columns.size();
-                        if (w <= 0 || rows == null || rows.isEmpty())
+                public boolean isValidCellSpans() {
+                        if (columns == null || rows == null || rows.isEmpty())
                                 return false;
-                        for (var r : rows)
-                                if (r == null || r.size() != w)
+
+                        int expectedWidth = columns.size();
+                        int rowCount = rows.size();
+
+                        // 각 위치에서 rowspan으로 차지된 셀을 추적
+                        // grid[row][col] = 위에서 내려온 rowspan 셀의 남은 rowspan 값 (0이면 비어있음)
+                        int[][] grid = new int[rowCount][expectedWidth];
+
+                        for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+                                var row = rows.get(rowIndex);
+                                if (row == null)
                                         return false;
+
+                                // 현재 행에서 rowspan으로 차지된 위치 수 계산
+                                int occupiedByRowspan = 0;
+                                for (int col = 0; col < expectedWidth; col++) {
+                                        if (grid[rowIndex][col] > 0) {
+                                                occupiedByRowspan++;
+                                        }
+                                }
+
+                                // 빈 행인 경우 (모든 위치가 rowspan으로 차지됨)
+                                if (row.isEmpty()) {
+                                        if (occupiedByRowspan == expectedWidth) {
+                                                // 빈 행이 유효함 (모든 위치가 rowspan으로 차지됨)
+                                                continue;
+                                        } else {
+                                                // 빈 행인데 rowspan으로 차지되지 않은 위치가 있음
+                                                return false;
+                                        }
+                                }
+
+                                // 현재 행의 셀들의 colspan 합 계산
+                                int rowCellWidth = 0;
+                                int colIndex = 0;
+
+                                for (var cell : row) {
+                                        if (cell == null)
+                                                return false;
+
+                                        // rowspan으로 차지된 위치는 건너뛰기 (HTML 테이블 규칙)
+                                        while (colIndex < expectedWidth && grid[rowIndex][colIndex] > 0) {
+                                                colIndex++;
+                                        }
+
+                                        if (colIndex >= expectedWidth) {
+                                                // 컬럼 범위를 벗어남
+                                                return false;
+                                        }
+
+                                        // colspan 범위 확인
+                                        if (colIndex + cell.colspan() > expectedWidth) {
+                                                return false;
+                                        }
+
+                                        // colspan 범위 내에 rowspan으로 차지된 셀이 있는지 확인 (HTML 테이블 규칙)
+                                        for (int i = 0; i < cell.colspan(); i++) {
+                                                if (grid[rowIndex][colIndex + i] > 0) {
+                                                        // rowspan으로 이미 차지된 위치와 겹침
+                                                        return false;
+                                                }
+                                        }
+
+                                        // 셀을 그리드에 배치 (rowspan이 있으면 아래 행들도 표시)
+                                        int cellRowspan = cell.rowspan();
+                                        int cellColspan = cell.colspan();
+
+                                        for (int r = 0; r < cellRowspan && rowIndex + r < rowCount; r++) {
+                                                for (int c = 0; c < cellColspan; c++) {
+                                                        if (rowIndex + r < rowCount && colIndex + c < expectedWidth) {
+                                                                grid[rowIndex + r][colIndex + c] = cellRowspan - r;
+                                                        }
+                                                }
+                                        }
+
+                                        rowCellWidth += cellColspan;
+                                        colIndex += cellColspan;
+                                }
+
+                                // 각 행의 실제 너비는 (컬럼 수 - rowspan으로 차지된 위치 수)와 일치해야 함
+                                if (rowCellWidth != expectedWidth - occupiedByRowspan) {
+                                        return false;
+                                }
+                        }
+
                         return true;
                 }
         }
diff --git a/src/main/java/starlight/adapter/order/persistence/OrderRepositoryJpa.java b/src/main/java/starlight/adapter/order/persistence/OrderRepositoryJpa.java
new file mode 100644
index 00000000..f4cf0f5d
--- /dev/null
+++ b/src/main/java/starlight/adapter/order/persistence/OrderRepositoryJpa.java
@@ -0,0 +1,40 @@
+package starlight.adapter.order.persistence;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Repository;
+import starlight.application.order.provided.OrdersQuery;
+import starlight.domain.expertReport.entity.ExpertReport;
+import starlight.domain.order.exception.OrderErrorType;
+import starlight.domain.order.exception.OrderException;
+import starlight.domain.order.order.Orders;
+
+import java.util.List;
+import java.util.Optional;
+
+@Repository
+@RequiredArgsConstructor
+public class OrderRepositoryJpa implements OrdersQuery {
+
+    private final OrdersRepository repository;
+
+    @Override
+    public Optional<Orders> findByOrderCode(String orderCode) {
+        return repository.findByOrderCode(orderCode);
+    }
+
+    @Override
+    public List<Orders> findAllWithPaymentsByBuyerIdOrderByCreatedAtDesc(Long buyerId) {
+        return repository.findAllWithPaymentsByBuyerIdOrderByCreatedAtDesc(buyerId);
+    }
+
+    @Override
+    public Orders getByOrderCodeOrThrow(String orderCode) {
+        return repository.findByOrderCode(orderCode)
+                .orElseThrow(() -> new OrderException(OrderErrorType.ORDER_NOT_FOUND));
+    }
+
+    @Override
+    public Orders save(Orders order) {
+        return repository.save(order);
+    }
+}
diff --git a/src/main/java/starlight/adapter/order/persistence/OrdersRepository.java b/src/main/java/starlight/adapter/order/persistence/OrdersRepository.java
new file mode 100644
index 00000000..b6ea0b27
--- /dev/null
+++ b/src/main/java/starlight/adapter/order/persistence/OrdersRepository.java
@@ -0,0 +1,24 @@
+package starlight.adapter.order.persistence;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import starlight.domain.order.order.Orders;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface OrdersRepository extends JpaRepository<Orders, Long> {
+
+    Optional<Orders> findByOrderCode(String orderCode);
+
+    @Query("""
+    select distinct o
+    from Orders o
+    left join fetch o.payments p
+    where o.buyerId = :buyerId
+    order by o.createdAt desc
+    """)
+    List<Orders> findAllWithPaymentsByBuyerIdOrderByCreatedAtDesc(@Param("buyerId") Long buyerId);
+
+}
diff --git a/src/main/java/starlight/adapter/order/toss/TossClient.java b/src/main/java/starlight/adapter/order/toss/TossClient.java
new file mode 100644
index 00000000..ee8640ea
--- /dev/null
+++ b/src/main/java/starlight/adapter/order/toss/TossClient.java
@@ -0,0 +1,120 @@
+package starlight.adapter.order.toss;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.http.MediaType;
+import org.springframework.stereotype.Component;
+import org.springframework.web.client.RestClient;
+import starlight.application.order.provided.dto.TossClientResponse;
+import starlight.domain.order.exception.OrderErrorType;
+import starlight.domain.order.exception.OrderException;
+
+import java.util.Map;
+import java.util.Objects;
+
+@Slf4j
+@Component
+public class TossClient {
+
+    private final RestClient restClient;
+
+    public TossClient(@Qualifier("tossRestClient") RestClient restClient) {
+        this.restClient = restClient;
+    }
+
+    public TossClientResponse.Confirm confirm(String orderCode, String paymentKey, Long price) {
+        Map<String, Object> body = Map.of(
+                "paymentKey", paymentKey,
+                "orderId",    orderCode,
+                "amount",     price
+        );
+        try {
+            TossClientResponse.Confirm response = restClient.post()
+                    .uri("/v1/payments/confirm")
+                    .header("Idempotency-Key", orderCode)
+                    .contentType(MediaType.APPLICATION_JSON)
+                    .body(body)
+                    .retrieve()
+                    .body(TossClientResponse.Confirm.class);
+
+            // 응답 검증
+            validateConfirmResponse(response, orderCode, price);
+
+            return response;
+
+        } catch (Exception e) {
+            log.error("토스 결제 승인 요청 중 에러 발생. orderId: {}, paymentKey: {}, message: {}", orderCode, paymentKey, e.getMessage(), e);
+            throw new OrderException(OrderErrorType.TOSS_CLIENT_CONFIRM_ERROR);
+        }
+    }
+
+    public TossClientResponse.Cancel cancel(String paymentKey, String reason) {
+        Map<String, Object> body = Map.of(
+                "cancelReason", reason != null ? reason : "user_request"
+        );
+        try {
+            TossClientResponse.Cancel response = restClient.post()
+                    .uri("/v1/payments/{paymentKey}/cancel", paymentKey)
+                    .contentType(MediaType.APPLICATION_JSON)
+                    .body(body)
+                    .retrieve()
+                    .body(TossClientResponse.Cancel.class);
+
+            // 응답 검증
+            validateCancelResponse(response);
+
+            return response;
+
+        } catch (Exception e) {
+            log.error("토스 환불 요청 중 에러발생: {}", e.getMessage(), e);
+            log.error("paymentKey: {}, reason: {}", paymentKey, reason);
+            throw new OrderException(OrderErrorType.TOSS_CLIENT_CONFIRM_ERROR);
+        }
+
+    }
+
+    /**
+     * confirm 응답 검증
+     */
+    private void validateConfirmResponse(TossClientResponse.Confirm response, String expectedOrderId, Long expectedAmount) {
+        if (response == null) {
+            throw new IllegalStateException("PG 응답이 null입니다.");
+        }
+
+        if (!Objects.equals(response.orderId(), expectedOrderId)) {
+            throw new IllegalStateException(
+                    String.format("PG 응답의 주문번호가 일치하지 않습니다. 예상: %s, 실제: %s",
+                            expectedOrderId, response.orderId())
+            );
+        }
+
+        if (!Objects.equals(response.totalAmount(), expectedAmount)) {
+            throw new IllegalStateException(
+                    String.format("PG 응답 금액이 주문 금액과 일치하지 않습니다. 예상: %d, 실제: %d",
+                            expectedAmount, response.totalAmount())
+            );
+        }
+
+        if (!"DONE".equals(response.status())) {
+            throw new IllegalStateException(
+                    "PG 응답 상태가 완료(DONE)가 아닙니다. status=" + response.status()
+            );
+        }
+    }
+
+    /**
+     * cancel 응답 검증
+     */
+    private void validateCancelResponse(TossClientResponse.Cancel response) {
+        if (response == null) {
+            throw new IllegalStateException("PG 취소 응답이 null입니다.");
+        }
+
+        // 취소 응답은 status가 CANCELED여야 함
+        if (response.status() != null && !"CANCELED".equals(response.status())) {
+            throw new IllegalStateException(
+                    "PG 취소가 완료 상태(CANCELED)가 아닙니다. status=" + response.status()
+            );
+        }
+    }
+}
diff --git a/src/main/java/starlight/adapter/order/webapi/OrderController.java b/src/main/java/starlight/adapter/order/webapi/OrderController.java
new file mode 100644
index 00000000..46829fee
--- /dev/null
+++ b/src/main/java/starlight/adapter/order/webapi/OrderController.java
@@ -0,0 +1,102 @@
+package starlight.adapter.order.webapi;
+
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.web.bind.annotation.*;
+import starlight.adapter.auth.security.auth.AuthDetails;
+import starlight.application.order.provided.dto.TossClientResponse;
+import starlight.adapter.order.webapi.dto.request.OrderCancelRequest;
+import starlight.adapter.order.webapi.dto.request.OrderConfirmRequest;
+import starlight.adapter.order.webapi.dto.request.OrderPrepareRequest;
+import starlight.adapter.order.webapi.dto.response.OrderCancelResponse;
+import starlight.adapter.order.webapi.dto.response.OrderConfirmResponse;
+import starlight.adapter.order.webapi.dto.response.OrderPrepareResponse;
+import starlight.adapter.order.webapi.dto.response.WalletCheckResponse;
+import starlight.application.order.provided.OrderPaymentService;
+import starlight.application.order.provided.dto.PaymentHistoryItemDto;
+import starlight.application.usage.provided.UsageCreditPort;
+import starlight.domain.order.order.Orders;
+import starlight.shared.apiPayload.response.ApiResponse;
+
+import java.util.List;
+
+@RestController
+@RequiredArgsConstructor
+@Tag(name = "결제", description = "결제 관련 API")
+@RequestMapping("/v1/orders")
+public class OrderController {
+
+    private final OrderPaymentService orderPaymentService;
+    private final UsageCreditPort usageCreditPort;
+
+    /**
+     * 결제 준비 (주문 생성)
+     * POST /api/toss/request
+     */
+    @PostMapping("/request")
+    public ApiResponse<OrderPrepareResponse> prepareOrder(
+            @Valid @RequestBody OrderPrepareRequest request,
+            @AuthenticationPrincipal AuthDetails authDetails
+    ) {
+        Orders order = orderPaymentService.prepare(
+                request.orderCode(),
+                authDetails.getMemberId(),
+                request.productCode()
+        );
+
+        OrderPrepareResponse response = OrderPrepareResponse.from(order);
+
+        return ApiResponse.success(response);
+    }
+
+    /**
+     * 결제 승인
+     * POST /api/toss/confirm
+     */
+    @PostMapping("/confirm")
+    public ApiResponse<OrderConfirmResponse> confirmPayment(
+            @Valid @RequestBody OrderConfirmRequest request,
+            @AuthenticationPrincipal AuthDetails authDetails
+    ) {
+        Orders order = orderPaymentService.confirm(
+                request.orderCode(),
+                request.paymentKey(),
+                authDetails.getMemberId()
+        );
+
+        OrderConfirmResponse response = OrderConfirmResponse.from(order);
+
+        return ApiResponse.success(response);
+    }
+
+    /**
+     * 결제 취소
+     * POST /api/toss/cancel
+     */
+    @PostMapping("/cancel")
+    public ApiResponse<OrderCancelResponse> cancelPayment(
+            @Valid @RequestBody OrderCancelRequest request
+    ) {
+        TossClientResponse.Cancel tossResponse = orderPaymentService.cancel(request);
+
+        OrderCancelResponse response = OrderCancelResponse.from(tossResponse);
+
+        return ApiResponse.success(response);
+    }
+
+    /**
+     * 나의 결제 내역 조회
+     * GET /api/orders
+     */
+    @GetMapping
+    public ApiResponse<List<PaymentHistoryItemDto>> getMyPayments(
+            @AuthenticationPrincipal AuthDetails authDetails
+    ) {
+        Long memberId = authDetails.getMemberId();
+        List<PaymentHistoryItemDto> history = orderPaymentService.getPaymentHistory(memberId);
+
+        return ApiResponse.success(history);
+    }
+}
diff --git a/src/main/java/starlight/adapter/order/webapi/dto/request/OrderCancelRequest.java b/src/main/java/starlight/adapter/order/webapi/dto/request/OrderCancelRequest.java
new file mode 100644
index 00000000..7aa386f3
--- /dev/null
+++ b/src/main/java/starlight/adapter/order/webapi/dto/request/OrderCancelRequest.java
@@ -0,0 +1,11 @@
+package starlight.adapter.order.webapi.dto.request;
+
+import jakarta.validation.constraints.NotBlank;
+
+public record OrderCancelRequest(
+        @NotBlank(message = "orderCode는 필수입니다.")
+        String orderCode,
+
+        @NotBlank(message = "취소 사유는 필수입니다.")
+        String reason
+) { }
diff --git a/src/main/java/starlight/adapter/order/webapi/dto/request/OrderConfirmRequest.java b/src/main/java/starlight/adapter/order/webapi/dto/request/OrderConfirmRequest.java
new file mode 100644
index 00000000..9e246bc0
--- /dev/null
+++ b/src/main/java/starlight/adapter/order/webapi/dto/request/OrderConfirmRequest.java
@@ -0,0 +1,11 @@
+package starlight.adapter.order.webapi.dto.request;
+
+import jakarta.validation.constraints.NotBlank;
+
+public record OrderConfirmRequest(
+        @NotBlank
+        String paymentKey,
+
+        @NotBlank
+        String orderCode
+) { }
diff --git a/src/main/java/starlight/adapter/order/webapi/dto/request/OrderPrepareRequest.java b/src/main/java/starlight/adapter/order/webapi/dto/request/OrderPrepareRequest.java
new file mode 100644
index 00000000..60db489f
--- /dev/null
+++ b/src/main/java/starlight/adapter/order/webapi/dto/request/OrderPrepareRequest.java
@@ -0,0 +1,11 @@
+package starlight.adapter.order.webapi.dto.request;
+
+import jakarta.validation.constraints.NotBlank;
+
+public record OrderPrepareRequest(
+        @NotBlank
+        String orderCode,
+
+        @NotBlank
+        String productCode
+) { }
diff --git a/src/main/java/starlight/adapter/order/webapi/dto/response/OrderCancelResponse.java b/src/main/java/starlight/adapter/order/webapi/dto/response/OrderCancelResponse.java
new file mode 100644
index 00000000..6ffc25cd
--- /dev/null
+++ b/src/main/java/starlight/adapter/order/webapi/dto/response/OrderCancelResponse.java
@@ -0,0 +1,19 @@
+package starlight.adapter.order.webapi.dto.response;
+
+import starlight.application.order.provided.dto.TossClientResponse;
+
+public record OrderCancelResponse(
+        String orderId,
+        String paymentKey,
+        String status,
+        Integer totalAmount
+) {
+    public static OrderCancelResponse from(TossClientResponse.Cancel tossResponse) {
+        return new OrderCancelResponse(
+                tossResponse.orderId(),
+                tossResponse.paymentKey(),
+                tossResponse.status(),
+                tossResponse.totalAmount()
+        );
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/starlight/adapter/order/webapi/dto/response/OrderConfirmResponse.java b/src/main/java/starlight/adapter/order/webapi/dto/response/OrderConfirmResponse.java
new file mode 100644
index 00000000..06c87607
--- /dev/null
+++ b/src/main/java/starlight/adapter/order/webapi/dto/response/OrderConfirmResponse.java
@@ -0,0 +1,34 @@
+package starlight.adapter.order.webapi.dto.response;
+
+import starlight.domain.order.order.Orders;
+import starlight.domain.order.order.PaymentRecords;
+
+import java.time.Instant;
+
+public record OrderConfirmResponse(
+        Long buyerId,
+        String paymentKey,
+        String orderId,
+        Long amount,
+        String status,
+        Instant approvedAt,
+        String receiptUrl,
+        String method,
+        String provider
+) {
+    public static OrderConfirmResponse from(Orders order) {
+        PaymentRecords done = order.getLatestPaymentOrThrow();
+
+        return new OrderConfirmResponse(
+                order.getBuyerId(),
+                done.getPaymentKey(),
+                order.getOrderCode(),
+                order.getPrice(),
+                order.getStatus().name(),
+                done.getApprovedAt(),
+                done.getReceiptUrl(),
+                done.getMethod(),
+                done.getProvider()
+        );
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/starlight/adapter/order/webapi/dto/response/OrderPrepareResponse.java b/src/main/java/starlight/adapter/order/webapi/dto/response/OrderPrepareResponse.java
new file mode 100644
index 00000000..daa67302
--- /dev/null
+++ b/src/main/java/starlight/adapter/order/webapi/dto/response/OrderPrepareResponse.java
@@ -0,0 +1,17 @@
+package starlight.adapter.order.webapi.dto.response;
+
+import starlight.domain.order.order.Orders;
+
+public record OrderPrepareResponse(
+        String orderCode,
+        Long amount,
+        String status
+) {
+    public static OrderPrepareResponse from(Orders order) {
+        return new OrderPrepareResponse(
+                order.getOrderCode(),
+                order.getPrice(),
+                order.getStatus().name()
+        );
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/starlight/adapter/order/webapi/dto/response/WalletCheckResponse.java b/src/main/java/starlight/adapter/order/webapi/dto/response/WalletCheckResponse.java
new file mode 100644
index 00000000..325321bf
--- /dev/null
+++ b/src/main/java/starlight/adapter/order/webapi/dto/response/WalletCheckResponse.java
@@ -0,0 +1,11 @@
+package starlight.adapter.order.webapi.dto.response;
+
+public record WalletCheckResponse(
+        Boolean hasCredit
+) {
+    public static WalletCheckResponse of(Boolean hasCredit) {
+        return new WalletCheckResponse(
+                hasCredit
+        );
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/starlight/adapter/usage/persistence/UsageHistoryRepository.java b/src/main/java/starlight/adapter/usage/persistence/UsageHistoryRepository.java
new file mode 100644
index 00000000..e055482b
--- /dev/null
+++ b/src/main/java/starlight/adapter/usage/persistence/UsageHistoryRepository.java
@@ -0,0 +1,7 @@
+package starlight.adapter.usage.persistence;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import starlight.domain.order.wallet.UsageHistory;
+
+public interface UsageHistoryRepository extends JpaRepository<UsageHistory, Long> {
+}
diff --git a/src/main/java/starlight/adapter/usage/persistence/UsageHistoryRepositoryJpa.java b/src/main/java/starlight/adapter/usage/persistence/UsageHistoryRepositoryJpa.java
new file mode 100644
index 00000000..803689b9
--- /dev/null
+++ b/src/main/java/starlight/adapter/usage/persistence/UsageHistoryRepositoryJpa.java
@@ -0,0 +1,18 @@
+package starlight.adapter.usage.persistence;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Repository;
+import starlight.application.usage.provided.UsageHistoryQuery;
+import starlight.domain.order.wallet.UsageHistory;
+
+@Repository
+@RequiredArgsConstructor
+public class UsageHistoryRepositoryJpa implements UsageHistoryQuery {
+
+    private final UsageHistoryRepository repository;
+
+    @Override
+    public UsageHistory save(UsageHistory usageHistory){
+        return repository.save(usageHistory);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/starlight/adapter/usage/persistence/UsageWalletRepository.java b/src/main/java/starlight/adapter/usage/persistence/UsageWalletRepository.java
new file mode 100644
index 00000000..5f1352a7
--- /dev/null
+++ b/src/main/java/starlight/adapter/usage/persistence/UsageWalletRepository.java
@@ -0,0 +1,11 @@
+package starlight.adapter.usage.persistence;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import starlight.domain.order.wallet.UsageWallet;
+
+import java.util.Optional;
+
+public interface UsageWalletRepository extends JpaRepository<UsageWallet, Long> {
+
+    Optional<UsageWallet> findByUserId(Long userId);
+}
\ No newline at end of file
diff --git a/src/main/java/starlight/adapter/usage/persistence/UsageWalletRepositoryJpa.java b/src/main/java/starlight/adapter/usage/persistence/UsageWalletRepositoryJpa.java
new file mode 100644
index 00000000..c8bdf4c6
--- /dev/null
+++ b/src/main/java/starlight/adapter/usage/persistence/UsageWalletRepositoryJpa.java
@@ -0,0 +1,25 @@
+package starlight.adapter.usage.persistence;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Repository;
+import starlight.application.usage.provided.UsageWalletQuery;
+import starlight.domain.order.wallet.UsageWallet;
+
+import java.util.Optional;
+
+@Repository
+@RequiredArgsConstructor
+public class UsageWalletRepositoryJpa implements UsageWalletQuery {
+
+    private final UsageWalletRepository repository;
+
+    @Override
+    public Optional<UsageWallet> findByUserId(Long userId){
+        return repository.findByUserId(userId);
+    }
+
+    @Override
+    public UsageWallet save(UsageWallet usageWallet){
+        return repository.save(usageWallet);
+    }
+}
diff --git a/src/main/java/starlight/application/businessplan/util/PlainTextExtractUtils.java b/src/main/java/starlight/application/businessplan/util/PlainTextExtractUtils.java
index a01b77ce..80011df2 100644
--- a/src/main/java/starlight/application/businessplan/util/PlainTextExtractUtils.java
+++ b/src/main/java/starlight/application/businessplan/util/PlainTextExtractUtils.java
@@ -11,17 +11,18 @@
 
 /**
  * Content(JSON) → 줄글 변환 (고정 포맷)
- *  - text  : value
- *  - image : "[사진] {caption}" (캡션 없으면 "[사진]")
- *  - table : "col1: v1, col2: v2, ..." (행마다 한 줄)
+ * - text : value
+ * - image : "[사진] {caption}" (캡션 없으면 "[사진]")
+ * - table : "col1: v1, col2: v2, ..." (행마다 한 줄)
  *
  * 지원 입력:
- *  (1) {"content":[ ... ]}
- *  (2) {"blocks":[ {"content":[ ... ]}, ... ]}
+ * (1) {"content":[ ... ]}
+ * (2) {"blocks":[ {"content":[ ... ]}, ... ]}
  */
 public final class PlainTextExtractUtils {
 
-    private PlainTextExtractUtils() {}
+    private PlainTextExtractUtils() {
+    }
 
     // 고정 포맷 상수
     private static final String IMAGE_TOKEN = "[사진]";
@@ -123,27 +124,112 @@ static List<String> extractTable_new(JsonNode contentItem) {
             return tableLines;
         }
 
-        // 헤더 추가
-        List<String> headers = new ArrayList<>();
-        for (JsonNode col : columnArrayNode) {
-            headers.add("\"" + col.asText() + "\"");
+        int columnCount = columnArrayNode.size();
+        int rowCount = rowArrayNode.size();
+
+        if (rowCount == 0) {
+            return tableLines;
         }
-        tableLines.add("[" + String.join(", ", headers) + "]");
 
-        // 각 행 추가
-        for (JsonNode rowNode : rowArrayNode) {
-            if (rowNode.isArray()) {
-                List<String> rowValues = new ArrayList<>();
-                for (JsonNode cell : rowNode) {
-                    rowValues.add("\"" + cell.asText() + "\"");
+        // 컬럼 개수 표시
+        tableLines.add("[" + columnCount + " columns]");
+
+        // rowspan과 colspan을 고려하여 실제 테이블 그리드 구성
+        // grid[row][col] = 해당 위치의 셀 텍스트 (null이면 rowspan으로 차지된 위치)
+        String[][] grid = new String[rowCount][columnCount];
+        boolean[][] isOccupied = new boolean[rowCount][columnCount];
+
+        // 각 행을 순회하며 셀 배치
+        for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+            JsonNode rowNode = rowArrayNode.get(rowIndex);
+            if (!rowNode.isArray()) {
+                continue;
+            }
+
+            int colIndex = 0;
+            for (JsonNode cellNode : rowNode) {
+                // rowspan으로 차지된 위치는 건너뛰기
+                while (colIndex < columnCount && isOccupied[rowIndex][colIndex]) {
+                    colIndex++;
+                }
+
+                if (colIndex >= columnCount) {
+                    break;
                 }
-                tableLines.add("[" + String.join(", ", rowValues) + "]");
+
+                // 셀 내용 추출
+                String cellText = extractCellContent(cellNode);
+
+                // rowspan과 colspan 값 가져오기 (기본값 1)
+                int rowspan = resolveSpanValue(cellNode, "rowspan", "rowSpan");
+                int colspan = resolveSpanValue(cellNode, "colspan", "colSpan");
+
+                // colspan 범위 확인
+                if (colIndex + colspan > columnCount) {
+                    colspan = columnCount - colIndex;
+                }
+
+                // 셀을 그리드에 배치
+                for (int r = 0; r < rowspan && rowIndex + r < rowCount; r++) {
+                    for (int c = 0; c < colspan && colIndex + c < columnCount; c++) {
+                        if (r == 0 && c == 0) {
+                            // 첫 번째 위치에만 텍스트 저장
+                            grid[rowIndex + r][colIndex + c] = cellText;
+                        }
+                        // 모든 위치를 차지된 것으로 표시
+                        isOccupied[rowIndex + r][colIndex + c] = true;
+                    }
+                }
+
+                colIndex += colspan;
             }
         }
 
+        // 그리드를 순회하며 각 행의 텍스트 생성
+        for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+            List<String> rowValues = new ArrayList<>();
+            for (int colIndex = 0; colIndex < columnCount; colIndex++) {
+                String cellText = grid[rowIndex][colIndex];
+                if (cellText == null) {
+                    // rowspan으로 차지된 위치는 빈 문자열
+                    cellText = "";
+                }
+                rowValues.add("\"" + cellText + "\"");
+            }
+            tableLines.add("[" + String.join(", ", rowValues) + "]");
+        }
+
         return tableLines;
     }
 
+    /** 셀 내부의 content (BasicContent 리스트)를 텍스트로 추출 */
+    static String extractCellContent(JsonNode cellNode) {
+        if (!cellNode.has("content") || !cellNode.path("content").isArray()) {
+            return "";
+        }
+
+        List<String> cellParts = new ArrayList<>();
+        for (JsonNode contentItem : cellNode.path("content")) {
+            String type = contentItem.path("type").asText("");
+            switch (type) {
+                case "text":
+                    String textValue = contentItem.path("value").asText("");
+                    if (!textValue.isBlank()) {
+                        cellParts.add(textValue);
+                    }
+                    break;
+                case "image":
+                    Optional<String> imageText = extractImage(contentItem);
+                    imageText.ifPresent(cellParts::add);
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        return String.join(" ", cellParts);
+    }
+
     /** 테이블 항목: 각 행을 "col1: v1, col2: v2 ..." */
     static List<String> extractTable(JsonNode contentItem) {
         List<String> tableLines = new ArrayList<>();
@@ -200,4 +286,14 @@ static String joinNonBlank(List<String> partsList, String separator) {
         }
         return result;
     }
+
+    private static int resolveSpanValue(JsonNode cellNode, String lowerKey, String camelKey) {
+        if (cellNode.has(lowerKey)) {
+            return Math.max(1, cellNode.path(lowerKey).asInt(1));
+        }
+        if (cellNode.has(camelKey)) {
+            return Math.max(1, cellNode.path(camelKey).asInt(1));
+        }
+        return 1;
+    }
 }
diff --git a/src/main/java/starlight/application/order/OrderPaymentServiceImpl.java b/src/main/java/starlight/application/order/OrderPaymentServiceImpl.java
new file mode 100644
index 00000000..489cb499
--- /dev/null
+++ b/src/main/java/starlight/application/order/OrderPaymentServiceImpl.java
@@ -0,0 +1,167 @@
+package starlight.application.order;
+
+import jakarta.transaction.Transactional;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import starlight.adapter.order.toss.TossClient;
+import starlight.application.order.provided.dto.TossClientResponse;
+import starlight.adapter.order.webapi.dto.request.OrderCancelRequest;
+import starlight.application.order.provided.OrderPaymentService;
+import starlight.application.order.provided.OrdersQuery;
+import starlight.application.order.provided.dto.PaymentHistoryItemDto;
+import starlight.application.usage.provided.UsageCreditPort;
+import starlight.domain.order.enumerate.OrderStatus;
+import starlight.domain.order.enumerate.UsageProductType;
+import starlight.domain.order.exception.OrderErrorType;
+import starlight.domain.order.exception.OrderException;
+import starlight.domain.order.order.Orders;
+import starlight.domain.order.order.PaymentRecords;
+import starlight.domain.order.order.vo.Money;
+import starlight.domain.order.order.vo.OrderCode;
+
+import java.time.Instant;
+import java.util.List;
+import java.util.Objects;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+@Transactional
+public class OrderPaymentServiceImpl implements OrderPaymentService {
+
+    private final TossClient tossClient;
+    private final OrdersQuery ordersQuery;
+    private final UsageCreditPort usageCreditPort;
+
+    /**
+     * 결제 전 주문 준비
+     * - orderCode로 주문이 있으면 재사용(검증 후 결제 시도 추가)
+     * - 없으면 새 주문 생성 후 첫 결제 시도 추가
+     *
+     * @param orderCodeStr 프론트에서 생성한 주문번호
+     * @param buyerId 구매자 ID
+     * @param productCode 결제 금액
+     * @return Orders 준비된 주문
+     */
+    @Override
+    public Orders prepare(String orderCodeStr, Long buyerId, String productCode) {
+        UsageProductType product = UsageProductType.fromCode(productCode);
+        Money money = Money.krw(product.getPrice());
+        OrderCode orderCode = OrderCode.of(orderCodeStr);
+
+        return ordersQuery.findByOrderCode(orderCodeStr)
+                .map(existing -> {
+                    existing.validateSameBuyer(buyerId);
+                    existing.validateSameProduct(product);
+                    existing.addPaymentAttempt(money);
+                    return existing;
+                })
+                .orElseGet(() -> {
+                    Orders newOrder = Orders.newUsageOrder(orderCode, buyerId, money, product);
+                    newOrder.addPaymentAttempt(money);
+                    return ordersQuery.save(newOrder);
+                });
+    }
+
+    /**
+     * 결제 승인 (Confirm)
+     * 토스 리다이렉트 성공 후 호출
+     *
+     * @param orderCodeStr 주문번호
+     * @param paymentKey 토스 결제키
+     * @return Orders 승인된 주문
+     */
+    @Override
+    public Orders confirm(String orderCodeStr, String paymentKey, Long buyerId) {
+
+        Orders order = ordersQuery.getByOrderCodeOrThrow(orderCodeStr);
+
+        UsageProductType product = UsageProductType.fromCode(order.getUsageProductCode());
+        long expectedAmount = product.getPrice();
+
+        if (!Objects.equals(order.getPrice(), expectedAmount)) {
+            throw new OrderException(OrderErrorType.PAYMENT_AMOUNT_MISMATCH);
+        }
+
+        PaymentRecords payment = order.getLatestRequestedOrThrow();
+
+        TossClientResponse.Confirm response = tossClient.confirm(
+                orderCodeStr, paymentKey, expectedAmount
+        );
+
+        String provider = response.providerOrNull();
+        String receiptUrl = response.receiptUrlOrNull();
+        Instant approvedAt = response.approvedAtOrNow();
+
+        payment.markDone(
+                response.paymentKey(), response.method(), provider, receiptUrl, approvedAt
+        );
+        order.markPaid();
+
+        usageCreditPort.chargeForOrder(
+                order.getBuyerId(),
+                order.getId(),
+                product.getUsageCount()
+        );
+
+        return ordersQuery.save(order);
+    }
+
+    /**
+     * 결제 취소
+     *
+     * @param request 취소 요청
+     * @return TossClientResponse.Cancel 취소 응답
+     */
+    @Override
+    public TossClientResponse.Cancel cancel(OrderCancelRequest request) {
+
+        Orders order = ordersQuery.getByOrderCodeOrThrow(request.orderCode());
+
+        PaymentRecords payment = order.getLatestDoneOrThrow();
+        payment.ensureHasPaymentKey();
+
+        TossClientResponse.Cancel response = tossClient.cancel(
+                payment.getPaymentKey(), request.reason()
+        );
+
+        payment.markCanceled();
+        order.cancel();
+
+        ordersQuery.save(order);
+
+        return response;
+    }
+
+    public List<PaymentHistoryItemDto> getPaymentHistory(Long buyerId) {
+        // 1) 이 회원(buyer)의 주문 전체를 최신순으로 가져오기
+        List<Orders> orders = ordersQuery.findAllWithPaymentsByBuyerIdOrderByCreatedAtDesc(buyerId);
+
+        return orders.stream()
+                // 결제완료(PAID) 주문만
+                .filter(o -> o.getStatus() == OrderStatus.PAID)
+                .map(order -> {
+                    // 2) 해당 주문의 가장 최근 DONE 결제
+                    PaymentRecords payment = order.getLatestDoneOrThrow();
+
+                    // 3) 상품명 매핑
+                    UsageProductType productType = UsageProductType.fromCode(order.getUsageProductCode());
+                    String productName = productType.getDescription();
+
+                    // 4) 결제일 (approvedAt 없으면 createdAt)
+                    Instant paidAt = payment.getApprovedAt() != null
+                            ? payment.getApprovedAt()
+                            : payment.getCreatedAt();
+
+                    return PaymentHistoryItemDto.of(
+                            productName,
+                            payment.getMethod(),
+                            payment.getPrice(),
+                            paidAt,
+                            payment.getReceiptUrl()
+                    );
+                })
+                .toList();
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/starlight/application/order/provided/OrderPaymentService.java b/src/main/java/starlight/application/order/provided/OrderPaymentService.java
new file mode 100644
index 00000000..ff293f2a
--- /dev/null
+++ b/src/main/java/starlight/application/order/provided/OrderPaymentService.java
@@ -0,0 +1,19 @@
+package starlight.application.order.provided;
+
+import starlight.application.order.provided.dto.TossClientResponse;
+import starlight.adapter.order.webapi.dto.request.OrderCancelRequest;
+import starlight.application.order.provided.dto.PaymentHistoryItemDto;
+import starlight.domain.order.order.Orders;
+
+import java.util.List;
+
+public interface OrderPaymentService{
+
+    Orders prepare(String orderCodeStr, Long buyerId, String productCode);
+
+    Orders confirm(String orderCodeStr, String paymentKey, Long buyerId);
+
+    TossClientResponse.Cancel cancel(OrderCancelRequest request);
+
+    List<PaymentHistoryItemDto> getPaymentHistory(Long buyerId);
+}
diff --git a/src/main/java/starlight/application/order/provided/OrdersQuery.java b/src/main/java/starlight/application/order/provided/OrdersQuery.java
new file mode 100644
index 00000000..16b5dfc3
--- /dev/null
+++ b/src/main/java/starlight/application/order/provided/OrdersQuery.java
@@ -0,0 +1,17 @@
+package starlight.application.order.provided;
+
+import starlight.domain.order.order.Orders;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface OrdersQuery {
+
+    Optional<Orders> findByOrderCode(String orderCode);
+
+    List<Orders> findAllWithPaymentsByBuyerIdOrderByCreatedAtDesc(Long buyerId);
+
+    Orders getByOrderCodeOrThrow(String orderCode);
+
+    Orders save(Orders order);
+}
\ No newline at end of file
diff --git a/src/main/java/starlight/application/order/provided/dto/PaymentHistoryItemDto.java b/src/main/java/starlight/application/order/provided/dto/PaymentHistoryItemDto.java
new file mode 100644
index 00000000..1e0f3e71
--- /dev/null
+++ b/src/main/java/starlight/application/order/provided/dto/PaymentHistoryItemDto.java
@@ -0,0 +1,27 @@
+package starlight.application.order.provided.dto;
+
+import java.time.Instant;
+
+public record PaymentHistoryItemDto(
+        String productName,
+        String paymentMethod,
+        Long price,
+        Instant paidAt,
+        String receiptUrl
+) {
+    public static PaymentHistoryItemDto of(
+            String productName,
+            String paymentMethod,
+            Long price,
+            Instant paidAt,
+            String receiptUrl
+    ) {
+        return new PaymentHistoryItemDto(
+                productName,
+                paymentMethod,
+                price,
+                paidAt,
+                receiptUrl
+        );
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/starlight/application/order/provided/dto/TossClientResponse.java b/src/main/java/starlight/application/order/provided/dto/TossClientResponse.java
new file mode 100644
index 00000000..97a4c932
--- /dev/null
+++ b/src/main/java/starlight/application/order/provided/dto/TossClientResponse.java
@@ -0,0 +1,98 @@
+package starlight.application.order.provided.dto;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.extern.slf4j.Slf4j;
+
+import java.time.Instant;
+import java.time.OffsetDateTime;
+import java.util.List;
+
+@Slf4j
+public record TossClientResponse (
+) {
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    public record Cancel(
+            // 기본 정보
+            String mId,                 // 가맹점 ID
+            String lastTransactionKey,  // 마지막 거래 키
+            String paymentKey,          // 결제 키
+            String orderId,             // ORD20251113-3PNGMYUX
+            String orderName,           // starlight 크레딧 5,000원
+            Integer taxExemptionAmount, // 비과세 금액
+            String status,              // (String) CANCELED
+            String requestedAt,         // 요청 시각
+            String approvedAt,          // 승인 시각
+
+            // 취소 내역
+            List<CancelDetail> cancels,
+
+            // 결제 정보
+            String secret,              // 가맹점 시크릿 코드 (ps_kYG57Eba3GKvEgqK6GnE3pWDOxmA)
+            String type,                // 결제 타입 ("NORMAL")
+            EasyPay easyPay,
+
+            // 영수증
+            Receipt receipt,
+
+            // 금액 정보
+            String currency,            // "KRW"
+            Integer totalAmount,        // 5000
+            Integer balanceAmount,      // 0
+            Integer suppliedAmount,     // 5000
+            Integer vat,                // 455
+            Integer taxFreeAmount,      // 0
+            String method               // "간편결제"
+    ) {
+
+        @JsonIgnoreProperties(ignoreUnknown = true)
+        public record CancelDetail(
+                String cancelReason,    // "user_request"
+                String canceledAt,      // "2025-11-13T19:09:04+09:00"
+                String cancelStatus,    // "DONE"
+                Integer cancelAmount    // 5000
+        ) {}
+
+        @JsonIgnoreProperties(ignoreUnknown = true)
+        public record EasyPay(
+                String provider,        // "카카오페이"
+                Integer amount,         // 5000
+                Integer discountAmount  // 0
+        ) {}
+
+        @JsonIgnoreProperties(ignoreUnknown = true)
+        public record Receipt(
+                String url              // 영수증 URL
+        ) {}
+    }
+
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    public record Confirm(
+            String paymentKey,
+            String orderId,
+            String status,           // e.g., DONE
+            String method,           // CARD/EASY_PAY...
+            Long totalAmount,
+            OffsetDateTime approvedAt,
+            EasyPay easyPay,
+            Receipt receipt
+    ) {
+        public record EasyPay(String provider) {}
+        public record Receipt(String url) {}
+
+        public String providerOrNull() {
+            return (easyPay != null) ? easyPay.provider() : null;
+        }
+
+        public String receiptUrlOrNull() {
+            return (receipt != null) ? receipt.url() : null;
+        }
+
+        public Instant approvedAtOrNow() {
+            if (approvedAt == null) {
+                log.warn("승인 시각이 누락되었습니다, orderId: {}", orderId);
+                return Instant.now();
+            }
+            return approvedAt.toInstant();
+        }
+    }
+}
diff --git a/src/main/java/starlight/application/usage/UsageCreditService.java b/src/main/java/starlight/application/usage/UsageCreditService.java
new file mode 100644
index 00000000..5b888b72
--- /dev/null
+++ b/src/main/java/starlight/application/usage/UsageCreditService.java
@@ -0,0 +1,53 @@
+package starlight.application.usage;
+
+import jakarta.transaction.Transactional;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import starlight.application.usage.provided.UsageCreditPort;
+import starlight.application.usage.provided.UsageHistoryQuery;
+import starlight.application.usage.provided.UsageWalletQuery;
+import starlight.domain.order.exception.OrderErrorType;
+import starlight.domain.order.exception.OrderException;
+import starlight.domain.order.wallet.UsageHistory;
+import starlight.domain.order.wallet.UsageWallet;
+
+@Service
+@RequiredArgsConstructor
+@Transactional
+public class UsageCreditService implements UsageCreditPort {
+
+    private final UsageWalletQuery usageWalletQuery;
+    private final UsageHistoryQuery usageHistoryQuery;
+
+    /**
+     * 주문 결제가 완료되었을 때 사용권(지갑)을 충전한다.
+     *
+     * @param userId     주문자 ID
+     * @param orderId    주문 PK (UsageHistory 연동용)
+     * @param usageCount 몇 회권인지 (1회 / 2회 등)
+     */
+    @Override
+    public void chargeForOrder(Long userId, Long orderId, int usageCount) {
+        if (userId == null || usageCount <= 0) {
+            throw new OrderException(OrderErrorType.INVALID_USAGE_COUNT);
+        }
+
+        // 지갑 조회 or 생성
+        UsageWallet wallet = usageWalletQuery.findByUserId(userId)
+                .orElseGet(() -> usageWalletQuery.save(UsageWallet.init(userId)));
+
+        // 사용권 충전
+        wallet.chargeAiReport(usageCount);
+        usageWalletQuery.save(wallet);
+
+        // 이력 기록
+        usageHistoryQuery.save(
+                UsageHistory.charged(
+                        userId,
+                        usageCount,
+                        wallet.getAiReportRemainingCount(),
+                        orderId
+                )
+        );
+    }
+}
diff --git a/src/main/java/starlight/application/usage/provided/UsageCreditPort.java b/src/main/java/starlight/application/usage/provided/UsageCreditPort.java
new file mode 100644
index 00000000..724eeb4c
--- /dev/null
+++ b/src/main/java/starlight/application/usage/provided/UsageCreditPort.java
@@ -0,0 +1,6 @@
+package starlight.application.usage.provided;
+
+public interface UsageCreditPort {
+
+    void chargeForOrder(Long userId, Long orderId, int usageCount);
+}
diff --git a/src/main/java/starlight/application/usage/provided/UsageHistoryQuery.java b/src/main/java/starlight/application/usage/provided/UsageHistoryQuery.java
new file mode 100644
index 00000000..2f9c10af
--- /dev/null
+++ b/src/main/java/starlight/application/usage/provided/UsageHistoryQuery.java
@@ -0,0 +1,8 @@
+package starlight.application.usage.provided;
+
+import starlight.domain.order.wallet.UsageHistory;
+
+public interface UsageHistoryQuery {
+
+    UsageHistory save(UsageHistory usageHistory);
+}
diff --git a/src/main/java/starlight/application/usage/provided/UsageWalletQuery.java b/src/main/java/starlight/application/usage/provided/UsageWalletQuery.java
new file mode 100644
index 00000000..37f99ee9
--- /dev/null
+++ b/src/main/java/starlight/application/usage/provided/UsageWalletQuery.java
@@ -0,0 +1,12 @@
+package starlight.application.usage.provided;
+
+import starlight.domain.order.wallet.UsageWallet;
+
+import java.util.Optional;
+
+public interface UsageWalletQuery {
+
+    Optional<UsageWallet> findByUserId(Long userId);
+
+    UsageWallet save(UsageWallet usageWallet);
+}
diff --git a/src/main/java/starlight/bootstrap/RestClientConfig.java b/src/main/java/starlight/bootstrap/RestClientConfig.java
index 652d7c15..047d4ff5 100644
--- a/src/main/java/starlight/bootstrap/RestClientConfig.java
+++ b/src/main/java/starlight/bootstrap/RestClientConfig.java
@@ -77,4 +77,24 @@ public RestClient clovaStudioClient(
                 .defaultHeader("Content-Type", "application/json")
                 .build();
     }
+
+    @Bean(name = "tossRestClient")
+    public RestClient tossRestClient(
+            @Value("${toss.secretKey}") String secretKey,
+            @Value("${toss.baseUrl}") String baseUrl
+    ) {
+        JdkClientHttpRequestFactory factory = new JdkClientHttpRequestFactory();
+        factory.setReadTimeout(Duration.ofSeconds(20)); // 필요 시 조정
+
+        String basic = java.util.Base64.getEncoder()
+                .encodeToString((secretKey + ":").getBytes(java.nio.charset.StandardCharsets.UTF_8));
+
+        return RestClient.builder()
+                .baseUrl(baseUrl)
+                .requestFactory(factory)
+                .defaultHeader("Authorization", "Basic " + basic)
+                .defaultHeader("Content-Type", "application/json")
+                .defaultHeader("Accept", "application/json")
+                .build();
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/starlight/bootstrap/SecurityConfig.java b/src/main/java/starlight/bootstrap/SecurityConfig.java
index 45856d33..bd76996f 100644
--- a/src/main/java/starlight/bootstrap/SecurityConfig.java
+++ b/src/main/java/starlight/bootstrap/SecurityConfig.java
@@ -4,6 +4,7 @@
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.autoconfigure.security.servlet.PathRequest;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.http.HttpMethod;
@@ -69,7 +70,7 @@ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
                         .requestMatchers("/error/**").permitAll()
                         .requestMatchers("/actuator/health").permitAll()
                         .requestMatchers(HttpMethod.OPTIONS, "/**").permitAll()
-                        .requestMatchers("/", "/index.html", "/ops.html").permitAll()
+                        .requestMatchers("/", "/index.html", "/ops.html", "/payment.html", "/api/payment/**").permitAll()
                         .requestMatchers("/v1/auth/**","/v1/user/**", "/v1/experts").permitAll()
                         .requestMatchers("/login/**", "/oauth2/**", "/login/oauth2/**", "/public/**").permitAll()
                         .requestMatchers("/v3/api-docs/**", "/v1/api-docs/**", "/swagger-ui/**", "/swagger-ui.html", "/swagger-resources/**").permitAll()
@@ -78,6 +79,7 @@ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
                         .requestMatchers(HttpMethod.GET,  "/v1/expert-reports/*").permitAll()
                         .requestMatchers(HttpMethod.POST, "/v1/expert-reports/*").permitAll()
 
+                        .requestMatchers(PathRequest.toStaticResources().atCommonLocations()).permitAll()
                         .anyRequest().authenticated())
                 .oauth2Login(oauth -> oauth
                         .loginPage("/login/oauth2/code/kakao")
@@ -88,6 +90,7 @@ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
                             response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
                         })
                 );
+
         return http.build();
     }
 
diff --git a/src/main/java/starlight/domain/expert/entity/Expert.java b/src/main/java/starlight/domain/expert/entity/Expert.java
index 61bd9e6f..da0c009d 100644
--- a/src/main/java/starlight/domain/expert/entity/Expert.java
+++ b/src/main/java/starlight/domain/expert/entity/Expert.java
@@ -1,6 +1,7 @@
 package starlight.domain.expert.entity;
 
 import jakarta.persistence.*;
+import jakarta.validation.constraints.Min;
 import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
@@ -29,6 +30,8 @@ public class Expert extends AbstractEntity {
     @Column(nullable = false, length = 320)
     private String email;
 
+    @Min(0)
+    @Column
     private Integer mentoringPriceWon;
 
     @ElementCollection
diff --git a/src/main/java/starlight/domain/order/enumerate/OrderStatus.java b/src/main/java/starlight/domain/order/enumerate/OrderStatus.java
new file mode 100644
index 00000000..f5095e8f
--- /dev/null
+++ b/src/main/java/starlight/domain/order/enumerate/OrderStatus.java
@@ -0,0 +1,15 @@
+package starlight.domain.order.enumerate;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+@Getter
+@RequiredArgsConstructor
+public enum OrderStatus {
+
+    NEW("주문 생성됨 (결제 전)"),
+    PAID("결제 완료"),
+    CANCELED("주문/결제 취소");
+
+    private final String description;
+}
diff --git a/src/main/java/starlight/domain/order/enumerate/UsageProductType.java b/src/main/java/starlight/domain/order/enumerate/UsageProductType.java
new file mode 100644
index 00000000..2c857d24
--- /dev/null
+++ b/src/main/java/starlight/domain/order/enumerate/UsageProductType.java
@@ -0,0 +1,27 @@
+package starlight.domain.order.enumerate;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import starlight.domain.order.exception.OrderErrorType;
+import starlight.domain.order.exception.OrderException;
+
+@Getter
+@RequiredArgsConstructor
+public enum UsageProductType {
+
+    AI_REPORT_1("AI_REPORT_1", 1, 49_000L, "LITE 요금제"),
+    AI_REPORT_2("AI_REPORT_2", 2, 89_000L, "STANDARD 요금제");
+
+    private final String code;        // 상품 코드
+    private final int usageCount;     // 사용 가능 횟수
+    private final long price;         // 가격
+    private final String description; // 설명
+
+    public static UsageProductType fromCode(String code) {
+        return switch (code) {
+            case "AI_REPORT_1" -> AI_REPORT_1;
+            case "AI_REPORT_2" -> AI_REPORT_2;
+            default -> throw new OrderException(OrderErrorType.INVALID_USAGE_PRODUCT);
+        };
+    }
+}
diff --git a/src/main/java/starlight/domain/order/exception/OrderErrorType.java b/src/main/java/starlight/domain/order/exception/OrderErrorType.java
new file mode 100644
index 00000000..07047987
--- /dev/null
+++ b/src/main/java/starlight/domain/order/exception/OrderErrorType.java
@@ -0,0 +1,50 @@
+package starlight.domain.order.exception;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import starlight.shared.apiPayload.exception.ErrorType;
+
+@Getter
+@RequiredArgsConstructor
+public enum OrderErrorType implements ErrorType {
+
+    // PG 통신 에러
+    TOSS_CLIENT_CONFIRM_ERROR(HttpStatus.BAD_REQUEST, "토스 결제 요청 중 오류가 발생했습니다."),
+    TOSS_CLIENT_CANCEL_ERROR(HttpStatus.BAD_REQUEST, "토스 결제 취소 요청 중 오류가 발생했습니다."),
+
+    // 도메인 규칙 위반 - 결제 상태
+    ALREADY_PAID(HttpStatus.BAD_REQUEST, "이미 결제가 완료된 주문입니다."),
+    INVALID_ORDER_STATE_FOR_PAYMENT(HttpStatus.BAD_REQUEST, "주문 생성 상태에서만 결제 가능합니다."),
+    INVALID_ORDER_STATE_FOR_CANCEL(HttpStatus.BAD_REQUEST, "결제 완료 상태에서만 취소 가능합니다."),
+
+    // 도메인 규칙 위반 - 금액/주문번호
+    PAYMENT_AMOUNT_MISMATCH(HttpStatus.BAD_REQUEST, "주문 금액과 결제 금액이 일치하지 않습니다."),
+    ORDER_CODE_BUYER_MISMATCH(HttpStatus.BAD_REQUEST, "이미 존재하는 주문번호입니다. (구매자 상이)"),
+    ORDER_CODE_BUSINESS_PLAN_MISMATCH(HttpStatus.BAD_REQUEST, "이미 존재하는 주문번호입니다. (사업계획서 상이)"),
+    ORDER_PRODUCT_MISMATCH(HttpStatus.BAD_REQUEST, "이미 존재하는 주문번호입니다. (이용권 금액 상이)"),
+
+    // 결제 이력 없음
+    NO_REQUESTED_PAYMENT(HttpStatus.BAD_REQUEST, "승인 가능한 결제 시도가 존재하지 않습니다."),
+    NO_DONE_PAYMENT(HttpStatus.BAD_REQUEST, "취소 가능한 결제 이력이 존재하지 않습니다."),
+    NO_PAYMENT_RECORDS(HttpStatus.BAD_REQUEST, "주문에 결제 이력이 존재하지 않습니다."),
+    NO_PAYMENT_KEY(HttpStatus.BAD_REQUEST, "paymentKey가 없어 PG 취소를 수행할 수 없습니다."),
+
+    // 조회 실패
+    ORDER_NOT_FOUND(HttpStatus.NOT_FOUND, "주문을 찾을 수 없습니다."),
+    ALREADY_PAID_FOR_BUSINESS_PLAN(HttpStatus.BAD_REQUEST, "이미 결제가 완료된 사업계획서입니다."),
+
+    // 사용 횟수 지갑 관련
+    INVALID_INITIAL_CHARGE_COUNT(HttpStatus.BAD_REQUEST, "초기 충전 횟수는 0 이상이어야 합니다."),
+    INVALID_USAGE_COUNT(HttpStatus.BAD_REQUEST, "사용/충전 횟수는 1 이상이어야 합니다."),
+    INSUFFICIENT_AI_REPORT_BALANCE(HttpStatus.BAD_REQUEST, "남은 AI 리포트 사용 가능 횟수가 부족합니다."),
+
+    // 기타
+    UNSUPPORTED_CURRENCY(HttpStatus.BAD_REQUEST, "지원하지 않는 통화입니다."),
+    INVALID_USAGE_PRODUCT(HttpStatus.BAD_REQUEST, "유효하지 않은 이용권 금액입니다."),
+    ;
+
+    private final HttpStatus status;
+
+    private final String message;
+}
diff --git a/src/main/java/starlight/domain/order/exception/OrderException.java b/src/main/java/starlight/domain/order/exception/OrderException.java
new file mode 100644
index 00000000..53d7cac8
--- /dev/null
+++ b/src/main/java/starlight/domain/order/exception/OrderException.java
@@ -0,0 +1,11 @@
+package starlight.domain.order.exception;
+
+import starlight.shared.apiPayload.exception.ErrorType;
+import starlight.shared.apiPayload.exception.GlobalException;
+
+public class OrderException extends GlobalException {
+
+    public OrderException(ErrorType errorType) {
+        super(errorType);
+    }
+}
diff --git a/src/main/java/starlight/domain/order/order/Orders.java b/src/main/java/starlight/domain/order/order/Orders.java
new file mode 100644
index 00000000..a6732db3
--- /dev/null
+++ b/src/main/java/starlight/domain/order/order/Orders.java
@@ -0,0 +1,161 @@
+package starlight.domain.order.order;
+
+import jakarta.persistence.*;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import starlight.domain.order.enumerate.OrderStatus;
+import starlight.domain.order.enumerate.UsageProductType;
+import starlight.domain.order.exception.OrderErrorType;
+import starlight.domain.order.exception.OrderException;
+import starlight.domain.order.order.vo.Money;
+import starlight.domain.order.order.vo.OrderCode;
+import starlight.shared.AbstractEntity;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Objects;
+
+@Entity
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class Orders extends AbstractEntity {
+
+    @Column(length = 64, nullable = false, unique = true)
+    private String orderCode;
+
+    @Column(name = "buyer_user_id", nullable = false)
+    private Long buyerId;
+
+    @Enumerated(EnumType.STRING)
+    @Column(length = 20, nullable = false)
+    private OrderStatus status = OrderStatus.NEW;
+
+    @Column(length = 3, nullable = false)
+    private String currency = "KRW";
+
+    @Column(nullable = false)
+    private Long price;
+
+    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true)
+    private List<PaymentRecords> payments = new ArrayList<>();
+
+    @Version
+    private Long version;
+
+    @Column(length = 50, nullable = false)
+    private String usageProductCode;    // 어떤 상품코드로 샀는지
+
+    @Column(nullable = false)
+    private Integer usageCount;         // 몇 회권인지 (1 / 2)
+
+    public static Orders newUsageOrder(OrderCode orderCode, Long buyerId, Money money, UsageProductType product) {
+        Objects.requireNonNull(orderCode, "orderCode는 필수입니다.");
+        Objects.requireNonNull(buyerId, "buyerId는 필수입니다.");
+        Objects.requireNonNull(money, "money는 필수입니다.");
+        Objects.requireNonNull(product, "product는 필수입니다.");
+
+        Orders orders = new Orders();
+        orders.orderCode = orderCode.getValue();
+        orders.buyerId = buyerId;
+        orders.price = money.getAmount();
+        orders.currency = money.getCurrency();
+        orders.usageProductCode = product.getCode();
+        orders.usageCount = product.getUsageCount();
+        orders.status = OrderStatus.NEW;
+        return orders;
+    }
+
+    public void validateSameBuyer(Long buyerId) {
+        if (!Objects.equals(this.buyerId, buyerId)) {
+            throw new OrderException(OrderErrorType.ORDER_CODE_BUYER_MISMATCH);
+        }
+    }
+
+    public void validateSameProduct(UsageProductType product) {
+        if (!Objects.equals(this.usageProductCode, product.getCode())) {
+            throw new OrderException(OrderErrorType.ORDER_PRODUCT_MISMATCH);
+        }
+    }
+
+    /**
+     * 결제 시도 추가
+     * - 이미 결제 완료된 주문이면 예외
+     * - 주문 금액과 다른 금액이면 예외
+     */
+    public void addPaymentAttempt(Money paymentMoney) {
+        // 이미 결제 완료된 주문이면 시도 불가
+        if (this.status == OrderStatus.PAID) {
+            throw new OrderException(OrderErrorType.ALREADY_PAID);
+        }
+
+        // 주문 금액과 결제 금액이 일치해야 함
+        Money orderMoney = Money.of(this.price, this.currency);
+        if (!orderMoney.equals(paymentMoney)) {
+            throw new OrderException(OrderErrorType.PAYMENT_AMOUNT_MISMATCH);
+        }
+
+        // 결제 시도 생성 및 추가
+        PaymentRecords p = PaymentRecords.requestedFor(this, paymentMoney.getAmount());
+        this.payments.add(p);
+    }
+
+    /**
+     * 결제 승인 처리
+     * - NEW 상태에서만 가능
+     */
+    public void markPaid() {
+        if (this.status == OrderStatus.PAID) {
+            throw new OrderException(OrderErrorType.ALREADY_PAID);
+        }
+        if (this.status != OrderStatus.NEW) {
+            throw new OrderException(OrderErrorType.INVALID_ORDER_STATE_FOR_PAYMENT);
+        }
+        this.status = OrderStatus.PAID;
+    }
+
+    /**
+     * 주문/결제 취소
+     * - PAID 상태에서만 가능
+     */
+    public void cancel() {
+        if (this.status != OrderStatus.PAID) {
+            throw new OrderException(OrderErrorType.INVALID_ORDER_STATE_FOR_CANCEL);
+        }
+        this.status = OrderStatus.CANCELED;
+    }
+
+    /**
+     * 가장 최근 REQUESTED 상태 결제 시도 조회
+     */
+    public PaymentRecords getLatestRequestedOrThrow() {
+        return payments.stream()
+                .filter(p -> "REQUESTED".equals(p.getStatus()))
+                .max(Comparator.comparing(PaymentRecords::getCreatedAt))
+                .orElseThrow(() -> new OrderException(OrderErrorType.NO_REQUESTED_PAYMENT));
+    }
+
+    /**
+     * 가장 최근 DONE 상태 결제 시도 조회
+     */
+    public PaymentRecords getLatestDoneOrThrow() {
+        return payments.stream()
+                .filter(p -> "DONE".equals(p.getStatus()))
+                .max(Comparator.comparing(p ->
+                        p.getApprovedAt() != null ? p.getApprovedAt() : p.getCreatedAt()
+                ))
+                .orElseThrow(() -> new OrderException(OrderErrorType.NO_PAYMENT_RECORDS));
+    }
+
+    /**
+     * 가장 최근 결제 이력 조회 (승인시간 기준)
+     */
+    public PaymentRecords getLatestPaymentOrThrow() {
+        return payments.stream()
+                .max(Comparator.comparing(p ->
+                        p.getApprovedAt() != null ? p.getApprovedAt() : p.getCreatedAt()
+                ))
+                .orElseThrow(() -> new OrderException(OrderErrorType.NO_DONE_PAYMENT));
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/starlight/domain/order/order/PaymentRecords.java b/src/main/java/starlight/domain/order/order/PaymentRecords.java
new file mode 100644
index 00000000..30e00793
--- /dev/null
+++ b/src/main/java/starlight/domain/order/order/PaymentRecords.java
@@ -0,0 +1,125 @@
+package starlight.domain.order.order;
+
+import jakarta.persistence.*;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import starlight.domain.order.exception.OrderErrorType;
+import starlight.domain.order.exception.OrderException;
+
+import java.time.Instant;
+import java.util.Objects;
+
+@Entity
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class PaymentRecords {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "order_id", nullable = false)
+    private Orders order;
+
+    @Column(length = 20, nullable = false)
+    private String pg;
+
+    @Column(length = 128, unique = true)
+    private String paymentKey;
+
+    @Column(length = 40)
+    private String method;
+
+    @Column(length = 40)
+    private String provider;
+
+    @Column(nullable = false)
+    private Long price;
+
+    @Column(length = 20, nullable = false)
+    private String status;
+
+    @Column(length = 255)
+    private String receiptUrl;
+
+    private Instant approvedAt;
+
+    @Column(nullable = false, updatable = false)
+    private Instant createdAt;
+
+    @PrePersist
+    void prePersist() {
+        createdAt = Instant.now();
+        if (status == null) status = "REQUESTED";
+        if (pg == null) pg = "TOSS";
+    }
+
+    /**
+     * 결제 요청 생성
+     * @param order 연관된 주문
+     * @param amount 결제 금액
+     * @return 생성된 PaymentRecords
+     */
+    public static PaymentRecords requestedFor(Orders order, Long amount) {
+        Objects.requireNonNull(order, "order는 필수입니다.");
+        Objects.requireNonNull(amount, "amount는 필수입니다.");
+
+        PaymentRecords payment = new PaymentRecords();
+        payment.order = order;
+        payment.pg = "TOSS";
+        payment.status = "REQUESTED";
+        payment.price = amount;
+
+        return payment;
+    }
+
+    /**
+     * 결제 승인 완료 처리
+     */
+    public void markDone(String paymentKey, String method, String provider,
+                         String receiptUrl, Instant approvedAt) {
+
+        validateForCompletion(paymentKey);
+
+        this.paymentKey = paymentKey;
+        this.method = method;
+        this.provider = provider;
+        this.receiptUrl = receiptUrl;
+        this.approvedAt = approvedAt != null ? approvedAt : Instant.now();
+        this.status = "DONE";
+    }
+
+    /**
+     * 결제 취소 처리
+     */
+    public void markCanceled() {
+        if (!"DONE".equals(this.status)) {
+            throw new IllegalStateException(
+                    "DONE 상태에서만 취소 가능합니다. 현재 상태: " + this.status
+            );
+        }
+        this.status = "CANCELED";
+    }
+
+    /**
+     * 결제키가 없으면 PG 취소 불가능
+     */
+    public void ensureHasPaymentKey() {
+        if (this.paymentKey == null || this.paymentKey.trim().isEmpty()) {
+            throw new OrderException(OrderErrorType.NO_PAYMENT_KEY);
+        }
+    }
+
+    private void validateForCompletion(String paymentKey) {
+        if (!"REQUESTED".equals(this.status)) {
+            throw new IllegalStateException(
+                    "REQUESTED 상태에서만 승인 가능합니다. 현재 상태: " + this.status
+            );
+        }
+        if (paymentKey == null || paymentKey.trim().isEmpty()) {
+            throw new IllegalArgumentException("paymentKey는 필수입니다.");
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/starlight/domain/order/order/vo/Money.java b/src/main/java/starlight/domain/order/order/vo/Money.java
new file mode 100644
index 00000000..97de8cdd
--- /dev/null
+++ b/src/main/java/starlight/domain/order/order/vo/Money.java
@@ -0,0 +1,70 @@
+package starlight.domain.order.order.vo;
+
+import java.util.Objects;
+
+/**
+ * 금액을 표현하는 값 객체
+ * 불변 객체로 통화와 금액을 함께 관리
+ */
+public class Money {
+
+    private final Long amount;
+    private final String currency;
+
+    private Money(Long amount, String currency) {
+        if (amount == null || amount < 0) {
+            throw new IllegalArgumentException("금액은 0 이상이어야 합니다.");
+        }
+        if (currency == null || currency.trim().isEmpty()) {
+            throw new IllegalArgumentException("통화는 필수입니다.");
+        }
+        this.amount = amount;
+        this.currency = currency.toUpperCase();
+    }
+
+    public static Money of(Long amount, String currency) {
+        return new Money(amount, currency);
+    }
+
+    public static Money krw(Long amount) {
+        return new Money(amount, "KRW");
+    }
+
+    public boolean isSameCurrency(Money other) {
+        return other != null && this.currency.equals(other.currency);
+    }
+
+    public boolean equalsInSameCurrency(Money other) {
+        if (!isSameCurrency(other)) {
+            throw new IllegalArgumentException("다른 통화는 비교할 수 없습니다.");
+        }
+        return Objects.equals(this.amount, other.amount);
+    }
+
+    public Long getAmount() {
+        return amount;
+    }
+
+    public String getCurrency() {
+        return currency;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof Money)) return false;
+        Money money = (Money) o;
+        return Objects.equals(amount, money.amount) &&
+                Objects.equals(currency, money.currency);
+    }
+
+    @Override
+    public String toString() {
+        return currency + " " + amount;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(amount, currency);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/starlight/domain/order/order/vo/OrderCode.java b/src/main/java/starlight/domain/order/order/vo/OrderCode.java
new file mode 100644
index 00000000..40e0e308
--- /dev/null
+++ b/src/main/java/starlight/domain/order/order/vo/OrderCode.java
@@ -0,0 +1,58 @@
+package starlight.domain.order.order.vo;
+
+import java.util.Objects;
+
+/**
+ * 주문번호를 표현하는 값 객체
+ * 프론트엔드에서 생성한 주문번호를 검증하고 캡슐화
+ */
+public class OrderCode {
+
+    private final String value;
+
+    private OrderCode(String value) {
+        validate(value);
+        this.value = value;
+    }
+
+    private void validate(String value) {
+        if (value == null || value.trim().isEmpty()) {
+            throw new IllegalArgumentException("주문번호는 필수입니다.");
+        }
+        if (value.length() > 64) {
+            throw new IllegalArgumentException("주문번호는 64자를 초과할 수 없습니다.");
+        }
+        if (!value.matches("^[a-zA-Z0-9_-]+$")) {
+            throw new IllegalArgumentException("주문번호는 영문, 숫자, -, _ 만 허용됩니다.");
+        }
+    }
+
+    /**
+     * 프론트엔드에서 전달받은 주문번호로 값 객체 생성
+     */
+    public static OrderCode of(String value) {
+        return new OrderCode(value);
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof OrderCode)) return false;
+        OrderCode orderCode = (OrderCode) o;
+        return Objects.equals(value, orderCode.value);
+    }
+
+    @Override
+    public String toString() {
+        return value;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(value);
+    }
+}
diff --git a/src/main/java/starlight/domain/order/wallet/UsageHistory.java b/src/main/java/starlight/domain/order/wallet/UsageHistory.java
new file mode 100644
index 00000000..670e7f67
--- /dev/null
+++ b/src/main/java/starlight/domain/order/wallet/UsageHistory.java
@@ -0,0 +1,91 @@
+package starlight.domain.order.wallet;
+
+import jakarta.persistence.*;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import starlight.domain.order.exception.OrderErrorType;
+import starlight.domain.order.exception.OrderException;
+
+import java.time.Instant;
+import java.util.Objects;
+
+@Entity
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class UsageHistory {
+
+    private static final String TYPE_CHARGE = "CHARGE";
+    private static final String TYPE_USE = "USE";
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(nullable = false)
+    private Long userId;            // 누가
+
+    @Column
+    private Long businessPlanId;    // 어떤 사업계획서에서 (사용 시에만 채움, 충전은 null 가능)
+
+    @Column(nullable = false)
+    private String type;            // CHARGE / USE 등
+
+    @Column(nullable = false)
+    private Integer amount;         // 이번에 증감된 횟수 (충전: +10, 사용: -1 이런 느낌)
+
+    @Column(nullable = false)
+    private Integer balanceAfter;   // 이 이벤트 이후 지갑 잔여 횟수
+
+    @Column
+    private Long orderId;           // 이 충전이 어느 주문에서 온 건지 대략 연결하고 싶으면
+
+    @Column(nullable = false, updatable = false)
+    private Instant createdAt;
+
+    @PrePersist
+    void prePersist() {
+        if (createdAt == null) createdAt = Instant.now();
+    }
+
+    /**
+     * 충전 이력 기록
+     */
+    public static UsageHistory charged(Long userId, int amount, int balanceAfter, Long orderId) {
+        Objects.requireNonNull(userId, "userId는 필수입니다.");
+
+        if (amount <= 0) {
+            throw new OrderException(OrderErrorType.INVALID_USAGE_COUNT);
+        }
+
+        UsageHistory history = new UsageHistory();
+        history.userId = userId;
+        history.type = TYPE_CHARGE;
+        history.amount = amount;          // 충전은 양수 그대로
+        history.balanceAfter = balanceAfter;
+        history.orderId = orderId;        // 없으면 null
+
+        return history;
+    }
+
+    /**
+     * 사용 이력 기록
+     */
+    public static UsageHistory used(Long userId, Long businessPlanId, int amount, int balanceAfter) {
+        Objects.requireNonNull(userId, "userId는 필수입니다.");
+        Objects.requireNonNull(businessPlanId, "businessPlanId는 필수입니다.");
+
+        if (amount <= 0) {
+            throw new OrderException(OrderErrorType.INVALID_USAGE_COUNT);
+        }
+
+        UsageHistory history = new UsageHistory();
+        history.userId = userId;
+        history.businessPlanId = businessPlanId;
+        history.type = TYPE_USE;
+        history.amount = -Math.abs(amount);  // 사용은 항상 음수로 저장
+        history.balanceAfter = balanceAfter;
+
+        return history;
+    }
+}
diff --git a/src/main/java/starlight/domain/order/wallet/UsageWallet.java b/src/main/java/starlight/domain/order/wallet/UsageWallet.java
new file mode 100644
index 00000000..e86a6b1d
--- /dev/null
+++ b/src/main/java/starlight/domain/order/wallet/UsageWallet.java
@@ -0,0 +1,72 @@
+package starlight.domain.order.wallet;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Version;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import starlight.domain.order.exception.OrderErrorType;
+import starlight.domain.order.exception.OrderException;
+import starlight.shared.AbstractEntity;
+
+import java.util.Objects;
+
+@Entity
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class UsageWallet extends AbstractEntity {
+
+    @Column(nullable = false, unique = true)
+    private Long userId;
+
+    @Column(nullable = false)
+    private Integer aiReportChargedCount;   // AI 리포트: 지금까지 충전된 총 횟수
+
+    @Column(nullable = false)
+    private Integer aiReportUsedCount;       // AI 리포트: 지금까지 사용된 총 횟수
+
+    @Version
+    private Long version;
+
+    /**
+     * 지갑 초기화
+     */
+    public static UsageWallet init(Long userId) {
+        UsageWallet wallet = new UsageWallet();
+        wallet.userId = Objects.requireNonNull(userId, "userId는 필수입니다.");
+        wallet.aiReportChargedCount = 0;
+        wallet.aiReportUsedCount = 0;
+        return wallet;
+    }
+
+    /**
+     * AI 리포트 횟수 충전
+     */
+    public void chargeAiReport(int count) {
+        if (count <= 0) {
+            throw new OrderException(OrderErrorType.INVALID_USAGE_COUNT);
+        }
+        this.aiReportChargedCount += count;
+    }
+
+    /**
+     * 남은 AI 리포트 사용 가능 횟수
+     */
+    public int getAiReportRemainingCount() {
+        return aiReportChargedCount - aiReportUsedCount;
+    }
+
+    /**
+     * AI 리포트 사용
+     */
+    public void useAiReport(int count) {
+        if (count <= 0) {
+            throw new OrderException(OrderErrorType.INVALID_USAGE_COUNT);
+        }
+        if (getAiReportRemainingCount() < count) {
+            throw new OrderException(OrderErrorType.INSUFFICIENT_AI_REPORT_BALANCE);
+        }
+        this.aiReportUsedCount += count;
+    }
+}
diff --git a/src/main/resources/static/index.html b/src/main/resources/static/index.html
index 0ad59da7..64b094a1 100644
--- a/src/main/resources/static/index.html
+++ b/src/main/resources/static/index.html
@@ -169,7 +169,8 @@ <h1 class="title">
             <a class="btn sec" href="/v3/api-docs">OpenAPI JSON</a>
             <a class="btn sec" href="/actuator/health">Health</a>
             <a class="btn" href="/ops.html">Ops Dashboard</a>
-            <a class="btn sec" href="/h2-console" title="개발 환경에서만">H2 Console</a>
+            <a class="btn sec" href="/payment.html">Toss</a>
+            <a class="btn sec" href="/payment2.html">IamPort</a>
         </div>
 
         <div class="grid">
diff --git a/src/main/resources/static/payment.html b/src/main/resources/static/payment.html
new file mode 100644
index 00000000..b9050217
--- /dev/null
+++ b/src/main/resources/static/payment.html
@@ -0,0 +1,250 @@
+<!DOCTYPE html>
+<html lang="ko">
+<head>
+    <meta charset="utf-8" />
+    <title>starlight 크레딧 결제하기 (Popup + postMessage)</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <!-- Toss v2 Standard SDK -->
+    <script src="https://js.tosspayments.com/v2/standard"></script>
+    <style>
+        :root { font-family: system-ui, -apple-system, "Noto Sans KR", Roboto, Arial, sans-serif; }
+        body { margin:0; padding:24px; background:#0b0c10; color:#e8e8e8; }
+        .container { max-width:720px; margin:0 auto; background:#111318; border:1px solid #1f2430; border-radius:16px; padding:24px; }
+        h1 { margin:0 0 8px; font-size:22px; }
+        p  { margin:0 0 16px; color:#b8c0cc; }
+        .row { display:flex; gap:10px; margin-bottom:12px; }
+        .btn { padding:12px 14px; border-radius:10px; border:1px solid #293140; background:#171c25; color:#e8e8e8; cursor:pointer; font-weight:600; text-align:center; }
+        .btn:hover { background:#1b222d; }
+        .btn:disabled { opacity:0.5; cursor:not-allowed; }
+        .btn.product.active {
+            border-color:#4f46e5;
+            background:#1f2937;
+        }
+        .field { width:100%; padding:14px; border-radius:10px; border:1px solid #293140; background:#0f141c; color:#e8e8e8; font-size:16px; }
+        .result { margin-top:14px; padding:12px; border-radius:10px; background:#0f141c; border:1px solid #1f2430; display:none; white-space:pre-wrap; }
+        .ok { border-color:#1f6c2a; }
+        .err{ border-color:#7a1d1d; }
+        .loading { display:inline-block; width:16px; height:16px; border:2px solid #e8e8e8; border-top-color:transparent; border-radius:50%; animation:spin 0.6s linear infinite; }
+        @keyframes spin { to { transform:rotate(360deg); } }
+    </style>
+</head>
+<body>
+<div class="container">
+    <h1>starlight 크레딧 결제하기</h1>
+    <p>상품(이용권)을 선택하고, 팝업에서 결제 후 <b>postMessage</b>로 결과를 받습니다.</p>
+
+    <!-- 상품 선택: AI_REPORT_1, AI_REPORT_2 -->
+    <div class="row">
+        <button
+                class="btn product"
+                data-product-code="AI_REPORT_1"
+                data-product-name="AI 리포트 1회권"
+        >
+            AI 리포트 1회권 (69,000원)
+        </button>
+        <button
+                class="btn product"
+                data-product-code="AI_REPORT_2"
+                data-product-name="AI 리포트 2회권"
+        >
+            AI 리포트 2회권 (99,000원)
+        </button>
+    </div>
+
+    <div class="row"><input id="buyerName"  class="field" placeholder="이름 (선택)" /></div>
+    <div class="row"><input id="buyerEmail" class="field" placeholder="이메일 (선택)" /></div>
+
+    <div class="row">
+        <button id="payCard"      class="btn" style="flex:1">카드 결제</button>
+        <button id="payTossEasy"  class="btn" style="flex:1">토스페이(간편)</button>
+        <button id="payKakaoEasy" class="btn" style="flex:1">카카오페이(간편)</button>
+    </div>
+
+    <div id="result" class="result"></div>
+</div>
+
+<script>
+    // ===== 유틸 =====
+    function genOrderCode() {
+        const d = new Date();
+        return 'ORD' + d.getFullYear()
+            + String(d.getMonth()+1).padStart(2,'0')
+            + String(d.getDate()).padStart(2,'0')
+            + '-' + Math.random().toString(36).slice(2,10).toUpperCase();
+    }
+    function out() { const el=document.getElementById('result'); el.style.display='block'; return el; }
+    function stamp(){ return `[${new Date().toLocaleString()}]\n`; }
+    function showOk(t){ const el=out(); el.classList.remove('err'); el.classList.add('ok'); el.textContent=stamp()+t; }
+    function showErr(t){ const el=out(); el.classList.remove('ok'); el.classList.add('err'); el.textContent=stamp()+t; }
+
+    function disableButtons() { document.querySelectorAll('.btn').forEach(b => b.disabled = true); }
+    function enableButtons() { document.querySelectorAll('.btn').forEach(b => b.disabled = false); }
+
+    (async () => {
+        let selectedProduct = null; // { code, name }
+
+        // 상품 버튼 클릭 처리
+        document.querySelectorAll('.btn.product').forEach(btn => {
+            btn.addEventListener('click', () => {
+                document.querySelectorAll('.btn.product').forEach(b => b.classList.remove('active'));
+                btn.classList.add('active');
+
+                selectedProduct = {
+                    code: btn.dataset.productCode,
+                    name: btn.dataset.productName
+                };
+            });
+        });
+
+        try {
+            // v2 Standard 초기화 (비회원 결제)
+            const toss = TossPayments("test_ck_0RnYX2w532eMEymGdQeK8NeyqApQ");
+            const payment = toss.payment({ customerKey: TossPayments.ANONYMOUS });
+
+            // 팝업에서 postMessage로 결과 받기
+            window.addEventListener('message', (e) => {
+                if (e.origin !== location.origin) return; // 보안
+                const d = e.data || {};
+
+                if (d.type === 'TOSS_SUCCESS') {
+                    showOk(
+                        `✅ 결제 성공!\n\n` +
+                        `주문번호: ${d.orderId}\n` +
+                        `금액: ${d.amount?.toLocaleString()}원\n` +
+                        `결제수단: ${d.method || '-'}\n` +
+                        `간편결제: ${d.provider || '-'}\n` +
+                        `영수증: ${d.receiptUrl || '-'}\n` +
+                        `승인시각: ${d.approvedAt ? new Date(d.approvedAt).toLocaleString() : '-'}`
+                    );
+                    enableButtons();
+                } else if (d.type === 'TOSS_FAIL') {
+                    showErr(
+                        `❌ 결제 실패\n\n` +
+                        `주문번호: ${d.orderId}\n` +
+                        `에러코드: ${d.code}\n` +
+                        `메시지: ${d.message}`
+                    );
+                    enableButtons();
+                }
+            });
+
+            function toAbsolute(url) {
+                return url.startsWith('http') ? url : (location.origin + url);
+            }
+
+            async function start({ method }) {
+                try {
+                    if (!selectedProduct) {
+                        showErr('❌ 먼저 상품(이용권)을 선택해 주세요.');
+                        return;
+                    }
+
+                    disableButtons();
+                    showOk('⏳ 주문 생성 중...');
+
+                    const orderCode = genOrderCode();
+
+                    // 1. 백엔드 주문 생성 (POST /api/toss/request)
+                    //    요청: productCode 기반
+                    const prepareResponse = await fetch(`${location.origin}/api/toss/request`, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({
+                            orderCode: orderCode,
+                            buyerId: 1,          // TODO: 실제 로그인 유저 ID로 교체
+                            productCode: selectedProduct.code // "AI_REPORT_1" / "AI_REPORT_2"
+                        })
+                    });
+
+                    if (!prepareResponse.ok) {
+                        let msg = '주문 생성 실패';
+                        try {
+                            const errorData = await prepareResponse.json();
+                            msg = errorData.message || msg;
+                        } catch (_) {}
+                        throw new Error(msg);
+                    }
+
+                    const prepareJson = await prepareResponse.json();
+                    console.log('✅ 주문 생성 완료:', prepareJson);
+
+                    // ApiResponse 형태: { result: 'SUCCESS', data: { ... }, error: ... }
+                    const data = prepareJson.data ?? prepareJson;
+
+                    // 백엔드가 돌려주는 필드명 맞추기
+                    // 지금은 data.amount 로 오고 있음
+                    const amount = (typeof data.amount === 'number' ? data.amount : data.price);
+                    const currency = data.currency || 'KRW';   // 서버에서 안 주면 일단 KRW로 고정
+                    const orderId = data.orderCode || data.orderId || orderCode;
+                    const orderName = data.orderName || selectedProduct.name;
+
+                    if (!Number.isFinite(amount) || amount <= 0) {
+                        throw new Error('서버에서 금액 정보를 올바르게 받지 못했습니다.');
+                    }
+
+
+                    showOk('🚀 결제창 호출 중...');
+
+                    // 2. 토스 결제창 호출
+                    const paymentRequest = {
+                        method: method,
+                        amount: { currency, value: amount },
+                        orderId: orderId,
+                        orderName: orderName,
+                        successUrl: toAbsolute("/toss/popup.html"),
+                        failUrl: toAbsolute("/toss/popup.html"),
+                        customerEmail: document.getElementById('buyerEmail').value || undefined,
+                        customerName: document.getElementById('buyerName').value || undefined,
+                    };
+
+                    await payment.requestPayment(paymentRequest);
+
+                } catch (e) {
+                    console.error('결제 처리 에러:', e);
+                    const code = e?.code ? ` [${e.code}]` : '';
+                    showErr(
+                        `❌ 결제 처리 실패\n\n` +
+                        `에러: ${e.message || e}${code}`
+                    );
+                    enableButtons();
+                }
+            }
+
+            // 결제 버튼 이벤트 리스너
+            document.getElementById('payCard')
+                .addEventListener('click', ()=> start({ method:'CARD' }));
+            document.getElementById('payTossEasy')
+                .addEventListener('click', ()=> start({ method:'EASY_PAY' }));
+            document.getElementById('payKakaoEasy')
+                .addEventListener('click', ()=> start({ method:'EASY_PAY' }));
+
+            // (리다이렉트 폴백) 팝업 차단 시 현재 탭으로 돌아온 경우
+            (function fallbackFromQuery(){
+                const p = new URLSearchParams(location.search);
+                if (!p.has('status')) return;
+
+                if (p.get('status') === 'success') {
+                    showOk(
+                        `✅ 결제 성공 (폴백)\n\n` +
+                        `주문번호: ${p.get('orderId')}\n` +
+                        `금액: ${p.get('amount')}`
+                    );
+                } else {
+                    showErr(
+                        `❌ 결제 실패 (폴백)\n\n` +
+                        `주문번호: ${p.get('orderId')}\n` +
+                        `코드: ${p.get('code')}\n` +
+                        `메시지: ${p.get('message')}`
+                    );
+                }
+                history.replaceState(null, '', location.pathname);
+            })();
+
+        } catch (e) {
+            console.error('SDK 초기화 에러:', e);
+            showErr('❌ 토스페이먼츠 SDK를 불러오지 못했습니다. 네트워크 연결을 확인하세요.');
+        }
+    })();
+</script>
+</body>
+</html>
diff --git a/src/main/resources/static/toss/popup.html b/src/main/resources/static/toss/popup.html
new file mode 100644
index 00000000..4fa47efe
--- /dev/null
+++ b/src/main/resources/static/toss/popup.html
@@ -0,0 +1,196 @@
+<!DOCTYPE html>
+<html lang="ko">
+<head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>결제 처리 중...</title>
+    <style>
+        :root { font-family: system-ui, -apple-system, "Noto Sans KR", Roboto, Arial, sans-serif; }
+        body {
+            margin:0; padding:0;
+            background:#0b0c10; color:#e8e8e8;
+            display:flex; align-items:center; justify-content:center;
+            min-height:100vh;
+        }
+        .container {
+            text-align:center;
+            padding:24px;
+            background:#111318;
+            border-radius:16px;
+            border:1px solid #1f2430;
+            max-width:360px;
+            box-shadow:0 10px 30px rgba(0,0,0,0.5);
+        }
+        h1 {
+            margin:0 0 8px;
+            font-size:20px;
+        }
+        p {
+            margin:0;
+            font-size:14px;
+            color:#b8c0cc;
+            white-space:pre-line;
+        }
+        .spinner {
+            margin:16px auto;
+            width:32px; height:32px;
+            border-radius:50%;
+            border:3px solid #e8e8e8;
+            border-top-color:transparent;
+            animation:spin 0.6s linear infinite;
+        }
+        .hidden { display:none; }
+        @keyframes spin { to { transform:rotate(360deg); } }
+        .error { color:#fca5a5; }
+        .ok { color:#bbf7d0; }
+    </style>
+</head>
+<body>
+<div class="container">
+    <h1 id="title">결제 처리 중...</h1>
+    <div id="spinner" class="spinner"></div>
+    <p id="status">잠시만 기다려 주세요.</p>
+</div>
+
+<script>
+    const params     = new URLSearchParams(location.search);
+    const orderId    = params.get('orderId');    // 우리가 넘긴 orderCode
+    const paymentKey = params.get('paymentKey'); // 토스 paymentKey
+    const code       = params.get('code');       // 실패 시 에러 코드
+    const message    = params.get('message');    // 실패 시 에러 메시지
+    const amount     = params.get('amount');     // 성공 시 금액 (선택)
+
+    const $title   = document.getElementById('title');
+    const $status  = document.getElementById('status');
+    const $spinner = document.getElementById('spinner');
+
+    function updateUI(title, text, opts = {}) {
+        const { ok = false, error = false } = opts;
+        $title.textContent = title;
+        $status.textContent = text;
+        $spinner.classList.add('hidden');
+        $status.classList.toggle('ok', ok);
+        $status.classList.toggle('error', error);
+    }
+
+    function postToOpenerSuccess(data) {
+        if (!window.opener) return;
+
+        const payload = {
+            type: 'TOSS_SUCCESS',
+            orderId: data.orderId,
+            amount: data.amount,
+            method: data.method,
+            provider: data.provider,
+            receiptUrl: data.receiptUrl,
+            approvedAt: data.approvedAt
+        };
+        window.opener.postMessage(payload, window.location.origin);
+    }
+
+    function postToOpenerFail(orderId, code, message) {
+        if (!window.opener) return;
+
+        const payload = {
+            type: 'TOSS_FAIL',
+            orderId: orderId || null,
+            code: code || null,
+            message: message || '결제에 실패했습니다.'
+        };
+        window.opener.postMessage(payload, window.location.origin);
+    }
+
+    async function callConfirm(orderId, paymentKey) {
+        try {
+            updateUI('결제 승인 중...', '서버에서 결제 승인 내역을 확인하고 있습니다.');
+
+            const response = await fetch(`${window.location.origin}/api/toss/confirm`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    orderCode: orderId,
+                    paymentKey: paymentKey
+                })
+            });
+
+            const json = await response.json().catch(() => ({}));
+
+            if (!response.ok) {
+                const msg = json.message || '결제 승인 처리 중 오류가 발생했습니다.';
+                throw new Error(msg);
+            }
+
+            // ApiResponse<T> 형태: { result: 'SUCCESS', data: { ... }, error: ... }라고 가정
+            const data = json.data ?? json.result ?? json;
+
+            // OrderConfirmResponse 기준 (필요한 필드만 사용)
+            updateUI(
+                '결제 승인 완료',
+                `결제가 정상적으로 처리되었습니다.\n\n주문번호: ${data.orderId}\n금액: ${(data.amount ?? 0).toLocaleString()}원`,
+                { ok: true }
+            );
+
+            postToOpenerSuccess(data);
+
+            setTimeout(() => window.close(), 2000);
+
+        } catch (e) {
+            console.error('confirm error:', e);
+            updateUI(
+                '결제 승인 실패',
+                e.message || '결제 승인 처리에 실패했습니다.',
+                { error: true }
+            );
+
+            postToOpenerFail(orderId, 'CONFIRM_ERROR', e.message);
+
+            setTimeout(() => {
+                if (window.opener) {
+                    window.close();
+                }
+            }, 2500);
+        }
+    }
+
+    (function main() {
+        // ✅ 1) 성공 케이스: paymentKey + orderId 둘 다 있으면 → 서버 confirm
+        if (paymentKey && orderId) {
+            updateUI('결제 승인 중...', '잠시만 기다려 주세요.');
+            callConfirm(orderId, paymentKey);
+            return;
+        }
+
+        // ✅ 2) 실패 케이스: code만 있고 paymentKey는 없음 → PG 단계 실패
+        if (code) {
+            const decodedMsg = message ? decodeURIComponent(message) : '결제에 실패했습니다.';
+            updateUI('결제 실패', decodedMsg, { error: true });
+
+            postToOpenerFail(orderId, code, decodedMsg);
+
+            setTimeout(() => {
+                if (window.opener) {
+                    window.close();
+                } else {
+                    // 단독창으로 열린 경우에 대비한 폴백
+                    location.href = '/payment.html?status=fail'
+                        + '&orderId=' + encodeURIComponent(orderId || '')
+                        + '&code=' + encodeURIComponent(code || '')
+                        + '&message=' + encodeURIComponent(decodedMsg);
+                }
+            }, 2500);
+            return;
+        }
+
+        // ❗ 3) 둘 다 없으면 진짜 이상한 접근
+        updateUI('⚠️ 잘못된 접근', '올바르지 않은 결제 요청이 아닙니다.', { error: true });
+        setTimeout(() => {
+            if (window.opener) {
+                window.close();
+            } else {
+                location.href = '/payment.html';
+            }
+        }, 2000);
+    })();
+</script>
+</body>
+</html>
diff --git a/src/test/java/starlight/application/businessplan/util/PlainTextExtractUtilsTest.java b/src/test/java/starlight/application/businessplan/util/PlainTextExtractUtilsTest.java
index 9791ada5..7b8e03ad 100644
--- a/src/test/java/starlight/application/businessplan/util/PlainTextExtractUtilsTest.java
+++ b/src/test/java/starlight/application/businessplan/util/PlainTextExtractUtilsTest.java
@@ -18,7 +18,14 @@ void extractPlainText_fromContentArray() {
                 "\"content\":[" +
                 "{\"type\":\"text\",\"value\":\"Hello\"}," +
                 "{\"type\":\"image\",\"caption\":\"cap\"}," +
-                "{\"type\":\"table\",\"columns\":[\"A\",\"B\"],\"rows\":[[\"1\",\"2\"],[\"3\",\"4\"]]}" +
+                "{\"type\":\"table\",\"columns\":[{\"width\":100},{\"width\":200}]," +
+                "\"rows\":[" +
+                "[{\"content\":[{\"type\":\"text\",\"value\":\"1\"}],\"rowspan\":1,\"colspan\":1}," +
+                "{\"content\":[{\"type\":\"text\",\"value\":\"2\"}],\"rowspan\":1,\"colspan\":1}]," +
+                "[{\"content\":[{\"type\":\"text\",\"value\":\"3\"}],\"rowspan\":1,\"colspan\":1}," +
+                "{\"content\":[{\"type\":\"text\",\"value\":\"4\"}],\"rowspan\":1,\"colspan\":1}]" +
+                "]" +
+                "}" +
                 "]}";
 
         String result = PlainTextExtractUtils.extractPlainText(mapper, json);
@@ -26,7 +33,7 @@ void extractPlainText_fromContentArray() {
         assertThat(result).isEqualTo(String.join("\n",
                 "Hello",
                 "[사진] cap",
-                "[\"A\", \"B\"]",
+                "[2 columns]",
                 "[\"1\", \"2\"]",
                 "[\"3\", \"4\"]"));
     }
@@ -60,5 +67,48 @@ void extractPlainText_imageWithoutCaption() {
     void extractPlainText_invalidJson_throws() {
         assertThrows(IllegalArgumentException.class, () -> PlainTextExtractUtils.extractPlainText(mapper, "not-json"));
     }
-}
 
+    @Test
+    @DisplayName("테이블 셀에서 rowspan/colspan (lowercase) 지원")
+    void extractPlainText_tableWithLowercaseSpans() {
+        String json = "{" +
+                "\"content\":[" +
+                "{\"type\":\"table\",\"columns\":[{\"width\":100},{\"width\":200}]," +
+                "\"rows\":[" +
+                "[{\"content\":[{\"type\":\"text\",\"value\":\"A\"}],\"rowspan\":2,\"colspan\":1}," +
+                "{\"content\":[{\"type\":\"text\",\"value\":\"B\"}],\"rowspan\":1,\"colspan\":1}]," +
+                "[]" +
+                "]" +
+                "}" +
+                "]}";
+
+        String result = PlainTextExtractUtils.extractPlainText(mapper, json);
+
+        assertThat(result).isEqualTo(String.join("\n",
+                "[2 columns]",
+                "[\"A\", \"B\"]",
+                "[\"\", \"\"]"));
+    }
+
+    @Test
+    @DisplayName("테이블 셀에서 rowSpan/colSpan (camelCase) 지원")
+    void extractPlainText_tableWithCamelCaseSpans() {
+        String json = "{" +
+                "\"content\":[" +
+                "{\"type\":\"table\",\"columns\":[{\"width\":100},{\"width\":200}]," +
+                "\"rows\":[" +
+                "[{\"content\":[{\"type\":\"text\",\"value\":\"X\"}],\"rowSpan\":2,\"colSpan\":1}," +
+                "{\"content\":[{\"type\":\"text\",\"value\":\"Y\"}],\"rowSpan\":1,\"colSpan\":1}]," +
+                "[{\"content\":[{\"type\":\"text\",\"value\":\"C\"}],\"rowSpan\":1,\"colSpan\":1}]" +
+                "]" +
+                "}" +
+                "]}";
+
+        String result = PlainTextExtractUtils.extractPlainText(mapper, json);
+
+        assertThat(result).isEqualTo(String.join("\n",
+                "[2 columns]",
+                "[\"X\", \"Y\"]",
+                "[\"\", \"C\"]"));
+    }
+}
diff --git "a/\353\217\204\353\251\224\354\235\270\353\252\250\353\215\270.md" "b/\353\217\204\353\251\224\354\235\270\353\252\250\353\215\270.md"
index c39e7641..8e8e6277 100644
--- "a/\353\217\204\353\251\224\354\235\270\353\252\250\353\215\270.md"
+++ "b/\353\217\204\353\251\224\354\235\270\353\252\250\353\215\270.md"
@@ -1,113 +1,427 @@
 # StarLight 도메인 모델
-## 예시로 넣어놓은거라서 나중에 수정하면 될 것 같아요
-
-## 도메인 모델 만들기
-1. 듣고 배우기
-2. '중요한 것'들 찾기 (개념 식별)
-3. '연결 고리' 찾기 (관계 정의)
-4. '것'들을 설명하기 (속성 및 기본 행위 명시)
-5. 그려보기 (시각화)
-6. 이야기 하고 다듬기 (반복)  
-
-## Splearn 도메인
-- 스프런은 회원이 강의를 수강하는 온라인 서비스이다.
-- 스프런은 스프링 프레임워크의 철학을 바탕으로 개발되고 운영되며 발전하는 학습 생태계를 목표로 한다.  
-  이 생태계를 구성하는 핵심 구성 요소는 학습(성장)하는 회원이다.
-    - 그래서 이름이 Spring + Learner = Splearn
-    - 유사한 이름으로 인프런이 있다.
-- 스프런에서 활동하기 위해서는 회원으로 등록해야 한다.
-    - 다만, 회원이 되기 전에도 스프런에 대한 소개와 강의 정보를 살펴볼 수 있다.
-    - 강의를 수강하기 위해서는 등록을 완료하고 활동 가능한 회원이 되어야 한다.
-    - 등록 신청을 한 뒤 정해진 요건을 충족하면 등록이 완료된다.
-    - 등록을 완료한 경우에 프로필 주소, 자기 소개를 등록하거나 수정할 수 있다. 
-      - 프로필 주소는 알파벳과 숫자로 구성된 15자리 이내의 중복되지 않은 값
-      - 탈퇴한 회원의 프로필 주소와 자기 소개는 수정할 수 없다. 
-    - 등록 시간, 등록 완료 시간, 탈퇴 시간을 저장한다. 
-- 원하는 회원은 자신이 가진 지식과 경험을 강의라는 형태로 다른 회원에게 제공하는 강사가 될 수도 있다.
-    - 회원이 최초로 강사가 되려면 강사 신청과 승인 과정을 거치도록 한다.
-    - 승인된 강사는 강의를 생성하고 검수를 거쳐 강의를 공개할 수 있다.
-    - 공개된 강의는 회원에게 노출되고, 회원은 이 강의를 수강할 수 있다.
-- 수강은 강의를 학습하는 것을 말한다. "내가 수강한 강의는 a이다. 나는 b 강의 수강중이다."
-    - 수강을 위해서는 먼저 수강 신청이 필요하다.
-    - 수강 신청은 강의의 수강 요건에 따라서 신청을 해야 하고 이후 추가 절차가 요구될 수 있다.
-    - 일부 강의는 수강 신청과 동시에 수강이 가능하다.
-    - 어떤 강의는 수강 신청후 강의비 결제를 완료해야 수강이 가능하다.
-    - 강사는 강의 수강 기간의 제한을 둘 수도 있다.
-- 강의는 영상, 문서와 같은 컨텐츠를 가진 하나 이상의 수업으로 구성 된다.
-    - 수업은 갯수가 많을 수 있다. 그래서 수업은 다시 섹션으로 구분한다.
-    - 하나의 강의는 여러 개의 섹션과 각 섹션에 속한 수업으로 구성된다.
-    - 수업과 섹션은 학습 순서를 가진다.
-    - 학습 진도는 매 수업 단위로 기록된다.
-    - 강의의 모든 수업의 학습을 마치고 수업 진도가 100%에 도달하면 강의 수강을 완료한 것이다.
+
+## StarLight 도메인
+- StarLight는 창업자가 사업계획서를 작성하고, 전문가의 피드백과 AI 분석을 받을 수 있는 서비스이다.
+- 창업자(Member with MemberType.FOUNDER)는 사업계획서를 작성할 수 있다.
+- 사업계획서는 5개의 주요 섹션(개요, 문제인식, 실현가능성, 성장전략, 팀역량)으로 구성되며, 각 섹션은 여러 서브 섹션으로 세분화된다.
+- 작성된 사업계획서에 대해 AI가 자동으로 분석 리포트를 생성할 수 있다.
+- 창업자는 전문가에게 피드백을 신청할 수 있으며, 동일한 사업계획서에 대해 동일한 전문가에게는 1회만 신청이 가능하다.
+- 전문가(Expert)는 피드백 신청을 받으면 7일 이내에 리포트를 작성하여 제출해야 한다.
+- 전문가 피드백 신청은 결제를 통해 이루어지며, 토스페이먼츠를 통해 처리된다.
 
 ## 도메인 모델
 
 ---
-### [ 피드백 신청 어그리거트 ]
+### [ 회원 어그리거트 ]
 
-### 피드백 신청(ExpertApplication)
+### 회원(Member)
 _Aggregate Root_
 #### 속성
 - `id`: `Long`
+- `name`: `String` - 이름
+- `email`: `String` - 이메일
+- `profileImageUrl`: `String` - 프로필 이미지 URL
+- `phoneNumber`: `String` - 전화번호
+- `memberType`: `MemberType` - 회원 타입 (FOUNDER, EXPERT)
+- `credential`: `Credential` - 인증 정보 (1:1 관계)
+- `provider`: `String` - 인증 제공자 (starlight, kakao, google 등)
+- `providerId`: `String` - 제공자 고유 ID
+
 #### 행위
-- `static register()`: 회원 등록: email, nickname, password, passwordEncoder
+- `static create()`: 일반 회원 생성 (이름, 이메일, 전화번호, 회원타입, 인증정보, 프로필이미지)
+- `static newSocial()`: 소셜 로그인 회원 생성 (이름, 이메일, 제공자, 제공자ID, 전화번호, 회원타입, 프로필이미지)
+- `updateProfileImage()`: 프로필 이미지 업데이트
+
 #### 규칙
-- 사업계획서 1개당 여러 전문가에게 피드백 신청이 가능하다.
-- 1개에 사업 계획서에 대해선 동일한 전문가에게 중복 신청 불가하다.(1회만 피드백 신청이 가능하다)
+- 회원은 FOUNDER(창업자) 또는 EXPERT(전문가) 타입 중 하나를 가진다.
+- 소프트 삭제를 지원한다.
 
-### 회원 상세(MemberDetail)
+### 인증 정보(Credential)
 _Entity_
+#### 속성
 - `id`: `Long`
-- `profile`: 프로필 주소. 모든 회원이 고유한 프로필 주소를 가져야 한다
-- `introduction`: 자기 소개
-- `registeredAt`: 등록 일시
-- `activatedAt`: 등록 완료 일시
-- `deactivatedAt`: 탈퇴 일시
-#### 행위
-- `static create()`: 회원 등록. 현재 시간을 등록 일시로 저장한다.
-- `activate()`: 등록 완료와 관련된 작업 수행. 등록 완료 일시 저장.
-- `deactivate()`: 탈퇴와 관련된 작업 수정. 탈퇴 일시 저장.
-- `updateInfo()`: 상세 정보 수정
-
-### 회원 상태(MemberStatus)
+- `password`: `String` - 암호화된 비밀번호
+
+#### 행위
+- `static create()`: 인증 정보 생성 (암호화된 비밀번호)
+
+### 회원 타입(MemberType)
 _Enum_
 #### 상수
-- `PENDING`: 등록 대기
-- `ACTIVE`: 등록 완료
-- `DEACTIVATED`: 탈퇴
+- `FOUNDER`: 창업자
+- `EXPERT`: 전문가
+
+---
+
+### [ 전문가 어그리거트 ]
+
+### 전문가(Expert)
+_Aggregate Root_
+#### 속성
+- `id`: `Long`
+- `name`: `String` - 이름
+- `email`: `String` - 이메일
+- `workedPeriod`: `Long` - 경력 기간
+- `profileImageUrl`: `String` - 프로필 이미지 URL
+- `mentoringPriceWon`: `Integer` - 멘토링 가격 (원)
+- `careers`: `List<String>` - 경력 목록
+- `tags`: `Set<String>` - 태그 목록
+- `categories`: `Set<TagCategory>` - 전문 분야 카테고리
+
+#### 규칙
+- Member와 독립적으로 존재하는 별도의 엔티티이다.
 
-### DuplicateEmailException
-_Exception_
+### 전문가 태그 카테고리(TagCategory)
+_Enum_
+#### 상수
+- `MARKET_BM`: 시장성/BM
+- `TEAM_CAPABILITY`: 팀 역량
+- `PROBLEM_DEFINITION`: 문제 정의
+- `GROWTH_STRATEGY`: 성장 전략
+- `METRIC_DATA`: 지표/데이터
+
+---
+
+### [ 사업계획서 어그리거트 ]
+
+### 사업계획서(BusinessPlan)
+_Aggregate Root_
+#### 속성
+- `id`: `Long`
+- `memberId`: `Long` - 작성자 회원 ID
+- `title`: `String` - 제목
+- `pdfUrl`: `String` - PDF 파일 URL (선택)
+- `planStatus`: `PlanStatus` - 사업계획서 상태
+- `overview`: `Overview` - 개요 섹션 (1:1 관계)
+- `problemRecognition`: `ProblemRecognition` - 문제 인식 섹션 (1:1 관계)
+- `feasibility`: `Feasibility` - 실현 가능성 섹션 (1:1 관계)
+- `growthTactic`: `GrowthTactic` - 성장 전략 섹션 (1:1 관계)
+- `teamCompetence`: `TeamCompetence` - 팀 역량 섹션 (1:1 관계)
+
+#### 행위
+- `static create()`: 사업계획서 생성 (제목, 회원ID) - STARTED 상태로 초기화
+- `static createWithPdf()`: PDF 기반 사업계획서 생성 (제목, 회원ID, PDF URL) - WRITTEN_COMPLETED 상태로 초기화
+- `isOwnedBy()`: 소유자 확인
+- `isPdfBased()`: PDF 기반 여부 확인
+- `updateTitle()`: 제목 업데이트
+- `updateStatus()`: 상태 업데이트
+- `areWritingCompleted()`: 모든 서브 섹션이 작성 완료되었는지 확인
+
+#### 규칙
+- 사업계획서 생성 시 5개의 섹션이 자동으로 초기화된다.
+- 모든 서브 섹션이 작성되면 작성 완료로 판단된다.
+- PDF 기반 사업계획서는 별도로 생성 가능하다.
+
+### 섹션 타입(SectionType)
+_Enum_
+#### 상수
+- `OVERVIEW`: 개요
+- `PROBLEM_RECOGNITION`: 문제 인식
+- `FEASIBILITY`: 실현 가능성
+- `GROWTH_STRATEGY`: 성장 전략
+- `TEAM_COMPETENCE`: 팀 역량
+
+### 기본 섹션(BaseSection)
+_MappedSuperclass (Abstract)_
+#### 속성
+- `id`: `Long` - BusinessPlan과 공유하는 기본키
+- `businessPlan`: `BusinessPlan` - 연관된 사업계획서
 
-### 비밀번호 인코더(PasswordEncoder)
-_Domain Service_
 #### 행위
-- `encode()`: 비밀번호 암호화하기
-- `matches()`: 비밀번호가 일치하는지 확인
+- `attachBusinessPlan()`: 사업계획서 연결
+- `putSubSection()`: 서브 섹션 추가
+- `removeSubSection()`: 서브 섹션 제거
+- `getSubSectionByType()`: 타입별 서브 섹션 조회 (추상 메서드)
+- `setSubSectionByType()`: 타입별 서브 섹션 설정 (추상 메서드)
+- `areAllSubSectionsCreated()`: 모든 서브 섹션 생성 여부 (추상 메서드)
+
+### 개요(Overview)
+_Entity (extends BaseSection)_
+#### 속성
+- `overviewBasic`: `SubSection` - 기본 개요 서브 섹션 (1:1 관계)
+
+#### 행위
+- `static create()`: 개요 섹션 생성
+
+### 문제 인식(ProblemRecognition)
+_Entity (extends BaseSection)_
+#### 속성
+- `problemBackground`: `SubSection` - 창업 배경 및 개발동기 (1:1 관계)
+- `problemPurpose`: `SubSection` - 창업아이템의 목적 및 필요성 (1:1 관계)
+- `problemMarket`: `SubSection` - 창업아이템의 목표시장 분석 (1:1 관계)
+
+#### 행위
+- `static create()`: 문제 인식 섹션 생성
+
+### 실현 가능성(Feasibility)
+_Entity (extends BaseSection)_
+#### 속성
+- `feasibilityStrategy`: `SubSection` - 사업화 전략 (1:1 관계)
+- `feasibilityMarket`: `SubSection` - 시장분석 및 경쟁력 확보 방안 (1:1 관계)
+
+#### 행위
+- `static create()`: 실현 가능성 섹션 생성
+
+### 성장 전략(GrowthTactic)
+_Entity (extends BaseSection)_
+#### 속성
+- `growthModel`: `SubSection` - 비즈니스 모델 (1:1 관계)
+- `growthFunding`: `SubSection` - 자금조달 계획 (1:1 관계)
+- `growthEntry`: `SubSection` - 시장진입 및 성과창출 전략 (1:1 관계)
+
+#### 행위
+- `static create()`: 성장 전략 섹션 생성
+
+### 팀 역량(TeamCompetence)
+_Entity (extends BaseSection)_
+#### 속성
+- `teamFounder`: `SubSection` - 창업자의 역량 (1:1 관계)
+- `teamMembers`: `SubSection` - 팀 역량 (1:1 관계)
+
+#### 행위
+- `static create()`: 팀 역량 섹션 생성
+
+### 서브 섹션(SubSection)
+_Entity_
+#### 속성
+- `id`: `Long`
+- `subSectionType`: `SubSectionType` - 서브 섹션 타입
+- `content`: `String` - 내용 (TEXT)
+- `rawJson`: `RawJson` - 원본 JSON 데이터 (TEXT)
+- `checkFirst`: `boolean` - 체크리스트 1번
+- `checkSecond`: `boolean` - 체크리스트 2번
+- `checkThird`: `boolean` - 체크리스트 3번
+- `checkFourth`: `boolean` - 체크리스트 4번
+- `checkFifth`: `boolean` - 체크리스트 5번
+
+#### 행위
+- `static create()`: 서브 섹션 생성 (타입, 내용, 원본JSON, 체크리스트)
+- `update()`: 서브 섹션 업데이트 (내용, 원본JSON, 체크리스트)
+- `getChecks()`: 체크리스트 조회
+
+#### 규칙
+- 체크리스트는 항상 5개의 항목을 가진다.
+
+### 서브 섹션 타입(SubSectionType)
+_Enum_
+#### 상수 (개요)
+- `OVERVIEW_BASIC`: 개요
+
+#### 상수 (문제 인식)
+- `PROBLEM_BACKGROUND`: 창업 배경 및 개발동기
+- `PROBLEM_PURPOSE`: 창업아이템의 목적 및 필요성
+- `PROBLEM_MARKET`: 창업아이템의 목표시장 분석
+
+#### 상수 (실현 가능성)
+- `FEASIBILITY_STRATEGY`: 사업화 전략
+- `FEASIBILITY_MARKET`: 시장분석 및 경쟁력 확보 방안
+
+#### 상수 (성장 전략)
+- `GROWTH_MODEL`: 비즈니스 모델
+- `GROWTH_FUNDING`: 자금조달 계획
+- `GROWTH_ENTRY`: 시장진입 및 성과창출 전략
+
+#### 상수 (팀 역량)
+- `TEAM_FOUNDER`: 창업자의 역량
+- `TEAM_MEMBERS`: 팀 역량
+
+### 사업계획서 상태(PlanStatus)
+_Enum_
+#### 상수
+- `STARTED`: 시작됨
+- `WRITTEN_COMPLETED`: 작성 완료
+- `AI_REVIEWED`: AI 리뷰 완료
+- `EXPERT_MATCHED`: 전문가 매칭 완료
+- `FINALIZED`: 최종 완료
 
-### 프로필 주소(Profile)
+### 원시 JSON(RawJson)
 _Value Object_
 #### 속성
-- `address`: 프로필 주소
+- `value`: `String` - JSON 문자열
+
+#### 행위
+- `static create()`: RawJson 생성
 
 ---
 
-### Email
-_Value Object_
+### [ 피드백 신청 어그리거트 ]
+
+### 피드백 신청(ExpertApplication)
+_Aggregate Root_
 #### 속성
-- `address`: 이메일 주소
+- `id`: `Long`
+- `businessPlanId`: `Long` - 사업계획서 ID
+- `expertId`: `Long` - 전문가 ID
+
+#### 행위
+- `static create()`: 피드백 신청 생성 (사업계획서ID, 전문가ID)
+
+#### 규칙
+- 사업계획서 1개당 여러 전문가에게 피드백 신청이 가능하다.
+- 동일한 사업계획서에 대해 동일한 전문가에게는 1회만 피드백 신청이 가능하다 (유니크 제약 조건).
+
 ---
 
+### [ 전문가 리포트 어그리거트 ]
 
-### 강사
+### 전문가 리포트(ExpertReport)
+_Aggregate Root_
+#### 속성
+- `id`: `Long`
+- `expertId`: `Long` - 전문가 ID
+- `businessPlanId`: `Long` - 사업계획서 ID
+- `expiredAt`: `LocalDateTime` - 만료 일시 (생성 후 7일)
+- `token`: `String` - 리포트 접근 토큰 (유니크)
+- `viewCount`: `int` - 조회 횟수
+- `overallComment`: `String` - 전체 코멘트 (TEXT)
+- `submitStatus`: `SubmitStatus` - 제출 상태 (기본값: PENDING)
+- `details`: `List<ExpertReportDetail>` - 리포트 상세 목록 (1:N 관계)
 
-### 강의
+#### 행위
+- `static create()`: 전문가 리포트 생성 (전문가ID, 사업계획서ID, 토큰) - 만료일시는 생성 후 7일
+- `isExpired()`: 만료 여부 확인
+- `syncStatus()`: 상태 동기화 (만료 확인 후 EXPIRED로 변경)
+- `validateCanEdit()`: 수정 가능 여부 검증
+- `canEdit()`: 수정 가능 여부 확인
+- `temporarySave()`: 임시 저장
+- `submit()`: 리포트 제출
+- `updateOverallComment()`: 전체 코멘트 업데이트
+- `updateDetails()`: 리포트 상세 목록 업데이트
+- `incrementViewCount()`: 조회 횟수 증가
 
-### 수업
+#### 규칙
+- 리포트는 생성 후 7일의 평가 기한을 가진다.
+- PENDING, TEMPORARY_SAVED 상태에서만 수정 가능하다.
+- PENDING, TEMPORARY_SAVED 상태에서 제출 가능하며, 제출 시 SUBMITTED 상태로 변경된다.
+- SUBMITTED, EXPIRED 상태에서는 수정 불가하다.
+- expiredAt가 현재 시간보다 이전이면 EXPIRED 상태로 변경된다.
+- 동일한 사업계획서와 전문가 조합에 대해 1개의 리포트만 존재할 수 있다 (유니크 제약 조건).
+
+### 리포트 상세(ExpertReportDetail)
+_Entity_
+#### 속성
+- `id`: `Long`
+- `commentType`: `CommentType` - 코멘트 타입 (STRENGTH, WEAKNESS)
+- `content`: `String` - 내용 (TEXT)
+
+#### 행위
+- `static create()`: 리포트 상세 생성 (코멘트타입, 내용)
+- `update()`: 내용 업데이트
+
+### 제출 상태(SubmitStatus)
+_Enum_
+#### 상수
+- `PENDING`: 평가 전
+- `TEMPORARY_SAVED`: 임시 저장
+- `SUBMITTED`: 제출 완료
+- `EXPIRED`: 만료됨
 
-### 섹션
+### 코멘트 타입(CommentType)
+_Enum_
+#### 상수
+- `STRENGTH`: 강점
+- `WEAKNESS`: 약점
+
+---
 
-### 수강
+### [ AI 리포트 어그리거트 ]
+
+### AI 리포트(AiReport)
+_Aggregate Root_
+#### 속성
+- `id`: `Long`
+- `businessPlanId`: `Long` - 사업계획서 ID
+- `rawJson`: `RawJson` - 원본 JSON 데이터 (TEXT)
 
-### 진도
+#### 행위
+- `static create()`: AI 리포트 생성 (사업계획서ID, 원본JSON)
+- `update()`: AI 리포트 업데이트 (원본JSON)
+
+#### 규칙
+- 사업계획서가 작성 완료되지 않으면 AI 리포트를 생성할 수 없다.
+
+---
+
+### [ 주문 어그리거트 ]
+
+### 주문(Orders)
+_Aggregate Root_
+#### 속성
+- `id`: `Long`
+- `orderCode`: `String` - 주문 코드 (유니크)
+- `buyerId`: `Long` - 구매자 회원 ID
+- `status`: `OrderStatus` - 주문 상태 (기본값: NEW)
+- `currency`: `String` - 통화 (기본값: "KRW")
+- `price`: `Long` - 주문 금액
+- `usageProductCode`: `String` - 사용 상품 코드
+- `usageCount`: `Integer` - 이용권 횟수 (1회권, 2회권 등)
+- `payments`: `List<PaymentRecords>` - 결제 기록 목록 (1:N 관계)
+- `version`: `Long` - 버전 (낙관적 locking)
+
+#### 행위
+- `static newUsageOrder()`: 이용권 주문 생성 (주문코드, 구매자ID, 금액, 상품타입)
+- `validateSameBuyer()`: 동일 구매자 확인
+- `validateSameProduct()`: 동일 상품 확인
+- `addPaymentAttempt()`: 결제 시도 추가
+- `markPaid()`: 결제 완료 처리
+- `cancel()`: 주문/결제 취소
+- `getLatestRequestedOrThrow()`: 가장 최근 REQUESTED 상태 결제 시도 조회
+- `getLatestDoneOrThrow()`: 가장 최근 DONE 상태 결제 시도 조회
+
+#### 규칙
+- 이미 결제 완료된 주문에는 결제 시도를 추가할 수 없다.
+- 주문 금액과 결제 금액이 일치해야 한다.
+- NEW 상태에서만 결제 승인이 가능하다.
+- PAID 상태에서만 취소가 가능하다.
+
+### 결제 기록(PaymentRecords)
+_Entity_
+#### 속성
+- `id`: `Long`
+- `order`: `Orders` - 주문 (N:1 관계)
+- `pg`: `String` - PG사 (기본값: "TOSS")
+- `paymentKey`: `String` - 결제 키 (유니크)
+- `method`: `String` - 결제 수단
+- `provider`: `String` - 결제 제공자
+- `price`: `Long` - 결제 금액
+- `status`: `String` - 결제 상태 (기본값: "REQUESTED")
+- `receiptUrl`: `String` - 영수증 URL
+- `approvedAt`: `Instant` - 승인 일시
+- `createdAt`: `Instant` - 생성 일시
+
+#### 행위
+- `static requestedFor()`: 결제 요청 생성 (주문, 금액)
+- `markDone()`: 결제 완료 처리
+- `markFailed()`: 결제 실패 처리
+
+### 주문 상태(OrderStatus)
+_Enum_
+#### 상수
+- `NEW`: 주문 생성됨 (결제 전)
+- `PAID`: 결제 완료
+- `CANCELED`: 주문/결제 취소
+
+### 사용 상품 타입(UsageProductType)
+_Enum_
+#### 상수
+- 사용 크레딧 상품 타입 (1회권, 2회권 등)
+
+### 주문 코드(OrderCode)
+_Value Object_
+#### 속성
+- `value`: `String` - 주문 코드 문자열
+
+#### 행위
+- `static of()`: OrderCode 생성
+
+### 금액(Money)
+_Value Object_
+#### 속성
+- `amount`: `Long` - 금액
+- `currency`: `String` - 통화
+
+#### 행위
+- `static of()`: Money 생성 (금액, 통화)
+- `static krw()`: 한국 원화 Money 생성
 
+---
\ No newline at end of file
diff --git "a/\354\232\251\354\226\264\354\202\254\354\240\204.md" "b/\354\232\251\354\226\264\354\202\254\354\240\204.md"
index 71f8c9fa..a046a8eb 100644
--- "a/\354\232\251\354\226\264\354\202\254\354\240\204.md"
+++ "b/\354\232\251\354\226\264\354\202\254\354\240\204.md"
@@ -2,6 +2,29 @@
 
 | **한국어** | **영어**  | **설명**                                   |
 |--------|---------|------------------------------------------|
-| 창업자    | Founder | starLight 서비스를 이용하는 사용자로 사업계획서를 작성할 수 있다. |
-| 전문가    | Expert  | 사업계획서를 검토하는 회원. 전문가는 회원과 독립적으로 존재한다      |
+| 창업자    | Founder | StarLight 서비스를 이용하는 사용자로 사업계획서를 작성할 수 있다. MemberType.FOUNDER를 가진 회원이다. |
+| 전문가    | Expert  | 사업계획서를 검토하고 피드백을 제공하는 회원. Member와 독립적으로 존재하는 별도의 엔티티이다. |
+| 회원    | Member  | StarLight 서비스를 이용하는 모든 사용자. |
+| 사업계획서  | BusinessPlan | 창업자가 작성하는 사업 계획서. 5개의 주요 섹션(개요, 문제인식, 실현가능성, 성장전략, 팀역량)으로 구성된다. |
+| 섹션    | Section | 사업계획서를 구성하는 5개의 주요 영역. Overview, ProblemRecognition, Feasibility, GrowthTactic, TeamCompetence가 있다. |
+| 서브 섹션  | SubSection | 각 섹션의 세부 항목. 내용, 원본 JSON 데이터, 체크리스트(5개 항목)를 포함한다. |
+| 개요    | Overview | 사업계획서의 첫 번째 섹션. 사업의 기본 정보를 담는다. |
+| 문제 인식  | ProblemRecognition | 사업계획서의 두 번째 섹션. 창업 배경, 개발 동기, 목적 및 필요성, 목표시장 분석을 포함한다. |
+| 실현 가능성 | Feasibility | 사업계획서의 세 번째 섹션. 사업화 전략, 시장분석 및 경쟁력 확보 방안을 포함한다. |
+| 성장 전략  | GrowthTactic | 사업계획서의 네 번째 섹션. 비즈니스 모델, 자금조달 계획, 시장진입 및 성과창출 전략을 포함한다. |
+| 팀 역량   | TeamCompetence | 사업계획서의 다섯 번째 섹션. 창업자의 역량, 팀 역량을 포함한다. |
+| 피드백 신청 | ExpertApplication | 창업자가 특정 전문가에게 자신의 사업계획서에 대한 피드백을 요청하는 신청. 동일한 사업계획서에 대해 동일한 전문가에게는 1회만 신청 가능하다. |
+| 전문가 리포트 | ExpertReport | 전문가가 사업계획서에 대한 피드백을 작성한 리포트. 전체 코멘트와 각 섹션별 상세 코멘트(강점/약점)를 포함한다. 7일의 평가 기한을 가진다. |
+| 리포트 상세 | ExpertReportDetail | 전문가 리포트의 세부 내용. 강점(STRENGTH) 또는 약점(WEAKNESS) 타입의 코멘트를 포함한다. |
+| AI 리포트  | AiReport | AI가 사업계획서를 분석하여 자동으로 생성한 리포트. JSON 형태로 저장된다. |
+| 주문    | Orders  | 전문가 피드백 신청을 위한 결제 주문. 토스페이먼츠를 통해 결제를 처리한다. |
+| 결제 기록  | PaymentRecords | 주문에 대한 결제 시도 및 완료 기록. 여러 번의 결제 시도를 기록할 수 있다. |
+| 사용 크레딧 | UsageCredit | 전문가 피드백 신청에 사용하는 크레딧(이용권). 1회권, 2회권 등의 상품이 있다. |
+| 사업계획서 상태 | PlanStatus | 사업계획서의 진행 상태. STARTED(시작됨), WRITTEN_COMPLETED(작성 완료), AI_REVIEWED(AI 리뷰 완료), EXPERT_MATCHED(전문가 매칭 완료), FINALIZED(최종 완료)가 있다. |
+| 제출 상태   | SubmitStatus | 전문가 리포트의 제출 상태. PENDING(평가 전), TEMPORARY_SAVED(임시 저장), SUBMITTED(제출 완료), EXPIRED(만료됨)가 있다. |
+| 코멘트 타입  | CommentType | 전문가 리포트 상세의 코멘트 타입. STRENGTH(강점), WEAKNESS(약점)이 있다. |
+| 전문가 태그 카테고리 | TagCategory | 전문가의 전문 분야 카테고리. MARKET_BM(시장성/BM), TEAM_CAPABILITY(팀 역량), PROBLEM_DEFINITION(문제 정의), GROWTH_STRATEGY(성장 전략), METRIC_DATA(지표/데이터)가 있다. |
+| 주문 상태   | OrderStatus | 주문의 결제 상태. NEW(주문 생성됨, 결제 전), PAID(결제 완료), CANCELED(주문/결제 취소)가 있다. |
+| 인증 정보   | Credential | 회원의 비밀번호 등 인증 관련 정보. Member와 1:1 관계이다. |
+| 원시 JSON  | RawJson | 원본 데이터를 JSON 형태로 저장하기 위한 값 객체. |