[fix] negodata: 협상카드 성공률에 회사 스코프 누락 — 타사 견적 이력이 섞이던 문제

card_success_map 이 quotations 조인 없이 DB 전체 chats 를 카드별로 집계해,
다른 회사 견적에서 쓰인 이력이 내 카드 목록의 used_count/success_rate 로 잡혔다.
통계 화면 '협상카드 성공률 TOP 5' 와 견적 생성 시 카드 추천 순위가 모두 이 값을 쓴다.

- quotations 조인 + 작성자 회사(users.company_id) 스코프 추가
- 소프트 삭제분 제외(sessions.deleted / quotations.deleted 필터 누락분 보강)

.gitignore

@@ -24,3 +24,11 @@ CLAUDE.md
 
 # OS
 .DS_Store
+
+# 로컬 리서치 노트(크롤링 라이브러리·안티스크래핑 조사) — 추적 안 함, 로컬 참고용
+/Temp.md
+/new.md
+
+/mobile.mov
+.gstack/
+.playwright-mcp/

README.md

@@ -1,63 +1,198 @@
 # O2O Negosium
 
-동일 구조의 두 서비스(**negosium**, **negodata**)가 **하나의 PostgreSQL 인스턴스**를 공유한다.
+AI 협상 솔루션. 여러 백엔드·프론트·배치가 **하나의 PostgreSQL 인스턴스**를 공유하고,
+전부 `docker compose` 하나로 뜬다. (인터넷 최저가 검색 LPS 만 별도 DB `lps_db` 사용.)
+
+## 서비스 소개
+
+구매기업(바이어)이 협력사(공급사)와 벌이는 **가격 협상을 AI 봇이 대신 수행**하는 B2B 협상 자동화 솔루션이다.
+바이어가 상품·목표가·기간만 정해 견적을 열면, 각 협력사와의 1:1 협상은 강화학습 기반 에이전트가
+**협상 카드로 밀당**하며 진행하고, 마감 시각에 최저 투찰가를 기준으로 자동 **낙찰/개찰**을 판정한다.
+
+크게 세 축 + 부속으로 나뉜다.
+
+| 축 | 구성요소 | 역할 |
+|---|---|---|
+| **바이어 측** | negodata (backend + front) | 어드민. 상품·협력사 관리, 견적 생성, 마감·낙찰 관리 |
+| **공급사 측** | negosium (backend + frontend) | 협력사 포털. 초청받은 협상 챗에 참여해 가격 제시 |
+| **협상 엔진** | agent | 실제 AI 협상 봇. 앵커링가·협상 카드로 자동 협상 (강화학습) |
+| 부속 | lps · anchoring · landing | 인터넷 최저가(목표가 재료) · 앵커값 자동 조정 배치 · 솔루션 소개 랜딩 |
 
 ## 구성
 
 ```
 o2o-negosium/
-├── docker-compose.yml          # 두 backend (DB 는 외부)
-├── postgres-init/        # DB·테이블 셋업 SQL (대상 DB 에 1회 적용)
-├── backend/                     # negosium 백엔드 (포트 9300)
-├── negodata/backend/            # negodata 백엔드 (포트 9400)
-├── agent/  front/               # (예정)
-└── negodata/front/              # (예정)
+├── docker-compose.yml           # 전체 서비스 (DB 는 compose 밖, config 로 외부 연결)
+├── postgres-init/               # DB·스키마·시드 SQL (대상 DB 에 1회 적용)
+│
+├── backend/                     # negosium 백엔드 — 공급사/협상 API (:9300)
+├── frontend/                    # negosium 공급사 프론트 (:3300, 프로덕션 빌드 정적 서빙)
+├── agent/                       # 협상 에이전트 — RL(learning 스키마) (:9500)
+│
+├── negodata/backend/            # negodata 백엔드 — 바이어/어드민 API (:9400)
+├── negodata/front/              # negodata 어드민 프론트 (Vite, :3000)
+│
+├── landing/                     # 솔루션 랜딩페이지 (react-router SSG, :3100)
+│
+├── lps/                         # 인터넷 최저가 검색: lps-api(:9600) + lps-worker(크롤)
+├── lps-admin/                   # LPS 관리자 UI (nginx → lps-api 프록시, :3400)
+│
+└── schedules/anchoring/         # 앵커링 값 자동 조정 배치 (포트 없음, 상주 스케줄러 + Redis)
 ```
 
-두 백엔드는 같은 코드 골격(MVC · 람다 DB · Depends 주입 · JWT 로그인)을 쓴다.
-아키텍처/패턴 상세는 각 서버 README 참고: [backend](backend/README.md) · [negodata/backend](negodata/backend/README.md)
+negosium·negodata·agent 백엔드는 같은 코드 골격(MVC · 람다 DB · Depends 주입 · JWT 로그인)을 쓴다.
+아키텍처/패턴 상세는 각 서브 README 참고:
+- 백엔드: [backend](backend/README.md) · [negodata/backend](negodata/backend/README.md) · [agent](agent/README.md) · [lps](lps/README.md)
+- 프론트: [frontend](frontend/README.md) · [negodata/front](negodata/front/README.md)
+- 배치: [schedules/anchoring](schedules/anchoring/README.md) · 관리자 UI: [lps-admin](lps-admin/README.md)
+
+### 서비스 / 포트
+
+| 서비스 | 주소 | 역할 | DB |
+|---|---|---|---|
+| negosium-backend | http://localhost:9300/docs | 공급사·협상 API | negosium_db |
+| negosium-front | http://localhost:3300 | 공급사 프론트 | — |
+| agent | http://localhost:9500/docs | 협상 에이전트(RL) | negosium_db (learning) |
+| negodata-backend | http://localhost:9400/docs | 바이어·어드민 API | negosium_db |
+| negodata-front | http://localhost:3000 | 어드민 프론트 | — |
+| landing | http://localhost:3100 | 솔루션 랜딩 | — |
+| lps-api | http://localhost:9600/docs | 최저가 검색 접수/조회 | lps_db |
+| lps-worker | 포트 없음 | 크롤 워커(헤드풀 Chromium) | lps_db |
+| lps-admin | http://localhost:3400 | LPS 관리자 UI | — |
+| anchoring | 포트 없음 | 앵커링 조정 배치(격주 토 00:00 KST) | negosium_db (anchoring) |
+| anchoring-redis | 127.0.0.1:6380 | anchoring 조회 캐시 | — |
+| autoheal | — | unhealthy 컨테이너 자동 재시작 | — |
 
 ### DB 는 compose 밖 (config 로 연결)
+
 DB 는 docker-compose 에서 관리하지 않는다. 각 backend 는 `config.<APP_ENV>.toml` 의 접속 정보대로
 **외부 PostgreSQL**(호스트 로컬 postgres, 또는 따로 떠 있는 docker postgres)에 연결한다.
-한 PostgreSQL 안에 서비스별 database 를 둔다.
+
+한 PostgreSQL 인스턴스 안에 **단일 `negosium_db`** 를 두고 도메인별 **schema** 로 묶는다.
+LPS 만 별도 database(`lps_db`) 를 쓴다.
+
 ```
 PostgreSQL (외부, 5432)
-├── negosium_db     ← negosium-backend
-└── negodata_db     ← negodata-backend
+├── negosium_db                       ← negosium-backend · negodata-backend · agent · anchoring 공유
+│   ├── company / supplier / partner  : 회사·유저·협력사·상품
+│   ├── card / quotation / negotiation: 협상 카드·견적·협상 세션
+│   ├── learning                      : RL 자산 (agent 소유)
+│   └── anchoring                     : 앵커링 조정 (schedules/anchoring 소유)
+└── lps_db                            ← lps-api · lps-worker
 ```
-- 컨테이너(docker env)에서 호스트 DB 접근: `host.docker.internal:5432` (`config.docker.toml`)
+- 컨테이너(docker env)에서 호스트 DB 접근: `host.docker.internal:5432` (compose 가 `DB_HOST` 로 override)
 - 로컬 실행/테스트(local·test env): `127.0.0.1:5432` (`config.local/test.toml`)
 - 계정/database 명은 config 에 맞춘다 (기본 `postgres` / `password`).
 
-| 서비스 | 서버 | docs | database |
-|---|---|---|---|
-| negosium-backend | http://localhost:9300 | /docs | negosium_db |
-| negodata-backend | http://localhost:9400 | /docs | negodata_db |
+## 핵심 플로우
+
+### 1. 견적 라이프사이클 (전체 개요)
+
+바이어가 견적을 열고 → 협력사가 협상에 참여 → 마감 시각에 판정되는 큰 흐름.
+견적 유형은 두 축(재/신규 × 협상 1:1 / 견적 1:N)으로 4종.
+
+```mermaid
+flowchart TD
+    A["바이어: 상품·협력사·기간 선택<br/>견적 유형 4종 + 낙찰 기준(mid/over_action) 설정"] --> B["목표가·앵커링가 산정<br/>(MD제시가 → 인터넷최저가/매입가/판매가)"]
+    B --> C["협력사 초청 (이메일)"]
+    C --> D{"견적 유형"}
+    D -->|"협상 1:1 (재협상·신규협상)"| E["AI 봇 밀당 협상<br/>(협상 카드 사용)"]
+    D -->|"견적 1:N (재견적·신규견적)"| F["정형 흐름<br/>(배송형태·추가할인 확인)"]
+    E --> G["세션별 투찰가 확정<br/>(협상완료) 또는 실패"]
+    F --> G
+    G --> H{"마감 트리거<br/>①마감시각 ②전세션종결 ③수동"}
+    H --> I["마감 판정<br/>(최저 투찰가 기준)"]
+    I --> J["낙찰 (승자 1)"]
+    I --> K["개찰 (낙찰자 미정)"]
+```
+
+### 2. 1:1 협상 봇 판정 (agent)
+
+협력사가 가격을 제시할 때마다 봇이 **앵커링가** 기준으로 판정한다.
+재제안은 카드를 한 장씩 쓰며 **최대 3번**, 카드 소진·3번 초과에도 앵커 밑으로 못 내리면 실패(투찰 없음).
+
+```mermaid
+flowchart TD
+    P["협력사 가격 제시"] --> Q{"제시가 vs 앵커링가"}
+    Q -->|"≤ 앵커링가"| R["협상완료 — 투찰 확정"]
+    Q -->|"앵커 ~ 앵커×1.02"| S["와일드카드: 1% 인하 요청<br/>(세션당 1회)"]
+    Q -->|"앵커×1.02 초과"| T["협상 카드로 재제안"]
+    S --> U{"재제안 횟수 ≤ 3?<br/>카드 남음?"}
+    T --> U
+    U -->|"예"| P
+    U -->|"아니오 (소진·3번 초과)"| V["협상 실패 — 낙찰 후보 아님"]
+```
+
+### 3. 마감 판정
+
+마감 시 **협상완료 세션의 최저 투찰가**를 본다. 공통 전제: 완료 세션이 없거나(전원 미응찰·협상거부)
+동가 최저가 2곳 이상이면 유형과 무관하게 **개찰**. 그 외 단독 최저가일 때만 낙찰 후보가 되며,
+이후 판정이 유형별로 갈린다.
+
+#### 3-1. 견적 1:N — 단독 최저면 무조건 낙찰
+
+가격 구간을 보지 않는다. 생성 시 `mid/over_action`이 낙찰(AWARD)로 강제되기 때문.
+
+```mermaid
+flowchart TD
+    M1["마감: 협상완료 세션 최저 투찰가"] --> N1{"완료 세션 있나?"}
+    N1 -->|"없음 (전원 미응찰·협상거부)"| O1["개찰"]
+    N1 -->|"동가 최저 2곳+"| O1
+    N1 -->|"단독 최저"| X1["낙찰 (가격 구간 무관, 무조건)"]
+```
+
+#### 3-2. 협상 1:1 — 가격 구간별, 생성 때 정한 값 적용
+
+앵커링가 이하는 무조건 낙찰. 그 위 구간은 **견적 생성 때 미리 정해둔 값**(`mid_action`/`over_action`,
+1=낙찰·2=개찰)을 마감 시 그대로 적용한다. 두 필드는 적용 구간만 다를 뿐 동작은 동일.
+
+```mermaid
+flowchart TD
+    M2["마감: 협상완료 세션 최저 투찰가"] --> N2{"완료 세션 있나?"}
+    N2 -->|"없음 (전원 미응찰·협상거부)"| O2["개찰"]
+    N2 -->|"동가 최저 2곳+"| O2
+    N2 -->|"단독 최저"| W2{"투찰가 위치"}
+    W2 -->|"≤ 앵커링가"| X2["낙찰"]
+    W2 -->|"앵커 ~ 목표가"| Y2["생성 시 정한 mid_action 적용<br/>(1=낙찰 / 2=개찰)"]
+    W2 -->|"목표가 초과"| Z2["생성 시 정한 over_action 적용<br/>(1=낙찰 / 2=개찰)"]
+```
+
+> 개찰 = 낙찰자 미정 마감(결렬 아님). 개찰 후 수동 처리로 **직접 낙찰 확정**(`/v1/quotation/award`)
+> 또는 **재견적 재생성**(`/v1/quotation/regenerate`)이 있다.
+> 비즈니스 로직 정본은 [negodata/docs/business-logic.md](negodata/docs/business-logic.md).
 
 ## 빠른 시작
 
 ```bash
 # 1) DB 준비 (최초 1회) — 사용할 PostgreSQL 에 스키마 + 시드 적용
-psql -h 127.0.0.1 -p 5432 -U postgres -f postgres-init/00-init.sql     # 스키마 전체 (negosium_db + 도메인·learning·anchoring schema)
-psql -h 127.0.0.1 -p 5432 -U postgres -f postgres-init/temp-data.sql   # 임시 데이터 시드 (admin / admin1234)
+#    스키마 DDL (구 01~05 통합, 전부 IF NOT EXISTS 라 재실행 안전)
+psql -h 127.0.0.1 -p 5432 -U postgres -d negosium_db -f postgres-init/init-data/init.sql
+#    로컬/개발 시드 (admin / admin1234, 회사·유저·협상 카드)
+psql -h 127.0.0.1 -p 5432 -U postgres -d negosium_db -f postgres-init/init-data/init-data.sql
 
-# 2) 백엔드 기동
-docker compose up -d            # 두 backend (DB 는 config 대로 외부 연결)
-docker compose logs -f
+# (DBeaver 로 처음부터 새로 깔 때는 postgres-init/dbeaver/ 의 0~5 순서 스크립트를 쓴다:
+#  0 drop&create → 1 스키마 → 2 시드 → 3 lps_db → 4 카드 리셋 → 5 o2o OWNER 유저)
+
+# 2) 전체 기동
+docker compose up -d
+docker compose logs -f          # 컨테이너별 로그는 ./logs.sh 메뉴로도 확인
 docker compose down
 ```
 
+> 스키마 변경 보정은 `postgres-init/alters/` 의 날짜별 SQL 을 대상 DB 에 수동 적용한다
+> (postgres-init 은 DB 최초 생성 때만 자동 실행되므로, 기존 DB 엔 alter 를 직접 돌려야 새 컬럼이 반영된다).
+
 ## 테스트
 
 ```bash
 # config.test.toml 의 PostgreSQL(기본 127.0.0.1:5432) 이 떠 있어야 한다
-cd backend            # 또는 negodata/backend
+cd backend            # 또는 negodata/backend, agent, lps ...
 pip install pytest pytest-asyncio httpx
 python -m pytest
 ```
-- httpx `ASGITransport` 로 네트워크 없이 앱을 직접 호출하는 e2e (각 5개).
+- httpx `ASGITransport` 로 네트워크 없이 앱을 직접 호출하는 e2e.
 - `DB_SESSION_MNG` 싱글톤의 커넥션 풀이 첫 이벤트 루프에 묶이므로, 모든 테스트가 단일 session 루프를 공유한다(`pytest.ini`).
+- ⚠️ 테스트는 `APP_ENV=test` 로 격리한다(테스트 DB). dev DB(`negosium_db`)에 대고 돌리면 데이터가 날아간다.
 
 ## 성능 / 벤치마크
 
@@ -99,4 +234,9 @@ python -m locust -f loadtest/locustfile.py --host http://localhost:9300 --headle
 ```
 
 ## 기술 스택
-FastAPI · SQLAlchemy(async) · asyncpg · PostgreSQL 16 · python-jose(JWT) · bcrypt · uvicorn · Docker Compose
+- **백엔드**: FastAPI · SQLAlchemy(async) · asyncpg · PostgreSQL 16 · python-jose(JWT) · bcrypt · uvicorn
+- **프론트**: React · react-router v7 · Vite · TanStack Query (negosium-front 는 프로덕션 빌드 정적 서빙)
+- **에이전트**: 강화학습(Q-learning, learning 스키마) · OpenAI
+- **LPS**: 헤드풀 Chromium + Patchright(스텔스 Playwright 포크, 크롤) · autoheal
+- **배치**: Redis(anchoring 캐시) · 상주 스케줄러
+- **공통**: Docker Compose

agent/negotiation/cards/domain/tactics.py

@@ -1,120 +1,240 @@
-"""협상카드 전술 레지스트리 — "멘트 카드 → 전술 카드" 승격 (가격 행동 실행 계층).
+"""협상카드 전술 — "스크립트에 꽂힌 변수가 곧 전술" 계층.
 
-카드 멘트에 이미 설계된 카운터 가격 제시({target_price}·{middle_price} 등)를 시스템 상태로
-실행한다: 카드가 카운터가를 제시하면 pending_counter_price 로 적재되고, 협력사가 수락하면
-그 가격으로 즉시 타결된다(기존 wild_card_1pct 의 offer_1pct 패턴을 일반화).
+카드 멘트가 제시하는 가격({target_price}·{middle_price} 등)을 파싱해 시스템 상태로 실행한다:
+카드가 제안가를 제시하면 pending_counter_price 로 적재되고, 협력사가 수락하면 그 가격으로 타결된다.
 
-원칙:
-- 구매자(갑) 대리이므로 카운터는 항상 min(counter, target_price) 클램프 — 목표가 초과 제시 금지.
-- 협력사 제시가가 이미 카운터 이하면 카운터가 무의미 → None(HOLD 강등, 순수 설득).
-- 미등록 카드번호(테넌트 데모 NGC-B*, 회사 커스텀 COMP-* 등)는 HOLD 폴백 → 기존 동작 그대로.
+세 계층으로 나뉜다.
+  1) 스크립트 파싱  — 이 카드가 부를 금액이 무엇인지 (parse_offer_variable)
+  2) 변수 정의      — 그 금액을 지금 쓸 수 있는지 (OFFER_VARIABLES 의 계산식 + 유효조건)
+  3) tactic JSONB   — 문장으로 알 수 없는 운영 규칙 (min_round·closing)
 
-전술 정본은 이 코드 레지스트리다(v1). negodata 카드 편집은 멘트만 담당하고, 전술을 negodata
-에서 편집할 필요가 생기면 v2 에서 card.nego_cards 컬럼로 승격해 "DB 우선, 코드 폴백"으로 바꾼다.
+유효 조건은 카드가 아니라 '변수'에 붙인다 — 금액이 성립하는지는 계산식의 성질이지 카드의
+성질이 아니다. 새 변수는 OFFER_VARIABLES 에 한 줄 추가하면 코드 분기 없이 끝난다.
 """
 
+import re
 from dataclasses import dataclass
-from enum import Enum
-from typing import Any, Dict, Optional
+from typing import Any, Callable, Dict, Optional
+
+# 제안가 변수 — 우리가 새로 부르는 금액. 값은 (계산식, 재료 설명).
+# 여기 없는 치환 변수({prev_partner_price}·{internet_lowest_price} 등)는 읽어주기 전용이라
+# 제안가가 되지 않는다 — 과거값·외부값을 협력사에게 "수락하라"고 내밀 수 없기 때문.
+OFFER_VARIABLES: Dict[str, Callable[[float, float, float, float], Optional[float]]] = {
+    # (target, anchor, price, prev_customer) -> 제안가 | None(재료 없음)
+    "target_price": lambda target, anchor, price, prev: target,
+    "anchoring_price": lambda target, anchor, price, prev: anchor or None,
+    # negodata 카드 에디터 칩 표기(variables.ts) — DB 시드 표기(anchoring_price)와 같은 값의 별칭.
+    "anchor_price": lambda target, anchor, price, prev: anchor or None,
+    "target_mid_price": lambda target, anchor, price, prev: (anchor + target) / 2 if anchor else None,
+    "middle_price": lambda target, anchor, price, prev: (prev + price) / 2 if prev else None,
+}
+
+_TOKEN_RE = re.compile(r"\{([a-z_]+)\}")
+
+# 절충 계열 변수 — 양측 사이/우리 두 값 사이의 중간을 부르는 카드. 목표가 이상이면 미발동한다.
+_MID_VARIABLES = ("middle_price", "target_mid_price")
 
 
-class PriceAction(str, Enum):
-    HOLD = "hold"                            # 카운터 없음 — 재제안 요구(순수 설득, 기존 동작)
-    COUNTER_TARGET = "counter_target"        # 목표가 제시
-    COUNTER_ANCHOR = "counter_anchor"        # 앵커가 제시 (예산 상한 프레이밍)
-    COUNTER_TARGET_MID = "counter_target_mid"  # (anchor+target)/2 — 시드 {target_mid_price}
-    COUNTER_MID = "counter_mid"              # (갑 직전 포지션+협력사 제시가)/2 — 시드 {middle_price}
-    ONE_PCT = "one_pct"                      # 제시가 1% 인하 (기존 offer_1pct)
-
-
-@dataclass(frozen=True)
-class TacticSpec:
-    """카드 1장의 전술 명세.
-
-    min_round: 발동 가능 최소 라운드(협력사 가격 입력 횟수 기준).
-    max_price_ratio: input_price ≤ anchor×ratio 일 때만 발동 (None=무제한).
-    closing: 종결 국면(라운드 만료·카드 소진) 우선 전술.
-    """
-
-    price_action: PriceAction = PriceAction.HOLD
-    min_round: int = 1
-    max_price_ratio: Optional[float] = None
-    closing: bool = False
-
-
-_DEFAULT = TacticSpec()  # HOLD — 미등록 카드 폴백
-
-# 카드번호 → 전술. 시드(init-data.sql) 멘트의 가격 변수와 1:1 정합.
-#   NGC-001~006: 순수 설득(경쟁 압박/승인 핑계/관계/명분/공정성/TCO) — 가격 변수 없음.
-#   NGC-008: {internet_lowest_price} 인용이나 데이터 소스 미보유 → v1 HOLD (소스 확보 시 승격).
-_TACTICS: Dict[str, TacticSpec] = {
-    "NGC-007": TacticSpec(PriceAction.COUNTER_ANCHOR),                       # 예산 상한 안내
-    "NGC-009": TacticSpec(PriceAction.COUNTER_TARGET),                       # 조건부 가격 조정
-    "NGC-010": TacticSpec(PriceAction.COUNTER_TARGET),                       # 향후 거래 연계
-    "NGC-011": TacticSpec(PriceAction.COUNTER_TARGET),                       # 양보 가치 강조
-    "WC-01": TacticSpec(PriceAction.COUNTER_TARGET, min_round=1),            # 목표가 선제안
-    "WC-02": TacticSpec(PriceAction.COUNTER_TARGET_MID),                     # 역제안가 제시
-    "WC-03": TacticSpec(PriceAction.COUNTER_TARGET, closing=True),           # 최종 통보(최후통첩)
-    "WC-04": TacticSpec(PriceAction.COUNTER_TARGET, min_round=2),            # 단계적 인하 제안
-    "WC-05": TacticSpec(PriceAction.COUNTER_MID, closing=True),              # 중간값 절충(종결)
+# 세션 데이터에 따라 값이 없을 수 있는 읽기 전용 변수 → 그 값을 담는 컨텍스트 키.
+# 스크립트가 이런 변수를 인용하면 값이 있을 때만 카드가 나간다 — 없는데 나가면 협력사 채팅에
+# {internet_lowest_price} 토큰이 원형 노출된다(vars_for 가 미수집이면 키를 안 만드는 것과 짝).
+# 견적 생성 화면 게이팅(useCardGating)이 1차 방어, 여기가 2차(런타임) 방어다.
+_CONTEXT_REQUIRED_VARIABLES = {
+    "internet_lowest_price": "internet_lowest_price",
+    "internet_min_price": "internet_lowest_price",
 }
 
 
-def tactic_for(card_number: Optional[str]) -> TacticSpec:
-    """카드번호의 전술. 미등록/None 은 HOLD(기존 동작)."""
-    return _TACTICS.get(str(card_number), _DEFAULT) if card_number else _DEFAULT
+@dataclass(frozen=True)
+class CardSpec:
+    """카드 1장의 전술. 스크립트 파싱 결과 + tactic JSONB 를 합친 값.
 
-
-def tactic_available(spec: TacticSpec, context: Dict[str, Any]) -> bool:
-    """발동 조건 평가 — action space 마스킹용. HOLD(설득)는 언제나 가능."""
-    if spec.price_action is PriceAction.HOLD:
-        return True
-    rnd = int(context.get("round") or 0)
-    if rnd < spec.min_round:
-        return False
-    if spec.max_price_ratio is not None:
-        price = float(context.get("input_price") or 0)
-        anchor = float(context.get("anchor_price") or 0)
-        if anchor > 0 and price > anchor * spec.max_price_ratio:
-            return False
-    return True
-
-
-def compute_counter(spec: TacticSpec, context: Dict[str, Any]) -> Optional[int]:
-    """전술의 카운터 제시가 계산 (결정론).
-
-    - 항상 min(counter, target) 클램프 — 구매자는 목표가 초과로 제시하지 않는다.
-    - counter ≥ 협력사 제시가(input_price)면 카운터가 무의미(이미 더 싸게 제시받음) → None.
-    - 필요한 컨텍스트(target/anchor/제시가)가 없으면 None → 호출부가 HOLD 로 강등.
+    offer_variable: 이 카드가 제시할 금액의 변수명. None 이면 순수 설득 카드(HOLD).
+    min_round: 발동 가능 최소 라운드(협력사 가격 입력 횟수 기준).
+    closing: 종결 국면 전용 — 라운드 상한·카드 소진 시의 마지막 한 방으로만 쓴다.
+    requires: 스크립트가 인용한 세션-의존 변수의 컨텍스트 키 — 값이 없으면 미발동(토큰 노출 방지).
     """
-    action = spec.price_action
-    if action is PriceAction.HOLD:
+
+    offer_variable: Optional[str] = None
+    min_round: int = 1
+    closing: bool = False
+    requires: tuple = ()
+
+
+HOLD = CardSpec()  # 스펙을 못 찾은 카드(테넌트 데모·회사 커스텀)의 폴백 — 기존 동작(설득만) 유지
+
+
+def settle_ceiling(context: Dict[str, Any]) -> float:
+    """이 협상에서 받아줄 수 있는 최고가 — 타결 판정선이자 카드 제안가의 상한.
+
+    견적 생성 시 세션에 박제한 done_ceiling_price(= 목표가 × (1 + 타결상한율)) — 목표가를 조금
+    넘더라도 기존 단가보다 인하됐으면 타결시키기 위한 값. 박제가 없으면 목표가로 폴백한다.
+    """
+    return float(context.get("done_ceiling_price") or context.get("target_price") or 0)
+
+
+def parse_offer_variable(script: Optional[str]) -> Optional[str]:
+    """스크립트가 제시하는 제안가 변수. 없으면 None(설득 카드).
+
+    변수가 여럿이면 마지막에 등장하는 것이 제안가다 — 카드 문장은 배경을 먼저 깔고 실제 제안을
+    마지막에 하기 때문이다.
+    """
+    found = [m.group(1) for m in _TOKEN_RE.finditer(script or "") if m.group(1) in OFFER_VARIABLES]
+    return found[-1] if found else None
+
+
+def build_card_spec(script: Optional[str], tactic: Optional[dict] = None) -> CardSpec:
+    """스크립트 + tactic JSONB → CardSpec. tactic 이 비어 있으면 전부 기본값."""
+    t = tactic or {}
+    cited = {m.group(1) for m in _TOKEN_RE.finditer(script or "")}
+    return CardSpec(
+        # 파싱이 정본 카드 전부를 맞히므로 offer_variable 은 예외 카드용 override 로만 둔다.
+        offer_variable=t.get("offer_variable") or parse_offer_variable(script),
+        min_round=int(t.get("min_round") or 1),
+        closing=bool(t.get("closing")),
+        requires=tuple(sorted({_CONTEXT_REQUIRED_VARIABLES[v] for v in cited if v in _CONTEXT_REQUIRED_VARIABLES})),
+    )
+
+
+def spec_from_context(context: Dict[str, Any], number: Optional[str]) -> CardSpec:
+    """세션 컨텍스트에 적재된 카드 스펙(card_specs)에서 꺼낸다. 없으면 HOLD 폴백.
+
+    스펙은 협상 시작 시 1회 적재된다(negotiation_context_loader) — 진행 중인 협상은
+    카드 멘트가 도중에 바뀌어도 시작 시점 전술로 끝까지 간다.
+    """
+    if not number:
+        return HOLD
+    raw = (context.get("card_specs") or {}).get(str(number))
+    if not raw:
+        return HOLD
+    return CardSpec(
+        offer_variable=raw.get("offer_variable"),
+        min_round=int(raw.get("min_round") or 1),
+        closing=bool(raw.get("closing")),
+        requires=tuple(raw.get("requires") or ()),
+    )
+
+
+@dataclass(frozen=True)
+class Offer:
+    """확정된 제안 한 건 — 금액과 그 금액을 만든 재료를 함께 들고 다닌다.
+
+    멘트 치환이 재료를 다시 계산하지 않게 하기 위한 것 — 재계산하면 그 사이 갱신된
+    prev_customer 를 읽어 문장이 자기모순이 된다.
+    """
+
+    price: int             # 협력사에게 제시할 금액(수락 시 타결가)
+    variable: str          # 이 금액을 만든 멘트 변수
+    prev_customer: int     # 계산에 쓴 당사 직전 제안
+    prev_partner: int      # 계산에 쓴 협력사 제시가
+
+
+def record_offer(context: Dict[str, Any], offer: Offer) -> None:
+    """확정 제안을 세션에 기록한다 — 수락 판정용 금액과 멘트 치환용 재료를 한 자리에서 쓴다.
+
+    두 키를 항상 함께 써야 표시가와 타결가가 갈라지지 않으므로 기록 지점을 여기 하나로 묶는다.
+    """
+    context["pending_counter_price"] = offer.price
+    context["pending_offer"] = {
+        "price": offer.price, "variable": offer.variable,
+        "prev_customer": offer.prev_customer, "prev_partner": offer.prev_partner,
+    }
+    context["prev_customer_price"] = offer.price  # 갑의 최신 포지션 — 다음 라운드 계산·역행 금지 기준
+
+
+def compute_offer_detail(spec: CardSpec, context: Dict[str, Any]) -> Optional[Offer]:
+    """카드가 제시할 금액 + 그 계산에 쓴 재료. 쓸 수 없는 상황이면 None."""
+    price = int(float(context.get("input_price") or 0))
+    prev_customer = int(float(context.get("prev_customer_price") or context.get("anchor_price") or 0))
+    value = compute_offer(spec, context)
+    if value is None:
         return None
+    return Offer(price=value, variable=spec.offer_variable or "", prev_customer=prev_customer, prev_partner=price)
+
+
+def compute_offer(spec: CardSpec, context: Dict[str, Any]) -> Optional[int]:
+    """카드가 제시할 금액. 쓸 수 없는 상황이면 None → 호출부가 카드를 건너뛴다.
+
+    변수 공통 유효조건 (전부 만족해야 발동):
+      · 값 ≤ 타결 상한가    — 받아줄 수 없는 금액은 부르지 않는다. 넘으면 깎지 않고 미발동
+      · 값 < 협력사 제시가  — 이미 더 싸게 받았는데 더 비싼 값을 부를 이유가 없다
+      · 값 ≥ 당사 직전 제안 — 역행 금지. 제안 시퀀스는 앵커→…→목표가로 단조 수렴해야 한다
+    """
+    variable = spec.offer_variable
+    if not variable:
+        return None  # 설득 카드 — 제시할 금액 없음
+    calc = OFFER_VARIABLES.get(variable)
+    if calc is None:
+        return None  # 미등록 변수(오타·구버전 카드)
     target = float(context.get("target_price") or 0)
     anchor = float(context.get("anchor_price") or 0)
     price = float(context.get("input_price") or 0)
+    # 갑의 직전 포지션. 첫 카운터 전에는 앵커가 갑의 포지션이다.
+    prev_customer = float(context.get("prev_customer_price") or anchor or 0)
     if target <= 0 or price <= 0:
-        return None
+        return None  # 목표가·제시가 없이는 어떤 변수도 판정 불가
 
-    if action is PriceAction.COUNTER_TARGET:
-        counter = target
-    elif action is PriceAction.COUNTER_ANCHOR:
-        counter = anchor
-    elif action is PriceAction.COUNTER_TARGET_MID:
-        counter = (anchor + target) / 2 if anchor > 0 else target
-    elif action is PriceAction.COUNTER_MID:
-        # 갑의 직전 포지션(직전 카운터). 첫 카운터 전에는 앵커가 갑의 포지션이다.
-        prev_customer = float(context.get("prev_customer_price") or anchor or target)
-        counter = (prev_customer + price) / 2
-    elif action is PriceAction.ONE_PCT:
-        counter = price * 0.99
+    value = calc(target, anchor, price, prev_customer)
+    if not value or value <= 0:
+        return None  # 재료 부족(앵커 미박제·직전 제안 없음)
+    if value > settle_ceiling(context):
+        return None  # 타결 상한 초과 — 받아줄 수 없는 금액이라 지금 못 쓴다
+    if variable in _MID_VARIABLES and value >= target:
+        # 절충 계열은 목표가 미만일 때만 의미가 있다. 목표가 이상이면 "절반씩 나누자"면서 목표가를
+        # 부르는 꼴이라 미발동 — 목표가 제시는 목표가 카드(최후통첩)가 할 일이다.
+        return None
+    if variable in ("target_price", "anchoring_price", "anchor_price"):
+        # 원값 인용 변수 — 멘트엔 {target_price} 등 저장 원값이 그대로 나가므로, 반올림하면
+        # 표시가≠타결가 미스매치가 난다(목표가 7652 멘트 → 7650 타결). 저장값 그대로 제시.
+        offer = int(value)
     else:
-        return None
+        offer = int(value / 10 + 0.5) * 10  # 파생가(절충·중간) 10원 반올림 — 앵커·목표가 산정과 표기 통일
+    if offer >= price:
+        return None  # 제시가가 이미 그 값 이하 → 부를 이유 없음
+    if prev_customer and offer < prev_customer:
+        return None  # 역행 금지 — 한번 부른 금액 아래로 되돌아가지 않는다(같은 금액 재제시는 허용)
+    return offer
 
-    if counter <= 0:
-        return None
-    counter = min(counter, target)          # 목표가 초과 제시 금지 (가드레일)
-    counter_i = int(round(counter))
-    if counter_i >= price:
-        return None                          # 제시가가 이미 카운터 이하 → 카운터 무의미
-    return counter_i
+
+def available(spec: CardSpec, context: Dict[str, Any], *, closing_phase: bool = False) -> bool:
+    """지금 이 카드를 꺼낼 수 있는지 — 금액과 무관한 조건들.
+
+    · 이미 쓴 카드는 다시 안 나간다(전 카드 공통 규칙 — 협상카드/와일드카드 구분 없음)
+    · 종결 전용 카드는 종결 국면에서만, 종결 국면에선 종결 전용 카드만
+    · min_round 미만이면 아직 이르다
+    · 스크립트가 인용한 세션-의존 변수(인터넷 최저가 등)가 결측이면 미발동 — 토큰 원형 노출 방지
+    """
+    if spec.closing != closing_phase:
+        return False
+    if int(context.get("round") or 0) < spec.min_round:
+        return False
+    return all(context.get(key) for key in spec.requires)
+
+
+def playable(spec: CardSpec, context: Dict[str, Any], *, closing_phase: bool = False) -> bool:
+    """이 카드를 지금 실제로 플레이할 수 있는지 — available + (금액 카드는) 제안가 유효까지.
+
+    금액을 인용하는 카드(offer_variable 있음)는 그 금액을 못 부르는 상황이면 설득 폴백으로도
+    내보내지 않는다 — 멘트에 무효한 금액(직전 제안보다 낮은 앵커, 제시가보다 높은 목표가)이
+    글자로 박혀 나가 역행/모순 서사가 되기 때문. 설득 카드는 금액이 없으니 무관.
+    """
+    if not available(spec, context, closing_phase=closing_phase):
+        return False
+    if not spec.offer_variable:
+        return True
+    return compute_offer(spec, context) is not None
+
+
+def is_played(context: Dict[str, Any], number: Optional[str]) -> bool:
+    """이 카드를 이 협상에서 이미 썼는지. 와일드 진입·종결·협상카드가 같은 이력을 본다."""
+    return bool(number) and str(number) in (context.get("played_card_numbers") or [])
+
+
+def mark_played(context: Dict[str, Any], number: Optional[str]) -> None:
+    """카드를 실제로 내보낸 시점에 이력에 남긴다(노출되지 않은 후보는 남기지 않는다)."""
+    if not number:
+        return
+    played = list(context.get("played_card_numbers") or [])
+    if str(number) not in played:
+        played.append(str(number))
+    context["played_card_numbers"] = played

agent/negotiation/chat/infra/repository/nego_context_crud.py

@@ -23,10 +23,43 @@ _SESSIONS = table(
     "sessions",
     column("session_id"), column("quotation_id"), column("item_id"), column("supplier_id"),
     column("qt_type"), column("target_price"), column("anchoring_price"),
+    column("done_ceiling_price"),   # 타결 상한가 — 견적 생성 시 박제(목표가×(1+타결상한율))
+    column("qt_setting_id"),
     column("deleted"),
     schema="negotiation",
 )
-_ITEMS = table("items", column("item_id"), column("name"), column("price"), column("deleted"), schema="partner")
+# 견적 설정 — card_count(협상 내 협상카드 사용 횟수 상한) 조회용.
+_QUOTATION_SETTINGS = table(
+    "quotation_settings",
+    column("qt_setting_id"), column("card_count"), column("deleted"),
+    schema="quotation",
+)
+_ITEMS = table("items", column("item_id"), column("name"), column("price"), column("purchase_price"),
+               column("company_id"), column("internet_lowest_price"), column("deleted"), schema="partner")
+# 고객사 설정(companies.settings) — 협상 기준가로 쓸 가격 컬럼을 여기서 정한다.
+_COMPANIES = table("companies", column("company_id"), column("settings"), column("deleted"), schema="company")
+
+# 협상 기준가 후보 컬럼. 어느 컬럼을 고르든 공급사 화면 호칭은 '공급가'로 고정한다 —
+# 같은 돈을 고객사는 매입가·상품 단가 등으로 부르지만 챗은 공급사가 보는 화면이라
+# 공급사 관점 용어 하나만 쓴다. 회사 용어 사전(labels)은 관리자 화면 전용.
+_BASELINE_PRICE = "price"
+_BASELINE_PURCHASE = "purchase_price"
+_SUPPLIER_PRICE_LABEL = "공급가"
+
+
+def _resolve_baseline(settings: dict) -> str:
+    """회사 설정 → 협상 기준가로 쓸 items 컬럼명.
+
+    1순위는 관리자가 회사 설정에서 고른 값(features.nego_baseline_field).
+    미설정 회사는 공급가가 기본이되, 공급가를 화면에서 감췄다면 그 회사는 공급가를 관리하지
+    않는다는 뜻이므로 매입가로 폴백한다 — 설정 화면이 생기기 전에 만들어진 회사를 위한 안전망."""
+    chosen = (settings.get("features") or {}).get("nego_baseline_field")
+    if chosen in (_BASELINE_PRICE, _BASELINE_PURCHASE):
+        return chosen
+    hidden = set(settings.get("hidden_fields") or [])
+    if "price" in hidden and "purchase_price" not in hidden:
+        return _BASELINE_PURCHASE
+    return _BASELINE_PRICE
 _SUPPLIERS = table("suppliers", column("supplier_id"), column("name"), column("total_revenue"), column("deleted"), schema="partner")
 _QUOTATIONS = table(
     "quotations",
@@ -45,12 +78,13 @@ _VERSION_WILD_CARDS = table(
 )
 _NEGO_CARDS = table(
     "nego_cards",
-    column("nego_card_id"), column("number"), column("deleted"),
+    column("nego_card_id"), column("number"), column("script"), column("tactic"), column("deleted"),
     schema="card",
 )
 _WILD_CARDS = table(
     "wild_cards",
-    column("wild_card_id"), column("number"), column("deleted"),
+    column("wild_card_id"), column("number"), column("script"), column("tactic"), column("deleted"),
+    column("available"),
     schema="card",
 )
 # 상품↔협력사 매핑 (2026-07-07 신설): supply_type = 이 협력사가 이 상품을 공급하는 방식(SupplierType).
@@ -64,12 +98,28 @@ _SUPPLIER_ITEMS = table(
 class INegoContextCRUD(ABC):
     @abstractmethod
     async def get_session_row(self, cdb: AsyncSession, session_id) -> Tuple[ErrorType, Optional[tuple]]:
-        """세션 행 (qt_type, target_price, anchoring_price, item_id, quotation_id, supplier_id). 없으면 None."""
+        """세션 행 (qt_type, target_price, anchoring_price, done_ceiling_price, item_id, quotation_id, supplier_id). 없으면 None."""
         pass
 
     @abstractmethod
-    async def get_item_price(self, cdb: AsyncSession, item_id) -> Tuple[ErrorType, int]:
-        """품목 기준가(items.price). 없으면 0."""
+    async def get_item_baseline(self, cdb: AsyncSession, item_id) -> Tuple[ErrorType, Tuple[int, str, dict]]:
+        """협상 기준가·그 호칭·회사 용어 사전 (가격, 호칭, labels).
+
+        어느 컬럼을 기준가로 쓰는지는 회사 설정(features.nego_baseline_field)이 정한다.
+        labels 는 companies.settings.labels 원본 — 협상 스크립트의 용어 토큰 치환에 쓴다.
+        값이 없으면 (0, 호칭, {})."""
+        pass
+
+    @abstractmethod
+    async def get_card_count(self, cdb: AsyncSession, session_id) -> Tuple[ErrorType, Optional[int]]:
+        """협상카드 사용 횟수 상한(quotation_settings.card_count) — 세션의 qt_setting_id 로 조인.
+        설정이 없으면 None(호출부가 상한 미적용). 이 값이 협상 중 실제로 플레이 가능한 협상카드 수를 캡한다."""
+        pass
+
+    @abstractmethod
+    async def get_item_lowest_price(self, cdb: AsyncSession, item_id) -> Tuple[ErrorType, int]:
+        """상품 인터넷 최저가(items.internet_lowest_price — LPS 수집 대표값). 미수집이면 0.
+        카드 스크립트 {internet_lowest_price} 치환용(NGC-008 등 시장가 인용 카드)."""
         pass
 
     @abstractmethod
@@ -104,8 +154,9 @@ class INegoContextCRUD(ABC):
         pass
 
     @abstractmethod
-    async def get_quotation_card_numbers(self, cdb: AsyncSession, quotation_id) -> Tuple[ErrorType, tuple[list[str], list[str]]]:
-        """견적 version_id 에 연결된 (일반카드 번호 목록, 와일드카드 번호 목록). 없으면 빈 목록."""
+    async def get_quotation_card_numbers(self, cdb: AsyncSession, quotation_id) -> Tuple[ErrorType, tuple[list[tuple], list[tuple]]]:
+        """견적 version_id 에 연결된 (일반카드 행 목록, 와일드카드 행 목록). 없으면 빈 목록.
+        행 = (number, script, tactic) — 스크립트 파싱 + tactic JSONB 로 카드 전술(CardSpec)을 만든다."""
         pass
 
 
@@ -114,6 +165,7 @@ class NegoContextCRUD(INegoContextCRUD):
         try:
             query = (
                 select(_SESSIONS.c.qt_type, _SESSIONS.c.target_price, _SESSIONS.c.anchoring_price,
+                       _SESSIONS.c.done_ceiling_price,
                        _SESSIONS.c.item_id, _SESSIONS.c.quotation_id, _SESSIONS.c.supplier_id)
                 .where(_SESSIONS.c.session_id == session_id, _SESSIONS.c.deleted == False)  # noqa: E712
                 .limit(1)
@@ -126,14 +178,61 @@ class NegoContextCRUD(INegoContextCRUD):
             LOG.e_no_callstack(ex)
             return ErrorType.DB_RUN_FAILED, None
 
-    async def get_item_price(self, cdb: AsyncSession, item_id) -> Tuple[ErrorType, int]:
+    async def get_item_baseline(self, cdb: AsyncSession, item_id) -> Tuple[ErrorType, Tuple[int, str, dict]]:
+        _fallback = (0, _SUPPLIER_PRICE_LABEL, {})
         try:
+            # 상품 + 소속 고객사 설정 한 번에. 회사가 없어도(데이터 이상) 상품 행은 나오도록 outer join.
             query = (
-                select(_ITEMS.c.price)
+                select(_ITEMS.c.price, _ITEMS.c.purchase_price, _COMPANIES.c.settings)
+                .select_from(_ITEMS.outerjoin(_COMPANIES, _ITEMS.c.company_id == _COMPANIES.c.company_id))
                 .where(_ITEMS.c.item_id == item_id, _ITEMS.c.deleted == False)  # noqa: E712
                 .limit(1)
             )
-            err_type, rows = await DB_SESSION_MNG.execute(cdb, query, "get_item_price failed.", raise_error=False)
+            err_type, rows = await DB_SESSION_MNG.execute(cdb, query, "get_item_baseline failed.", raise_error=False)
+            if err_type != ErrorType.SUCCESS or not rows:
+                return err_type, _fallback
+            # 컬럼이 2개 이상이면 execute 가 행 리스트를 준다(1개일 때만 스칼라 리스트).
+            price, purchase_price, settings = rows[0]
+            settings = settings if isinstance(settings, dict) else {}
+            labels = settings.get("labels") or {}
+            field = _resolve_baseline(settings)
+            value = purchase_price if field == _BASELINE_PURCHASE else price
+            return ErrorType.SUCCESS, (int(value or 0), _SUPPLIER_PRICE_LABEL, labels)
+        except Exception as ex:
+            LOG.e_no_callstack(ex)
+            return ErrorType.DB_RUN_FAILED, _fallback
+
+    async def get_card_count(self, cdb: AsyncSession, session_id) -> Tuple[ErrorType, Optional[int]]:
+        try:
+            query = (
+                select(_QUOTATION_SETTINGS.c.card_count)
+                .select_from(
+                    _SESSIONS.join(
+                        _QUOTATION_SETTINGS,
+                        _QUOTATION_SETTINGS.c.qt_setting_id == _SESSIONS.c.qt_setting_id,
+                    )
+                )
+                .where(_SESSIONS.c.session_id == session_id,
+                       _SESSIONS.c.deleted == False,  # noqa: E712
+                       _QUOTATION_SETTINGS.c.deleted == False)  # noqa: E712
+                .limit(1)
+            )
+            err_type, rows = await DB_SESSION_MNG.execute(cdb, query, "get_card_count failed.", raise_error=False)
+            if err_type != ErrorType.SUCCESS or not rows or rows[0] is None:
+                return err_type, None
+            return ErrorType.SUCCESS, int(rows[0])
+        except Exception as ex:
+            LOG.e_no_callstack(ex)
+            return ErrorType.DB_RUN_FAILED, None
+
+    async def get_item_lowest_price(self, cdb: AsyncSession, item_id) -> Tuple[ErrorType, int]:
+        try:
+            query = (
+                select(_ITEMS.c.internet_lowest_price)
+                .where(_ITEMS.c.item_id == item_id, _ITEMS.c.deleted == False)  # noqa: E712
+                .limit(1)
+            )
+            err_type, rows = await DB_SESSION_MNG.execute(cdb, query, "get_item_lowest_price failed.", raise_error=False)
             if err_type != ErrorType.SUCCESS or not rows or not rows[0]:
                 return err_type, 0
             return ErrorType.SUCCESS, int(rows[0])
@@ -231,7 +330,7 @@ class NegoContextCRUD(INegoContextCRUD):
             LOG.e_no_callstack(ex)
             return ErrorType.DB_RUN_FAILED, 0
 
-    async def get_quotation_card_numbers(self, cdb: AsyncSession, quotation_id) -> Tuple[ErrorType, tuple[list[str], list[str]]]:
+    async def get_quotation_card_numbers(self, cdb: AsyncSession, quotation_id) -> Tuple[ErrorType, tuple[list[tuple], list[tuple]]]:
         try:
             version_q = (
                 select(_QUOTATIONS.c.version_id)
@@ -246,7 +345,7 @@ class NegoContextCRUD(INegoContextCRUD):
             version_id = rows[0]
 
             nego_q = (
-                select(_NEGO_CARDS.c.number)
+                select(_NEGO_CARDS.c.number, _NEGO_CARDS.c.script, _NEGO_CARDS.c.tactic)
                 .select_from(
                     _VERSION_NEGO_CARDS.join(
                         _NEGO_CARDS,
@@ -265,7 +364,7 @@ class NegoContextCRUD(INegoContextCRUD):
                 return n_err, ([], [])
 
             wild_q = (
-                select(_WILD_CARDS.c.number)
+                select(_WILD_CARDS.c.number, _WILD_CARDS.c.script, _WILD_CARDS.c.tactic)
                 .select_from(
                     _VERSION_WILD_CARDS.join(
                         _WILD_CARDS,
@@ -276,6 +375,8 @@ class NegoContextCRUD(INegoContextCRUD):
                     _VERSION_WILD_CARDS.c.version_id == version_id,
                     _VERSION_WILD_CARDS.c.deleted == False,  # noqa: E712
                     _WILD_CARDS.c.deleted == False,  # noqa: E712
+                    # 협상 적용 여부(카드 설정 '적용 대기(수동)') — 꺼진 카드는 견적에 담겨 있어도 발동 금지
+                    _WILD_CARDS.c.available == True,  # noqa: E712
                 )
                 .order_by(_VERSION_WILD_CARDS.c.created_at)
             )
@@ -284,8 +385,8 @@ class NegoContextCRUD(INegoContextCRUD):
                 return w_err, ([], [])
 
             return ErrorType.SUCCESS, (
-                [str(r) for r in n_rows if r is not None],
-                [str(r) for r in w_rows if r is not None],
+                [(str(r[0]), r[1], r[2]) for r in n_rows if r[0] is not None],
+                [(str(r[0]), r[1], r[2]) for r in w_rows if r[0] is not None],
             )
         except Exception as ex:
             LOG.e_no_callstack(ex)

agent/negotiation/chat/service/chat_engine.py

@@ -10,10 +10,16 @@ import re
 from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional
 
-from negotiation.cards.domain.tactics import compute_counter, tactic_for
+from negotiation.cards.domain.tactics import (
+    OFFER_VARIABLES, Offer, available, compute_offer_detail, is_played, mark_played, playable,
+    record_offer, settle_ceiling, spec_from_context,
+)
 from negotiation.chat.service.script_repository import ScriptRepository
 
 MAX_ROUNDS = 3   # config 미주입 시 폴백 (규칙 정본은 tenant config negotiation.max_counter_rounds)
+# 멘트에 찍히는 파생 가격 — 값이 다른 값에서 계산돼 나오는 것들(원값 인용 target/anchor 는 제외).
+_DERIVED_PRICE_VARIABLES = ("target_mid_price", "middle_price")
+
 _PRICE_MODES = ("price",)
 _CHOICE_MODES = ("yes_no", "confirm", "delivery_type")
 
@@ -43,6 +49,39 @@ def _parse_price(user_input: Any) -> Optional[float]:
     return price if price > 0 else None
 
 
+# 협상 스크립트가 쓰는 용어 토큰: {label_*} = 회사 용어(없으면 기본값).
+# 값은 negodata 용어 카탈로그(LABEL_CATALOG)의 base 와 같아야 화면·멘트 표기가 갈리지 않는다.
+_SCRIPT_LABELS = {
+    "label_supplier": ("supplier", "협력사"),
+    "label_target_price": ("target_price", "목표가"),
+    "label_delivery_type": ("item.delivery_type", "배송 형태"),
+    "label_delivery_type_1": ("delivery_type.1", "협력사배송"),
+    "label_delivery_type_2": ("delivery_type.2", "지정택배배송"),
+    "label_delivery_type_3": ("delivery_type.3", "픽업배송"),
+    "label_product": ("item.name", "상품명"),
+}
+# 협상 기준가 호칭 — 공급사 화면 고정 용어. 회사 용어 사전(labels)을 타지 않는다(그건 관리자 화면 전용).
+#   실제 값은 loader 가 컨텍스트에 박제하고, DB 컨텍스트가 없는 데모/직접호출 경로만 이 폴백을 쓴다.
+_SUPPLIER_PRICE_LABEL = "공급가"
+# 조사 자동 보정: 토큰 뒤에 조사가 붙는 자리는 {label_supplier_를} 처럼 대표형을 적는다.
+# 회사가 바꾼 용어의 받침을 예측할 수 없어 스크립트에 조사를 고정할 수 없다("협력사를"/"공급업체을").
+_JOSA = {"은": ("은", "는"), "는": ("은", "는"), "이": ("이", "가"), "가": ("이", "가"),
+         "을": ("을", "를"), "를": ("을", "를"), "과": ("과", "와"), "와": ("과", "와")}
+
+
+def _has_batchim(word: str) -> bool:
+    last = word[-1] if word else ""
+    return "가" <= last <= "힣" and (ord(last) - 0xAC00) % 28 != 0
+
+
+def _josa(word: str, form: str) -> str:
+    """단어 + 받침에 맞는 조사. form 은 대표형('를'·'는'·'가'·'와')."""
+    pair = _JOSA.get(form)
+    if not pair:
+        return word
+    return word + (pair[0] if _has_batchim(word) else pair[1])
+
+
 @dataclass
 class ChatSession:
     session_id: str
@@ -96,8 +135,9 @@ class ChatEngine:
             if price is None:
                 return self._error(session, "가격을 숫자로 입력해 주세요.")
             session.context["input_price"] = price
-            # 새 가격 제시 = 직전 카운터 제안 거절 확정 → 대기 중 카운터 폐기.
+            # 새 가격 제시 = 직전 카운터 제안 거절 확정 → 대기 중 카운터·그 재료 폐기.
             session.context.pop("pending_counter_price", None)
+            session.context.pop("pending_offer", None)
             session.context["prev_partner_price"] = price
             # 협력사 첫 제시가 — 가격 수용률(첫 제시가 대비 양보율) 동적 계산의 기준값.
             session.context.setdefault("first_offer_price", price)
@@ -115,6 +155,7 @@ class ChatEngine:
         #  원 제시가 수락 종결 — 는 카운터를 버리고 기존 input_price 로 타결한다.)
         if mode in _CHOICE_MODES and nxt in _SUCCESS_STEPS:
             pending = session.context.pop("pending_counter_price", None)
+            session.context.pop("pending_offer", None)
             if pending and user_input in _ACCEPT_INPUTS:
                 session.context["input_price"] = float(pending)
         return self._render(session, nxt)
@@ -169,6 +210,15 @@ class ChatEngine:
                             and price <= anchor * self.rules.wildcard_entry_ratio)
                     )
                 )
+                # 구간에 들어와도 실제로 낼 카드가 없으면(전부 종결 전용·사용됨·유효조건 미달) 이 조건은
+                # 불충족으로 두고 다음 조건(우선협상·소진 판정)을 평가한다 — 여기서 매칭돼 버리면
+                # 카드 소진 판정이 영영 돌지 않아, 빈 덱에서 쓴 카드를 또 꺼내는 무한 협상이 된다.
+                if ok:
+                    probe = ChatSession(
+                        session_id=session.session_id, tenant_id=session.tenant_id,
+                        company_id=session.company_id, context=dict(ctx),
+                    )
+                    ok = self._pick_wildcard(probe) != "가격협상"
             elif cond == "check_is_supplier_type_c":
                 ok = False  # 공급사 유형 미보유 (PoC 단순화)
             elif cond == "check_price_match":   # = 우선협상: 제시가가 앵커가 이하
@@ -181,13 +231,27 @@ class ChatEngine:
                 #   ② 종결 전술까지 소진(closing_played)이면 → 최종 제시가 ≤ target 은 타결,
                 #      초과는 결렬(협상실패) — "목표가 초과 타결 금지" 가드레일과 정합.
                 counter_rounds = max(0, ctx.get("round", 0) - 1)
-                exhausted = counter_rounds >= self.rules.max_counter_rounds or (cards_total > 0 and cards_used >= cards_total)
+                # 담은 협상카드 중 지금 낼 수 있는 게 하나도 없으면(사용됨·발동조건 미달 — 예:
+                # 시장가 인용 카드인데 최저가 결측) 장수와 무관하게 소진으로 본다 — 안 그러면
+                # 선택 마스크가 전부 막힌 채 폴백이 부적합 카드를 억지로 꺼낸다(토큰 노출).
+                selected = ctx.get("selected_nego_card_numbers") or []
+                none_playable = bool(selected) and not any(
+                    not is_played(ctx, n) and playable(spec_from_context(ctx, n), ctx)
+                    for n in selected
+                )
+                exhausted = (
+                    counter_rounds >= self.rules.max_counter_rounds
+                    or (cards_total > 0 and cards_used >= cards_total)
+                    or none_playable
+                )
                 if exhausted:
-                    target = ctx.get("target_price", 0)
+                    # 타결선은 목표가가 아니라 타결 상한가(견적 생성 시 박제) — 목표가를 넘어도
+                    # 상한 이내면 타결한다.
+                    ceiling = settle_ceiling(ctx)
                     if not ctx.get("closing_played"):
                         ctx["force_closing"] = True
                         return "가격협상"
-                    return "협상완료" if (target > 0 and price <= target) else c.get("next")
+                    return "협상완료" if (ceiling > 0 and price <= ceiling) else c.get("next")
                 ok = False
             elif cond == "default":
                 ok = True
@@ -197,32 +261,42 @@ class ChatEngine:
 
     def _pick_wildcard(self, session: ChatSession) -> str:
         """앵커가에 아주 근접(≤ anchor×wildcard_1pct_ratio)한 구간에서만 1% 인하 요청(wild_card_1pct)으로
-        앵커가 이하로 유도한다. 그 외 구간은 일반 가격협상(카드 플레이)으로 돌린다.
-
-        과거 여기서 반환하던 '재원부족'(wild_card_budget) 하드코딩 카드는 제거했다 —
-        견적에서 실제 선택한 와일드카드(중간값 절충·목표가 선제안 등)와 매핑되지 않은 채
-        '와일드카드를 하나라도 골랐으면' 조건만으로 발동해, 선택하지도 않은 재원부족 멘트가
-        노출되는 오작동이 있었다.
+        앵커가 이하로 유도한다. 그 외 구간은 견적에서 선택한 와일드카드의 전술로 카운터하고,
+        낼 카드가 없으면 일반 가격협상(카드 플레이)으로 돌린다.
         """
         ctx = session.context
         price = ctx.get("input_price", 0)
         anchor = ctx.get("anchor_price", 0)
+        target = ctx.get("target_price", 0)
         if anchor > 0 and price <= anchor * self.rules.wildcard_1pct_ratio:
-            # 와일드카드는 실제로 노출할 때만 '사용됨'으로 마킹한다 — 가격협상으로 돌아가는
-            # 경우에도 마킹하면 이후 라운드에서 정당한 1% 카드까지 억제된다.
-            ctx["wildcard_used"] = True
-            ctx["offer_1pct"] = int(round(price * 0.99))  # 1% 인하가 (멘트 변수)
-            ctx["pending_counter_price"] = ctx["offer_1pct"]  # 수락 시 이 가격으로 타결
-            return "wild_card_1pct"
+            offer_1pct = int(price * 0.99 / 10 + 0.5) * 10  # 1% 인하가 — 10원 반올림(앵커·카운터와 통일)
+            # 제안가 공통 유효조건(≤목표가 · <제시가 · 직전 당사 제안 이상=역행 금지)은 시스템 1% 카드에도
+            # 동일하게 건다. 기본 앵커 밴드에선 수학적으로 항상 통과하지만 극단 데이터를 방어한다.
+            prev_customer = ctx.get("prev_customer_price") or 0
+            if 0 < offer_1pct < price and (target <= 0 or offer_1pct <= target) and offer_1pct >= prev_customer:
+                # 와일드카드는 실제로 노출할 때만 '사용됨'으로 마킹한다 — 가격협상으로 돌아가는
+                # 경우에도 마킹하면 이후 라운드에서 정당한 1% 카드까지 억제된다.
+                ctx["wildcard_used"] = True
+                ctx["offer_1pct"] = offer_1pct
+                record_offer(ctx, Offer(price=offer_1pct, variable="offer_1pct",
+                                        prev_customer=int(prev_customer or anchor), prev_partner=int(price)))
+                return "wild_card_1pct"
         # 1.02 초과 ~ entry(1.05) 구간: 견적에서 선택한 와일드카드의 전술로 카운터 제시.
         #   (구현 전에는 이 구간이 일반 가격협상으로 회귀해 선택형 WC 가 영영 발동하지 않던 갭.)
         if anchor > 0 and price <= anchor * self.rules.wildcard_entry_ratio:
             for number in (ctx.get("selected_wild_card_numbers") or []):
-                counter = compute_counter(tactic_for(str(number)), ctx)
-                if counter is not None:
+                number = str(number)
+                spec = spec_from_context(ctx, number)
+                # 종결 전용 카드(최종 통보·중간값 절충)는 여기서 안 꺼낸다 — 종결 국면의 마지막 한 방으로 예약.
+                # 이미 쓴 카드도 제외(같은 멘트 반복 방지).
+                if not available(spec, ctx) or is_played(ctx, number):
+                    continue
+                offer = compute_offer_detail(spec, ctx)
+                if offer is not None:
                     ctx["wildcard_used"] = True
-                    ctx["pending_counter_price"] = counter
-                    ctx["active_wild_card_number"] = str(number)
+                    record_offer(ctx, offer)
+                    ctx["active_wild_card_number"] = number
+                    mark_played(ctx, number)
                     return "wild_card_dynamic"
         return "가격협상"
 
@@ -240,6 +314,19 @@ class ChatEngine:
         if "anchor_price" in ctx:
             # anchoring_price = DB 시드 기본 카드/sessions 컬럼 표기, anchor_price = 카드 에디터 표기.
             out["anchor"] = out["anchor_price"] = out["anchoring_price"] = int(ctx["anchor_price"])
+        # 용어 토큰 — 회사 용어 사전(labels)이 있으면 그 단어, 없으면 카탈로그 기본값.
+        #   조사가 붙는 자리를 위해 {label_supplier_를} 같은 파생 키도 함께 만든다.
+        labels = ctx.get("labels") or {}
+        for token, (label_key, fallback) in _SCRIPT_LABELS.items():
+            word = labels.get(label_key) or fallback
+            out[token] = word
+            for form in ("는", "가", "를", "와"):
+                out[f"{token}_{form}"] = _josa(word, form)
+        # 기준가 호칭은 회사 용어가 아니라 공급사 관점 고정 — loader 박제값(없으면 '공급가').
+        price_word = str(ctx.get("item_price_label") or _SUPPLIER_PRICE_LABEL)
+        out["label_item_price"] = price_word
+        for form in ("는", "가", "를", "와"):
+            out[f"label_item_price_{form}"] = _josa(price_word, form)
         # 카드 에디터 카탈로그의 협력사명/상품명(partner_name·product_name) 치환.
         if ctx.get("partner_name"):
             out["partner_name"] = str(ctx["partner_name"])
@@ -247,35 +334,57 @@ class ChatEngine:
             out["product_name"] = str(ctx["product_name"])
         if "offer_1pct" in ctx:
             out["offer_1pct"] = int(ctx["offer_1pct"])
-        # 전술 카운터 변수(카드 시드 멘트의 가격 변수) — tactics.compute_counter 산식과 동일 정의.
+        # 인터넷 최저가: LPS 대표값(items.internet_lowest_price). 카드는 {internet_lowest_price},
+        #   라벨 매핑(variable_mapping.json)은 internet_min_price 를 쓰므로 target/anchor 처럼 양쪽 이름 모두 채운다.
+        #   미수집(0/없음)이면 키를 만들지 않는다 — 원형 유지 → 허위 시장가 인용 방지(NGC-008 은 값 있을 때만 유효).
+        ilp = ctx.get("internet_lowest_price") or 0
+        if ilp > 0:
+            out["internet_lowest_price"] = out["internet_min_price"] = int(ilp)
+        # 전술 카운터 변수(카드 시드 멘트의 가격 변수) — tactics.OFFER_VARIABLES 산식과 동일 정의.
         anchor = ctx.get("anchor_price") or 0
         target = ctx.get("target_price") or 0
-        if "input_price" in ctx:
-            out["prev_partner_price"] = int(ctx.get("prev_partner_price") or ctx["input_price"])
-        prev_customer = ctx.get("prev_customer_price") or anchor
+        # 표시 기준값 — 제안이 확정된 턴이면 그 계산에 쓴 재료(pending_offer)를 쓴다.
+        #   prev_customer_price 는 확정 즉시 새 제안가로 갱신되므로, 그대로 읽으면 멘트가
+        #   "당사 제안과 귀사 제안의 절반이 당사 제안" 같은 자기모순이 된다.
+        pending_offer = ctx.get("pending_offer") or {}
+        prev_customer = int(pending_offer.get("prev_customer") or ctx.get("prev_customer_price") or anchor or 0)
+        partner_price = int(pending_offer.get("prev_partner") or ctx.get("prev_partner_price") or ctx.get("input_price") or 0)
+        offer_price = int(pending_offer.get("price") or ctx.get("pending_counter_price") or 0)
+        offer_variable = pending_offer.get("variable") or ""
         if prev_customer:
-            out["prev_customer_price"] = int(prev_customer)
-        if anchor and target:
-            out["target_mid_price"] = int(round((anchor + target) / 2))
-        if prev_customer and "input_price" in ctx:
-            out["middle_price"] = int(round((prev_customer + ctx["input_price"]) / 2))
-        if ctx.get("pending_counter_price"):
-            out["counter_price"] = int(ctx["pending_counter_price"])
-        # 인하율 = (기존 공급가(상품단가) - 제시가) / 기존 공급가 * 100. 기존가 없으면 미표시(0.0).
-        #   제시가가 기존가보다 높으면(인상 제시) 음수가 나오는데, "-1.3% 인하된 금액" 같은
+            out["prev_customer_price"] = prev_customer
+        if partner_price:
+            out["prev_partner_price"] = partner_price
+        if offer_price:
+            out["counter_price"] = offer_price
+        # 파생 가격(절충가·중간가) — 제안가로 확정된 변수는 그 금액을 그대로 쓴다(멘트에 보이는 금액과
+        #   수락 시 타결가는 항상 같아야 한다). 나머지는 참고 인용이므로 tactics 산식으로 채운다.
+        #   산식을 여기 복사해 두면 갱신 시점 차이로 표시가와 제안가가 갈라지므로 정의를 호출만 한다.
+        #   어느 변수가 제안가인지 모르는 진행 중 세션(구버전 기록)은 종전대로 전부 제안가로 고정한다.
+        for name in _DERIVED_PRICE_VARIABLES:
+            if offer_price and (name == offer_variable or not offer_variable):
+                out[name] = offer_price
+                continue
+            value = OFFER_VARIABLES[name](target, anchor, partner_price, prev_customer)
+            if value:
+                out[name] = int(value / 10 + 0.5) * 10  # 10원 반올림 — compute_offer 와 동일
+        # 인하율 = (협상 기준가 - 제시가) / 기준가 * 100. 기준가 없으면 미표시(0.0).
+        #   제시가가 기준가보다 높으면(인상 제시) 음수가 나오는데, "-1.3% 인하된 금액" 같은
         #   모순 표현이 되므로 discount_rate 는 0 미만 금지하고, 인상/동일/인하를 구분한
         #   문구는 discount_phrase 로 별도 제공한다(가격협상_확인 멘트가 사용).
+        #   기준가 호칭은 공급사 화면 고정 용어('공급가') — loader 가 박제한 값.
         base = ctx.get("item_price") or 0
+        label = ctx.get("item_price_label") or _SUPPLIER_PRICE_LABEL
         if base > 1 and "input_price" in ctx:
             rate = ((base - ctx["input_price"]) / base) * 100
             out["discount_rate"] = f"{max(0.0, rate):.1f}"
             if rate >= 0.05:
-                out["discount_phrase"] = f"기존 공급가 대비 약 **{rate:.1f}%** 인하된 금액입니다. "
+                out["discount_phrase"] = f"기존 {label} 대비 약 **{rate:.1f}%** 인하된 금액입니다. "
             elif rate <= -0.05:
                 out["discount_phrase"] = (
-                    f"기존 공급가(**{int(base)}원**)보다 약 **{abs(rate):.1f}%** 높은 금액입니다. ")
+                    f"기존 {label}(**{int(base)}원**)보다 약 **{abs(rate):.1f}%** 높은 금액입니다. ")
             else:
-                out["discount_phrase"] = "기존 공급가와 동일한 수준의 금액입니다. "
+                out["discount_phrase"] = f"기존 {_josa(label, '와')} 동일한 수준의 금액입니다. "
         else:
             out["discount_rate"] = "0.0"
             out["discount_phrase"] = ""
@@ -292,13 +401,14 @@ class ChatEngine:
     def _render(self, session: ChatSession, step_key: Optional[str]) -> StepView:
         if not step_key or step_key not in self.scripts:
             return self._error(session, f"다음 단계를 찾을 수 없습니다: {step_key}")
-        # 가드레일(최후 방어선): 구매자 대리는 목표가 초과로 절대 타결하지 않는다.
-        #   카운터 클램프·종결 규칙이 정상이면 도달하지 않지만, 스크립트 편집 실수 등으로
-        #   성공 스텝에 초과가로 진입하면 결렬로 강제 전환한다. (재협상 흐름 한정)
+        # 가드레일(최후 방어선): 구매자 대리는 타결 상한가를 넘겨 타결하지 않는다.
+        #   상한 = 견적 생성 시 박제한 done_ceiling_price(목표가×(1+타결상한율)), 미박제면 목표가.
+        #   목표가를 조금 넘어도 상한 이내면 타결이 정상이므로 여기서 뒤집지 않는다.
+        #   상한까지 넘은 경우만 결렬로 강제 전환한다.
         if step_key in _SUCCESS_STEPS and self.rq_type == "재협상":
             ctx = session.context
-            target = ctx.get("target_price") or 0
-            if target > 0 and ctx.get("input_price", 0) > target:
+            ceiling = settle_ceiling(ctx)
+            if ceiling > 0 and ctx.get("input_price", 0) > ceiling:
                 step_key = "협상실패"
         node = self.scripts[step_key]
         session.step = step_key
@@ -312,11 +422,14 @@ class ChatEngine:
         elif step_key in _FAILURE_STEPS:
             session.context["final_outcome"] = "failure"
         outcome = session.context.get("final_outcome") if chat_end else None
+        # 선택지도 스크립트와 같은 변수 치환을 태운다 — 배송형태 보기가 회사 용어({label_delivery_type_1} 등)라
+        # 치환을 건너뛰면 사용자에게 토큰 원문이 그대로 보인다.
+        step_vars = self._vars(session)
         return StepView(
             step=step_key,
-            script=self.repo.format_script(node.get("script", ""), self._vars(session)),
+            script=self.repo.format_script(node.get("script", ""), step_vars),
             input_mode=node.get("next_input_mode", "null"),
-            input_options=node.get("input_options", []),
+            input_options=[self.repo.format_script(o, step_vars) for o in node.get("input_options", [])],
             chat_end=bool(node.get("chat_end")),
             client_step=self.step_map.get(step_key, step_key),
             needs_card_selection=(step_key == "가격협상"),
@@ -325,9 +438,13 @@ class ChatEngine:
         )
 
     def _error(self, session: ChatSession, msg: str) -> StepView:
+        # 에러 재렌더도 정상 렌더와 같은 변수 치환을 태운다 — 여기만 raw 로 두면
+        # 가격 오입력 시 옵션 버튼에 {label_*} 토큰이 그대로 노출된다.
         node = self.scripts.get(session.step, {})
+        step_vars = self._vars(session)
         return StepView(
-            step=session.step, script=node.get("script", ""),
-            input_mode=node.get("next_input_mode", "null"), input_options=node.get("input_options", []),
+            step=session.step, script=self.repo.format_script(node.get("script", ""), step_vars),
+            input_mode=node.get("next_input_mode", "null"),
+            input_options=[self.repo.format_script(o, step_vars) for o in node.get("input_options", [])],
             chat_end=session.ended, client_step=self.step_map.get(session.step, session.step), error=msg,
         )

agent/negotiation/chat/service/negotiation_context_loader.py

@@ -19,6 +19,7 @@ from typing import Optional
 from common.database.db_session_manager import DB_SESSION_MNG
 from common.enums import DBType, DBWRType, ErrorType
 from common.logger import LOG
+from negotiation.cards.domain.tactics import build_card_spec
 from negotiation.chat.infra.repository.nego_context_crud import INegoContextCRUD, NegoContextCRUD
 from negotiation.qtable.domain.model.snapshot import PartnerType
 
@@ -38,7 +39,11 @@ class NegotiationDbContext:
     rq_type: str                 # 재협상(1:1) | 재견적(1:N) — sessions.qt_type 으로 판별
     target_price: int            # 목표 매입가(원) — sessions.target_price
     anchor_price: int            # 앵커링가 — sessions.anchoring_price(생성 시 박제). 없으면 target(무할인 폴백)
-    item_price: int              # 기존 공급가(품목 기준가, items.price) — 인하율 멘트용. 없으면 0
+    done_ceiling_price: int      # 타결 상한가 — sessions.done_ceiling_price(생성 시 박제). 없으면 target
+    item_price: int              # 협상 기준가(고객사가 관리하는 가격 — 공급가 또는 매입가) — 인하율 멘트용. 없으면 0
+    item_price_label: str        # 협상 멘트에서 기준가를 부르는 말(회사 용어 설정 → 없으면 카탈로그 기본값)
+    labels: dict                 # 회사 용어 사전(companies.settings.labels) — 스크립트 {label_*} 토큰 치환용
+    internet_lowest_price: int   # 인터넷 최저가(items.internet_lowest_price, LPS 대표값) — 카드 {internet_lowest_price} 치환용. 미수집이면 0
     partner_name: Optional[str]  # 협력사명(suppliers.name) — 카드 {partner_name} 치환용. 없으면 None
     product_name: Optional[str]  # 상품명(items.name) — 카드 {product_name} 치환용. 없으면 None
     partner_type: PartnerType    # 상품에 연결된 협력사 수(supplier_items 매핑, 없으면 세션 이력) → NONE/SINGLE/MULTIPLE
@@ -46,6 +51,10 @@ class NegotiationDbContext:
     distribution_code: Optional[str]  # 유통 코드(A/B/C) — supplier_items.supply_type. 미지정 시 None
     selected_nego_card_numbers: list[str]  # 견적 생성 시 선택된 일반 협상카드 번호(card.nego_cards.number)
     selected_wild_card_numbers: list[str]  # 견적 생성 시 선택된 와일드카드 번호(card.wild_cards.number)
+    card_count: Optional[int]  # 협상카드 사용 횟수 상한(quotation_settings.card_count). None=상한 미적용
+    # 카드번호 → 전술 {offer_variable, min_round, closing}. 스크립트 파싱 + tactic JSONB 로 시작 시 1회 확정 —
+    # 진행 중 협상은 카드 멘트가 도중에 바뀌어도 시작 시점 전술로 끝까지 간다(세션 컨텍스트에 박제).
+    card_specs: dict
 
 
 class NegotiationContextLoader:
@@ -65,8 +74,10 @@ class NegotiationContextLoader:
             err, row = await self.crud.get_session_row(s, sid)
             if err != ErrorType.SUCCESS or row is None:
                 return None
-            qt_type, target_price, anchoring_price, item_id, quotation_id, supplier_id = row
+            qt_type, target_price, anchoring_price, done_ceiling_price, item_id, quotation_id, supplier_id = row
             target = int(target_price or 0)
+            # 타결 상한가: 견적 생성 시 박제(목표가×(1+타결상한율)). 옛 세션은 NULL → 목표가로 폴백.
+            ceiling = int(done_ceiling_price or 0) or target
 
             # 앵커링가: 세션 생성 시 박제된 값(anchoring_price)을 그대로 사용 — 협상 중 불변.
             # 박제가 없으면(데이터 이상) 무할인 폴백 anchor=target + WARN — 앵커링 v1.2 정책상
@@ -83,8 +94,12 @@ class NegotiationContextLoader:
             #   매핑이 없거나 미지정이면 None → 호출부 기본값.
             _, supplier_type = await self.crud.get_supply_type(s, supplier_id, item_id)
 
-            # 기존 공급가(품목 기준가) — 없으면 0(인하율 멘트 미표시).
-            _, item_price = await self.crud.get_item_price(s, item_id)
+            # 협상 기준가 + 그 호칭 — 어느 컬럼을 쓸지는 고객사 설정(hidden_fields)이 정한다(crud).
+            #   없으면 0(인하율 멘트 미표시).
+            _, (item_price, item_price_label, labels) = await self.crud.get_item_baseline(s, item_id)
+
+            # 인터넷 최저가(LPS 수집 대표값) — 없으면 0(시장가 인용 카드는 값 있을 때만 치환).
+            _, internet_lowest_price = await self.crud.get_item_lowest_price(s, item_id)
 
             # 카드 스크립트 치환용 이름 — 협력사명/상품명. 없으면 None(호출부 기본값 폴백).
             _, partner_name = await self.crud.get_supplier_name(s, supplier_id)
@@ -101,13 +116,32 @@ class NegotiationContextLoader:
             # 견적 생성 모달에서 고른 카드셋. 값이 없으면 운영 DB 기준으로 "선택 카드 없음"이다.
             # 데모/직접호출 경로(DB context 없음)만 ChatService 에서 기존 기본 카드셋으로 폴백한다.
             _, selected_cards = await self.crud.get_quotation_card_numbers(s, quotation_id)
-            selected_nego_cards, selected_wild_cards = selected_cards
+            nego_rows, wild_rows = selected_cards
+            selected_nego_cards = [number for number, _script, _tactic in nego_rows]
+            selected_wild_cards = [number for number, _script, _tactic in wild_rows]
+            # 카드 전술 확정 — "스크립트에 꽂힌 변수가 곧 전술"(제안가 파싱) + tactic JSONB(min_round·closing).
+            card_specs = {}
+            for number, script, tactic in [*nego_rows, *wild_rows]:
+                spec = build_card_spec(script, tactic if isinstance(tactic, dict) else None)
+                card_specs[number] = {
+                    "offer_variable": spec.offer_variable,
+                    "min_round": spec.min_round,
+                    "closing": spec.closing,
+                    "requires": list(spec.requires),  # 세션-의존 변수 결측 시 미발동(available)
+                }
+
+            # 협상카드 사용 횟수 상한(견적 설정). 없으면 None → 상한 미적용(선택 카드 수로만 캡).
+            _, card_count = await self.crud.get_card_count(s, sid)
 
             return NegotiationDbContext(
                 rq_type="재협상" if int(qt_type) in _ONE_TO_ONE_QT_TYPES else "재견적",
                 target_price=target,
                 anchor_price=anchor,
+                done_ceiling_price=ceiling,
                 item_price=item_price,
+                item_price_label=item_price_label,
+                labels=labels,
+                internet_lowest_price=internet_lowest_price,
                 partner_name=partner_name,
                 product_name=product_name,
                 partner_type=PartnerType.from_count(supplier_count),
@@ -115,6 +149,8 @@ class NegotiationContextLoader:
                 distribution_code=_SUPPLIER_TYPE_TO_CODE.get(supplier_type) if supplier_type else None,
                 selected_nego_card_numbers=selected_nego_cards,
                 selected_wild_card_numbers=selected_wild_cards,
+                card_count=card_count,
+                card_specs=card_specs,
             )
 
         try:

agent/negotiation/chat/service/script_naturalizer.py

@@ -121,7 +121,7 @@ class ScriptNaturalizer:
 def build_situation(context: Dict[str, Any]) -> Dict[str, Any]:
     """세션 컨텍스트 → 정성 상황 라벨 (수치 미노출 — 숫자 환각 차단의 핵심).
 
-    가격구간: 제시가 vs 앵커/목표 관계, 라운드: 협상 진행 단계, 인하 진행: 기존 공급가 대비.
+    가격구간: 제시가 vs 앵커/목표 관계, 라운드: 협상 진행 단계, 인하 진행: 협상 기준가 대비.
     """
     out: Dict[str, Any] = {}
     rnd = context.get("round") or 0

agent/services/chat_service.py

@@ -13,7 +13,9 @@ from common.enums import DBType, ErrorType
 from common.database.db_session_manager import DB_SESSION_MNG
 from common.logger import LOG
 from config.server_configs import agent_config
-from negotiation.cards.domain.tactics import compute_counter, tactic_available, tactic_for
+from negotiation.cards.domain.tactics import (
+    Offer, available, compute_offer_detail, is_played, mark_played, playable, record_offer, spec_from_context,
+)
 from negotiation.chat.service.chat_engine import (
     _CHOICE_MODES, _PRICE_MODES, ChatEngine, ChatSession, StepView,
 )
@@ -41,6 +43,8 @@ _DEFAULT_REVENUE_AMOUNT = 20_000_000  # 매출액(원) — suppliers.total_reven
 _DEFAULT_DISTRIBUTION_CODE = "A"      # 유통 코드 — supplier_items.supply_type 미지정 시 폴백
 _DEFAULT_PARTNER_NAME = "귀사"        # 협력사명 — suppliers.name 미기재/데모 시 폴백(카드 {partner_name})
 _DEFAULT_PRODUCT_NAME = "본 상품"     # 상품명 — items.name 미기재/데모 시 폴백(카드 {product_name})
+_DEFAULT_ITEM_PRICE_LABEL = "공급가"  # 협상 기준가 호칭(공급사 화면 고정 용어) — DB 컨텍스트 없는 데모/직접호출 경로 폴백
+                                       # (negodata 용어 카탈로그 item.price 의 base 와 같아야 표기가 갈리지 않는다)
 
 
 class ChatService:
@@ -82,8 +86,12 @@ class ChatService:
             selected_wild_cards = db_ctx.selected_wild_card_numbers if db_ctx else []
             # 운영 DB 세션은 견적 version_id 에 묶인 카드만 사용한다. 직접 호출/데모(DB context 없음)는
             # 기존 테넌트 기본 action mapping 으로 폴백해 로컬 테스트와 콘솔 데모를 유지한다.
+            # 협상카드 사용 횟수 상한(quotation_settings.card_count)으로 실제 플레이 가능한 카드 수를 캡한다 —
+            #   session.action_space_size 는 카드 소진 판정(cards_total) 전용이라 여기서 줄여도 Q-table 은
+            #   engine.action_space_size(카탈로그 전체)로 별도 고정된다. card_count 미설정(None)이면 선택 수 그대로.
+            card_cap = db_ctx.card_count if (db_ctx and db_ctx.card_count and db_ctx.card_count > 0) else None
             action_space_size = (
-                min(len(selected_nego_cards), engine.action_space_size)
+                min(len(selected_nego_cards), engine.action_space_size, *( [card_cap] if card_cap else [] ))
                 if db_ctx is not None
                 else engine.action_space_size
             )
@@ -104,18 +112,31 @@ class ChatService:
                     # 목표가/앵커링가: sessions 행(생성 시 박제된 anchoring_price) → 박제 ‰ → 1% 폴백 (loader).
                     "anchor_price": db_ctx.anchor_price if db_ctx else _DEFAULT_ANCHOR_PRICE,
                     "target_price": db_ctx.target_price if db_ctx else _DEFAULT_TARGET_PRICE,
+                    # 타결 상한가(sessions.done_ceiling_price 박제) — 타결 판정선이자 카드 제안가 상한.
+                    #   목표가를 조금 넘어도 이 이하면 타결한다. 미박제/데모는 목표가와 같다.
+                    "done_ceiling_price": db_ctx.done_ceiling_price if db_ctx else _DEFAULT_TARGET_PRICE,
                     # 협력사명/상품명 — 카드 스크립트 {partner_name}·{product_name} 치환용(loader). 없으면 폴백.
                     "partner_name": (db_ctx.partner_name if db_ctx and db_ctx.partner_name else _DEFAULT_PARTNER_NAME),
                     "product_name": (db_ctx.product_name if db_ctx and db_ctx.product_name else _DEFAULT_PRODUCT_NAME),
                     "round": 0,
-                    # 기존 공급가(품목 기준가) — 가격협상_확인 인하율 산출용.
+                    # 협상 기준가(고객사가 관리하는 가격 — 공급가 또는 매입가) — 가격협상_확인 인하율 산출용.
+                    #   호칭은 회사 설정 라벨을 따른다("기존 {label} 대비 …" 멘트).
                     "item_price": db_ctx.item_price if db_ctx else 0,
+                    "item_price_label": db_ctx.item_price_label if db_ctx else _DEFAULT_ITEM_PRICE_LABEL,
+                    # 회사 용어 사전 — 스크립트의 {label_*} 토큰(협력사·목표가·배송형태 등) 치환용.
+                    "labels": (db_ctx.labels if db_ctx else {}),
+                    # 인터넷 최저가(items.internet_lowest_price, LPS 대표값) — 카드 {internet_lowest_price} 치환용.
+                    #   미수집(0)이면 vars_for 가 키를 만들지 않아 원형 유지(허위 시장가 표기 방지).
+                    "internet_lowest_price": db_ctx.internet_lowest_price if db_ctx else 0,
                     # 견적 생성 시 선택한 카드. 일반카드는 action_id 0..N-1 에 그대로 매핑한다.
                     # 1% 인하는 기본 와일드카드로 항상 열고, 재원부족 등 선택형 와일드카드는
                     # 선택된 와일드카드가 있을 때만 허용한다.
                     "db_context_loaded": db_ctx is not None,
                     "selected_nego_card_numbers": selected_nego_cards,
                     "selected_wild_card_numbers": selected_wild_cards,
+                    # 카드번호 → 전술 {offer_variable, min_round, closing}. 시작 시 1회 박제(loader) —
+                    # 이후 카드 멘트가 바뀌어도 이 협상은 시작 시점 전술로 끝까지 간다.
+                    "card_specs": (db_ctx.card_specs if db_ctx else {}),
                     "allow_selected_wildcards": True if db_ctx is None else bool(selected_wild_cards),
                 },
             )
@@ -283,20 +304,24 @@ class ChatService:
         decision = policy.select(ctx)
         session.used_action_ids.add(decision.action_id)
         card_id = self._card_id_for_action(engine, session, decision.action_id)
-        # 전술 실행(재설계): 카드의 가격 행동 — 카운터 제시가를 계산해 세션에 적재한다.
+        # 카드번호 공용 이력 — 와일드/종결 경로와 같은 목록을 본다("한 협상 한 카드 1회" 단일 판정).
+        mark_played(session.context, card_id)
+        # 전술 실행: 카드가 제시할 금액(스크립트 파싱 결과)을 계산해 세션에 적재한다.
         #   pending 이 있으면 이 턴은 수락/거절 스텝(가격협상_카운터)으로 전환되고,
         #   협력사가 수락하면 이 가격으로 즉시 타결된다(chat_engine 의 수락 메커니즘).
-        spec = tactic_for(card_id)
-        counter = compute_counter(spec, session.context) if tactic_available(spec, session.context) else None
-        if counter is not None:
-            session.context["pending_counter_price"] = counter
-            session.context["prev_customer_price"] = counter   # 갑의 최신 포지션(middle_price 기준)
+        #   유효조건(≤목표가 · <제시가) 미달이면 None → 금액 없이 설득 멘트만 나간다(HOLD 강등).
+        spec = spec_from_context(session.context, card_id)
+        offer = compute_offer_detail(spec, session.context) if available(spec, session.context) else None
+        counter = offer.price if offer else None
+        if offer is not None:
+            record_offer(session.context, offer)
         reward = RewardCalculator(engine.config.reward, engine.config.state).calculate(snap)
         policy.update(Transition(state_index=idx, action_id=decision.action_id, reward=reward.total, done=False))
         await QTablePolicyStore.persist_cell(repo, version_id, policy, idx, decision.action_id)
         session.context["last_state"] = idx
         session.context["last_action"] = decision.action_id
-        await self._log(repo, session, idx, decision.action_id, card_id, snap, reward, decision.propensity, done=False)
+        await self._log(repo, session, idx, decision.action_id, card_id, snap, reward, done=False,
+                        decision=decision, policy=policy)
 
         res.card_id = card_id
         res.policy = policy.name
@@ -345,20 +370,31 @@ class ChatService:
         규칙층의 강제 결정이므로 RL 선택/학습을 우회한다."""
         ctx = session.context
         ctx["closing_played"] = True
-        # 선택 와일드카드 중 종결 전술 (WC-05/WC-03) — 순서대로 첫 매치.
-        closing_number = next(
-            (str(n) for n in (ctx.get("selected_wild_card_numbers") or []) if tactic_for(str(n)).closing),
-            None,
-        )
-        counter = compute_counter(tactic_for(closing_number), ctx) if closing_number else None
-        if counter is None:
+        # 선택 와일드카드 중 종결 전용 카드(closing) — 이미 쓴 카드는 건너뛰고(같은 멘트 반복 방지),
+        # 제안가 유효조건(≤목표가 · <제시가) 미달 카드도 건너뛴다(예: 절충가가 목표가 초과 → 미발동).
+        closing_number, closing_offer = None, None
+        for n in (ctx.get("selected_wild_card_numbers") or []):
+            n = str(n)
+            spec = spec_from_context(ctx, n)
+            if not available(spec, ctx, closing_phase=True) or is_played(ctx, n):
+                continue
+            offer = compute_offer_detail(spec, ctx)
+            if offer is not None:
+                closing_number, closing_offer = n, offer
+                break
+        if closing_offer is None:
             # 폴백 최후통첩: 목표가 제시 (여기 도달 = 제시가 > target 이므로 항상 유효한 카운터).
+            closing_number = None
             target = int(ctx.get("target_price") or 0)
-            counter = target if 0 < target < ctx.get("input_price", 0) else None
-        if counter is None:
+            price = int(ctx.get("input_price") or 0)
+            if 0 < target < price:
+                closing_offer = Offer(price=target, variable="target_price",
+                                      prev_customer=int(ctx.get("prev_customer_price") or ctx.get("anchor_price") or 0),
+                                      prev_partner=price)
+        if closing_offer is None:
             return  # 컨텍스트 이상 — 기존 가격협상 스텝 그대로(재제안 요구)
-        ctx["pending_counter_price"] = counter
-        ctx["prev_customer_price"] = counter
+        mark_played(ctx, closing_number)  # None(폴백 최후통첩)이면 no-op
+        record_offer(ctx, closing_offer)
 
         template = None
         if closing_number:
@@ -385,7 +421,7 @@ class ChatService:
         policy.update(Transition(state_index=last_state, action_id=last_action, reward=reward.total, done=True))
         await QTablePolicyStore.persist_cell(repo, version_id, policy, last_state, last_action)
         await self._log(repo, session, last_state, last_action,
-                        self._card_id_for_action(engine, session, last_action), snap, reward, None, done=True)
+                        self._card_id_for_action(engine, session, last_action), snap, reward, done=True)
         res.updated_q = float(policy.qtable.q[last_state, last_action])
 
     @staticmethod
@@ -434,10 +470,12 @@ class ChatService:
 
     @staticmethod
     def _tactic_mask(engine: TenantEngine, session: ChatSession) -> Optional[np.ndarray]:
-        """전술 발동조건(min_round·가격구간)을 만족하는 action 만 True. HOLD(설득)는 항상 True.
+        """지금 플레이 가능한 action 만 True. HOLD(설득)는 발동조건만, 금액 카드는 제안가 유효까지
+        본다(playable) — 무효 금액(역행·목표가 초과 등)이 멘트 글자로 나가는 것 자체를 막는다.
         전부 True 면 None(마스크 불필요)."""
+        ctx = session.context
         mask = np.array(
-            [tactic_available(tactic_for(engine.mapper.get_card_id(a)), session.context)
+            [playable(spec_from_context(ctx, engine.mapper.get_card_id(a)), ctx)
              for a in range(engine.action_space_size)],
             dtype=bool,
         )
@@ -462,13 +500,26 @@ class ChatService:
                 prior[a] = 0.3 * (n - rank) / n
         return prior if prior.any() else None
 
-    async def _log(self, repo: LearningRepository, session, state_index, action_id, card_id, snap, reward, propensity, done):
+    async def _log(self, repo: LearningRepository, session, state_index, action_id, card_id, snap, reward, done,
+                   decision=None, policy=None):
         data = {
             "session_id": session.session_id, "state_index": state_index, "action_id": action_id,
-            "card_id": card_id, "snapshot": snap.to_dict(), "propensity": propensity,
+            "card_id": card_id, "snapshot": snap.to_dict(),
             "turn": snap.round_number, "reward": reward.total, "done": done,
             "settled_price": int(snap.input_price) if snap.outcome == NegotiationOutcome.SUCCESS else None,
         }
+        if decision is not None and policy is not None:
+            # 선택 근거(Q값·UCB·방문수)를 그 턴 값 그대로 박제한다 — 사후에 q_values 를 읽으면 이미 갱신된 뒤라
+            # "그때 왜 이 카드였나"를 복원할 수 없다. negodata 협상 학습 화면이 이 컬럼들을 읽는다.
+            # 종료 로그(카드 선택 없는 done 행)는 decision 이 없어 NULL — 화면 집계(avg/max)가 무시한다.
+            data.update({
+                "propensity": decision.propensity,
+                "available_actions": decision.available_actions,
+                "q_value_at_selection": decision.q_value,
+                "ucb_score_at_selection": decision.ucb_score,
+                "visit_count_at_selection": int(policy.qtable.visits[state_index, action_id]),
+                "total_visits_at_selection": int(policy.qtable.state_visits(state_index)),
+            })
         try:
             await DB_SESSION_MNG.execute_lambda_run([DBType.MAIN.value], [lambda s: repo.log_transition(s, data)])
         except Exception as ex:

agent/services/negotiation_service.py

@@ -97,10 +97,10 @@ class NegotiationService:
 
         # 7) experience_logs 기록
         if req.log:
-            res.logged = await self._log(engine, session_id, idx, decision, snap, reward)
+            res.logged = await self._log(engine, session_id, idx, decision, snap, reward, policy)
         return res
 
-    async def _log(self, engine, session_id, idx, decision, snap, reward) -> bool:
+    async def _log(self, engine, session_id, idx, decision, snap, reward, policy) -> bool:
         repo = LearningRepository(engine.company_id)
         data = {
             "session_id": session_id, "state_index": idx, "action_id": decision.action_id,
@@ -108,6 +108,8 @@ class NegotiationService:
             "turn": snap.round_number, "available_actions": decision.available_actions,
             "reward": reward.total, "done": snap.outcome != NegotiationOutcome.ONGOING,
             "q_value_at_selection": decision.q_value, "ucb_score_at_selection": decision.ucb_score,
+            "visit_count_at_selection": int(policy.qtable.visits[idx, decision.action_id]),
+            "total_visits_at_selection": int(policy.qtable.state_visits(idx)),
             "settled_price": int(snap.input_price) if snap.outcome == NegotiationOutcome.SUCCESS else None,
         }
         try:

agent/tenants/_base/resources/scripts_cards.json

@@ -1,12 +1,12 @@
 {
-    "_comment": "가격협상(카드선택) 턴에 출력할 협상 카드 스크립트. action_id(0~8) → 멘트. 선행 chat_server 의 nego_card_scripts 를 대체하는 중립 기본값(CLEANROOM.md). 실제 운영 시 card.nego_cards.script 로 override(내부 소스만 변경, 흐름 동일). 변수: {target}=목표 매입가, {input_price}=직전 제시가, {anchor}=앵커가, {discount_rate}=기존가 대비 인하율(%).",
+    "_comment": "가격협상(카드선택) 턴에 출력할 협상 카드 스크립트. action_id(0~8) → 멘트. 선행 chat_server 의 nego_card_scripts 를 대체하는 중립 기본값(CLEANROOM.md). 실제 운영 시 card.nego_cards.script 로 override(내부 소스만 변경, 흐름 동일). 변수: {target}=목표가, {input_price}=직전 제시가, {anchor}=앵커가, {discount_rate}=기존가 대비 인하율(%).",
     "0": "제안해 주신 **{input_price}원**, 감사합니다. 다만 동일 품목의 시장 거래가를 감안하면 추가 조정 여력이 있어 보입니다. 한 번 더 검토해 가격을 제안해 주시겠어요?",
-    "1": "적극적으로 협조해 주셔서 감사합니다. 현재 제시가는 목표 매입가(**{target}원**)와는 아직 차이가 있습니다. 조금만 더 좁혀 주시면 우선협상 대상으로 검토하겠습니다.",
-    "2": "좋은 제안 감사합니다. 다른 협력사들의 제안 수준을 고려할 때, 현재 금액으로는 경쟁력이 다소 부족합니다. 재검토된 가격을 부탁드립니다.",
+    "1": "적극적으로 협조해 주셔서 감사합니다. 현재 제시가는 {label_target_price}(**{target}원**)와는 아직 차이가 있습니다. 조금만 더 좁혀 주시면 우선협상 대상으로 검토하겠습니다.",
+    "2": "좋은 제안 감사합니다. 다른 {label_supplier}들의 제안 수준을 고려할 때, 현재 금액으로는 경쟁력이 다소 부족합니다. 재검토된 가격을 부탁드립니다.",
     "3": "협상에 성실히 임해 주셔서 감사합니다. 내부 승인 기준에 맞추려면 앵커가({anchor}원) 수준에 가까운 제안이 필요합니다. 가능하신 범위에서 다시 제안해 주세요.",
-    "4": "제시해 주신 인하율 약 {discount_rate}%는 의미 있는 진전입니다. 다만 거래를 확정하려면 조금 더 협조가 필요합니다. 한 차례 더 조정해 주시겠어요?",
+    "4": "제시해 주신 조건은 의미 있는 진전입니다. 다만 거래를 확정하려면 조금 더 협조가 필요합니다. 한 차례 더 조정해 주시겠어요?",
     "5": "장기적인 협력 관계를 고려해 최대한 반영하고자 합니다. 현재 제시가에서 추가로 조정해 주시면 즉시 검토를 진행하겠습니다. 다시 제안 부탁드립니다.",
     "6": "검토 결과, 현재 제시가는 우리 기준을 충족하기 직전 단계입니다. 마지막으로 한 번 더 조정된 가격을 제안해 주시면 협상을 마무리할 수 있습니다.",
-    "7": "성의 있는 제안 감사합니다. 다만 물량과 납기 조건을 함께 고려하면 {input_price}원은 다소 높습니다. 목표 매입가({target}원)에 가까운 금액을 제안해 주세요.",
+    "7": "성의 있는 제안 감사합니다. 다만 물량과 납기 조건을 함께 고려하면 {input_price}원은 다소 높습니다. {label_target_price}({target}원)에 가까운 금액을 제안해 주세요.",
     "8": "긍정적으로 검토되고 있습니다. 내부 결재를 위해 명분이 조금 더 필요한 상황입니다. 가능하신 선에서 한 번 더 인하된 가격을 제안해 주시겠어요?"
 }

agent/tenants/_base/resources/scripts_renegotiation.json

@@ -12,7 +12,7 @@
         "chat_end": false
     },
     "서비스안내": {
-        "script": "안녕하세요. {company_name} {service_name}입니다. 본 서비스는 {company_name}와 협력사 간 물품 공급 가격 협상을 위한 것으로, 귀사가 공급 중인 품목의 새로운 가격 협상을 진행합니다. 안내 사항을 확인하신 뒤, 다음 단계로 넘어가려면 [확인]을 눌러 주세요.",
+        "script": "안녕하세요. {company_name} {service_name}입니다. 본 서비스는 {company_name}와 {label_supplier} 간 물품 공급 가격 협상을 위한 것으로, 귀사가 공급 중인 품목의 새로운 가격 협상을 진행합니다. 안내 사항을 확인하신 뒤, 다음 단계로 넘어가려면 [확인]을 눌러 주세요.",
         "editor_script_id": "서비스안내",
         "next_input_mode": "confirm",
         "input_options": [
@@ -25,7 +25,7 @@
         "chat_end": false
     },
     "담당자확인": {
-        "script": "본 안내는 협력사 포털에 등록된 담당자에게 발송되었습니다. 구매 협상 담당자가 맞는지 다시 한 번 확인 부탁드립니다. 담당자가 맞다면 [예], 맞지 않다면 [아니오]를 선택해 주세요.",
+        "script": "본 안내는 {label_supplier} 포털에 등록된 담당자에게 발송되었습니다. 구매 협상 담당자가 맞는지 다시 한 번 확인 부탁드립니다. 담당자가 맞다면 [예], 맞지 않다면 [아니오]를 선택해 주세요.",
         "editor_script_id": "담당자확인",
         "next_input_mode": "yes_no",
         "input_options": [
@@ -55,7 +55,7 @@
         "chat_end": false
     },
     "정보변경_완료": {
-        "script": "[정보변경]을 선택하셨습니다. 협력사 관리 시스템에서 담당자 정보를 변경하신 뒤, 고객센터로 새 견적 생성을 요청해 주세요. 24시간 이내에 갱신되지 않으면 참여 의사가 없는 것으로 간주되어 해당 견적 건이 미참여로 처리될 수 있습니다.",
+        "script": "[정보변경]을 선택하셨습니다. {label_supplier} 관리 시스템에서 담당자 정보를 변경하신 뒤, 고객센터로 새 견적 생성을 요청해 주세요. 24시간 이내에 갱신되지 않으면 참여 의사가 없는 것으로 간주되어 해당 견적 건이 미참여로 처리될 수 있습니다.",
         "editor_script_id": "정보변경_완료",
         "next_input_mode": "null",
         "input_options": [],

agent/tenants/_base/resources/scripts_requote.json

@@ -10,7 +10,7 @@
         "chat_end": false
     },
     "서비스안내": {
-        "script": "안녕하세요. {company_name} {service_name}입니다. 본 서비스는 {company_name}와 협력사 간 신규 물품 공급 협상을 위한 것으로, 귀사에 새로운 공급 기회를 제공하고자 합니다. 이용 방법 안내를 확인하신 뒤 [확인]을 눌러 주세요.",
+        "script": "안녕하세요. {company_name} {service_name}입니다. 본 서비스는 {company_name}와 {label_supplier} 간 신규 물품 공급 협상을 위한 것으로, 귀사에 새로운 공급 기회를 제공하고자 합니다. 이용 방법 안내를 확인하신 뒤 [확인]을 눌러 주세요.",
         "editor_script_id": "서비스안내",
         "next_input_mode": "confirm",
         "input_options": ["확인"],
@@ -19,7 +19,7 @@
         "chat_end": false
     },
     "담당자확인": {
-        "script": "본 안내는 협력사 포털에 등록된 담당자에게 발송되었습니다. 구매 협상 담당자가 맞는지 확인 부탁드립니다. 담당자가 맞다면 [예], 맞지 않다면 [아니오]를 선택해 주세요.",
+        "script": "본 안내는 {label_supplier} 포털에 등록된 담당자에게 발송되었습니다. 구매 협상 담당자가 맞는지 확인 부탁드립니다. 담당자가 맞다면 [예], 맞지 않다면 [아니오]를 선택해 주세요.",
         "editor_script_id": "담당자확인",
         "next_input_mode": "yes_no",
         "input_options": ["예", "아니오"],
@@ -37,7 +37,7 @@
         "chat_end": false
     },
     "정보변경_완료": {
-        "script": "[정보변경]을 선택하셨습니다. 협력사 관리 시스템에서 담당자 정보를 변경하신 뒤 고객센터로 새 견적 생성을 요청해 주세요. 24시간 이내 갱신되지 않으면 미참여로 처리될 수 있습니다.",
+        "script": "[정보변경]을 선택하셨습니다. {label_supplier} 관리 시스템에서 담당자 정보를 변경하신 뒤 고객센터로 새 견적 생성을 요청해 주세요. 24시간 이내 갱신되지 않으면 미참여로 처리될 수 있습니다.",
         "editor_script_id": "정보변경_완료",
         "next_input_mode": "null",
         "input_options": [],
@@ -46,7 +46,7 @@
         "chat_end": true
     },
     "협상품목안내": {
-        "script": "{company_name}는 아래 상품에 대해 신규 공급사를 선정하고 있으며, 귀사를 초대하여 견적을 요청드립니다. 제출하신 견적은 복수 업체와의 비교 평가를 통해 공급사 선정에 반영됩니다. 상품 정보를 확인해 주세요.",
+        "script": "{company_name}는 아래 상품에 대해 신규 {label_supplier_를} 선정하고 있으며, 귀사를 초대하여 견적을 요청드립니다. 제출하신 견적은 복수 업체와의 비교 평가를 통해 {label_supplier} 선정에 반영됩니다. 상품 정보를 확인해 주세요.",
         "editor_script_id": "협상품목안내",
         "next_input_mode": "confirm",
         "input_options": ["네, 알겠습니다."],
@@ -73,10 +73,10 @@
         "chat_end": false
     },
     "배송형태선택": {
-        "script": "배송 형태를 선택해 주세요.",
+        "script": "{label_delivery_type_를} 선택해 주세요.",
         "editor_script_id": "배송형태선택",
         "next_input_mode": "delivery_type",
-        "input_options": ["협력사배송", "지정택배배송", "픽업배송"],
+        "input_options": ["{label_delivery_type_1}", "{label_delivery_type_2}", "{label_delivery_type_3}"],
         "next_step": { "default": "가격협상_입력" },
         "type": "text",
         "chat_end": false

agent/tenants/_base/resources/scripts_wildcard.json

@@ -15,7 +15,7 @@
         "editor_script_id": "wild_card_1pct"
     },
     "wild_card_budget": {
-        "script": "솔직히 말씀드리면 현재 내부 예산(재원) 사정상 제안을 그대로 수용하기 어렵습니다. 목표 매입가는 **{target}원**입니다. 이 가격에 맞춰 주신다면 즉시 계약을 진행하고자 합니다. 마지막으로 한 번 더 제안 부탁드립니다.",
+        "script": "솔직히 말씀드리면 현재 내부 예산(재원) 사정상 제안을 그대로 수용하기 어렵습니다. 당사 {label_target_price}는 **{target}원**입니다. 이 가격에 맞춰 주신다면 즉시 계약을 진행하고자 합니다. 마지막으로 한 번 더 제안 부탁드립니다.",
         "type": "text",
         "chat_end": false,
         "next_input_mode": "price",

agent/tests/fuzz_negotiation.py

@@ -0,0 +1,157 @@
+"""협상 퍼즈 하네스 — 랜덤 조건·랜덤 협력사 행동으로 N회 완주시키고 불변식 위반을 수집한다.
+시드 고정(재현 가능). test_ 접두사 없음 — pytest 수집 대상 아님, 수동 실행 전용:
+  docker run --rm -v $PWD/agent:/work -w /work -e APP_ENV=local -e DB_HOST=host.docker.internal \
+    o2o-negosium-agent sh -lc "pip install -q pytest pytest-asyncio httpx; python tests/fuzz_negotiation.py"
+
+케이스마다 검사하는 불변식:
+  1. 전 턴 success
+  2. 같은 카드 2회 발동 금지
+  3. 종결 전용(WC-03·05)은 가격협상_카운터에서만 / 비종결 와일드는 wild_card_dynamic 에서만
+  4. 타결 시 타결가 ≤ 목표가
+  5. 카운터/1% 수락으로 타결하면 그 멘트에 타결가 표기
+  6. 멘트·버튼에 미치환 토큰({xxx}) 잔존 금지
+  7. 턴 상한(60) 안에 반드시 종료
+"""
+import asyncio
+import random
+import re
+import sys
+import uuid
+
+sys.path.insert(0, "/work")
+
+from router.v1.chat.protocol import Req_Chat  # noqa: E402
+from services.chat_service import ChatService, reset_sessions  # noqa: E402
+from tenancy.config_loader import TenantConfigLoader  # noqa: E402
+from tenancy.registry import TenantEngineRegistry  # noqa: E402
+from tests.test_card_tactics import _TENANTS_DIR, _cleanup, _seed_quote_session  # noqa: E402
+
+N = 100
+SEED = 20260805
+TARGET = 10_000
+NEGO_POOL = ["NGC-001", "NGC-002", "NGC-003", "NGC-004", "NGC-005",
+             "NGC-007", "NGC-008", "NGC-010", "NGC-011"]
+WILD_POOL = ["WC-01", "WC-02", "WC-03", "WC-04", "WC-05"]
+CLOSING = {"WC-03", "WC-05"}
+TOKEN_RE = re.compile(r"(?<!\{)\{([a-z_0-9]+)\}(?!\})")
+
+
+class Supplier:
+    """랜덤 협력사 — 높은 시작가에서 점진 양보, 카운터는 확률적으로 수락/거절."""
+
+    def __init__(self, rng, anchor):
+        self.rng = rng
+        self.anchor = anchor
+        self.price = TARGET * rng.uniform(1.02, 1.30)
+        self.accept_p = rng.uniform(0.15, 0.5)
+
+    def next_price(self):
+        p = int(self.price)
+        # 다음 라운드를 위해 양보 — 가끔 앵커 밑까지 다이브(우선협상 유도).
+        self.price *= self.rng.uniform(0.90, 0.99)
+        if self.rng.random() < 0.15:
+            self.price = self.anchor * self.rng.uniform(0.95, 1.04)
+        return str(max(p, 100))
+
+    def choose(self, options):
+        if "수락" in options:
+            return "수락" if self.rng.random() < self.accept_p else "다른 가격 제시"
+        if set(options) >= {"예", "아니오"}:
+            return "예" if self.rng.random() < max(self.accept_p, 0.5) else "아니오"
+        return options[0] if options else "확인"
+
+
+async def run_case(idx, rng):
+    anchor = int(TARGET * rng.choice([0.99, 0.99, 0.97, 0.95, 1.0]))
+    nego = rng.sample(NEGO_POOL, rng.randint(1, 5))
+    wild = rng.sample(WILD_POOL, rng.randint(0, 5))
+    sup = Supplier(rng, anchor)
+
+    reset_sessions()
+    sid = uuid.uuid4()
+    qid, ver = await _seed_quote_session(sid, nego, wild_numbers=wild, target=TARGET, anchor=anchor)
+    violations, fired, settled, outcome, ended = [], [], None, None, False
+    try:
+        reg = TenantEngineRegistry(loader=TenantConfigLoader(tenants_dir=_TENANTS_DIR, cache_ttl_seconds=0))
+        eng = await reg.get_engine(str(uuid.uuid4()))
+        svc = ChatService()
+        ui, last_input = None, None
+        for _turn in range(60):
+            r = await svc.chat(eng, Req_Chat(session_id=str(sid), user_input=ui))
+            if r.result.success is not True:
+                violations.append(f"턴 실패 input={ui} msg={r.msg}")
+                break
+            script, opts = r.script or "", list(r.input_options or [])
+            if TOKEN_RE.search(script):
+                violations.append(f"미치환 토큰(script): {TOKEN_RE.findall(script)} @ {r.step}")
+            for o in opts:
+                if TOKEN_RE.search(o):
+                    violations.append(f"미치환 토큰(option): {o} @ {r.step}")
+            if r.card_id:
+                fired.append((r.step, r.card_id))
+            if r.settled_price is not None:
+                settled = r.settled_price
+                # 카운터/1% '수락' 타결이면 마지막 카운터 멘트에 타결가가 보였어야 한다.
+                if last_input in ("수락",) and str(settled) not in (last_counter or ""):
+                    violations.append(f"표시가≠타결가: {settled} not in counter script")
+            if r.step in ("가격협상_카운터", "wild_card_dynamic", "wild_card_1pct"):
+                last_counter = script
+            if r.chat_end:
+                outcome, ended = r.outcome, True
+                break
+            # 다음 입력 결정
+            last_input = None
+            if r.input_mode == "price":
+                ui = sup.next_price()
+            elif opts:
+                ui = sup.choose(opts)
+                last_input = ui
+            else:
+                ui = "확인"
+        if not ended:
+            violations.append("60턴 내 미종료")
+
+        # 카드 불변식
+        ids = [c for _, c in fired]
+        if len(ids) != len(set(ids)):
+            violations.append(f"카드 중복: {ids}")
+        for step, c in fired:
+            if c in CLOSING and step != "가격협상_카운터":
+                violations.append(f"종결 카드 {c} 가 {step} 에서 발동")
+            if c.startswith("WC") and c not in CLOSING and step != "wild_card_dynamic":
+                violations.append(f"비종결 와일드 {c} 가 {step} 에서 발동")
+        if outcome == "success":
+            if settled is None:
+                violations.append("성공인데 settled 없음")
+            elif settled > TARGET:
+                violations.append(f"목표가 초과 타결: {settled}")
+    finally:
+        await _cleanup(sid, qid, ver)
+    return {"idx": idx, "anchor": anchor, "nego": nego, "wild": wild,
+            "fired": fired, "settled": settled, "outcome": outcome, "violations": violations}
+
+
+async def main():
+    rng = random.Random(SEED)
+    results, bad = [], []
+    for i in range(N):
+        res = await run_case(i, random.Random(rng.random()))
+        results.append(res)
+        if res["violations"]:
+            bad.append(res)
+        tag = "OK " if not res["violations"] else "BAD"
+        print(f"[{tag}] #{i:02d} anchor={res['anchor']} nego={len(res['nego'])} wild={len(res['wild'])} "
+              f"fired={'→'.join(c for _, c in res['fired']) or '-'} settled={res['settled']} {res['outcome']}")
+    ok = sum(1 for r in results if not r["violations"])
+    succ = sum(1 for r in results if r["outcome"] == "success")
+    print(f"\n===== {ok}/{N} clean · 타결 {succ} / 결렬 {N - succ} =====")
+    for r in bad:
+        print(f"\n#{r['idx']} 위반: nego={r['nego']} wild={r['wild']} anchor={r['anchor']}")
+        for v in r["violations"]:
+            print("  -", v)
+    from common.database.db_session_manager import DB_SESSION_MNG
+    await DB_SESSION_MNG.dispose_all()
+    sys.exit(0 if not bad else 1)
+
+
+asyncio.run(main())

agent/tests/test_agent_integration.py

@@ -53,7 +53,7 @@ async def test_4_4_company_id_auto_onboard():
     eng = await _reg().get_engine(COMPANY_ID)
     assert eng.tenant_id == COMPANY_ID
     assert eng.company_id == COMPANY_ID            # 학습/세션이 이 company_id 로 격리
-    assert eng.action_space_size == 11              # base 기본 카드(162×11 정합)
+    assert eng.action_space_size == 9               # DB 카탈로그 9장(NGC-006·009 소프트삭제)
     assert eng.state_space_size == 162
 
 

agent/tests/test_card_selection_e2e.py

@@ -91,7 +91,7 @@ async def test_selected_cards_only_are_played(db_engine):
     try:
         reg = TenantEngineRegistry(loader=TenantConfigLoader(tenants_dir=_TENANTS_DIR, cache_ttl_seconds=0))
         eng = await reg.get_engine(str(_uuid.uuid4()))   # 자동 온보딩(_base type:db → 실 DB 카탈로그)
-        assert eng.action_space_size == 11               # 카탈로그 11장(NGC-001~011)
+        assert eng.action_space_size == 9                # 카탈로그 9장(NGC-006·009 소프트삭제)
 
         svc = ChatService()
         played = []

agent/tests/test_card_tactics.py

@@ -1,11 +1,12 @@
-"""카드 전술 재설계 검증 — "멘트 카드 → 전술 카드" (가격 행동 실행 계층).
+"""카드 전술 검증 — "스크립트에 꽂힌 변수가 곧 전술" (파싱 + 변수별 유효조건 + tactic JSONB).
 
-① 카운터 산식 결정론 + min(counter, target) 클램프 + 무의미 카운터(HOLD 강등)
-② 카운터 수락 = 즉시 타결 / 거절 = 재입력 + pending 폐기
-③ 목표가 초과 타결 금지 가드(성공 스텝 진입 차단)
-④ 선택형 와일드카드(WC-05 중간값 절충) 발동 — 1.02~1.05 구간 갭 해소
-⑤ E2E: 견적 선택 카드(NGC-009 조건부 가격 조정)의 카운터를 수락하면 settled=target
-⑥ E2E: 협력사가 target 초과를 고수하면 종결 전술(최후통첩) 후 결렬 — 고객사 이득 가드레일
+① 제안가 파싱(마지막 제안가 변수) + 변수별 계산식 결정론
+② 변수 공통 유효조건 — 목표가 초과·제시가 이상이면 미발동(클램프 아님 — IMK 8AB0 회귀)
+③ 카운터 수락 = 즉시 타결 / 거절 = 재입력 + pending 폐기
+④ 목표가 초과 타결 금지 가드(성공 스텝 진입 차단)
+⑤ 와일드 진입 — 종결 전용 카드 예약(중반 미발동) + 카드 이력 공유(중복 발동 차단, IMK BB9A 회귀)
+⑥ E2E: 견적 선택 카드(NGC-010 목표가 제안)의 카운터를 수락하면 settled=target
+⑦ E2E: 협력사가 target 초과를 고수하면 종결 전술(최후통첩) 후 결렬 — 고객사 이득 가드레일
 """
 
 import os
@@ -15,7 +16,8 @@ from datetime import datetime, timedelta, timezone
 import pytest
 
 from negotiation.cards.domain.tactics import (
-    PriceAction, TacticSpec, compute_counter, tactic_available, tactic_for,
+    CardSpec, HOLD, available, build_card_spec, compute_offer,
+    is_played, mark_played, parse_offer_variable, playable, spec_from_context,
 )
 from negotiation.chat.service.chat_engine import ChatEngine, ChatSession
 from negotiation.chat.service.script_repository import ScriptRepository
@@ -23,6 +25,12 @@ from tenancy.config_loader import TenantConfigLoader
 
 _TENANTS_DIR = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "tenants")
 
+# 엔진 단위 테스트용 카드 스펙(로더가 DB 스크립트 파싱으로 만드는 것과 같은 형태).
+_SPECS = {
+    "WC-02": {"offer_variable": "target_mid_price", "min_round": 1, "closing": False},
+    "WC-05": {"offer_variable": "middle_price", "min_round": 1, "closing": True},
+}
+
 
 def _engine() -> ChatEngine:
     cfg = TenantConfigLoader(tenants_dir=_TENANTS_DIR, cache_ttl_seconds=0).load("imarketkorea")
@@ -31,47 +39,134 @@ def _engine() -> ChatEngine:
 
 def _session(step="가격협상_확인", **ctx_over):
     ctx = {"input_price": 10300, "anchor_price": 10000, "target_price": 10100,
-           "round": 1, "allow_selected_wildcards": False}
+           "round": 1, "allow_selected_wildcards": False, "card_specs": dict(_SPECS)}
     ctx.update(ctx_over)
     return ChatSession(session_id="00000000-0000-0000-0000-00000000e001", tenant_id="imarketkorea",
                        company_id="imarketkorea", step=step, action_space_size=0, context=ctx)
 
 
-# ---- ① 카운터 산식 (결정론 + 가드레일 클램프) --------------------------------
-def test_counter_formulas_and_clamp():
+# ---- ① 제안가 파싱 + 계산식 ---------------------------------------------------
+def test_parse_offer_variable_last_offer_wins():
+    """제안가 변수가 여럿이면 마지막 것 — 카드 문장은 배경을 먼저, 제안을 마지막에 한다(WC-04)."""
+    assert parse_offer_variable("적정가는 {anchoring_price}원이었으나 {target_price}원으로 제안") == "target_price"
+    assert parse_offer_variable("{target_price}원을 제안 드립니다") == "target_price"
+    # 읽어주기 변수만 있으면 설득 카드 — 제안가 없음
+    assert parse_offer_variable("시장가 {internet_lowest_price}원 안팎, 제시가 {prev_partner_price}원") is None
+    assert parse_offer_variable("가격 변수 없는 설득 멘트") is None
+    assert parse_offer_variable(None) is None
+    # WC-05 정본: 읽어주기(직전 제안·제시가) 뒤 절충가 제안
+    assert parse_offer_variable("당사 제안 {prev_customer_price}원과 귀사 제안 {prev_partner_price}원을 절반씩, {middle_price}원으로") == "middle_price"
+    # negodata 에디터 칩 표기(anchor_price)도 앵커가 제안으로 인식 — DB 시드 표기(anchoring_price)의 별칭
+    assert parse_offer_variable("예산 한도는 {anchor_price}원입니다") == "anchor_price"
+
+
+def test_build_card_spec_merges_script_and_tactic():
+    spec = build_card_spec("{target_price}원으로 제안", {"min_round": 2, "closing": True})
+    assert spec == CardSpec(offer_variable="target_price", min_round=2, closing=True)
+    # tactic 없음 → 기본값. offer_variable override 는 파싱보다 우선.
+    assert build_card_spec("설득 멘트", None) == HOLD
+    assert build_card_spec("멘트", {"offer_variable": "anchoring_price"}).offer_variable == "anchoring_price"
+
+
+def test_offer_formulas():
     ctx = {"input_price": 11000, "anchor_price": 9900, "target_price": 10000}
-    assert compute_counter(tactic_for("NGC-009"), ctx) == 10000        # COUNTER_TARGET
-    assert compute_counter(tactic_for("NGC-007"), ctx) == 9900         # COUNTER_ANCHOR
-    assert compute_counter(tactic_for("WC-02"), ctx) == 9950           # (anchor+target)/2
-    # COUNTER_MID: 갑 직전 포지션 폴백 = anchor → (9900+11000)/2 = 10450 → target 클램프
-    assert compute_counter(tactic_for("WC-05"), ctx) == 10000
-    # 갑 직전 포지션이 있으면 그 기준: (9800+11000)/2 = 10400 → 역시 클램프 10000
-    assert compute_counter(tactic_for("WC-05"), dict(ctx, prev_customer_price=9800)) == 10000
-    # 클램프 미발동 구간: (9900+10050)/2 = 9975 ≤ target
-    assert compute_counter(tactic_for("WC-05"), dict(ctx, input_price=10050)) == 9975
+    offer = lambda var, c=None: compute_offer(CardSpec(offer_variable=var), c or ctx)  # noqa: E731
+    assert offer("target_price") == 10000
+    assert offer("anchoring_price") == 9900
+    assert offer("target_mid_price") == 9950                       # (anchor+target)/2
+    # 절충가: 갑 직전 포지션 폴백 = anchor → (8900+9500)/2 = 9200
+    assert offer("middle_price", dict(ctx, input_price=9500, anchor_price=8900)) == 9200
+    # 갑 직전 포지션이 있으면 그 기준: (9000+9500)/2 = 9250
+    assert offer("middle_price", dict(ctx, input_price=9500, prev_customer_price=9000)) == 9250
 
 
-def test_counter_meaningless_degrades_to_hold():
-    """협력사 제시가가 이미 카운터 이하면 카운터가 무의미 → None(순수 설득 유지)."""
+# ---- ② 변수 공통 유효조건 — 미발동(클램프 아님) --------------------------------
+def test_offer_over_target_does_not_fire_imk_8ab0():
+    """IMK 8AB0 회귀: 목표가 9,000 / 제시가 9,500 → 절충가 (8,910+9,500)/2 = 9,205 > 목표가.
+    구현이 목표가로 깎아 부르면 '중간에서 만나자며 목표가를 부르는' 모순 — 클램프가 아니라 미발동이 정답."""
+    ctx = {"input_price": 9500, "anchor_price": 8910, "target_price": 9000}
+    assert compute_offer(CardSpec(offer_variable="middle_price"), ctx) is None
+
+
+def test_offer_at_or_above_input_price_does_not_fire():
+    """협력사 제시가가 이미 제안가 이하면 부를 이유가 없다 → 미발동."""
     ctx = {"input_price": 9950, "anchor_price": 9900, "target_price": 10000}
-    assert compute_counter(tactic_for("NGC-009"), ctx) is None         # target(10000) ≥ 제시가
-    assert compute_counter(TacticSpec(PriceAction.COUNTER_ANCHOR), dict(ctx, input_price=9900)) is None
+    assert compute_offer(CardSpec(offer_variable="target_price"), ctx) is None      # target ≥ 제시가
+    assert compute_offer(CardSpec(offer_variable="anchoring_price"), dict(ctx, input_price=9900)) is None
 
 
-def test_unknown_card_falls_back_to_hold():
-    """미등록 카드번호(데모 NGC-B*, 커스텀 COMP-*)는 HOLD — 기존 동작 그대로."""
-    spec = tactic_for("NGC-B003")
-    assert spec.price_action is PriceAction.HOLD
-    assert compute_counter(spec, {"input_price": 11000, "target_price": 10000}) is None
-    assert tactic_available(spec, {}) is True
+def test_offer_without_materials_does_not_fire():
+    """재료 결측(목표가·제시가·앵커) — 어떤 변수도 미발동."""
+    assert compute_offer(CardSpec(offer_variable="target_price"), {"input_price": 11000}) is None   # 목표가 없음
+    assert compute_offer(CardSpec(offer_variable="anchoring_price"),
+                         {"input_price": 11000, "target_price": 10000}) is None                     # 앵커 없음
+    assert compute_offer(HOLD, {"input_price": 11000, "target_price": 10000}) is None               # 설득 카드
+    assert compute_offer(CardSpec(offer_variable="없는변수"), {"input_price": 11000, "target_price": 10000}) is None
 
 
-def test_tactic_availability_conditions():
-    assert tactic_available(tactic_for("WC-04"), {"round": 1}) is False   # min_round=2
-    assert tactic_available(tactic_for("WC-04"), {"round": 2}) is True
+def test_available_min_round_and_closing_phase():
+    spec2 = CardSpec(offer_variable="target_price", min_round=2)
+    assert available(spec2, {"round": 1}) is False                  # min_round 미만
+    assert available(spec2, {"round": 2}) is True
+    closing = CardSpec(offer_variable="middle_price", closing=True)
+    assert available(closing, {"round": 1}) is False                # 종결 전용 — 중반 미발동(예약)
+    assert available(closing, {"round": 1}, closing_phase=True) is True
+    assert available(spec2, {"round": 3}, closing_phase=True) is False  # 종결 국면엔 종결 카드만
 
 
-# ---- ② 카운터 수락/거절 메커니즘 (엔진) ---------------------------------------
+def test_tactic_offer_variable_overrides_parse():
+    """검증: tactic.offer_variable 명시 지정(negodata 셀렉트) — 파싱(마지막 변수) 대신 지정 변수 사용.
+    기대결과: 멘트 마지막이 target_price 여도 지정한 anchoring_price 가 제안가 변수가 된다."""
+    script = "적정가는 {anchoring_price}원이었으나 {target_price}원으로 제안 드립니다."
+    assert build_card_spec(script).offer_variable == "target_price"  # 자동: 마지막 변수
+    spec = build_card_spec(script, {"offer_variable": "anchoring_price"})
+    assert spec.offer_variable == "anchoring_price"                  # 명시 지정이 우선
+
+
+def test_available_requires_context_value():
+    """검증: 시장가 인용 카드(NGC-008류)의 requires 게이트 — build_card_spec 이 스크립트에서 잡아내고,
+    기대결과: 컨텍스트에 인터넷 최저가가 없으면(0/결측) 미발동, 있으면 발동(퍼즈 #3·13·23·40 회귀)."""
+    spec = build_card_spec("유사 거래는 {internet_lowest_price}원 안팎에서 합의되고 있습니다.")
+    assert spec.requires == ("internet_lowest_price",)
+    assert available(spec, {"round": 1}) is False                                   # 결측
+    assert available(spec, {"round": 1, "internet_lowest_price": 0}) is False       # 미수집(0)
+    assert available(spec, {"round": 1, "internet_lowest_price": 6300}) is True
+    # 일반 카드는 requires 없음 — 기존 동작 그대로.
+    assert build_card_spec("귀사와의 협력을 소중히 생각합니다.").requires == ()
+
+
+def test_offer_monotonic_no_regression():
+    """검증: 역행 금지(IMK 논의 — 절충 16,980 후 예산 상한 16,810 제시) 재현.
+    기대결과: 직전 당사 제안보다 낮은 제안가 카드는 미발동(설득 폴백으로도 안 나감).
+    직전 제안이 없으면 앵커 제시 허용, 같은 금액 재제시 허용, 더 높은 제안은 정상."""
+    anchor_card = CardSpec(offer_variable="anchoring_price")
+    ctx = {"round": 2, "target_price": 17_300, "anchor_price": 16_810, "input_price": 17_500}
+    assert compute_offer(anchor_card, ctx) == 16_810   # 첫 카운터 전(포지션=앵커): 같은 금액 → 허용
+    ctx["prev_customer_price"] = 16_980                # 절충 카드가 이미 16,980 을 부른 상태
+    assert compute_offer(anchor_card, ctx) is None     # 앵커 16,810 은 역행 → 미발동
+    assert playable(anchor_card, ctx) is False         # 멘트에 금액이 박히므로 설득 폴백도 금지
+    assert compute_offer(CardSpec(offer_variable="target_price"), ctx) == 17_300  # 상향 제안은 정상
+
+
+def test_played_history_is_shared_by_number():
+    ctx = {}
+    assert is_played(ctx, "WC-05") is False
+    mark_played(ctx, "WC-05")
+    assert is_played(ctx, "WC-05") is True
+    mark_played(ctx, "WC-05")                                       # 재기록해도 1건 유지
+    assert ctx["played_card_numbers"] == ["WC-05"]
+    mark_played(ctx, None)                                          # no-op(폴백 최후통첩)
+    assert ctx["played_card_numbers"] == ["WC-05"]
+
+
+def test_spec_from_context_reads_snapshot_and_falls_back_to_hold():
+    ctx = {"card_specs": dict(_SPECS)}
+    assert spec_from_context(ctx, "WC-05") == CardSpec(offer_variable="middle_price", min_round=1, closing=True)
+    assert spec_from_context(ctx, "NGC-B003") == HOLD               # 미등록 카드(데모) 폴백
+    assert spec_from_context({}, "WC-05") == HOLD                   # 스펙 미적재(구세션·데모) 폴백
+
+
+# ---- ③ 카운터 수락/거절 메커니즘 (엔진) ---------------------------------------
 def test_accept_counter_settles_at_counter_price():
     eng = _engine()
     s = _session(step="가격협상_카운터", pending_counter_price=10000)
@@ -102,7 +197,7 @@ def test_wildcard_1pct_decline_keeps_original_price():
     assert s.context["input_price"] == 10000                # 거절 → 카운터 미적용
 
 
-# ---- ③ 목표가 초과 타결 금지 가드 --------------------------------------------
+# ---- ④ 목표가 초과 타결 금지 가드 --------------------------------------------
 def test_success_step_guard_rejects_over_target():
     eng = _engine()
     s = _session(input_price=10800, target_price=10000)
@@ -110,20 +205,46 @@ def test_success_step_guard_rejects_over_target():
     assert view.step == "협상실패"                          # 초과가 성공 진입 → 결렬 강제
 
 
-# ---- ④ 선택형 와일드카드 발동 (1.02~1.05 구간 갭 해소) -------------------------
-def test_selected_wildcard_fires_in_entry_zone():
+# ---- ⑤ 와일드 진입 — 종결 예약 + 중복 차단 (IMK BB9A 회귀) ---------------------
+def test_selected_wildcard_fires_in_entry_zone_and_records_position():
+    eng = _engine()
+    # 10300: 1pct 존(≤10200) 밖, entry 존(≤10500) 안 + 비종결 WC-02 선택
+    s = _session(input_price=10300, allow_selected_wildcards=True,
+                 selected_wild_card_numbers=["WC-02"])
+    view = eng.advance(s, "예")
+    assert view.step == "wild_card_dynamic"
+    # 제안가 = (anchor 10000 + target 10100)/2 = 10050 ≤ target — 그대로 제시(클램프 없음)
+    assert s.context["pending_counter_price"] == 10050
+    assert s.context["prev_customer_price"] == 10050        # 갑 포지션 기록 — "당사 제안" 멘트 정합(BB9A ③)
+    assert s.context["active_wild_card_number"] == "WC-02"
+    assert is_played(s.context, "WC-02")                    # 카드 이력 기록
+    # 수락 → 그 가격으로 타결
+    view = eng.advance(s, "수락")
+    assert view.step == "협상완료" and s.context["input_price"] == 10050
+
+
+def test_closing_card_is_reserved_never_fires_mid_negotiation():
+    """종결 전용 카드(WC-05)는 entry 존이라도 중반에 안 나간다 — 종결 국면의 마지막 한 방으로 예약.
+    (BB9A 중복의 절반: 중반에 당겨 쓴 카드를 종결에서 또 쓰던 경로 차단.)"""
     eng = _engine()
-    # 10300: 1pct 존(≤10200) 밖, entry 존(≤10500) 안 + WC-05 선택
     s = _session(input_price=10300, allow_selected_wildcards=True,
                  selected_wild_card_numbers=["WC-05"])
     view = eng.advance(s, "예")
-    assert view.step == "wild_card_dynamic"
-    # 카운터 = (anchor 10000 + 10300)/2 = 10150 → target(10100) 클램프
-    assert s.context["pending_counter_price"] == 10100
-    assert s.context["active_wild_card_number"] == "WC-05"
-    # 수락 → 그 가격으로 타결
-    view = eng.advance(s, "수락")
-    assert view.step == "협상완료" and s.context["input_price"] == 10100
+    assert view.step == "가격협상"                          # 종결 카드뿐 → 일반 카드 플레이로
+    assert "active_wild_card_number" not in s.context
+    assert not is_played(s.context, "WC-05")                # 안 나갔으니 이력도 없음
+    # 종결 국면에선 발동 가능 + 이력 없음 — 서비스 종결 루프가 이 카드를 쓴다
+    spec = spec_from_context(s.context, "WC-05")
+    assert available(spec, s.context, closing_phase=True) is True
+
+
+def test_played_wildcard_is_skipped_on_reentry():
+    """이미 쓴 카드는 같은 협상에서 다시 안 나간다 — 다음 후보로 넘어간다."""
+    eng = _engine()
+    s = _session(input_price=10300, allow_selected_wildcards=True, wildcard_used=False,
+                 selected_wild_card_numbers=["WC-02"], played_card_numbers=["WC-02"])
+    view = eng.advance(s, "예")
+    assert view.step == "가격협상"                          # 유일 후보가 사용됨 → 발동 없음
 
 
 def test_unselected_wildcard_zone_still_falls_to_nego():
@@ -169,16 +290,24 @@ def test_price_confirm_script_renders_raise_correctly():
 # ---- vars_for 전술 변수 치환 ---------------------------------------------------
 def test_vars_for_supplies_tactic_variables():
     eng = _engine()
-    s = _session(input_price=10300, prev_customer_price=10000, pending_counter_price=10100)
-    v = eng.vars_for(s)
-    assert v["prev_partner_price"] == 10300
-    assert v["prev_customer_price"] == 10000
-    assert v["target_mid_price"] == 10050            # (10000+10100)/2
-    assert v["middle_price"] == 10150                # (10000+10300)/2
-    assert v["counter_price"] == 10100
+    # 카운터 미제시(정보성): 절충/중간 변수는 원 계산값.
+    s0 = _session(input_price=10300, prev_customer_price=10000)  # anchor=10000, target=10100 (기본)
+    v0 = eng.vars_for(s0)
+    assert v0["prev_partner_price"] == 10300
+    assert v0["prev_customer_price"] == 10000
+    assert v0["target_mid_price"] == 10050           # (anchor 10000 + target 10100)/2
+    assert v0["middle_price"] == 10150               # (prev_customer 10000 + input 10300)/2
+
+    # 카운터 제시 중: 표시 제시가(middle/target_mid/counter) == 타결가(pending) 로 고정.
+    #   회귀(표시가≠투찰가): 예전엔 middle_price 가 재계산값 10150 을 표시하면서 10100 으로 타결됐다.
+    s1 = _session(input_price=10300, prev_customer_price=10000, pending_counter_price=10100)
+    v1 = eng.vars_for(s1)
+    assert v1["counter_price"] == 10100
+    assert v1["middle_price"] == 10100               # 재계산 10150 이 아니라 pending
+    assert v1["target_mid_price"] == 10100
 
 
-# ---- ⑤⑥ E2E (실 DB — 견적 선택 카드 + 서비스 레이어) ---------------------------
+# ---- ⑥⑦ E2E (실 DB — 견적 선택 카드 + 서비스 레이어) ---------------------------
 from sqlalchemy import column, delete, insert, select, table  # noqa: E402
 
 from common.database.db_session_manager import DB_SESSION_MNG  # noqa: E402
@@ -203,24 +332,30 @@ _T_QUOTATIONS = table(
 )
 _T_VNC = table("version_nego_cards", column("vnc_id"), column("version_id"), column("nego_card_id"), schema="card")
 _T_NEGO = table("nego_cards", column("nego_card_id"), column("number"), column("deleted"), schema="card")
+_T_VWC = table("version_wild_cards", column("vwc_id"), column("version_id"), column("wild_card_id"), schema="card")
+_T_WILD = table("wild_cards", column("wild_card_id"), column("number"), column("deleted"), schema="card")
 
 
-async def _card_uuid(number: str):
+async def _card_uuid(number: str, *, wild=False):
+    tbl, pk = (_T_WILD, _T_WILD.c.wild_card_id) if wild else (_T_NEGO, _T_NEGO.c.nego_card_id)
+
     def _q(s):
         return DB_SESSION_MNG.execute(
-            s, select(_T_NEGO.c.nego_card_id).where(
-                _T_NEGO.c.number == number, _T_NEGO.c.deleted == False).limit(1))  # noqa: E712
+            s, select(pk).where(tbl.c.number == number, tbl.c.deleted == False).limit(1))  # noqa: E712
     _, rows = await DB_SESSION_MNG.execute_lambda(DBType.MAIN.value, DBWRType.DB_READ.value, _q)
     return rows[0] if rows else None
 
 
-async def _seed_quote_session(sid, selected_numbers, target=10000, anchor=9900):
+async def _seed_quote_session(sid, selected_numbers, wild_numbers=(), target=10000, anchor=9900):
     qid, ver_id, iid, sup = _uuid.uuid4(), _uuid.uuid4(), _uuid.uuid4(), _uuid.uuid4()
     now = datetime.now(timezone.utc)
-    card_ids = {}
+    card_ids, wild_ids = {}, {}
     for n in selected_numbers:
         card_ids[n] = await _card_uuid(n)
         assert card_ids[n] is not None, f"카탈로그에 {n} 없음(시드 확인)"
+    for n in wild_numbers:
+        wild_ids[n] = await _card_uuid(n, wild=True)
+        assert wild_ids[n] is not None, f"카탈로그에 {n} 없음(시드 확인)"
 
     def _seed(s_):
         async def run(s):
@@ -235,6 +370,11 @@ async def _seed_quote_session(sid, selected_numbers, target=10000, anchor=9900):
                     vnc_id=_uuid.uuid4(), version_id=ver_id, nego_card_id=card_ids[n]))
                 if e != ErrorType.SUCCESS:
                     return e
+            for n in wild_numbers:
+                e = await DB_SESSION_MNG.add(s, insert(_T_VWC).values(
+                    vwc_id=_uuid.uuid4(), version_id=ver_id, wild_card_id=wild_ids[n]))
+                if e != ErrorType.SUCCESS:
+                    return e
             return await DB_SESSION_MNG.add(s, insert(_T_SESSIONS).values(
                 session_id=sid, quotation_id=qid, item_id=iid, supplier_id=sup,
                 qt_number=f"QT-TACTIC-{str(sid)[:8]}", qt_round=1, qt_type=1,
@@ -252,17 +392,18 @@ async def _cleanup(sid, qid, ver_id):
         [DBType.MAIN.value],
         [lambda s: DB_SESSION_MNG.add(s, delete(_T_SESSIONS).where(_T_SESSIONS.c.session_id == sid)),
          lambda s: DB_SESSION_MNG.add(s, delete(_T_VNC).where(_T_VNC.c.version_id == ver_id)),
+         lambda s: DB_SESSION_MNG.add(s, delete(_T_VWC).where(_T_VWC.c.version_id == ver_id)),
          lambda s: DB_SESSION_MNG.add(s, delete(_T_QUOTATIONS).where(_T_QUOTATIONS.c.qt_id == qid))],
     )
 
 
 @pytest.mark.asyncio
 async def test_e2e_counter_accept_settles_at_target(db_engine):
-    """견적 선택 카드 NGC-009(조건부 가격 조정 → COUNTER_TARGET)의 카운터를 수락하면
-    합의가 = 목표가(10000) — '수락 즉시 타결' 기획 결정의 E2E 검증."""
+    """견적 선택 카드 NGC-010(향후 거래 연계 — 스크립트 {target_price} 파싱 → 목표가 제안)의
+    카운터를 수락하면 합의가 = 목표가(10000) — '수락 즉시 타결' 기획 결정의 E2E 검증."""
     reset_sessions()
     sid = _uuid.uuid4()
-    qid, ver_id = await _seed_quote_session(sid, ["NGC-009"])
+    qid, ver_id = await _seed_quote_session(sid, ["NGC-010"])
     try:
         reg = TenantEngineRegistry(loader=TenantConfigLoader(tenants_dir=_TENANTS_DIR, cache_ttl_seconds=0))
         eng = await reg.get_engine(str(_uuid.uuid4()))
@@ -271,9 +412,9 @@ async def test_e2e_counter_accept_settles_at_target(db_engine):
         r = None
         for ui in [None, "확인", "예", "확인", "11000", "예"]:
             r = await svc.chat(eng, Req_Chat(session_id=session_id, user_input=ui))
-        # 가격협상 카드 턴 → NGC-009 카운터(target) 제시 스텝
+        # 가격협상 카드 턴 → NGC-010 카운터(target) 제시 스텝
         assert r.step == "가격협상_카운터", f"카운터 스텝 기대, 실제 {r.step}"
-        assert r.card_id == "NGC-009"
+        assert r.card_id == "NGC-010"
         assert r.input_options == ["수락", "다른 가격 제시"]
 
         r = await svc.chat(eng, Req_Chat(session_id=session_id, user_input="수락"))
@@ -289,7 +430,7 @@ async def test_e2e_over_target_ends_in_failure_after_closing(db_engine):
     그래도 거절 → 결렬(협상실패). 목표가 초과로는 절대 타결되지 않는다."""
     reset_sessions()
     sid = _uuid.uuid4()
-    qid, ver_id = await _seed_quote_session(sid, ["NGC-003"])   # HOLD 카드 1장 → 빠른 소진
+    qid, ver_id = await _seed_quote_session(sid, ["NGC-003"])   # 설득 카드 1장 → 빠른 소진
     try:
         reg = TenantEngineRegistry(loader=TenantConfigLoader(tenants_dir=_TENANTS_DIR, cache_ttl_seconds=0))
         eng = await reg.get_engine(str(_uuid.uuid4()))
@@ -313,3 +454,46 @@ async def test_e2e_over_target_ends_in_failure_after_closing(db_engine):
         assert r.settled_price is None                       # 초과가 타결 없음
     finally:
         await _cleanup(sid, qid, ver_id)
+
+
+@pytest.mark.asyncio
+async def test_e2e_bb9a_no_duplicate_wildcard_and_real_middle(db_engine):
+    """IMK BB9A 재현 E2E — 와일드카드 2장(WC-02·WC-05) + 설득 카드 1장.
+
+    기대 흐름(수정 후):
+      · 중반 와일드 진입 = 비종결 WC-02 (종결 전용 WC-05 는 예약 — 구현 전엔 WC-05 가 먼저 나갔다)
+      · 종결 국면 = WC-05, 절충가 = (당사 직전 제안 + 협력사 제시가)/2 실계산 (구현 전엔 목표가로 클램프)
+      · 같은 카드 2회 발동 없음 + 종결 발동도 card_id 기록
+    """
+    reset_sessions()
+    sid = _uuid.uuid4()
+    qid, ver_id = await _seed_quote_session(sid, ["NGC-003"], wild_numbers=["WC-02", "WC-05"])
+    try:
+        reg = TenantEngineRegistry(loader=TenantConfigLoader(tenants_dir=_TENANTS_DIR, cache_ttl_seconds=0))
+        eng = await reg.get_engine(str(_uuid.uuid4()))
+        svc = ChatService()
+        session_id = str(sid)
+        r = None
+        # 10300: 1pct 존(≤ 9900×1.02=10098) 밖, entry 존(≤ 10395) 안 → 선택형 와일드 발동 구간
+        for ui in [None, "확인", "예", "확인", "10300", "예"]:
+            r = await svc.chat(eng, Req_Chat(session_id=session_id, user_input=ui))
+        assert r.step == "wild_card_dynamic"
+        assert r.card_id == "WC-02"                          # 종결 전용 WC-05 가 아니라 비종결 카드
+        # WC-02 제안가 = (anchor 9900 + target 10000)/2 = 9950
+        r = await svc.chat(eng, Req_Chat(session_id=session_id, user_input="다른 가격 제시"))
+        # 10010 재제시 → 설득 카드(NGC-003) 1장 소진
+        r = await svc.chat(eng, Req_Chat(session_id=session_id, user_input="10010"))
+        r = await svc.chat(eng, Req_Chat(session_id=session_id, user_input="예"))
+        assert r.step == "가격협상" and r.card_id == "NGC-003"
+        # 10005 재제시 → 카드 소진 → 종결 국면: WC-05 절충가 = (9950 + 10005)/2 = 9980 (≤ target)
+        r = await svc.chat(eng, Req_Chat(session_id=session_id, user_input="10005"))
+        r = await svc.chat(eng, Req_Chat(session_id=session_id, user_input="예"))
+        assert r.step == "가격협상_카운터"
+        assert r.card_id == "WC-05"                          # 종결 발동도 카드 기록(구현 전 null)
+        assert "9980" in r.script                            # 실제 절충가 — 목표가(10000) 클램프 아님
+
+        r = await svc.chat(eng, Req_Chat(session_id=session_id, user_input="수락"))
+        assert r.step == "협상완료"
+        assert r.settled_price == 9980                       # 표시가 = 타결가
+    finally:
+        await _cleanup(sid, qid, ver_id)

agent/tests/test_context_loader.py

@@ -186,11 +186,20 @@ async def test_loader_with_crud_double(db_engine):
 
     class _FakeCRUD(INegoContextCRUD):
         async def get_session_row(self, cdb, session_id):
-            # (qt_type, target, anchoring_price, item_id, quotation_id, supplier_id) — 재견적(2)·앵커 미박제
-            return ErrorType.SUCCESS, (2, 50000, None, uuid.uuid4(), uuid.uuid4(), uuid.uuid4())
+            # (qt_type, target, anchoring_price, done_ceiling_price, item_id, quotation_id, supplier_id)
+            #   — 재견적(2)·앵커 미박제·타결상한 52,500(목표가 +5%)
+            return ErrorType.SUCCESS, (2, 50000, None, 52500, uuid.uuid4(), uuid.uuid4(), uuid.uuid4())
 
-        async def get_item_price(self, cdb, item_id):
-            return ErrorType.SUCCESS, 7000
+        async def get_item_baseline(self, cdb, item_id):
+            # 기준가를 매입가로 고른 회사 + 거래상대 호칭을 '공급업체'로 바꾼 용어 사전.
+            # 호칭은 crud 가 어떤 회사든 '공급가'(공급사 화면 고정 용어)로 내려준다.
+            return ErrorType.SUCCESS, (7000, "공급가", {"supplier": "공급업체"})
+
+        async def get_item_lowest_price(self, cdb, item_id):
+            return ErrorType.SUCCESS, 6300  # 인터넷 최저가(items.internet_lowest_price)
+
+        async def get_card_count(self, cdb, session_id):
+            return ErrorType.SUCCESS, 3  # 협상카드 사용 횟수 상한(quotation_settings.card_count)
 
         async def get_supplier_total_revenue(self, cdb, supplier_id):
             return ErrorType.SUCCESS, 12_000_000.0
@@ -211,14 +220,24 @@ async def test_loader_with_crud_double(db_engine):
             return ErrorType.SUCCESS, 0  # 이력도 없음 → NONE
 
         async def get_quotation_card_numbers(self, cdb, quotation_id):
-            return ErrorType.SUCCESS, (["NGC-003", "NGC-008"], ["WC-02"])  # 견적 선택 카드
+            # 행 = (number, script, tactic) — 스크립트 파싱 + tactic JSONB 로 card_specs 를 만든다
+            return ErrorType.SUCCESS, (
+                [("NGC-003", "설득 멘트(가격 변수 없음)", None),
+                 ("NGC-008", "시장가 {internet_lowest_price}원 인용(읽기 전용 변수)", None)],
+                [("WC-02", "이에 당사는 {target_mid_price}원을 역으로 제안 드립니다.", None)],
+            )
 
     ctx = await NegotiationContextLoader(crud=_FakeCRUD()).load(str(uuid.uuid4()))
     assert ctx is not None
     assert ctx.rq_type == "재견적"            # qt_type=2(1:N)
     assert ctx.target_price == 50000
     assert ctx.anchor_price == 50000         # 미박제 → 무할인 폴백(anchor=target)
+    assert ctx.done_ceiling_price == 52500   # 타결 상한가 박제값(목표가 +5%)
     assert ctx.item_price == 7000
+    assert ctx.item_price_label == "공급가"          # 기준가 호칭이 멘트까지 전달되는지
+    assert ctx.labels == {"supplier": "공급업체"}    # 회사 용어 사전이 스크립트 토큰용으로 실리는지
+    assert ctx.internet_lowest_price == 6300   # 인터넷 최저가 로드 확인
+    assert ctx.card_count == 3                  # 협상카드 사용 횟수 상한 로드 확인
     assert ctx.partner_name == "테스트협력사"
     assert ctx.product_name == "테스트상품"
     assert ctx.revenue_amount == 12_000_000.0
@@ -226,6 +245,14 @@ async def test_loader_with_crud_double(db_engine):
     assert ctx.partner_type is PartnerType.NONE
     assert ctx.selected_nego_card_numbers == ["NGC-003", "NGC-008"]
     assert ctx.selected_wild_card_numbers == ["WC-02"]
+    # 카드 전술 확정 — 설득 카드/읽기 전용 변수는 제안가 없음, WC-02 는 스크립트 파싱으로 중간가.
+    assert ctx.card_specs["NGC-003"]["offer_variable"] is None
+    assert ctx.card_specs["NGC-008"]["offer_variable"] is None  # 인터넷 최저가는 읽어주기 변수 — 제안가 아님
+    # 시장가 인용 카드는 최저가 결측 세션에서 미발동하도록 requires 로 표시된다(토큰 노출 방지).
+    assert ctx.card_specs["NGC-008"]["requires"] == ["internet_lowest_price"]
+    assert ctx.card_specs["WC-02"] == {
+        "offer_variable": "target_mid_price", "min_round": 1, "closing": False, "requires": [],
+    }
 
 
 @pytest.mark.asyncio

agent/tests/test_decision_rules.py

@@ -49,9 +49,14 @@ def test_wildcard_threshold_is_config_driven():
     # 기본(1.02): anchor 10000, 제시 10800 → 임계 밖 → 일반 가격협상
     view = _engine().advance(_session(10800), "예")
     assert view.step == "가격협상"
-    # 임계를 1.10 으로 완화한 테넌트 → 같은 가격에서 1% 인하 와일드카드 발동
-    view = _engine(wildcard_1pct_ratio=1.10).advance(_session(10800), "예")
+    # 임계를 1.10 으로 완화한 테넌트 → 같은 가격에서 1% 인하 와일드카드 발동.
+    #   1%가(10800×0.99=10692)도 제안가 공통 유효조건(≤목표가)을 타므로 목표가를 그 위로 둔다 —
+    #   기본 target(10100)이면 초과 제시 금지 규칙에 걸려 발동하지 않는 게 새 정답.
+    view = _engine(wildcard_1pct_ratio=1.10).advance(_session(10800, target_price=11000), "예")
     assert view.step == "wild_card_1pct"
+    # 목표가가 1%가 아래면(초과 제시 금지) 완화 임계라도 미발동 — 수락해도 결렬되는 모순 제안 차단.
+    view = _engine(wildcard_1pct_ratio=1.10).advance(_session(10800), "예")
+    assert view.step == "가격협상"
 
 
 def test_max_counter_rounds_is_config_driven():

agent/tests/test_negotiation_invariants.py

@@ -0,0 +1,190 @@
+"""협상 불변식 시나리오 하네스 — 실서비스 스택(ChatService + 실 DB 카드)으로 13개 협상을 완주시키고,
+IMK 가 잡은 두 부류의 사고(같은 카드 반복 · 이상한 금액)가 어떤 흐름에서도 안 나는지 검사한다.
+
+시나리오별 기대 이벤트(카드가 나간 턴의 step·카드·금액)를 정확히 못박고, 공통 불변식을 전 턴에 건다:
+  · 카드 중복 없음 — 한 협상에서 같은 card_id 2회 발동 금지
+  · 카드 자리 규칙 — 종결 전용(WC-03·05)은 가격협상_카운터에서만, 비종결 와일드는 wild_card_dynamic 에서만
+  · 타결가 ≤ 목표가 — 어떤 성공 경로도 목표가 초과로 안 끝남
+  · 카운터 멘트의 금액 = 수락 시 타결가 (표시가=타결가)
+"""
+
+import uuid as _uuid
+from dataclasses import dataclass, field
+from typing import Optional
+
+import pytest
+
+from router.v1.chat.protocol import Req_Chat
+from services.chat_service import ChatService, reset_sessions
+from tenancy.config_loader import TenantConfigLoader
+from tenancy.registry import TenantEngineRegistry
+from tests.test_card_tactics import _TENANTS_DIR, _cleanup, _seed_quote_session
+
+# 종결 전용 와일드카드(DB tactic 시드와 동일) — 자리 규칙 검사용.
+_CLOSING_WILDS = {"WC-03", "WC-05"}
+_NONCLOSING_WILDS = {"WC-01", "WC-02", "WC-04"}
+# 카드가 나갈 수 있는 스텝(이벤트로 수집).
+_CARD_STEPS = {"가격협상", "wild_card_dynamic", "wild_card_1pct", "가격협상_카운터"}
+_BOILERPLATE = [None, "확인", "예", "확인"]
+
+
+@dataclass
+class Scenario:
+    name: str
+    inputs: list                      # 서두(안내~기존가격제시) 이후의 협력사 입력 시퀀스
+    # 기대 이벤트: (step, card, offer_substring). card="NGC-*" 는 임의 협상카드(중복만 검사).
+    events: list
+    settled: Optional[int]            # 기대 타결가(원). None=결렬
+    nego: list = field(default_factory=lambda: ["NGC-001"])
+    wild: list = field(default_factory=list)
+    target: int = 10_000
+    anchor: int = 9_900
+
+
+# 밴드(기본 target 10000·anchor 9900): 1% 존 ≤ 10,098 · 진입 존 ≤ 10,395.
+SCENARIOS = [
+    # S01 BB9A 재현 — 중반 비종결 WC-02, 종결 WC-05 실절충가. 같은 카드 2회 없음.
+    Scenario("S01_bb9a_mid_wc02_close_wc05",
+             ["10300", "예", "다른 가격 제시", "10010", "예", "10005", "예", "수락", "확인"],
+             [("wild_card_dynamic", "WC-02", "9950"),
+              ("가격협상", "NGC-001", None),
+              ("가격협상_카운터", "WC-05", "9980")],
+             settled=9980, wild=["WC-02", "WC-05"]),
+    # S02 8AB0 재현 — 절충가(9,205)가 목표가(9,000) 초과 → WC-05 미발동, 목표가 최후통첩(카드 없음).
+    Scenario("S02_8ab0_middle_over_target_skips",
+             ["9500", "예", "9500", "예", "다른 가격 제시", "9500", "예", "확인"],
+             [("가격협상", "NGC-001", None),
+              ("가격협상_카운터", None, "9000")],
+             settled=None, wild=["WC-05"], target=9_000, anchor=8_910),
+    # S03 와일드 5장 전부 + 협상카드 2장 — 중반 1장(WC-01)·종결 1장(WC-03)만, 협상카드는 서로 다른 2장.
+    Scenario("S03_five_wilds_full_run",
+             ["10300", "예", "다른 가격 제시", "10200", "예", "10150", "예", "10100", "예", "수락", "확인"],
+             [("wild_card_dynamic", "WC-01", "10000"),
+              ("가격협상", "NGC-*", None),
+              ("가격협상", "NGC-*", None),
+              ("가격협상_카운터", "WC-03", "10000")],
+             settled=10_000, nego=["NGC-001", "NGC-003"],
+             wild=["WC-01", "WC-02", "WC-03", "WC-04", "WC-05"]),
+    # S04 종결 전용 와일드만 담김 + 제시가가 진입 존에 머무름 — 소진 판정이 막히지 않고
+    #     종결로 넘어간다(프로브 픽스 회귀: 픽스 전엔 빈 덱에서 쓴 카드를 또 꺼내는 무한 협상).
+    Scenario("S04_closing_only_wild_no_deadlock",
+             ["10300", "예", "10250", "예", "수락", "확인"],
+             [("가격협상", "NGC-001", None),
+              ("가격협상_카운터", None, "10000")],   # WC-05 절충 10,075>목표가 → 미발동 → 최후통첩
+             settled=10_000, wild=["WC-05"]),
+    # S05 1% 존 — 시스템 1% 카드, 수락 시 표시 금액 그대로 타결.
+    Scenario("S05_one_pct_zone_accept",
+             ["10050", "예", "예", "확인"],
+             [("wild_card_1pct", None, "9950")],
+             settled=9_950),
+    # S06 앵커 이하 즉시 타결 — 카드 0장.
+    Scenario("S06_priority_match_no_cards",
+             ["9800", "예", "확인"],
+             [],
+             settled=9_800),
+    # S07 목표가 초과 고수 → 설득 1장 → 최후통첩 → 결렬.
+    Scenario("S07_hold_high_fails",
+             ["11000", "예", "11000", "예", "다른 가격 제시", "11000", "예", "확인"],
+             [("가격협상", "NGC-003", None),
+              ("가격협상_카운터", None, "10000")],
+             settled=None, nego=["NGC-003"]),
+    # S08 협상카드 카운터(NGC-010 목표가 제안) 수락 — 협상카드도 카운터 스텝을 쓴다.
+    Scenario("S08_nego_counter_accept",
+             ["11000", "예", "수락", "확인"],
+             [("가격협상_카운터", "NGC-010", "10000")],
+             settled=10_000, nego=["NGC-010"]),
+    # S09 min_round=2 — WC-04 는 1라운드 진입 존에서 안 나가고 2라운드에 나간다.
+    Scenario("S09_min_round_two_defers_wc04",
+             ["10300", "예", "10200", "예", "수락", "확인"],
+             [("가격협상", "NGC-001", None),
+              ("wild_card_dynamic", "WC-04", "10000")],
+             settled=10_000, wild=["WC-04"]),
+    # S10 종결 체인 폴백 — WC-05 무효(절충 10,175>목표) → 다음 종결 WC-03 발동.
+    Scenario("S10_closing_chain_falls_to_wc03",
+             ["10500", "예", "10450", "예", "다른 가격 제시", "10450", "예", "확인"],
+             [("가격협상", "NGC-001", None),
+              ("가격협상_카운터", "WC-03", "10000")],
+             settled=None, wild=["WC-05", "WC-03"]),
+    # S11 중반+종결 콤보 — WC-02 중반, 종결은 WC-05 무효 건너뛰고 WC-03. 전 카드 1회씩.
+    Scenario("S11_mid_and_closing_combo",
+             ["10300", "예", "다른 가격 제시", "10400", "예", "10350", "예", "수락", "확인"],
+             [("wild_card_dynamic", "WC-02", "9950"),
+              ("가격협상", "NGC-001", None),
+              ("가격협상_카운터", "WC-03", "10000")],
+             settled=10_000, wild=["WC-02", "WC-05", "WC-03"]),
+    # S12 라운드 상한 — 협상카드 3장 각 1회(중복 없음) 후 상한 도달 → 최후통첩 → 결렬.
+    Scenario("S12_round_cap_distinct_nego_cards",
+             ["11000", "예", "11000", "예", "11000", "예", "11000", "예", "다른 가격 제시", "11000", "예", "확인"],
+             [("가격협상", "NGC-*", None),
+              ("가격협상", "NGC-*", None),
+              ("가격협상", "NGC-*", None),
+              ("가격협상_카운터", None, "10000")],
+             settled=None, nego=["NGC-001", "NGC-002", "NGC-003", "NGC-004", "NGC-005"]),
+    # S13 재생성 아님·재료 극단 — 앵커 미박제 세션(anchor=target 폴백)에서도 초과 제시·중복 없음.
+    Scenario("S13_anchor_equals_target_fallback",
+             ["10300", "예", "10200", "예", "수락", "확인"],
+             [("가격협상", "NGC-001", None),
+              ("가격협상_카운터", "WC-03", "10000")],   # WC-05 절충 (10000+10200)/2=10100>목표 → 스킵
+             settled=10_000, wild=["WC-05", "WC-03"], anchor=10_000),
+    # S14 역행 금지(IMK 논의 재현) — 절충 카드(9,950) 뒤에 예산 상한 카드(NGC-007, 앵커 9,900)가
+    #     선택돼 있어도 발동하지 않는다(설득 폴백으로도 안 나감). 낼 카드가 없어져 종결(목표가 최후통첩)로.
+    Scenario("S14_no_offer_regression",
+             ["10300", "예", "다른 가격 제시", "10200", "예", "수락", "확인"],
+             [("wild_card_dynamic", "WC-02", "9950"),
+              ("가격협상_카운터", None, "10000")],      # NGC-007 이벤트가 없어야 함(역행 차단)
+             settled=10_000, nego=["NGC-007"], wild=["WC-02"]),
+]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("sc", SCENARIOS, ids=[s.name for s in SCENARIOS])
+async def test_negotiation_invariants(db_engine, sc: Scenario):
+    reset_sessions()
+    sid = _uuid.uuid4()
+    qid, ver_id = await _seed_quote_session(sid, sc.nego, wild_numbers=sc.wild,
+                                            target=sc.target, anchor=sc.anchor)
+    try:
+        reg = TenantEngineRegistry(loader=TenantConfigLoader(tenants_dir=_TENANTS_DIR, cache_ttl_seconds=0))
+        eng = await reg.get_engine(str(_uuid.uuid4()))
+        svc = ChatService()
+        trace, settled, outcome = [], None, None
+        for ui in [*_BOILERPLATE, *sc.inputs]:
+            r = await svc.chat(eng, Req_Chat(session_id=str(sid), user_input=ui))
+            assert r.result.success is True, f"{sc.name}: 턴 실패 input={ui} msg={r.msg}"
+            trace.append(r)
+            if r.settled_price is not None:
+                settled = r.settled_price
+            if r.chat_end:
+                outcome = r.outcome
+
+        # ── 기대 이벤트(카드/카운터 턴) 정확 일치 ──
+        events = [r for r in trace if r.step in _CARD_STEPS]
+        got = [(r.step, r.card_id) for r in events]
+        assert len(events) == len(sc.events), f"{sc.name}: 이벤트 수 {got} ≠ 기대 {sc.events}"
+        for r, (step, card, offer) in zip(events, sc.events):
+            assert r.step == step, f"{sc.name}: step {r.step} ≠ {step} (전체 {got})"
+            if card == "NGC-*":
+                assert r.card_id and r.card_id.startswith("NGC-"), f"{sc.name}: 협상카드 기대, 실제 {r.card_id}"
+            else:
+                assert r.card_id == card, f"{sc.name}: card {r.card_id} ≠ {card} (전체 {got})"
+            if offer is not None:
+                assert offer in (r.script or ""), f"{sc.name}: 멘트에 금액 {offer} 없음 — {r.script[:80]}"
+
+        # ── 공통 불변식 ──
+        played = [r.card_id for r in events if r.card_id]
+        assert len(played) == len(set(played)), f"{sc.name}: 카드 중복 발동 {played}"
+        for r in events:
+            if r.card_id in _CLOSING_WILDS:
+                assert r.step == "가격협상_카운터", f"{sc.name}: 종결 카드 {r.card_id}가 중반({r.step})에 발동"
+            if r.card_id in _NONCLOSING_WILDS:
+                assert r.step == "wild_card_dynamic", f"{sc.name}: 비종결 와일드 {r.card_id}가 {r.step}에서 발동"
+
+        # ── 결말 ──
+        if sc.settled is None:
+            assert outcome == "failure" and settled is None, f"{sc.name}: 결렬 기대, settled={settled} outcome={outcome}"
+        else:
+            assert outcome == "success", f"{sc.name}: 타결 기대, outcome={outcome}"
+            assert settled == sc.settled, f"{sc.name}: 타결가 {settled} ≠ 기대 {sc.settled}"
+            assert settled <= sc.target, f"{sc.name}: 목표가 초과 타결 {settled} > {sc.target}"
+    finally:
+        await _cleanup(sid, qid, ver_id)

agent/tests/test_p4_registry_middleware.py

@@ -35,7 +35,7 @@ async def test_two_tenants_distinct_engines():
     assert e1.mapper.get_card_id(0) == "NGC-001"
     assert e2.mapper.get_card_id(0) == "NGC-B001"
     # 차원
-    assert e1.state_space_size == 162 and e1.action_space_size == 11
+    assert e1.state_space_size == 162 and e1.action_space_size == 9  # 카탈로그 9장(NGC-006·009 소프트삭제)
 
 
 @pytest.mark.asyncio
@@ -69,7 +69,7 @@ async def test_unregistered_company_id_auto_onboards():
     reg = _registry()
     # 미등록 company_id(uuid)는 _base 자동 온보딩 → 엔진 생성됨(베이스 9카드, 162 state).
     eng = await reg.get_engine("00000000-0000-0000-0000-000000000001")
-    assert eng.action_space_size == 11 and eng.state_space_size == 162
+    assert eng.action_space_size == 9 and eng.state_space_size == 162  # DB 카탈로그 9장
     assert eng.company_id == "00000000-0000-0000-0000-000000000001"
     assert reg.is_registered("imarketkorea") is True
     # 빈 키만 미등록 → KeyError

agent/tests/test_p5_warmstart.py

@@ -69,27 +69,27 @@ async def test_cold_start_creates_warmstart_version(db_engine):
 
 @pytest.mark.asyncio
 async def test_catalog_dim_change_migrates_preserving_learning(db_engine):
-    """카탈로그 카드 수 변경(9→11) 시 학습 보존 마이그레이션 — 겹치는 셀 복사 + 새 카드 fresh."""
+    """카탈로그 카드 수 변경(7→9) 시 학습 보존 마이그레이션 — 겹치는 셀 복사 + 새 카드 fresh."""
     import uuid as _uuid
     cid = str(_uuid.uuid4())
-    # 이 회사 활성 버전을 A=9 로 시드 + 셀 (5,2)=0.9
+    # 이 회사 활성 버전을 A=7 로 시드 + 셀 (5,2)=0.9
     repo = LearningRepository(cid)
     vid = await repo.get_or_create_active_version(
-        state_space_size=162, action_space_size=9, learning_rate=0.1, discount_factor=0.95,
-        scope=2, version_name="old_v9")
+        state_space_size=162, action_space_size=7, learning_rate=0.1, discount_factor=0.95,
+        scope=2, version_name="old_v7")
     await repo.upsert_cell(vid, state_index=5, action_id=2, q_value=0.9, count=7)
 
-    # 엔진(_base type:db → 카탈로그 11장) 로드 → 9≠11 감지 → 마이그레이션
+    # 엔진(_base type:db → 카탈로그 9장) 로드 → 7≠9 감지 → 마이그레이션
     eng = await _reg().get_engine(cid)
-    assert eng.action_space_size == 11
+    assert eng.action_space_size == 9
     policy, new_vid, _ = await QTablePolicyStore.load(eng)
     assert str(new_vid) != str(vid)            # 새 버전
     assert policy.qtable.q[5, 2] == 0.9        # 기존 학습 보존
-    assert policy.qtable.q[5, 10] == 0.0       # 새 카드(action 10) fresh
+    assert policy.qtable.q[5, 8] == 0.0        # 새 카드(action 8) fresh
     assert policy.qtable.visits[5, 2] == 7     # 방문수도 보존
     # 새 버전이 활성 · 차원 11
     err, active = await repo.read(lambda s: repo.get_active_version(s))
-    assert str(active.version_id) == str(new_vid) and active.action_space_size == 11
+    assert str(active.version_id) == str(new_vid) and active.action_space_size == 9
 
 
 @pytest.mark.asyncio

agent/tests/test_p7_chat.py

@@ -162,6 +162,31 @@ def test_card_id_fixed_mapping_and_selection_mask():
     assert ChatService._selection_mask(eng, session) is None
 
 
+def test_counter_display_price_equals_settlement():
+    """회귀(표시가≠투찰가): 카운터 제시 중 멘트에 보이는 절충/중간 변수
+    (middle_price·target_mid_price)는 수락 시 타결가(pending_counter_price)와 정확히 일치해야 한다.
+
+    버그: WC-05(중간값 절충)에서 compute_counter 는 target 클램프·prev_customer 갱신으로 1,700,000 을
+    pending 으로 적재하는데, vars_for 가 {middle_price} 를 재계산해 1,740,000 으로 표시 → 화면엔
+    1,740,000 인데 실제로는 1,700,000 으로 투찰되던 문제. pending 으로 고정해 표시가==타결가."""
+    cfg = TenantConfigLoader(tenants_dir=_TENANTS_DIR, cache_ttl_seconds=0).load("imarketkorea")
+    repo = ScriptRepository(cfg, _TENANTS_DIR)
+    engine = ChatEngine(repo, rq_type="재협상")
+    session = ChatSession(
+        session_id="00000000-0000-0000-0000-000000000009",
+        tenant_id="imarketkorea", company_id="imarketkorea", action_space_size=0,
+        context={
+            "anchor_price": 2000000, "target_price": 1700000, "input_price": 1780000,
+            "prev_customer_price": 1700000,      # 종결 전술이 counter 로 덮어쓴 상태
+            "pending_counter_price": 1700000,    # compute_counter 의 target 클램프 결과(실제 타결가)
+        },
+    )
+    v = engine.vars_for(session)
+    assert v["counter_price"] == 1700000
+    assert v["middle_price"] == 1700000      # 재계산값 1,740,000 이 아니라 pending
+    assert v["target_mid_price"] == 1700000
+
+
 def test_default_1pct_wildcard_still_runs_without_selected_wildcard():
     """1% 인하는 기본 제공 카드라 DB 견적에서 와일드카드를 선택하지 않아도 발동한다."""
     cfg = TenantConfigLoader(tenants_dir=_TENANTS_DIR, cache_ttl_seconds=0).load("imarketkorea")

agent/tests/test_scripts_resources.py

@@ -42,7 +42,10 @@ def test_requote_structure_preserved():
     for key in ["서비스안내", "가격제안", "배송형태선택", "가격협상_확인", "결과안내", "결과제출", "협상종료"]:
         assert key in s
     assert s["배송형태선택"]["next_input_mode"] == "delivery_type"
-    assert s["배송형태선택"]["input_options"] == ["협력사배송", "지정택배배송", "픽업배송"]
+    # 리소스 원본은 회사 용어 토큰({label_*}) — 렌더 시 회사 라벨(없으면 기본값)로 치환된다.
+    assert s["배송형태선택"]["input_options"] == [
+        "{label_delivery_type_1}", "{label_delivery_type_2}", "{label_delivery_type_3}",
+    ]
 
 
 def test_wildcard_present_and_merged():
@@ -170,3 +173,24 @@ async def test_resolve_card_script_prefer_db_for_selected_cards(monkeypatch):
 
     out = await repo.resolve_card_script(1, "2", {"input_price": 10200}, prefer_db=True)
     assert out == "선택 카드 DB 멘트 **10200원**"
+
+
+def test_option_label_tokens_rendered():
+    """검증: 옵션에 회사 용어 토큰({label_delivery_type_*})이 있는 스텝을 정상 렌더·에러 재렌더로 출력.
+    기대결과: 두 경로 모두 버튼 문자열이 기본 라벨(협력사배송 등)로 치환되고 토큰이 남지 않는다."""
+    import os
+
+    from negotiation.chat.service.chat_engine import ChatEngine, ChatSession
+    from tenancy.config_loader import TenantConfigLoader
+
+    tenants = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "tenants")
+    cfg = TenantConfigLoader(tenants_dir=tenants, cache_ttl_seconds=0).load("_base")
+    engine = ChatEngine(ScriptRepository(cfg, tenants), rq_type="재견적")
+    session = ChatSession(session_id="s", tenant_id="_base", company_id="_base")
+
+    view = engine.render_step(session, "배송형태선택")
+    assert view.input_options == ["협력사배송", "지정택배배송", "픽업배송"]
+
+    # 에러 재렌더(잘못된 입력 등)도 같은 치환을 타야 한다 — raw 옵션이면 토큰이 버튼에 노출된다.
+    err_view = engine._error(session, "다시 선택해 주세요.")
+    assert err_view.input_options == ["협력사배송", "지정택배배송", "픽업배송"]

backend/common/database/model/models.py

@@ -58,6 +58,21 @@ class suppliers(MAIN_BASE):
     deleted = Column(Boolean, nullable=False, server_default=text("false"))                                          # 소프트 삭제 여부
 
 
+class companies(MAIN_BASE):
+    # company.companies (고객사). 공급사 포털 브랜딩(settings.branding) 조회 전용 미러.
+    @staticmethod
+    def DBType():
+        return DBType.PARTNER.value
+
+    __tablename__ = "companies"
+    __table_args__ = {"schema": "company"}
+
+    company_id = Column(UUID(as_uuid=True), primary_key=True, server_default=text("gen_random_uuid()"))              # 회사 식별자(PK)
+    name = Column(String(100), nullable=False)                                                                       # 회사명
+    settings = Column(JSONB, nullable=True)                                                                          # 회사별 커스터마이징(branding/labels 등, negodata 소유)
+    deleted = Column(Boolean, nullable=False, server_default=text("false"))                                          # 소프트 삭제 여부
+
+
 class items(MAIN_BASE):
     # partner.items (상품).
     @staticmethod
@@ -123,6 +138,7 @@ class sessions(MAIN_BASE):
     reject_reason = Column(String(255), nullable=True)                                                               # 거절 사유
     reject_price = Column(BigInteger, nullable=True)                                                                 # 거절 시 제시가(원)
     reject_delivery_type = Column(SmallInteger, nullable=True)                                                       # 거절 시 배송 유형 (코드)
+    custom = Column(JSONB, nullable=True)                                                                            # 협상완료 부가정보 값 {key: value} (정의는 companies.settings.session_fields)
     created_at = Column(DateTime(timezone=True), nullable=False, server_default=text("(now() AT TIME ZONE 'utc')"))  # 생성 시각(UTC)
     updated_at = Column(DateTime(timezone=True), nullable=False, server_default=text("(now() AT TIME ZONE 'utc')"), onupdate=text("(now() AT TIME ZONE 'utc')"))  # 수정 시각(UTC, UPDATE 시 자동 갱신)
     deleted = Column(Boolean, nullable=False, server_default=text("false"))                                          # 소프트 삭제 여부
@@ -157,6 +173,7 @@ class quotations(MAIN_BASE):
     preferred_sp_yn = Column(Boolean, nullable=True)                                                                 # 선호 공급사 지정 여부
     preferred_sp_id = Column(UUID(as_uuid=True), nullable=True)                                                      # 선호 공급사(partner.suppliers.supplier_id)
     preferred_sp_name = Column(String(20), nullable=True)                                                            # 선호 공급사명(스냅샷)
+    close_reason = Column(SmallInteger, nullable=True)                                                               # 마감 사유(CloseReason). 재협상 요청 자격 판정에 읽는다
     equal_bid_yn = Column(Boolean, nullable=True)                                                                    # 동일가 입찰 발생 여부
     equal_bid_data = Column(JSONB, nullable=True)                                                                    # 동일가 입찰 상세(JSON)
     created_at = Column(DateTime(timezone=True), nullable=False, server_default=text("(now() AT TIME ZONE 'utc')"))  # 생성 시각(UTC)
@@ -164,6 +181,28 @@ class quotations(MAIN_BASE):
     deleted = Column(Boolean, nullable=False, server_default=text("false"))                                          # 소프트 삭제 여부
 
 
+class notifications(MAIN_BASE):
+    # company.notifications (담당자 인박스). 포털은 재협상 요청 알림을 만들기 위해서만 쓴다(조회는 negodata).
+    # company 스키마 전용 DBType 이 없어 USER 커넥션을 재사용한다(물리 DB 동일).
+    @staticmethod
+    def DBType():
+        return DBType.USER.value
+
+    __tablename__ = "notifications"
+    __table_args__ = {"schema": "company"}
+
+    notification_id = Column(UUID(as_uuid=True), primary_key=True, server_default=text("gen_random_uuid()"))
+    user_id = Column(UUID(as_uuid=True), nullable=False)                                                             # 수신자(company.users.user_id) = 견적 작성자
+    type = Column(SmallInteger, nullable=False)                                                                      # NotificationType
+    ref_qt_id = Column(UUID(as_uuid=True), nullable=True)
+    ref_session_id = Column(UUID(as_uuid=True), nullable=True)
+    data = Column(JSONB, nullable=True)                                                                              # 렌더 스냅샷(공급사명·사유·희망가 등)
+    read_at = Column(DateTime(timezone=True), nullable=True)
+    created_at = Column(DateTime(timezone=True), nullable=False, server_default=text("(now() AT TIME ZONE 'utc')"))
+    updated_at = Column(DateTime(timezone=True), nullable=False, server_default=text("(now() AT TIME ZONE 'utc')"), onupdate=text("(now() AT TIME ZONE 'utc')"))
+    deleted = Column(Boolean, nullable=False, server_default=text("false"))
+
+
 class quotation_settings(MAIN_BASE):
     # quotation.quotation_settings (견적 설정). 견적 설정 스냅샷 — anchoring_value 는 구(舊) 앵커 산출용으로 채팅 경로에서는 더 이상 사용하지 않음(앵커는 sessions.anchoring_price 박제값).
     @staticmethod
@@ -183,6 +222,34 @@ class quotation_settings(MAIN_BASE):
     deleted = Column(Boolean, nullable=False, server_default=text("false"))                                          # 소프트 삭제 여부
 
 
+class nego_cards(MAIN_BASE):
+    # card.nego_cards (협상카드). backend 는 번호→UUID 변환(chats.card_id 저장)만 위해 최소 컬럼 미러.
+    @staticmethod
+    def DBType():
+        return DBType.NEGOTIATION.value  # 같은 negosium_db — chats 와 동일 세션풀로 조회
+
+    __tablename__ = "nego_cards"
+    __table_args__ = {"schema": "card"}
+
+    nego_card_id = Column(UUID(as_uuid=True), primary_key=True, server_default=text("gen_random_uuid()"))
+    number = Column(String(10), nullable=True)                                                                       # 카드 번호(agent turn.card_id 와 매칭)
+    deleted = Column(Boolean, nullable=False, server_default=text("false"))
+
+
+class wild_cards(MAIN_BASE):
+    # card.wild_cards (와일드카드). backend 는 번호→UUID 변환(chats.card_id 저장)만 위해 최소 컬럼 미러.
+    @staticmethod
+    def DBType():
+        return DBType.NEGOTIATION.value  # 같은 negosium_db
+
+    __tablename__ = "wild_cards"
+    __table_args__ = {"schema": "card"}
+
+    wild_card_id = Column(UUID(as_uuid=True), primary_key=True, server_default=text("gen_random_uuid()"))
+    number = Column(String(10), nullable=True)
+    deleted = Column(Boolean, nullable=False, server_default=text("false"))
+
+
 class chats(MAIN_BASE):
     # negotiation.chats (협상 채팅 메시지 로그). session 1 : N chats. (session_id, seq) 유니크.
     @staticmethod

backend/common/enums.py

@@ -130,6 +130,41 @@ class QuotationStatus(Enum):
     CLOSED = 3       # 견적마감
 
 
+class CloseReason(Enum):
+    """견적 마감 사유. quotation.quotations.close_reason
+    낙찰(AWARDED) 외 OPEN_* 는 낙찰자 미정으로 마감된 '결렬' 건 — 공급사 재협상 요청 대상."""
+
+    AWARDED = 1      # 낙찰
+    OPEN_PRICE = 5   # 개찰: 낙찰 기준 미달
+    OPEN_EQUAL = 6   # 개찰: 동가
+    OPEN_NOSHOW = 7  # 개찰: 전원 미응찰
+    OPEN_REJECT = 8  # 개찰: 협상거부 존재
+
+
+# 재협상 요청 가능한 마감 사유(낙찰 건은 제외).
+RENEGOTIABLE_CLOSE_REASONS = (
+    CloseReason.OPEN_PRICE.value,
+    CloseReason.OPEN_EQUAL.value,
+    CloseReason.OPEN_NOSHOW.value,
+    CloseReason.OPEN_REJECT.value,
+)
+
+
+class RenegotiationStatus(Enum):
+    """sessions.custom.renegotiation.status — 공급사 재협상 요청 상태(IMK #15)."""
+
+    PENDING = 1    # 접수, 담당자 심사 대기
+    APPROVED = 2   # 승인 — 다음 라운드 생성됨
+    REJECTED = 3   # 반려
+    CANCELED = 4   # 공급사 철회
+
+
+class NotificationType(Enum):
+    """company.notifications.type — negodata 담당자 인박스. 포털에서 만드는 건 재협상 요청뿐."""
+
+    RENEGO_REQUESTED = 5
+
+
 class ChatSender(Enum):
     """채팅 발신자 코드. negotiation.chats.sender """
 

backend/crud/chat_crud.py

@@ -6,7 +6,7 @@ from sqlalchemy import asc, desc, select, update
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from common.database.db_session_manager import DB_SESSION_MNG
-from common.database.model.models import chats, items, sessions
+from common.database.model.models import chats, items, sessions, nego_cards, wild_cards
 from common.enums import ErrorType, SessionStatus
 from common.logger import LOG
 
@@ -47,6 +47,14 @@ class IChatCRUD(ABC):
     async def update_last_offer_price(self, cdb: AsyncSession, session_id, price: int) -> ErrorType:
         pass
 
+    @abstractmethod
+    async def get_nego_card_id_by_number(self, cdb: AsyncSession, number: str):
+        pass
+
+    @abstractmethod
+    async def get_wild_card_id_by_number(self, cdb: AsyncSession, number: str):
+        pass
+
 
 class ChatCRUD(IChatCRUD):
     async def list_by_session(self, cdb: AsyncSession, session_id) -> Tuple[ErrorType, list]:
@@ -112,6 +120,30 @@ class ChatCRUD(IChatCRUD):
             LOG.e_no_callstack(ex)
             return ErrorType.DB_RUN_FAILED, None
 
+    async def get_nego_card_id_by_number(self, cdb: AsyncSession, number: str):
+        # 협상카드 번호(agent turn.card_id) → nego_card_id(UUID). 없으면 None. 카드 사용 로그(chats.card_id) 저장용.
+        try:
+            query = select(nego_cards.nego_card_id).where(nego_cards.number == number, nego_cards.deleted == False).limit(1)  # noqa: E712
+            err_type, row_list = await DB_SESSION_MNG.execute(cdb, query, f"get_nego_card_id_by_number({number}) failed.")
+            if err_type != ErrorType.SUCCESS or not row_list:
+                return None
+            return row_list[0]
+        except Exception as ex:
+            LOG.e_no_callstack(ex)
+            return None
+
+    async def get_wild_card_id_by_number(self, cdb: AsyncSession, number: str):
+        # 와일드카드 번호(agent turn.card_id, wild_card_dynamic) → wild_card_id(UUID). 없으면 None.
+        try:
+            query = select(wild_cards.wild_card_id).where(wild_cards.number == number, wild_cards.deleted == False).limit(1)  # noqa: E712
+            err_type, row_list = await DB_SESSION_MNG.execute(cdb, query, f"get_wild_card_id_by_number({number}) failed.")
+            if err_type != ErrorType.SUCCESS or not row_list:
+                return None
+            return row_list[0]
+        except Exception as ex:
+            LOG.e_no_callstack(ex)
+            return None
+
     async def finalize_session(
         self, cdb: AsyncSession, session_id, status: int,
         bid_price: Optional[int] = None, reject_reason: Optional[str] = None, reject_price: Optional[int] = None,

backend/crud/session_crud.py

@@ -1,24 +1,40 @@
 from abc import ABC, abstractmethod
-from typing import Tuple
+from typing import Optional, Tuple
 
-from sqlalchemy import case, func, nulls_last, select, update
+from sqlalchemy import and_, case, cast, func, nulls_last, or_, select, text, update
+from sqlalchemy.dialects.postgresql import JSONB
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from common.database.db_session_manager import DB_SESSION_MNG
-from common.database.model.models import items, quotations, sessions
-from common.enums import ErrorType, SessionStatus
+from common.database.model.models import chats, items, quotations, sessions
+from common.enums import CloseReason, ErrorType, QuotationStatus, RENEGOTIABLE_CLOSE_REASONS, SessionStatus
 from common.logger import LOG
 
 
 # 협상 세션 CRUD. 목록은 세션(negotiation) ⨝ 상품(partner) ⨝ 견적(quotation) 조인으로 만든다.
 # 마감일(qt_end_time)은 견적(quotation.end_time)이 진실값이다(session.end_time 은 협상 종료 시점 기록용).
+
+
+def _effective_status():
+    """표시용 세션 상태. 견적이 마감됐거나 마감시간이 지났으면 협상생성(1)은 더 참여할 수 없으므로 미참여(4)로 본다.
+
+    참여/채팅진입이 진입 시점에 하는 전이(negotiation_service._load_actionable_session, chat_service.init)와 같은 규칙을
+    목록에서는 쓰기 없이 파생으로만 맞춘다. 마감 일괄정리 이후에 만들어진 세션도 '협상 대기'로 남지 않는다.
+    """
+    ended = or_(quotations.status == QuotationStatus.CLOSED.value, quotations.end_time < func.now())
+    return case(
+        (and_(sessions.status == SessionStatus.CREATED.value, ended), SessionStatus.NOT_PARTICIPATED.value),
+        else_=sessions.status,
+    )
+
+
 class ISessionCRUD(ABC):
     @abstractmethod
-    async def list_by_supplier(self, cdb: AsyncSession, supplier_id, status, qt_type, order, offset, limit) -> Tuple[ErrorType, list]:
+    async def list_by_supplier(self, cdb: AsyncSession, supplier_id, status, qt_type, order, offset, limit, keyword=None, result=None) -> Tuple[ErrorType, list]:
         pass
 
     @abstractmethod
-    async def count_by_supplier(self, cdb: AsyncSession, supplier_id, status, qt_type) -> Tuple[ErrorType, int]:
+    async def count_by_supplier(self, cdb: AsyncSession, supplier_id, status, qt_type, keyword=None, result=None) -> Tuple[ErrorType, int]:
         pass
 
     @abstractmethod
@@ -38,23 +54,56 @@ class ISessionCRUD(ABC):
         pass
 
     @abstractmethod
-    async def update_session_reject(self, cdb: AsyncSession, session_id, status: int, reject_reason: str) -> ErrorType:
+    async def update_session_reject(
+        self, cdb: AsyncSession, session_id, status: int, reject_reason: str, reject_price: Optional[int] = None,
+    ) -> ErrorType:
+        pass
+
+    @abstractmethod
+    async def update_session_custom(self, cdb: AsyncSession, session_id, supplier_id, custom: dict) -> ErrorType:
+        pass
+
+    @abstractmethod
+    async def merge_session_custom(self, cdb: AsyncSession, session_id, supplier_id, patch: dict) -> ErrorType:
+        pass
+
+    @abstractmethod
+    async def chain_max_round(self, cdb: AsyncSession, number: str) -> Tuple[ErrorType, int]:
         pass
 
 
 class SessionCRUD(ISessionCRUD):
     @staticmethod
-    def __filters(supplier_id, status, qt_type):
+    def __filters(supplier_id, status, qt_type, keyword=None, result=None):
         conds = [sessions.supplier_id == supplier_id, sessions.deleted == False]  # noqa: E712
         if status is not None:
-            conds.append(sessions.status == status)
+            # 표시 상태로 필터 — 탭/KPI 카운트가 목록 배지와 어긋나지 않게 파생값을 그대로 쓴다.
+            conds.append(_effective_status() == status)
         if qt_type is not None:
             conds.append(sessions.qt_type == qt_type)
+        # 검색: 견적번호·상품명·상품코드 부분일치(대소문자 무시). items 는 목록/카운트 둘 다 조인돼 있다.
+        # ILIKE 와일드카드(%,_)는 escape 해 사용자 입력이 패턴으로 새지 않게 한다.
+        if keyword and keyword.strip():
+            kw = keyword.strip().replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")
+            like = f"%{kw}%"
+            conds.append(or_(sessions.qt_number.ilike(like), items.name.ilike(like), items.code.ilike(like)))
+        # 결과(SessionResult) 필터 — _to_result 파생 규칙을 SQL WHERE 로 그대로 복제(집계·필터 일치용).
+        # 1=낙찰 2=미낙찰 3=결렬(개찰). 전부 견적 마감(CLOSED) 이 전제.
+        if result in (1, 2, 3):
+            conds.append(quotations.status == QuotationStatus.CLOSED.value)
+            if result == 1:
+                conds.append(quotations.close_reason == CloseReason.AWARDED.value)
+                conds.append(quotations.preferred_sp_id == sessions.supplier_id)
+            elif result == 2:
+                conds.append(quotations.close_reason == CloseReason.AWARDED.value)
+                conds.append(or_(quotations.preferred_sp_id.is_(None), quotations.preferred_sp_id != sessions.supplier_id))
+            else:
+                conds.append(quotations.close_reason.in_(RENEGOTIABLE_CLOSE_REASONS))
         return conds
 
-    async def list_by_supplier(self, cdb: AsyncSession, supplier_id, status, qt_type, order, offset, limit) -> Tuple[ErrorType, list]:
+    async def list_by_supplier(self, cdb: AsyncSession, supplier_id, status, qt_type, order, offset, limit, keyword=None, result=None) -> Tuple[ErrorType, list]:
         try:
-            conds = self.__filters(supplier_id, status, qt_type)
+            conds = self.__filters(supplier_id, status, qt_type, keyword, result)
 
             # 정렬 규칙:
             #  - order 를 명시(asc/desc)하면 그룹 구분 없이 전체를 마감 기준 한 줄로 정렬(전체 정렬).
@@ -69,7 +118,7 @@ class SessionCRUD(ISessionCRUD):
             else:
                 # 그룹별로 정렬 방향이 달라, case 로 '자기 그룹 행만 end_time' 을 갖는 키를 만들고
                 # 반대 그룹은 NULL 로 눌러 간섭을 없앤다. status_rank 가 1차 키라 그룹 경계는 항상 유지.
-                actionable = sessions.status.in_((SessionStatus.CREATED.value, SessionStatus.IN_PROGRESS.value))
+                actionable = _effective_status().in_((SessionStatus.CREATED.value, SessionStatus.IN_PROGRESS.value))
                 status_rank = case((actionable, 0), else_=1)
                 action_order = case((actionable, quotations.end_time), else_=None).asc()
                 done_order = case((~actionable, quotations.end_time), else_=None).desc()
@@ -78,7 +127,7 @@ class SessionCRUD(ISessionCRUD):
             query = (
                 select(
                     sessions.session_id,
-                    sessions.status,
+                    _effective_status(),  # 마감 후 남은 협상생성은 미참여로 내린다
                     sessions.qt_type,
                     sessions.qt_number,
                     quotations.end_time,  # qt_end_time = 견적 마감 시각
@@ -86,6 +135,17 @@ class SessionCRUD(ISessionCRUD):
                     items.name,
                     items.model_name,
                     items.manufacturer,
+                    sessions.custom,
+                    quotations.status,        # 재협상 요청 자격 판정용(마감 여부)
+                    quotations.close_reason,  # 개찰(결렬) 사유
+                    quotations.round,
+                    quotations.preferred_sp_id,  # 낙찰자(공급사) — 나와 같으면 낙찰, 다르면 미낙찰
+                    sessions.supplier_id,        # 이 세션 소유 공급사(=조회자). 낙찰자와 대조
+                    # 대화 이력 유무 — 종료된 협상의 '결과 보기'(열람) 버튼을 띄울지 판단용. 열 게 없으면 프론트가 감춘다.
+                    select(1).where(chats.session_id == sessions.session_id, chats.deleted == False).exists(),  # noqa: E712
+                    # 거부 건이 제출한 사유·희망가 — 목록의 '거부 내역' 열람용(의견은 custom.opinion).
+                    sessions.reject_reason,
+                    sessions.reject_price,
                 )
                 .join(items, items.item_id == sessions.item_id)
                 .join(quotations, quotations.qt_id == sessions.quotation_id)
@@ -102,9 +162,9 @@ class SessionCRUD(ISessionCRUD):
             LOG.e_no_callstack(ex)
             return ErrorType.DB_RUN_FAILED, []
 
-    async def count_by_supplier(self, cdb: AsyncSession, supplier_id, status, qt_type) -> Tuple[ErrorType, int]:
+    async def count_by_supplier(self, cdb: AsyncSession, supplier_id, status, qt_type, keyword=None, result=None) -> Tuple[ErrorType, int]:
         try:
-            conds = self.__filters(supplier_id, status, qt_type)
+            conds = self.__filters(supplier_id, status, qt_type, keyword, result)
             query = (
                 select(func.count())
                 .select_from(sessions)
@@ -162,12 +222,58 @@ class SessionCRUD(ISessionCRUD):
             LOG.e_no_callstack(ex)
             return ErrorType.DB_RUN_FAILED
 
-    async def update_session_reject(self, cdb: AsyncSession, session_id, status: int, reject_reason: str) -> ErrorType:
+    async def update_session_reject(
+        self, cdb: AsyncSession, session_id, status: int, reject_reason: str, reject_price: Optional[int] = None,
+    ) -> ErrorType:
         try:
+            values = {"status": status, "reject_reason": reject_reason}
+            # 공급 희망 가격은 선택 입력이라 안 들어올 수 있다 — 그때는 컬럼을 건드리지 않는다.
+            if reject_price is not None:
+                values["reject_price"] = reject_price
             query = (
                 update(sessions)
                 .where(sessions.session_id == session_id)
-                .values(status=status, reject_reason=reject_reason)
+                .values(**values)
+            )
+            return await DB_SESSION_MNG.add(cdb, query)
+        except Exception as ex:
+            LOG.e_no_callstack(ex)
+            return ErrorType.DB_RUN_FAILED
+
+    async def chain_max_round(self, cdb: AsyncSession, number: str) -> Tuple[ErrorType, int]:
+        # 같은 견적번호(체인)의 최대 차수. 이미 다음 라운드가 있으면 재협상 요청은 의미가 없다.
+        try:
+            query = select(func.max(quotations.round)).where(quotations.number == number, quotations.deleted == False)  # noqa: E712
+            err_type, rows = await DB_SESSION_MNG.execute(cdb, query)
+            if err_type != ErrorType.SUCCESS:
+                return err_type, 0
+            # 단일 컬럼 select 는 scalars() 로 내려와 rows 가 값 리스트다(행 튜플이 아님).
+            top = rows[0] if rows else None
+            return ErrorType.SUCCESS, int(top or 0)
+        except Exception as ex:
+            LOG.e_no_callstack(ex)
+            return ErrorType.DB_RUN_FAILED, 0
+
+    async def merge_session_custom(self, cdb: AsyncSession, session_id, supplier_id, patch: dict) -> ErrorType:
+        # sessions.custom 부분 갱신(기존 키 보존). 부가정보와 재협상 요청이 같은 컬럼을 쓰므로 덮어쓰면 안 된다.
+        try:
+            query = (
+                update(sessions)
+                .where(sessions.session_id == session_id, sessions.supplier_id == supplier_id)
+                .values(custom=func.coalesce(sessions.custom, cast(text("'{}'"), JSONB)).op("||")(cast(patch, JSONB)))
+            )
+            return await DB_SESSION_MNG.add(cdb, query)
+        except Exception as ex:
+            LOG.e_no_callstack(ex)
+            return ErrorType.DB_RUN_FAILED
+
+    async def update_session_custom(self, cdb: AsyncSession, session_id, supplier_id, custom: dict) -> ErrorType:
+        # 협상완료 부가정보(sessions.custom) 저장. 본인 공급사 세션만(supplier_id 가드).
+        try:
+            query = (
+                update(sessions)
+                .where(sessions.session_id == session_id, sessions.supplier_id == supplier_id)
+                .values(custom=custom)
             )
             return await DB_SESSION_MNG.add(cdb, query)
         except Exception as ex:

backend/crud/user_crud.py

@@ -5,7 +5,7 @@ from sqlalchemy import delete, select, update
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from common.database.db_session_manager import DB_SESSION_MNG
-from common.database.model.models import supplier_user_tokens, supplier_users, suppliers
+from common.database.model.models import supplier_user_tokens, supplier_users, suppliers, companies, sessions
 from common.enums import ErrorType, TokenType
 from common.logger import LOG
 from common.utils.gtime import GTime
@@ -28,6 +28,14 @@ class IUserCRUD(ABC):
     async def get_supplier_name(self, cdb: AsyncSession, supplier_id) -> Tuple[ErrorType, str]:
         pass
 
+    @abstractmethod
+    async def get_company_settings(self, cdb: AsyncSession, supplier_id) -> Tuple[ErrorType, dict]:
+        pass
+
+    @abstractmethod
+    async def get_branding_by_session(self, cdb: AsyncSession, session_id) -> Tuple[ErrorType, dict]:
+        pass
+
     @abstractmethod
     async def is_account(self, cdb: AsyncSession, login_id: str) -> ErrorType:
         pass
@@ -117,6 +125,43 @@ class UserCRUD(IUserCRUD):
             LOG.e_no_callstack(ex)
             return ErrorType.DB_RUN_FAILED, None
 
+    async def get_company_settings(self, cdb: AsyncSession, supplier_id) -> Tuple[ErrorType, dict]:
+        """공급사 소속 회사 설정(companies.settings) 전체. 브랜딩·협상완료 필드 등이 들어있다. 미설정이면 빈 dict."""
+        try:
+            query = (
+                select(companies.settings)
+                .join(suppliers, suppliers.company_id == companies.company_id)
+                .where(suppliers.supplier_id == supplier_id, suppliers.deleted == False, companies.deleted == False)  # noqa: E712
+                .limit(1)
+            )
+            err_type, row_list = await DB_SESSION_MNG.execute(cdb, query, f"get_company_settings(supplier_id:{supplier_id}) failed.")
+            if err_type != ErrorType.SUCCESS:
+                return err_type, {}
+            settings = row_list[0] if row_list else None
+            return ErrorType.SUCCESS, settings or {}
+        except Exception as ex:
+            LOG.e_no_callstack(ex)
+            return ErrorType.DB_RUN_FAILED, {}
+
+    async def get_branding_by_session(self, cdb: AsyncSession, session_id) -> Tuple[ErrorType, dict]:
+        """세션이 속한 회사의 브랜딩(companies.settings.branding). 로그인 전 화면이 쓰므로 branding 만 꺼낸다."""
+        try:
+            query = (
+                select(companies.settings)
+                .join(suppliers, suppliers.company_id == companies.company_id)
+                .join(sessions, sessions.supplier_id == suppliers.supplier_id)
+                .where(sessions.session_id == session_id, sessions.deleted == False, companies.deleted == False)  # noqa: E712
+                .limit(1)
+            )
+            err_type, row_list = await DB_SESSION_MNG.execute(cdb, query, f"get_branding_by_session(session_id:{session_id}) failed.")
+            if err_type != ErrorType.SUCCESS:
+                return err_type, {}
+            settings = (row_list[0] if row_list else None) or {}
+            return ErrorType.SUCCESS, settings.get("branding") or {}
+        except Exception as ex:
+            LOG.e_no_callstack(ex)
+            return ErrorType.DB_RUN_FAILED, {}
+
     async def is_account(self, cdb: AsyncSession, login_id: str) -> ErrorType:
         try:
             query = (

backend/router/v1/auth/account.py

@@ -1,4 +1,4 @@
-from fastapi import APIRouter, Depends, Request
+from fastapi import APIRouter, Depends, Path, Request
 from fastapi.security import HTTPAuthorizationCredentials
 
 from common.models.gmodel import UserInfo
@@ -20,6 +20,7 @@ from .protocol import (
     Res_Me,
     Res_PopupStatus,
     Res_RefreshToken,
+    Res_SessionBranding,
 )
 
 # 라우터(MVC 의 컨트롤러). 요청 검증 -> service 호출 -> RemoveNoneResponse 반환만 담당.
@@ -106,3 +107,16 @@ async def hide_popup(
     service: AuthService = Depends(),
 ):
     return RemoveNoneResponse(await service.hide_popup(user_info, credentials.credentials, req.popup_type))
+
+
+@router.get(
+    path="/session-branding/{session_id}",
+    response_model=Res_SessionBranding,
+    summary="세션 브랜딩(무인증)",
+    description="초청 링크로 진입한 로그인 전 화면에서 회사 서비스명·로고·색상만 조회한다. 인증 없이 열려 있으므로 브랜딩 외 정보는 내리지 않는다.",
+)
+async def session_branding(
+    session_id: str = Path(..., description="협상 세션 uuid (초청 링크의 session_id)"),
+    service: AuthService = Depends(),
+):
+    return RemoveNoneResponse(await service.session_branding(session_id))

backend/router/v1/auth/protocol.py

@@ -48,6 +48,9 @@ class Res_Me(Res_WebPacketProtocol):
     supplier_id: str = Field("", description="소속 공급사 uuid")
     supplier_name: str = Field("", description="공급사명")
     role: int = Field(0, description="권한 코드 1=user, 2=manager (UserRole)")
+    branding: dict = Field(default_factory=dict, description="소속 회사 브랜딩(companies.settings.branding). 서비스명/로고/색")
+    session_fields: list = Field(default_factory=list, description="협상완료 부가정보 필드 정의(companies.settings.session_fields). 공급사가 타결 후 입력")
+    guide_notices: list = Field(default_factory=list, description="협상 유의사항 항목(companies.settings.guide_notices). 빈 값이면 포털 기본 문구")
 
 
 class Res_Logout(Res_WebPacketProtocol):
@@ -64,3 +67,9 @@ class Req_HidePopup(AuthProtocol):
 
 class Res_HidePopup(Res_WebPacketProtocol):
     pass
+
+
+class Res_SessionBranding(Res_WebPacketProtocol):
+    service_name: str = Field("", description="회사 서비스명(companies.settings.branding.service_name). 미설정 시 빈 값")
+    logo_url: str = Field("", description="회사 로고 URL")
+    helpdesk: list = Field(default_factory=list, description="헬프데스크 연락처 줄 목록(companies.settings.branding.helpdesk). 한 줄 = 담당자 한 명")

backend/router/v1/chat/protocol.py

@@ -63,6 +63,7 @@ class Res_ChatInit(Res_WebPacketProtocol):
     session_id: str = Field("", description="협상 세션 uuid")
     session_status: int = Field(0, description="세션 상태 코드 (SessionStatus: 1=생성 2=진행중 3=완료 4=미참여 5=거부)")
     quotation_id: str = Field("", description="소속 견적 uuid")
+    qt_number: str = Field("", description="견적번호(EST-...)")
     quotation_end_time: str = Field("", description="견적 마감 시각 (ISO 8601, 타이머용)")
     quotation_memo: str = Field("", description="견적 메모")
     item_id: str = Field("", description="상품 uuid")
@@ -77,6 +78,10 @@ class Res_ChatInit(Res_WebPacketProtocol):
     item_min_order_quantity: str = Field("", description="최소 주문 수량")
     item_vat_yn: Optional[bool] = Field(None, description="VAT 포함 여부(미설정 시 null)")
     item_delivery_fee_yn: Optional[bool] = Field(None, description="배송비 포함 여부(미설정 시 null)")
+    custom: dict = Field(default_factory=dict, description="협상완료 부가정보 기존 입력값(sessions.custom). 재진입 시 폼 프리필용")
+    reject_reason: str = Field("", description="협상 거부 시 제출한 사유. 거부 건이 아니면 빈 문자열")
+    reject_price: Optional[int] = Field(None, description="협상 거부 시 함께 낸 공급 희망 가격(원). 미입력이면 null")
+    labels: dict = Field(default_factory=dict, description="회사 커스텀 라벨(companies.settings.labels). 상품 상세 필드명(예: lead_time) 치환용. 없으면 프론트 기본값")
 
 
 # 대화 히스토리(재진입 복원)

backend/router/v1/negotiation/protocol.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from pydantic import Field
 
 from common.models.gmodel import Res_WebPacketProtocol, WebPacketProtocol
@@ -14,6 +16,14 @@ class ListItem(WebPacketProtocol):
     item_name: str = Field("", description="상품명")
     model_name: str = Field("", description="모델명")
     maker_name: str = Field("", description="제조사")
+    custom: dict = Field(default_factory=dict, description="협상완료 부가정보 값(sessions.custom). 미입력이면 빈 dict")
+    renegotiable: bool = Field(False, description="재협상 요청 가능 여부 — 낙찰 없이 마감(개찰)된 마지막 차수이고 대기 중 요청이 없을 때만 True")
+    renegotiation_status: int = Field(0, description="현재 재협상 요청 상태(RenegotiationStatus). 요청 이력이 없으면 0")
+    renegotiation_memo: str = Field("", description="담당자 심사 메모(반려 사유). 없으면 빈 문자열")
+    result: int = Field(0, description="공급사 관점 협상 결과(SessionResult): 0=미정 1=낙찰 2=미낙찰 3=결렬(개찰, 재협상 대상)")
+    has_chat: bool = Field(False, description="대화 이력 존재 여부 — 종료된 협상(미참여·거부)의 '결과 보기' 노출 판단용")
+    reject_reason: str = Field("", description="협상 거부 시 제출한 사유. 거부 건이 아니면 빈 문자열")
+    reject_price: Optional[int] = Field(None, description="협상 거부 시 함께 낸 공급 희망 가격(원). 미입력이면 null")
 
 
 class Res_SessionList(Res_WebPacketProtocol):
@@ -29,7 +39,27 @@ class Res_Participate(Res_WebPacketProtocol):
 
 class Req_Reject(WebPacketProtocol):
     reject_reason: str = Field("", max_length=255, description="거부 사유 (단종/품절 프리셋 라벨 또는 직접 입력)")
+    reject_price: Optional[int] = Field(None, description="공급 희망 가격(원). 선택 입력 — 없으면 컬럼 미변경")
+    opinion: Optional[str] = Field(None, max_length=255, description="추가 의견 — sessions.custom.opinion 에 병합")
 
 
 class Res_Reject(Res_WebPacketProtocol):
     session_id: str = Field("", description="거부 처리된 세션 uuid")
+
+
+class Req_ExtraInfo(WebPacketProtocol):
+    custom: dict = Field(default_factory=dict, description="협상완료 부가정보 값 {key: value} (회사 정의 session_fields 대로)")
+
+
+class Res_ExtraInfo(Res_WebPacketProtocol):
+    session_id: str = Field("", description="부가정보 저장된 세션 uuid")
+
+
+class Req_Renegotiation(WebPacketProtocol):
+    reason: str = Field("", max_length=255, description="재협상 요청 사유(프리셋 라벨 또는 직접 입력)")
+    desired_price: Optional[int] = Field(None, description="희망 공급가(원). 담당자 판단 근거로만 쓰인다")
+
+
+class Res_Renegotiation(Res_WebPacketProtocol):
+    session_id: str = Field("", description="요청이 기록된 세션 uuid")
+    status: int = Field(0, description="요청 상태(RenegotiationStatus): 1=심사중 2=승인 3=반려 4=철회")

backend/router/v1/negotiation/session.py

@@ -6,7 +6,16 @@ from fastapi.security import HTTPAuthorizationCredentials
 from common.models.gmodel import UserInfo
 from router.v1.validator.dependencies import IsValidAccessToken, RemoveNoneResponse, security
 from services.negotiation_service import NegotiationService
-from .protocol import Req_Reject, Res_Participate, Res_Reject, Res_SessionList
+from .protocol import (
+    Req_ExtraInfo,
+    Req_Reject,
+    Req_Renegotiation,
+    Res_ExtraInfo,
+    Res_Participate,
+    Res_Reject,
+    Res_Renegotiation,
+    Res_SessionList,
+)
 
 router = APIRouter(prefix="/v1/negotiation", tags=["Negotiation"], responses={404: {"description": "Not found"}})
 
@@ -26,9 +35,11 @@ async def list_sessions(
     order: Optional[str] = Query(None, description="마감일 전체 정렬: asc(임박순)/desc(여유순). 미지정 시 기본 그룹 정렬('할 일' 우선 → 종료는 하단·최근순). 지정하면 그룹 없이 전체를 마감 기준으로 정렬."),
     page: int = Query(1, ge=1, description="페이지 (1부터)"),
     page_size: int = Query(20, ge=1, le=100, description="페이지당 건수 (1~100)"),
+    keyword: Optional[str] = Query(None, description="검색어 — 견적번호·상품명·상품코드 부분일치(대소문자 무시)"),
+    result: Optional[int] = Query(None, description="결과 필터(SessionResult): 1=낙찰 2=미낙찰 3=결렬(개찰). 미지정 시 전체"),
 ):
     return RemoveNoneResponse(
-        await service.list_sessions(user_info, credentials.credentials, status, qt_type, order, page, page_size)
+        await service.list_sessions(user_info, credentials.credentials, status, qt_type, order, page, page_size, keyword, result)
     )
 
 
@@ -51,7 +62,7 @@ async def participate(
     path="/sessions/{session_id}/reject",
     response_model=Res_Reject,
     summary="협상 거부",
-    description="세션 참여를 거부한다. 소유(공급사)·세션상태(완료/미참여/거부 불가)·견적마감·마감시간 검증 후 협상거부로 전이하고 사유를 저장.",
+    description="세션 참여를 거부하거나 진행 중인 협상을 거부한다. 소유(공급사)·세션상태(완료/미참여/거부 불가)·견적마감·마감시간 검증 후 협상거부로 전이하고 사유·공급 희망 가격·의견을 저장.",
 )
 async def reject(
     session_id: str = Path(description="대상 협상 세션 uuid"),
@@ -60,4 +71,59 @@ async def reject(
     credentials: HTTPAuthorizationCredentials = Depends(security),
     service: NegotiationService = Depends(),
 ):
-    return RemoveNoneResponse(await service.reject(user_info, credentials.credentials, session_id, req.reject_reason))
+    return RemoveNoneResponse(
+        await service.reject(
+            user_info, credentials.credentials, session_id, req.reject_reason, req.reject_price, req.opinion,
+        )
+    )
+
+
+@router.post(
+    path="/sessions/{session_id}/extra-info",
+    response_model=Res_ExtraInfo,
+    summary="협상완료 부가정보 저장",
+    description="협상 타결(완료) 세션에 부가정보(표준납기/MOQ/발주배수/배송유형 등, 회사 정의 session_fields)를 저장한다. 본인 공급사의 완료 세션만 허용.",
+)
+async def save_extra_info(
+    session_id: str = Path(description="대상 협상 세션 uuid"),
+    req: Req_ExtraInfo = ...,
+    user_info: UserInfo = Depends(IsValidAccessToken),
+    credentials: HTTPAuthorizationCredentials = Depends(security),
+    service: NegotiationService = Depends(),
+):
+    return RemoveNoneResponse(await service.save_extra_info(user_info, credentials.credentials, session_id, req))
+
+
+@router.post(
+    path="/session/{session_id}/renegotiation",
+    response_model=Res_Renegotiation,
+    summary="재협상 요청",
+    description="낙찰 없이 마감된(개찰) 건에 대해 공급사가 재협상을 요청한다. 담당자 승인 시 다음 라운드가 생성된다. 본인 공급사의 마지막 라운드 세션만 허용.",
+)
+async def request_renegotiation(
+    req: Req_Renegotiation,
+    session_id: str = Path(..., description="협상 세션 uuid"),
+    user_info: UserInfo = Depends(IsValidAccessToken),
+    credentials: HTTPAuthorizationCredentials = Depends(security),
+    service: NegotiationService = Depends(),
+):
+    return RemoveNoneResponse(
+        await service.request_renegotiation(user_info, credentials.credentials, session_id, req)
+    )
+
+
+@router.delete(
+    path="/session/{session_id}/renegotiation",
+    response_model=Res_Renegotiation,
+    summary="재협상 요청 철회",
+    description="심사 대기(PENDING) 중인 본인 요청을 철회한다.",
+)
+async def cancel_renegotiation(
+    session_id: str = Path(..., description="협상 세션 uuid"),
+    user_info: UserInfo = Depends(IsValidAccessToken),
+    credentials: HTTPAuthorizationCredentials = Depends(security),
+    service: NegotiationService = Depends(),
+):
+    return RemoveNoneResponse(
+        await service.cancel_renegotiation(user_info, credentials.credentials, session_id)
+    )

backend/services/auth_service.py

@@ -18,6 +18,7 @@ from router.v1.auth.protocol import (
     Res_Me,
     Res_PopupStatus,
     Res_RefreshToken,
+    Res_SessionBranding,
 )
 from router.v1.validator.dependencies import CreateAccessToken, CreateRefreshToken, GetHashedPW, VerifyPW
 
@@ -250,6 +251,35 @@ class AuthService:
         res.supplier_id = info.supplier_id
         res.supplier_name = info.supplier_name
         res.role = info.role
+        # 소속 회사 설정(companies.settings) — 로고/서비스명(branding) + 협상완료 부가필드(session_fields). 실패해도 기본값.
+        _e, settings = await DB_SESSION_MNG.execute_lambda(
+            suppliers.DBType(),
+            DBWRType.DB_READ.value,
+            lambda s: self.user_crud.get_company_settings(s, uuid.UUID(info.supplier_id)),
+        )
+        settings = settings or {}
+        res.branding = settings.get("branding") or {}
+        res.session_fields = settings.get("session_fields") or []
+        res.guide_notices = settings.get("guide_notices") or []
+        return res
+
+    async def session_branding(self, session_id: str) -> Res_SessionBranding:
+        """로그인 전(초청 링크 진입) 화면용 브랜딩. 인증 없이 session_id 로만 조회하며 브랜딩 외 정보는 내리지 않는다."""
+        res = Res_SessionBranding()
+        try:
+            sid = uuid.UUID(session_id)
+        except ValueError:
+            res.result.SetResult(ErrorType.INVALID_REQUEST_DATA)
+            return res
+        _e, branding = await DB_SESSION_MNG.execute_lambda(
+            suppliers.DBType(),
+            DBWRType.DB_READ.value,
+            lambda s: self.user_crud.get_branding_by_session(s, sid),
+        )
+        branding = branding or {}
+        res.service_name = branding.get("service_name") or ""
+        res.logo_url = branding.get("logo_url") or ""
+        res.helpdesk = branding.get("helpdesk") or []
         return res
 
     async def popup_status(self, user_info: UserInfo, access_token: str) -> Res_PopupStatus:

backend/services/chat_service.py

@@ -24,6 +24,7 @@ from common.logger import LOG
 from common.models.gmodel import UserInfo
 from crud.chat_crud import ChatCRUD, IChatCRUD
 from crud.session_crud import ISessionCRUD, SessionCRUD
+from crud.user_crud import IUserCRUD, UserCRUD
 from router.v1.chat.protocol import ChatMessage, ChatSummary, Res_ChatInit, Res_ChatMessages, Res_ChatSend
 from services.agent_client import AgentChatContext, IAgentClient, get_agent_client
 from services.auth_service import AuthService
@@ -44,11 +45,13 @@ class ChatService:
         auth: AuthService = Depends(AuthService),
         session_crud: ISessionCRUD = Depends(SessionCRUD),
         chat_crud: IChatCRUD = Depends(ChatCRUD),
+        user_crud: IUserCRUD = Depends(UserCRUD),
         agent: IAgentClient = Depends(get_agent_client),
     ):
         self.auth = auth
         self.session_crud = session_crud
         self.chat_crud = chat_crud
+        self.user_crud = user_crud
         self.agent = agent
 
     # ---- 순수 헬퍼/매퍼 (self 불필요, 상단 집약) ----
@@ -59,6 +62,35 @@ class ChatService:
         digits = "".join(ch for ch in text if ch.isdigit())
         return int(digits) if digits else None
 
+    @staticmethod
+    def _parse_reject(text: Optional[str]) -> dict:
+        """통일 결렬 폼 제출 문자열 파싱 → {offer_price, reason, opinion}.
+        형식: '공급희망가격-{원}, 합의불가사유-{사유}, 의견-{의견}' (사유는 '기타-{내용}' 가능).
+        의견은 자유서술이라 콤마 포함 가능 → 맨 뒤 '의견-' 기준으로 먼저 떼어낸다."""
+        s = text or ""
+        opinion = None
+        if ", 의견-" in s:
+            s, opinion = s.split(", 의견-", 1)
+        # 폼이 아닌 자유 입력("협상 포기합니다" 등)은 원문이 곧 사유다. 폼 마커가 없으면 가격도 읽지 않는다
+        # — 문장에 섞인 숫자를 희망가로 오인해 저장하는 것을 막는다.
+        if "합의불가사유-" not in s and "공급희망가격-" not in s:
+            return {
+                "offer_price": None,
+                "reason": s.strip()[:255] or None,
+                "opinion": (opinion.strip() or None) if opinion is not None else None,
+            }
+        reason = None
+        if ", 합의불가사유-" in s:
+            price_part, reason = s.split(", 합의불가사유-", 1)
+        else:
+            price_part = s
+        price_digits = "".join(ch for ch in price_part.replace("공급희망가격-", "") if ch.isdigit())
+        return {
+            "offer_price": int(price_digits) if price_digits else None,
+            "reason": reason or None,
+            "opinion": (opinion.strip() or None) if opinion is not None else None,
+        }
+
     @staticmethod
     def _in_price_range(price: int, target_price: Optional[int]) -> bool:
         if not target_price:
@@ -103,13 +135,18 @@ class ChatService:
         )
 
     @staticmethod
-    def _build_bot_chat(sess, seq: int, turn, bot_chat_type: Optional[str] = None, summary: Optional[dict] = None) -> chats:
+    def _build_bot_chat(sess, seq: int, turn, bot_chat_type: Optional[str] = None, summary: Optional[dict] = None, card_uuid=None, card_type=None) -> chats:
         # bot_chat_type/summary 도 meta 에 영속화 → 히스토리 복원 시 폼 재현. indicator_value 는 전용 컬럼에도 적재.
+        # nego_card_uuid: turn.card_id(번호)를 UUID 로 변환한 값(nego 카드). 있으면 chats.card_id/card_type/card_used_yn 컬럼에 적재
+        # → negodata 가 이 컬럼으로 카드 사용/효과를 조인한다. (wild 카드는 agent 가 card_id 미제공 — 별도 작업)
         return chats(
             chat_id=uuid.uuid4(), session_id=sess.session_id, seq=seq,
             sender=ChatSender.BOT.value,
             target_price=int(sess.target_price or 0),
             indicator_value=turn.indicator_value,
+            card_id=card_uuid,
+            card_type=card_type if card_uuid else None,   # CardType: 1=nego, 2=wild
+            card_used_yn=True if card_uuid else None,
             meta={
                 "script": turn.script, "step": turn.step, "client_step": turn.client_step,
                 "input_mode": turn.input_mode, "input_options": turn.input_options,
@@ -198,15 +235,15 @@ class ChatService:
             )
             sess.status = SessionStatus.NOT_PARTICIPATED.value
 
-        # 미참여/협상거부 상태는 진입(열람) 불가 (participate/reject 와 동일 규칙).
-        # 위 마감 변환으로 미참여가 된 세션도 여기서 함께 막힌다.
-        if sess.status in (SessionStatus.NOT_PARTICIPATED.value, SessionStatus.REJECTED.value):
-            res.result.SetResult(ErrorType.NEGO_NOT_PARTICIPABLE)
-            return res
+        # 미참여/협상거부 세션도 '결과 보기'로 지난 대화를 열람할 수 있다(중간 이탈·거부로 끝난 건).
+        # 대화 재개는 send() 가 협상중(2)만 허용하므로 여기서 막지 않아도 읽기 전용이다.
+
+        await self._ensure_in_progress(sess, quote)
 
         res.session_id = str(sess.session_id)
         res.session_status = sess.status
         res.quotation_id = str(sess.quotation_id)
+        res.qt_number = sess.qt_number or ""
         res.quotation_end_time = quote.end_time.isoformat(timespec="seconds") if quote.end_time else ""
         res.quotation_memo = quote.memo or ""
         res.item_id = str(item.item_id)
@@ -221,8 +258,65 @@ class ChatService:
         res.item_min_order_quantity = item.moq or ""
         res.item_vat_yn = item.vat_yn
         res.item_delivery_fee_yn = item.delivery_fee_yn
+        res.custom = sess.custom or {}
+        # 거부로 끝난 세션은 대화에 남지 않는 제출 내역(사유·희망가)을 열람용으로 함께 내린다.
+        res.reject_reason = sess.reject_reason or ""
+        res.reject_price = sess.reject_price
+
+        # 회사 커스텀 라벨(companies.settings.labels) — 상품 상세 필드명 치환용(예: lead_time→표준납기). 실패해도 빈 dict 폴백.
+        _e, settings = await DB_SESSION_MNG.execute_lambda(
+            suppliers.DBType(), DBWRType.DB_READ.value,
+            lambda s: self.user_crud.get_company_settings(s, sess.supplier_id),
+        )
+        res.labels = (settings.get("labels") or {}) if _e == ErrorType.SUCCESS and settings else {}
+
+        _hidden = (settings.get("hidden_fields") or []) if _e == ErrorType.SUCCESS and settings else []
+        _features = (settings.get("features") or {}) if _e == ErrorType.SUCCESS and settings else {}
+
+        # VAT 표기 — 부가세 전체 통일 회사(features.vat_mode)는 상품 잔존값과 무관하게 'VAT 별도' 고정(False).
+        # 상품별 관리 회사가 vat_yn 을 숨겼으면(구 방식) 표기 자체를 생략한다(값 null → 프론트 라벨 생략).
+        if _features.get("vat_mode") == "unified_excluded":
+            res.item_vat_yn = False
+        elif "vat_yn" in _hidden:
+            res.item_vat_yn = None
+
+        # 협상 기준가 — 회사 설정에서 고른 가격 컬럼(features.nego_baseline_field).
+        # agent 의 인하율 멘트(nego_context_crud._resolve_baseline)와 같은 규칙이어야 화면과 멘트가 어긋나지 않는다.
+        _baseline = _features.get("nego_baseline_field")
+        if _baseline not in ("price", "purchase_price"):
+            # 미설정 회사 폴백 — 공급가를 감췄으면 그 회사는 공급가를 관리하지 않는다는 뜻.
+            _baseline = "purchase_price" if ("price" in _hidden and "purchase_price" not in _hidden) else "price"
+        if _baseline == "purchase_price":
+            res.item_price = item.purchase_price or 0
         return res
 
+    async def _ensure_in_progress(self, sess, quote) -> None:
+        """협상생성(1) 세션을 채팅 진입만으로 협상중(2)으로 전이한다(participate 와 동일 전이).
+
+        negodata 안내 메일/링크는 목록의 참여 버튼을 거치지 않고 chat 으로 바로 들어오는데,
+        오프닝 메시지는 협상중일 때만 seed 되므로 전이가 없으면 빈 채팅으로 멈춘다.
+        마감된 견적은 진입해도 대화가 불가하므로 전이하지 않는다."""
+        if sess.status != SessionStatus.CREATED.value:
+            return
+        if quote is None or quote.status == QuotationStatus.CLOSED.value:
+            return
+        end = quote.end_time
+        if end is not None and end.tzinfo is None:
+            end = end.replace(tzinfo=timezone.utc)
+        if end is not None and end < datetime.now(timezone.utc):
+            return
+
+        err_type = await DB_SESSION_MNG.execute_lambda_run(
+            [sessions.DBType()],
+            [
+                lambda s: self.session_crud.update_session_status(s, sess.session_id, SessionStatus.IN_PROGRESS.value),
+                lambda s: self.session_crud.update_quotation_status(s, sess.quotation_id, QuotationStatus.IN_PROGRESS.value),
+            ],
+        )
+        if err_type != ErrorType.SUCCESS:
+            return
+        sess.status = SessionStatus.IN_PROGRESS.value
+
     # ---- messages -------------------------------------------------------
     async def messages(self, user_info: UserInfo, access_token: str, session_id_str: str) -> Res_ChatMessages:
         res = Res_ChatMessages()
@@ -239,6 +333,15 @@ class ChatService:
             res.result.SetResult(err_type)
             return res
 
+        # 협상생성 상태로 바로 진입한 경우(메일 링크) 여기서도 전이한다 —
+        # init 과 병렬로 호출돼 init 의 전이를 못 본 채 읽었을 수 있다.
+        if not rows and sess.status == SessionStatus.CREATED.value:
+            _, quote = await DB_SESSION_MNG.execute_lambda(
+                quotations.DBType(), DBWRType.DB_READ.value,
+                lambda s: self.session_crud.get_quotation_by_id(s, sess.quotation_id),
+            )
+            await self._ensure_in_progress(sess, quote)
+
         # 비어 있고 협상중이면 agent 오프닝 한 턴을 seed (재진입 시 인사 메시지 보존)
         if not rows and sess.status == SessionStatus.IN_PROGRESS.value:
             opening = await self._seed_opening(sess)
@@ -371,8 +474,43 @@ class ChatService:
             # 유저 미입력 가격 타결 케이스 — 마지막 유저 제시가와 다를 수 있다).
             summary = await self._build_summary(sess, quote, item, final_price, turn.settled_price or last_price)
 
+        # 카드 번호(turn.card_id) → UUID 변환. 번호 정본 표기(NGC-/WC- prefix)로 종류를 가르고,
+        # prefix 없는 구번호는 step 휴리스틱 폴백. 1차 조회가 비면 반대 테이블 재조회 —
+        # 종결 전술의 와일드카드는 step 이 '가격협상_카운터'(wild 미시작)라 step 만으론 카드가
+        # 영영 null 로 남았다(사용 카드 통계·화면 누락 원인).
+        # 카드 사용 로그(chats.card_id/type/used)를 negodata 조인용으로 남긴다. (1% 인하 시스템 카드는 agent 가 card_id 미제공)
+        card_uuid = None
+        card_type = None
+        if turn.card_id:
+            number = str(turn.card_id)
+            if number.startswith("WC"):
+                wild_first = True
+            elif number.startswith("NGC"):
+                wild_first = False
+            else:
+                wild_first = bool(turn.step and turn.step.startswith("wild"))
+
+            async def _lookup(wild: bool):
+                if wild:
+                    found = await DB_SESSION_MNG.execute_lambda(
+                        chats.DBType(), DBWRType.DB_READ.value,
+                        lambda s: self.chat_crud.get_wild_card_id_by_number(s, number),
+                    )
+                    return found, 2
+                found = await DB_SESSION_MNG.execute_lambda(
+                    chats.DBType(), DBWRType.DB_READ.value,
+                    lambda s: self.chat_crud.get_nego_card_id_by_number(s, number),
+                )
+                return found, 1
+
+            card_uuid, card_type = await _lookup(wild_first)
+            if card_uuid is None:
+                card_uuid, card_type = await _lookup(not wild_first)
+            if card_uuid is None:
+                card_type = None
+
         # 봇 메시지 + 종료 시 확정(성공=DONE+입찰가 / 실패=REJECTED+거부사유·제시가). 한 트랜잭션.
-        bot_msg = self._build_bot_chat(sess, seq=max_seq + 2, turn=turn, bot_chat_type=bot_chat_type, summary=summary)
+        bot_msg = self._build_bot_chat(sess, seq=max_seq + 2, turn=turn, bot_chat_type=bot_chat_type, summary=summary, card_uuid=card_uuid, card_type=card_type)
         funcs = [lambda s: self.chat_crud.insert_message(s, bot_msg)]
         # 가격 입력 턴 → 마지막 제시가를 봇 메시지 저장과 같은 트랜잭션으로 갱신.
         # 앵커링 표본 판정의 "가격 흔적"(가격을 써낸 협상만 집계 — 중간 이탈해도 실패로 측정 가능).
@@ -392,10 +530,15 @@ class ChatService:
                 funcs.append(lambda s: self.chat_crud.finalize_session(s, sess.session_id, new_status, bid_price=bid))
             else:
                 new_status = SessionStatus.REJECTED.value
+                parsed = self._parse_reject(user_input)
                 funcs.append(lambda s: self.chat_crud.finalize_session(
                     s, sess.session_id, new_status,
-                    reject_reason=(user_input or None), reject_price=price,
+                    reject_reason=parsed["reason"], reject_price=parsed["offer_price"],
                 ))
+                if parsed["opinion"]:
+                    funcs.append(lambda s, op=parsed["opinion"]: self.session_crud.merge_session_custom(
+                        s, sess.session_id, sess.supplier_id, {"opinion": op},
+                    ))
 
         err_type = await DB_SESSION_MNG.execute_lambda_run([chats.DBType()], funcs)
         if err_type != ErrorType.SUCCESS:
@@ -505,7 +648,17 @@ class ChatService:
         # 배송형태: 재견적(CM)의 '배송형태선택' 단계에서 공급사가 고른 라벨. 재협상엔 단계가 없어 None.
         delivery_label = await self._delivery_choice(sess) if sess.qt_type == 2 else None
         # 상품 기본 배송유형(코드→라벨). 선택값이 없으면 표시에 폴백으로 쓸 수 있다.
-        item_delivery_label = DeliveryType.label_of(item.delivery_type) if item and item.delivery_type is not None else ""
+        #   회사가 배송유형 보기를 자기 용어로 바꿨으면(settings.labels['delivery_type.N']) 그 단어를 쓴다 —
+        #   협상 중 공급사가 고른 보기와 요약 표기가 갈리지 않도록.
+        item_delivery_label = ""
+        if item and item.delivery_type is not None:
+            _e2, _settings = await DB_SESSION_MNG.execute_lambda(
+                suppliers.DBType(), DBWRType.DB_READ.value,
+                lambda s: self.user_crud.get_company_settings(s, sess.supplier_id),
+            )
+            _labels = (_settings.get("labels") or {}) if _e2 == ErrorType.SUCCESS and _settings else {}
+            item_delivery_label = (_labels.get(f"delivery_type.{item.delivery_type}")
+                                   or DeliveryType.label_of(item.delivery_type))
 
         def _iso(dt):
             if dt is None:

backend/services/negotiation_service.py

@@ -1,14 +1,35 @@
 import uuid
 from datetime import datetime, timezone
+from typing import Optional
 
 from fastapi import Depends
 
 from common.database.db_session_manager import DB_SESSION_MNG
-from common.database.model.models import sessions
-from common.enums import DBWRType, ErrorType, QuotationStatus, SessionStatus
+from common.database.model.models import chats, notifications, sessions
+from common.enums import (
+    CloseReason,
+    DBWRType,
+    ErrorType,
+    NotificationType,
+    QuotationStatus,
+    RENEGOTIABLE_CLOSE_REASONS,
+    RenegotiationStatus,
+    SessionStatus,
+)
+from common.logger import LOG
 from common.models.gmodel import UserInfo
+from crud.chat_crud import ChatCRUD, IChatCRUD
 from crud.session_crud import ISessionCRUD, SessionCRUD
-from router.v1.negotiation.protocol import ListItem, Res_Participate, Res_Reject, Res_SessionList
+from router.v1.negotiation.protocol import (
+    ListItem,
+    Req_ExtraInfo,
+    Req_Renegotiation,
+    Res_ExtraInfo,
+    Res_Participate,
+    Res_Reject,
+    Res_Renegotiation,
+    Res_SessionList,
+)
 from services.auth_service import AuthService
 
 
@@ -18,11 +39,20 @@ class NegotiationService:
     - 목록은 로그인 유저의 supplier_id 로만 조회한다.
     """
 
-    def __init__(self, auth: AuthService = Depends(AuthService), session_crud: ISessionCRUD = Depends(SessionCRUD)):
+    # 부가정보 입력 폼을 띄우는 요약 말풍선 종류. 이 말풍선이 나온 뒤면 협상은 타결된 것으로 본다.
+    _SUMMARY_BOT_TYPES = ("summaryRSP", "summaryCM")
+
+    def __init__(
+        self,
+        auth: AuthService = Depends(AuthService),
+        session_crud: ISessionCRUD = Depends(SessionCRUD),
+        chat_crud: IChatCRUD = Depends(ChatCRUD),
+    ):
         self.auth = auth
         self.session_crud = session_crud
+        self.chat_crud = chat_crud
 
-    async def list_sessions(self, user_info: UserInfo, access_token: str, status, qt_type, order: str, page: int, page_size: int) -> Res_SessionList:
+    async def list_sessions(self, user_info: UserInfo, access_token: str, status, qt_type, order: str, page: int, page_size: int, keyword: str = None, result: int = None) -> Res_SessionList:
         res = Res_SessionList()
 
         # 1) 인증 (활성 + 저장된 access 토큰 대조)
@@ -38,7 +68,7 @@ class NegotiationService:
         err_type, rows = await DB_SESSION_MNG.execute_lambda(
             sessions.DBType(),
             DBWRType.DB_READ.value,
-            lambda s: self.session_crud.list_by_supplier(s, supplier_id, status, qt_type, order, offset, page_size),
+            lambda s: self.session_crud.list_by_supplier(s, supplier_id, status, qt_type, order, offset, page_size, keyword, result),
         )
         if err_type != ErrorType.SUCCESS:
             res.result.SetResult(err_type)
@@ -48,31 +78,274 @@ class NegotiationService:
         err_type, total = await DB_SESSION_MNG.execute_lambda(
             sessions.DBType(),
             DBWRType.DB_READ.value,
-            lambda s: self.session_crud.count_by_supplier(s, supplier_id, status, qt_type),
+            lambda s: self.session_crud.count_by_supplier(s, supplier_id, status, qt_type, keyword, result),
         )
         if err_type != ErrorType.SUCCESS:
             res.result.SetResult(err_type)
             return res
 
-        res.items = [
-            ListItem(
-                session_id=str(r[0]),
-                session_status=r[1],
-                qt_type=r[2],
-                qt_number=r[3],
-                qt_end_time=r[4].isoformat(timespec="seconds") if r[4] else "",
-                item_code=r[5] or "",
-                item_name=r[6] or "",
-                model_name=r[7] or "",
-                maker_name=r[8] or "",
+        # 같은 견적번호(체인)의 최대 차수 — 이미 다음 라운드가 있으면 재협상 요청 대상이 아니다.
+        max_rounds: dict = {}
+        for number in {r[3] for r in rows if r[3]}:
+            _e, mx = await DB_SESSION_MNG.execute_lambda(
+                sessions.DBType(), DBWRType.DB_READ.value,
+                lambda s, n=number: self.session_crud.chain_max_round(s, n),
             )
-            for r in rows
-        ]
+            max_rounds[number] = mx or 0
+
+        res.items = [self._to_list_item(r, max_rounds) for r in rows]
         res.total = total
         res.page = page
         res.page_size = page_size
         return res
 
+    async def save_extra_info(self, user_info: UserInfo, access_token: str, session_id_str: str, req: Req_ExtraInfo) -> Res_ExtraInfo:
+        """협상완료(타결) 부가정보 저장. 견적 마감 여부와 무관하게, 본인 공급사의 '협상완료' 세션에만 허용.
+
+        _load_actionable_session 은 견적마감·마감시간을 막으므로(타결 후엔 마감됐을 수 있음) 쓰지 않고 직접 검증한다.
+        """
+        res = Res_ExtraInfo()
+
+        # 1) 인증
+        err_type, info = await self.auth.authenticate(user_info, access_token)
+        if err_type != ErrorType.SUCCESS:
+            res.result.SetResult(err_type)
+            return res
+        try:
+            session_id = uuid.UUID(session_id_str)
+        except (ValueError, TypeError):
+            res.result.SetResult(ErrorType.NEGO_NOT_FOUND)
+            return res
+
+        # 2) 세션 조회 + 소유 검증
+        err_type, sess = await DB_SESSION_MNG.execute_lambda(
+            sessions.DBType(), DBWRType.DB_READ.value,
+            lambda s: self.session_crud.get_session_by_id(s, session_id),
+        )
+        if err_type != ErrorType.SUCCESS or sess is None:
+            res.result.SetResult(ErrorType.NEGO_NOT_FOUND)
+            return res
+        if str(sess.supplier_id) != info.supplier_id:
+            res.result.SetResult(ErrorType.NEGO_FORBIDDEN)
+            return res
+
+        # 3) 협상완료(타결) 세션만 부가정보 입력 허용.
+        #    단 '협상완료' 요약 말풍선은 chat_end=false 라 세션이 아직 협상중(2)이다
+        #    (동의 → '협상종료' 턴에서야 완료로 전이). 폼은 요약 시점에 뜨므로 그 구간도 허용한다.
+        if sess.status != SessionStatus.DONE.value:
+            if sess.status != SessionStatus.IN_PROGRESS.value or not await self._is_after_summary(sess.session_id):
+                res.result.SetResult(ErrorType.NEGO_NOT_PARTICIPABLE)
+                return res
+
+        # 4) 저장(supplier_id 가드 crud)
+        err_type = await DB_SESSION_MNG.execute_lambda_run(
+            [sessions.DBType()],
+            [lambda s: self.session_crud.update_session_custom(s, session_id, uuid.UUID(info.supplier_id), req.custom or {})],
+        )
+        if err_type != ErrorType.SUCCESS:
+            res.result.SetResult(err_type)
+            return res
+
+        res.session_id = str(session_id)
+        return res
+
+    @staticmethod
+    def _to_list_item(r, max_rounds: dict) -> ListItem:
+        """세션 행 → 목록 아이템. 재협상 요청 가능 여부는 서버가 판정해 내려준다(프론트가 규칙을 몰라도 되게)."""
+        custom = r[9] or {}
+        renego = custom.get("renegotiation") or {}
+        status = renego.get("status") or 0
+
+        is_last_round = (r[12] or 0) >= max_rounds.get(r[3], 0)
+        renegotiable = (
+            r[10] == QuotationStatus.CLOSED.value
+            and r[11] in RENEGOTIABLE_CLOSE_REASONS
+            and is_last_round
+            and status
+            not in (
+                RenegotiationStatus.PENDING.value,
+                RenegotiationStatus.APPROVED.value,
+                RenegotiationStatus.REJECTED.value,
+            )
+        )
+        return ListItem(
+            session_id=str(r[0]),
+            session_status=r[1],
+            qt_type=r[2],
+            qt_number=r[3],
+            qt_end_time=r[4].isoformat(timespec="seconds") if r[4] else "",
+            item_code=r[5] or "",
+            item_name=r[6] or "",
+            model_name=r[7] or "",
+            maker_name=r[8] or "",
+            custom=custom,
+            renegotiable=renegotiable,
+            renegotiation_status=status,
+            renegotiation_memo=renego.get("memo") or "",
+            result=NegotiationService._to_result(r[10], r[11], r[13], r[14]),
+            has_chat=bool(r[15]),
+            reject_reason=r[16] or "",
+            reject_price=r[17],
+        )
+
+    @staticmethod
+    def _to_result(qt_status, close_reason, winner_id, my_id) -> int:
+        """공급사 관점 협상 결과(SessionResult). 견적 마감 전이면 0(미정).
+        낙찰 건은 낙찰자가 나면 1(낙찰)·아니면 2(미낙찰), 개찰(OPEN_*) 마감은 3(결렬=재협상 대상)."""
+        if qt_status != QuotationStatus.CLOSED.value:
+            return 0
+        if close_reason == CloseReason.AWARDED.value:
+            return 1 if winner_id is not None and str(winner_id) == str(my_id) else 2
+        if close_reason in RENEGOTIABLE_CLOSE_REASONS:
+            return 3
+        return 0
+
+    async def request_renegotiation(
+        self, user_info: UserInfo, access_token: str, session_id_str: str, req: Req_Renegotiation
+    ) -> Res_Renegotiation:
+        """결렬(개찰) 마감 건에 대해 공급사가 재협상을 요청한다(IMK #15).
+        전용 테이블 없이 sessions.custom.renegotiation 에 기록하고, 견적 작성자에게 알림을 남긴다."""
+        res = Res_Renegotiation()
+
+        err_type, info, sess, quote = await self._load_renegotiable(user_info, access_token, session_id_str)
+        if err_type != ErrorType.SUCCESS:
+            res.result.SetResult(err_type)
+            return res
+
+        # 심사 대기·승인·반려 건은 재요청을 막는다(전용 테이블이 없어 유니크 대신 여기서 검증).
+        # 반려는 담당자가 이미 판단한 결과라 같은 건으로 다시 올릴 수 없다. 철회(CANCELED)만 재요청 허용.
+        current = (sess.custom or {}).get("renegotiation") or {}
+        if current.get("status") in (
+            RenegotiationStatus.PENDING.value,
+            RenegotiationStatus.APPROVED.value,
+            RenegotiationStatus.REJECTED.value,
+        ):
+            res.result.SetResult(ErrorType.NEGO_NOT_PARTICIPABLE)
+            return res
+
+        payload = {
+            "status": RenegotiationStatus.PENDING.value,
+            "reason": (req.reason or "").strip(),
+            "desired_price": req.desired_price,
+            "requested_at": datetime.now(timezone.utc).isoformat(),
+        }
+        err_type = await DB_SESSION_MNG.execute_lambda_run(
+            [sessions.DBType()],
+            [lambda s: self.session_crud.merge_session_custom(
+                s, sess.session_id, uuid.UUID(info.supplier_id), {"renegotiation": payload}
+            )],
+        )
+        if err_type != ErrorType.SUCCESS:
+            res.result.SetResult(err_type)
+            return res
+
+        await self._notify_renegotiation(quote, sess, info, payload)
+        res.session_id = str(sess.session_id)
+        res.status = RenegotiationStatus.PENDING.value
+        return res
+
+    async def cancel_renegotiation(self, user_info: UserInfo, access_token: str, session_id_str: str) -> Res_Renegotiation:
+        """공급사가 자기 요청을 철회한다. 심사 대기(PENDING) 중에만 가능."""
+        res = Res_Renegotiation()
+
+        err_type, info, sess, _quote = await self._load_renegotiable(user_info, access_token, session_id_str)
+        if err_type != ErrorType.SUCCESS:
+            res.result.SetResult(err_type)
+            return res
+
+        current = (sess.custom or {}).get("renegotiation") or {}
+        if current.get("status") != RenegotiationStatus.PENDING.value:
+            res.result.SetResult(ErrorType.NEGO_NOT_PARTICIPABLE)
+            return res
+
+        patch = {**current, "status": RenegotiationStatus.CANCELED.value}
+        err_type = await DB_SESSION_MNG.execute_lambda_run(
+            [sessions.DBType()],
+            [lambda s: self.session_crud.merge_session_custom(
+                s, sess.session_id, uuid.UUID(info.supplier_id), {"renegotiation": patch}
+            )],
+        )
+        if err_type != ErrorType.SUCCESS:
+            res.result.SetResult(err_type)
+            return res
+
+        res.session_id = str(sess.session_id)
+        res.status = RenegotiationStatus.CANCELED.value
+        return res
+
+    async def _load_renegotiable(self, user_info: UserInfo, access_token: str, session_id_str: str):
+        """재협상 요청 자격 검증 — 인증 → 본인 세션 → 결렬(개찰) 마감 → 마지막 라운드.
+        성공 시 (SUCCESS, info, sess, quote)."""
+        err_type, info = await self.auth.authenticate(user_info, access_token)
+        if err_type != ErrorType.SUCCESS:
+            return err_type, None, None, None
+        try:
+            session_id = uuid.UUID(session_id_str)
+        except (ValueError, TypeError):
+            return ErrorType.NEGO_NOT_FOUND, None, None, None
+
+        err_type, sess = await DB_SESSION_MNG.execute_lambda(
+            sessions.DBType(), DBWRType.DB_READ.value,
+            lambda s: self.session_crud.get_session_by_id(s, session_id),
+        )
+        if err_type != ErrorType.SUCCESS or sess is None:
+            return ErrorType.NEGO_NOT_FOUND, None, None, None
+        if str(sess.supplier_id) != info.supplier_id:
+            return ErrorType.NEGO_FORBIDDEN, None, None, None
+
+        err_type, quote = await DB_SESSION_MNG.execute_lambda(
+            sessions.DBType(), DBWRType.DB_READ.value,
+            lambda s: self.session_crud.get_quotation_by_id(s, sess.quotation_id),
+        )
+        if err_type != ErrorType.SUCCESS or quote is None:
+            return ErrorType.NEGO_NOT_FOUND, None, None, None
+
+        # 낙찰됐거나 아직 진행 중인 건은 요청 대상이 아니다.
+        if quote.status != QuotationStatus.CLOSED.value or quote.close_reason not in RENEGOTIABLE_CLOSE_REASONS:
+            return ErrorType.NEGO_NOT_PARTICIPABLE, None, None, None
+
+        # 이미 다음 라운드가 만들어졌으면 요청할 이유가 없다.
+        _e, max_round = await DB_SESSION_MNG.execute_lambda(
+            sessions.DBType(), DBWRType.DB_READ.value,
+            lambda s: self.session_crud.chain_max_round(s, quote.number),
+        )
+        if max_round and quote.round < max_round:
+            return ErrorType.NEGO_NOT_PARTICIPABLE, None, None, None
+
+        return ErrorType.SUCCESS, info, sess, quote
+
+    async def _notify_renegotiation(self, quote, sess, info, payload: dict) -> None:
+        """견적 작성자 인박스에 재협상 요청 알림을 남긴다. 부가 효과라 실패해도 본 흐름을 막지 않는다."""
+        notif = notifications(
+            user_id=quote.user_id,
+            type=NotificationType.RENEGO_REQUESTED.value,
+            ref_qt_id=quote.qt_id,
+            ref_session_id=sess.session_id,
+            data={
+                "supplier_name": info.supplier_name,
+                "qt_number": quote.number,
+                "qt_round": quote.round,
+                "reason": payload.get("reason"),
+                "desired_price": payload.get("desired_price"),
+            },
+        )
+        err = await DB_SESSION_MNG.execute_lambda_run(
+            [notifications.DBType()],
+            [lambda s: DB_SESSION_MNG.insert(s, notif, raise_error=False)],
+        )
+        if err != ErrorType.SUCCESS:
+            LOG.e_no_callstack(f"[renego] 알림 기록 실패 qt={quote.qt_id} session={sess.session_id}")
+
+    async def _is_after_summary(self, session_id) -> bool:
+        """마지막 말풍선이 타결 요약(summaryRSP/CM)인지 — 즉 협상이 타결된 뒤인지."""
+        err_type, (_, _, last_meta) = await DB_SESSION_MNG.execute_lambda(
+            chats.DBType(), DBWRType.DB_READ.value,
+            lambda s: self.chat_crud.get_last(s, session_id),
+        )
+        if err_type != ErrorType.SUCCESS or not last_meta:
+            return False
+        return last_meta.get("bot_chat_type") in self._SUMMARY_BOT_TYPES
+
     async def _load_actionable_session(self, user_info: UserInfo, access_token: str, session_id_str: str, blocked_statuses: tuple):
         """참여/거부 공통 전처리: 인증 → 세션/견적 로드 → 소유·상태·견적마감·마감시간 검증.
         성공 시 (SUCCESS, sess, quote), 실패 시 (err_type, None, None) 을 반환한다.
@@ -165,7 +438,10 @@ class NegotiationService:
         res.session_id = str(sess.session_id)
         return res
 
-    async def reject(self, user_info: UserInfo, access_token: str, session_id_str: str, reject_reason: str) -> Res_Reject:
+    async def reject(
+        self, user_info: UserInfo, access_token: str, session_id_str: str, reject_reason: str,
+        reject_price: Optional[int] = None, opinion: Optional[str] = None,
+    ) -> Res_Reject:
         res = Res_Reject()
 
         # 거부 사유 필수
@@ -185,11 +461,19 @@ class NegotiationService:
             res.result.SetResult(err_type)
             return res
 
-        # 거부 처리 — 세션을 협상거부로 전이하고 사유 저장
-        err_type = await DB_SESSION_MNG.execute_lambda_run(
-            [sessions.DBType()],
-            [lambda s: self.session_crud.update_session_reject(s, sess.session_id, SessionStatus.REJECTED.value, reason)],
-        )
+        # 거부 처리 — 세션을 협상거부로 전이하고 사유·공급 희망 가격 저장.
+        # 의견은 부가정보와 같은 custom 컬럼이라 병합(덮어쓰기 금지) — 채팅 결렬 폼과 같은 자리.
+        funcs = [
+            lambda s: self.session_crud.update_session_reject(
+                s, sess.session_id, SessionStatus.REJECTED.value, reason, reject_price,
+            )
+        ]
+        note = (opinion or "").strip()[:255]
+        if note:
+            funcs.append(
+                lambda s: self.session_crud.merge_session_custom(s, sess.session_id, sess.supplier_id, {"opinion": note})
+            )
+        err_type = await DB_SESSION_MNG.execute_lambda_run([sessions.DBType()], funcs)
         if err_type != ErrorType.SUCCESS:
             res.result.SetResult(err_type)
             return res

backend/tests/test_chat.py

@@ -220,12 +220,58 @@ async def test_chat_init_returns_meta(client, chat_seed):
     assert body["quotation_end_time"]  # 타이머용 마감 시각
 
 
+async def test_chat_init_returns_reject_detail(client, chat_seed, db_engine):
+    """검증: 협상 거부로 끝난 세션에 재진입('결과 보기')했을 때의 init 응답.
+    기대결과: 대화에 남지 않는 제출 내역(reject_reason·reject_price)이 실려 열람 카드를 그릴 수 있다."""
+    token = await _login_token(client)
+    sid = chat_seed["sids"]["P"]
+    await client.post(
+        f"/v1/negotiation/sessions/{sid}/reject",
+        headers={"Authorization": f"Bearer {token}"},
+        json={"reject_reason": "단종", "reject_price": 91000, "opinion": "후속 모델로 제안 가능합니다"},
+    )
+    body = (await _init(client, token, sid)).json()
+    assert body["session_status"] == 5
+    assert body["reject_reason"] == "단종"
+    assert body["reject_price"] == 91000
+    assert body["custom"]["opinion"] == "후속 모델로 제안 가능합니다"
+
+
 async def test_chat_init_forbidden_other_supplier(client, chat_seed):
     token = await _login_token(client)
     body = (await _init(client, token, chat_seed["sids"]["X"])).json()
     assert body["result"]["code"] == 1300  # NEGO_FORBIDDEN
 
 
+async def test_chat_init_vat_mode_unified_shows_excluded(client, chat_seed, db_engine):
+    """검증: 부가세 전체 통일 회사(features.vat_mode=unified_excluded)의 세션 채팅 init.
+    기대결과: 상품에 vat_yn=true 잔존값이 있어도 item_vat_yn=False — 프론트가 'VAT별도'로 고정 표기."""
+    import json
+
+    company_id = uuid.uuid4()
+    async with db_engine.begin() as conn:
+        await conn.execute(
+            text("INSERT INTO company.companies (company_id, name, status, settings) VALUES (:c, :n, 1, CAST(:s AS JSONB))"),
+            {"c": company_id, "n": f"{MARK}VAT통일사", "s": json.dumps({"features": {"vat_mode": "unified_excluded"}})},
+        )
+        await conn.execute(
+            text("UPDATE partner.suppliers SET company_id = :c WHERE supplier_id = :sid"),
+            {"c": company_id, "sid": chat_seed["supplier_id"]},
+        )
+        await conn.execute(
+            text("UPDATE partner.items SET vat_yn = true WHERE item_id = (SELECT item_id FROM negotiation.sessions WHERE session_id = :s)"),
+            {"s": chat_seed["sids"]["P"]},
+        )
+    try:
+        token = await _login_token(client)
+        body = (await _init(client, token, chat_seed["sids"]["P"])).json()
+        assert body["result"]["success"] is True
+        assert body["item_vat_yn"] is False
+    finally:
+        async with db_engine.begin() as conn:
+            await conn.execute(text("DELETE FROM company.companies WHERE company_id = :c"), {"c": company_id})
+
+
 # ---- messages (오프닝 seed) -------------------------------------------------
 async def test_messages_seeds_opening(client, chat_seed):
     token = await _login_token(client)
@@ -351,23 +397,28 @@ async def test_send_blocked_when_prev_turn_pending(client, chat_seed, db_engine)
 
 
 async def test_init_marks_expired_created_as_not_participated(client, chat_seed, db_engine):
+    """검증: 마감시간이 지난 협상생성 세션으로 채팅 진입.
+    기대결과: DB 상태가 미참여(4)로 정리되고, init 자체는 열람용으로 성공한다."""
     token = await _login_token(client)
     sid, qid = chat_seed["sids"]["C"], chat_seed["qids"]["C"]  # 협상생성(1)
     async with db_engine.begin() as conn:
         await conn.execute(text("UPDATE quotation.quotations SET end_time = now() - make_interval(hours => 1) WHERE qt_id = :qid"), {"qid": qid})
     body = (await _init(client, token, sid)).json()
-    # 마감된 협상생성은 DB 상 미참여로 정리되고, 미참여는 진입 불가라 init 은 에러로 막는다.
-    assert body["result"]["code"] == 1301           # NEGO_NOT_PARTICIPABLE
-    assert await _session_status(db_engine, sid) == 4  # DB 는 미참여로 전이됨
+    assert body["result"]["success"] is True
+    assert body["session_status"] == 4
+    assert await _session_status(db_engine, sid) == 4  # DB 도 미참여로 전이
 
 
-async def test_init_blocks_rejected_session(client, chat_seed, db_engine):
+async def test_init_allows_viewing_rejected_session(client, chat_seed, db_engine):
+    """검증: 협상거부(5)로 끝난 세션에 '결과 보기'로 재진입.
+    기대결과: init 성공(열람 허용) — 대화 재개는 send 가 협상중만 허용해 막는다."""
     token = await _login_token(client)
     sid = chat_seed["sids"]["P"]
     async with db_engine.begin() as conn:
         await conn.execute(text("UPDATE negotiation.sessions SET status = 5 WHERE session_id = :sid"), {"sid": sid})  # 협상거부
     body = (await _init(client, token, sid)).json()
-    assert body["result"]["code"] == 1301           # NEGO_NOT_PARTICIPABLE — 거부 세션 진입 차단
+    assert body["result"]["success"] is True and body["session_status"] == 5
+    assert (await _send(client, token, sid, "네")).json()["result"]["code"] == 1400  # CHAT_NOT_IN_PROGRESS
 
 
 # ---- 순수 헬퍼 단위 테스트 (DB 불필요, ChatService @staticmethod) ----------

backend/tests/test_negotiation.py

@@ -16,6 +16,35 @@ TEST_SUPPLIER_NAME = "파이테스트협상공급사"
 MARK = "PYTESTNEGO-"  # 시드 식별용 prefix (item code / qt number)
 
 
+async def _seed_case(conn, code, sess_st, qt_type, hrs, quote_st, sup):
+    """상품·견적·세션 1세트 시드. 코드/견적번호에 MARK prefix 를 달아 cleanup 이 함께 지운다.
+    hrs 는 마감(quotation.end_time)까지의 시간 — 음수면 이미 마감시간이 지난 건. 반환: (session_id, qt_id)."""
+    item_id, qt_id, session_id = uuid.uuid4(), uuid.uuid4(), uuid.uuid4()
+    await conn.execute(
+        text(
+            "INSERT INTO partner.items (item_id, company_id, user_id, name, code, model_name, manufacturer) "
+            "VALUES (:iid, gen_random_uuid(), gen_random_uuid(), :name, :code, :model, '테스트제조사')"
+        ),
+        {"iid": item_id, "name": f"상품 {code}", "code": f"{MARK}{code}", "model": f"MODEL-{code}"},
+    )
+    await conn.execute(
+        text(
+            "INSERT INTO quotation.quotations (qt_id, user_id, qt_setting_id, version_id, name, number, type, status, start_time, end_time) "
+            "VALUES (:qid, gen_random_uuid(), gen_random_uuid(), gen_random_uuid(), :name, :num, :tp, :st, now(), now() + make_interval(hours => :hrs))"
+        ),
+        {"qid": qt_id, "name": f"견적 {code}", "num": f"{MARK}{code}", "tp": qt_type, "st": quote_st, "hrs": hrs},
+    )
+    await conn.execute(
+        text(
+            "INSERT INTO negotiation.sessions "
+            "(session_id, quotation_id, item_id, supplier_id, qt_number, qt_round, qt_type, target_price, status, end_time) "
+            "VALUES (:sesid, :qid, :iid, :sup, :qtn, 1, :qtt, 100000, :st, now())"
+        ),
+        {"sesid": session_id, "qid": qt_id, "iid": item_id, "sup": sup, "qtn": f"{MARK}{code}", "qtt": qt_type, "st": sess_st},
+    )
+    return session_id, qt_id
+
+
 @pytest_asyncio.fixture
 async def nego_seed(db_engine):
     """공급사 + 유저 + 세션/견적 3건(본인) + 1건(타 공급사) 시드. 세션/견적 id 를 반환."""
@@ -33,6 +62,11 @@ async def nego_seed(db_engine):
     sids, qids = {}, {}
 
     async def _cleanup(conn):
+        # 대화는 세션보다 먼저 지운다(세션이 사라지면 대상을 못 고른다).
+        await conn.execute(text(
+            f"DELETE FROM negotiation.chats WHERE session_id IN "
+            f"(SELECT session_id FROM negotiation.sessions WHERE qt_number LIKE '{MARK}%')"
+        ))
         await conn.execute(text(f"DELETE FROM negotiation.sessions WHERE qt_number LIKE '{MARK}%'"))
         await conn.execute(text(f"DELETE FROM quotation.quotations WHERE number LIKE '{MARK}%'"))
         await conn.execute(text(f"DELETE FROM partner.items WHERE code LIKE '{MARK}%'"))
@@ -52,31 +86,9 @@ async def nego_seed(db_engine):
             ),
             {"sid": supplier_id, "id": TEST_LOGIN_ID, "pw": pw_hash},
         )
-        for code, sess_st, qt_type, hrs, quote_st, sup in specs:
-            item_id, qt_id, session_id = uuid.uuid4(), uuid.uuid4(), uuid.uuid4()
-            sids[code], qids[code] = session_id, qt_id
-            await conn.execute(
-                text(
-                    "INSERT INTO partner.items (item_id, company_id, user_id, name, code, model_name, manufacturer) "
-                    "VALUES (:iid, gen_random_uuid(), gen_random_uuid(), :name, :code, :model, '테스트제조사')"
-                ),
-                {"iid": item_id, "name": f"상품 {code}", "code": f"{MARK}{code}", "model": f"MODEL-{code}"},
-            )
-            await conn.execute(
-                text(
-                    "INSERT INTO quotation.quotations (qt_id, user_id, qt_setting_id, version_id, name, number, type, status, start_time, end_time) "
-                    "VALUES (:qid, gen_random_uuid(), gen_random_uuid(), gen_random_uuid(), :name, :num, :tp, :st, now(), now() + make_interval(hours => :hrs))"
-                ),
-                {"qid": qt_id, "name": f"견적 {code}", "num": f"{MARK}{code}", "tp": qt_type, "st": quote_st, "hrs": hrs},
-            )
-            await conn.execute(
-                text(
-                    "INSERT INTO negotiation.sessions "
-                    "(session_id, quotation_id, item_id, supplier_id, qt_number, qt_round, qt_type, target_price, status, end_time) "
-                    "VALUES (:sesid, :qid, :iid, :sup, :qtn, 1, :qtt, 100000, :st, now())"
-                ),
-                {"sesid": session_id, "qid": qt_id, "iid": item_id, "sup": sup, "qtn": f"{MARK}{code}", "qtt": qt_type, "st": sess_st},
-            )
+        for spec in specs:
+            code = spec[0]
+            sids[code], qids[code] = await _seed_case(conn, *spec)
 
     yield {"supplier_id": supplier_id, "sids": sids, "qids": qids}
 
@@ -141,6 +153,63 @@ async def test_list_filter_status(client, nego_seed):
     assert body["total"] == 1 and body["items"][0]["item_code"] == f"{MARK}B"
 
 
+async def test_list_shows_closed_quotation_created_session_as_not_participated(client, db_engine, nego_seed):
+    """검증: 견적이 마감(3)된 뒤에도 세션이 협상생성(1)으로 남아 있는 건(마감 일괄정리 이후 생성 등).
+    기대결과: 목록 상태는 미참여(4) — '협상 대기'로 새지 않고, status=1 필터에서도 빠지고 status=4 필터에 잡힌다."""
+    async with db_engine.begin() as conn:
+        await _seed_case(conn, "CLOSED1", 1, 2, -1, 3, nego_seed["supplier_id"])
+    token = await _login_token(client)
+
+    listed = next(i for i in (await _list(client, token)).json()["items"] if i["item_code"] == f"{MARK}CLOSED1")
+    assert listed["session_status"] == 4
+
+    waiting = (await _list(client, token, status=1)).json()
+    assert waiting["total"] == 1 and {i["item_code"] for i in waiting["items"]} == {f"{MARK}A"}
+    assert f"{MARK}CLOSED1" in {i["item_code"] for i in (await _list(client, token, status=4)).json()["items"]}
+
+
+async def test_list_shows_deadline_passed_created_session_as_not_participated(client, db_engine, nego_seed):
+    """검증: 견적은 아직 진행중(2)인데 마감시간(end_time)만 지난 협상생성 세션.
+    기대결과: 미참여(4) — 참여/입장이 막히는 건이라 목록도 같은 상태로 보인다(DB 값은 그대로)."""
+    async with db_engine.begin() as conn:
+        session_id, _ = await _seed_case(conn, "OVERDUE", 1, 2, -3, 2, nego_seed["supplier_id"])
+    token = await _login_token(client)
+
+    listed = next(i for i in (await _list(client, token)).json()["items"] if i["item_code"] == f"{MARK}OVERDUE")
+    assert listed["session_status"] == 4
+    assert await _session_status(db_engine, session_id) == 1  # 목록은 파생 표시만, 쓰기는 하지 않는다
+
+
+async def test_list_marks_stale_round_not_renegotiable(client, db_engine, nego_seed):
+    """검증: 개찰(결렬) 마감된 1차 견적에 2차가 이미 생성돼 있는 체인.
+    기대결과: renegotiable False — 다음 라운드가 있으면 재협상 요청 대상이 아니다(체인 최대 차수 판정)."""
+    async with db_engine.begin() as conn:
+        await _seed_case(conn, "CHAIN", 3, 2, -2, 3, nego_seed["supplier_id"])
+        await conn.execute(text(
+            f"UPDATE quotation.quotations SET close_reason = 5 WHERE number = '{MARK}CHAIN'"))
+        # 같은 견적번호의 2차 — 번호가 같아야 체인으로 묶인다.
+        await conn.execute(text(
+            "INSERT INTO quotation.quotations (qt_id, user_id, qt_setting_id, version_id, name, number, type, status, round, start_time, end_time) "
+            f"VALUES (gen_random_uuid(), gen_random_uuid(), gen_random_uuid(), gen_random_uuid(), '견적 CHAIN 2차', '{MARK}CHAIN', 2, 2, 2, now(), now() + make_interval(hours => 2))"))
+    token = await _login_token(client)
+    listed = next(i for i in (await _list(client, token)).json()["items"] if i["item_code"] == f"{MARK}CHAIN")
+    assert listed["result"] == 3 and listed["renegotiable"] is False
+
+
+async def test_list_has_chat_flags_sessions_with_history(client, db_engine, nego_seed):
+    """검증: 대화 이력이 있는 세션과 없는 세션의 has_chat.
+    기대결과: 이력 있는 건만 True — 종료 건의 '결과 보기' 노출이 이 값으로 갈린다."""
+    async with db_engine.begin() as conn:
+        await conn.execute(
+            text("INSERT INTO negotiation.chats (session_id, seq, sender, target_price) VALUES (:sid, 1, 1, 0)"),
+            {"sid": nego_seed["sids"]["C"]},
+        )
+    token = await _login_token(client)
+    by_code = {i["item_code"]: i["has_chat"] for i in (await _list(client, token)).json()["items"]}
+    assert by_code[f"{MARK}C"] is True
+    assert by_code[f"{MARK}A"] is False
+
+
 async def test_list_filter_qt_type(client, nego_seed):
     token = await _login_token(client)
     body = (await _list(client, token, qt_type=2)).json()
@@ -177,6 +246,56 @@ async def test_list_requires_auth(client):
     assert (await client.get("/v1/negotiation/sessions")).status_code in (401, 403)
 
 
+# ---- 검색(keyword) ----------------------------------------------------------
+async def test_search_by_qt_number_and_item_code(client, nego_seed):
+    """검증: 견적번호/상품코드가 같은 값(PYTESTNEGO-B)으로 검색.
+    기대결과: B 1건만, total 도 1(카운트도 같은 필터 적용)."""
+    token = await _login_token(client)
+    body = (await _list(client, token, keyword=f"{MARK}B")).json()
+    assert body["total"] == 1
+    assert [i["item_code"] for i in body["items"]] == [f"{MARK}B"]
+
+
+async def test_search_by_item_name(client, nego_seed):
+    """검증: 상품명 일부('상품 A')로 검색.
+    기대결과: A 1건만."""
+    token = await _login_token(client)
+    body = (await _list(client, token, keyword="상품 A")).json()
+    assert {i["item_code"] for i in body["items"]} == {f"{MARK}A"}
+
+
+async def test_search_prefix_matches_all_own(client, nego_seed):
+    """검증: 공통 prefix(PYTESTNEGO)로 검색.
+    기대결과: 본인 공급사 3건 전부(타 공급사 X 는 제외 유지)."""
+    token = await _login_token(client)
+    body = (await _list(client, token, keyword=MARK.rstrip("-"))).json()
+    assert body["total"] == 3
+
+
+async def test_search_case_insensitive(client, nego_seed):
+    """검증: 소문자로 검색(pytestnego-c).
+    기대결과: ILIKE 라 대소문자 무시하고 C 매칭."""
+    token = await _login_token(client)
+    body = (await _list(client, token, keyword=f"{MARK}c".lower())).json()
+    assert {i["item_code"] for i in body["items"]} == {f"{MARK}C"}
+
+
+async def test_search_no_match_returns_empty(client, nego_seed):
+    """검증: 어디에도 없는 검색어.
+    기대결과: 0건, total 0."""
+    token = await _login_token(client)
+    body = (await _list(client, token, keyword="존재하지않는검색어zzz")).json()
+    assert body["total"] == 0 and body["items"] == []
+
+
+async def test_search_wildcard_is_escaped(client, nego_seed):
+    """검증: ILIKE 와일드카드('%')를 그대로 검색 — 패턴으로 새면 전건 매칭될 위험.
+    기대결과: escape 되어 리터럴 '%' 로 취급 → 매칭 0건."""
+    token = await _login_token(client)
+    body = (await _list(client, token, keyword="%")).json()
+    assert body["total"] == 0
+
+
 # ---- 참여 -------------------------------------------------------------------
 async def test_participate_success(client, nego_seed, db_engine):
     token = await _login_token(client)
@@ -266,6 +385,65 @@ async def test_reject_success(client, nego_seed, db_engine):
     assert status == 5 and reason == "단종 상품입니다"  # REJECTED + 사유 저장
 
 
+async def test_reject_with_price_and_opinion(client, nego_seed, db_engine):
+    # 채팅 내 협상 거부 경로 — 사유 외에 공급 희망 가격과 의견까지 함께 남긴다.
+    token = await _login_token(client)
+    sid = nego_seed["sids"]["B"]
+    r = await client.post(
+        f"/v1/negotiation/sessions/{sid}/reject",
+        headers={"Authorization": f"Bearer {token}"},
+        json={"reject_reason": "품절", "reject_price": 88000, "opinion": "대체품으로 재견적 부탁드립니다"},
+    )
+    assert r.json()["result"]["success"] is True
+    async with db_engine.begin() as conn:
+        row = (await conn.execute(
+            text("SELECT status, reject_reason, reject_price, custom FROM negotiation.sessions WHERE session_id = :sid"),
+            {"sid": sid},
+        )).first()
+    assert row.status == 5 and row.reject_reason == "품절"
+    assert row.reject_price == 88000
+    assert row.custom["opinion"] == "대체품으로 재견적 부탁드립니다"
+
+
+async def test_reject_without_price_keeps_null(client, nego_seed, db_engine):
+    # 목록 거부 경로 — 가격이 없으면 reject_price 를 건드리지 않는다.
+    token = await _login_token(client)
+    sid = nego_seed["sids"]["B"]
+    r = await _reject(client, token, sid, "단종")
+    assert r.json()["result"]["success"] is True
+    async with db_engine.begin() as conn:
+        row = (await conn.execute(
+            text("SELECT reject_price, custom FROM negotiation.sessions WHERE session_id = :sid"),
+            {"sid": sid},
+        )).first()
+    assert row.reject_price is None and row.custom is None
+
+
+async def test_list_returns_reject_detail(client, nego_seed):
+    # 거부 제출 내역은 대화에 남지 않는다 — 목록이 사유·희망가를 실어야 '거부 내역'을 열람할 수 있다.
+    token = await _login_token(client)
+    sid = nego_seed["sids"]["B"]
+    await client.post(
+        f"/v1/negotiation/sessions/{sid}/reject",
+        headers={"Authorization": f"Bearer {token}"},
+        json={"reject_reason": "품절", "reject_price": 77000, "opinion": "재고 확보 후 연락드리겠습니다"},
+    )
+    items = (await _list(client, token)).json()["items"]
+    row = next(i for i in items if i["session_id"] == str(sid))
+    assert row["reject_reason"] == "품절"
+    assert row["reject_price"] == 77000
+    assert row["custom"]["opinion"] == "재고 확보 후 연락드리겠습니다"
+
+
+async def test_list_reject_detail_empty_for_active(client, nego_seed):
+    # 거부 건이 아니면 빈 값 — 프론트가 '거부 내역' 버튼 노출을 상태로만 판단하므로 값이 새면 안 된다.
+    token = await _login_token(client)
+    items = (await _list(client, token)).json()["items"]
+    row = next(i for i in items if i["session_id"] == str(nego_seed["sids"]["A"]))
+    assert row["reject_reason"] == ""
+    assert row.get("reject_price") is None
+
+
 async def test_reject_empty_reason(client, nego_seed):
     token = await _login_token(client)
     r = await _reject(client, token, nego_seed["sids"]["B"], "   ")  # 공백만 → 사유 없음
@@ -294,3 +472,76 @@ async def test_reject_requires_auth(client, nego_seed):
     sid = nego_seed["sids"]["B"]
     r = await client.post(f"/v1/negotiation/sessions/{sid}/reject", json={"reject_reason": "사유"})
     assert r.status_code in (401, 403)
+
+
+# ---- 결과 필터(result) ------------------------------------------------------
+# 마감(CLOSED) + 마감사유/낙찰자로 낙찰(1)·미낙찰(2)·결렬(3)을 만들고 result= 로 거른다.
+# nego_seed 의 공급사/로그인을 재사용하고, MARK prefix 라 픽스처 teardown 이 함께 정리한다.
+async def _seed_result_row(engine, *, supplier_id, code, close_reason, winner_id):
+    import uuid as _uuid
+    item_id, qt_id, session_id = _uuid.uuid4(), _uuid.uuid4(), _uuid.uuid4()
+    async with engine.begin() as conn:
+        await conn.execute(
+            text("INSERT INTO partner.items (item_id, company_id, user_id, name, code, model_name, manufacturer) "
+                 "VALUES (:iid, gen_random_uuid(), gen_random_uuid(), :name, :code, 'M', '제조사')"),
+            {"iid": item_id, "name": f"상품 {code}", "code": f"{MARK}{code}"},
+        )
+        await conn.execute(
+            text("INSERT INTO quotation.quotations "
+                 "(qt_id, user_id, qt_setting_id, version_id, name, number, type, status, close_reason, "
+                 " preferred_sp_id, round, start_time, end_time) VALUES "
+                 "(:qid, gen_random_uuid(), gen_random_uuid(), gen_random_uuid(), :name, :num, 2, 3, :cr, "
+                 " :win, 1, now() - make_interval(hours => 2), now() - make_interval(hours => 1))"),
+            {"qid": qt_id, "name": f"견적 {code}", "num": f"{MARK}{code}", "cr": close_reason, "win": winner_id},
+        )
+        await conn.execute(
+            text("INSERT INTO negotiation.sessions "
+                 "(session_id, quotation_id, item_id, supplier_id, qt_number, qt_round, qt_type, "
+                 " target_price, status, bid_price, end_time) VALUES "
+                 "(:sid, :qid, :iid, :sup, :num, 1, 2, 100000, 3, 95000, now() - make_interval(hours => 1))"),
+            {"sid": session_id, "qid": qt_id, "iid": item_id, "sup": supplier_id, "num": f"{MARK}{code}"},
+        )
+
+
+@pytest_asyncio.fixture
+async def result_rows(nego_seed, db_engine):
+    """nego_seed 공급사에 낙찰/미낙찰/결렬 각 1건을 추가한다(개찰 5=OPEN_PRICE, 1=AWARDED)."""
+    sup = nego_seed["supplier_id"]
+    await _seed_result_row(db_engine, supplier_id=sup, code="RWON", close_reason=1, winner_id=sup)              # 낙찰(나)
+    await _seed_result_row(db_engine, supplier_id=sup, code="RLOST", close_reason=1, winner_id=uuid.uuid4())    # 미낙찰(남)
+    await _seed_result_row(db_engine, supplier_id=sup, code="ROPEN", close_reason=5, winner_id=None)            # 결렬(개찰)
+    return nego_seed
+
+
+async def test_result_filter_won(client, result_rows):
+    """검증: result=1(낙찰)로 필터. 기대결과: 낙찰 건만, total=1."""
+    token = await _login_token(client)
+    body = (await _list(client, token, result=1)).json()
+    assert body["total"] == 1
+    assert body["items"][0]["item_code"] == f"{MARK}RWON"
+    assert body["items"][0]["result"] == 1
+
+
+async def test_result_filter_lost(client, result_rows):
+    """검증: result=2(미낙찰)로 필터. 기대결과: 미낙찰 건만."""
+    token = await _login_token(client)
+    body = (await _list(client, token, result=2)).json()
+    assert {i["item_code"] for i in body["items"]} == {f"{MARK}RLOST"}
+    assert body["items"][0]["result"] == 2
+
+
+async def test_result_filter_open(client, result_rows):
+    """검증: result=3(결렬)로 필터. 기대결과: 개찰 결렬 건만 + 재협상 대상(renegotiable=True)."""
+    token = await _login_token(client)
+    body = (await _list(client, token, result=3)).json()
+    assert {i["item_code"] for i in body["items"]} == {f"{MARK}ROPEN"}
+    assert body["items"][0]["result"] == 3
+    assert body["items"][0]["renegotiable"] is True
+
+
+async def test_result_filter_composes_with_paging(client, result_rows):
+    """검증: 결과 필터가 total(페이징)에 반영. 기대결과: result=1 이면 total=1(전체 목록과 별개)."""
+    token = await _login_token(client)
+    all_total = (await _list(client, token)).json()["total"]
+    won_total = (await _list(client, token, result=1)).json()["total"]
+    assert won_total == 1 and all_total > won_total

backend/tests/test_renegotiation.py

@@ -0,0 +1,215 @@
+"""공급사 재협상 요청/철회(IMK #15) 포털 e2e — 요청 접수 + 철회.
+
+담당자 심사(승인/반려)는 negodata 백엔드 몫이고, 여기(포털)는 공급사가
+sessions.custom.renegotiation 에 요청을 남기고(PENDING) 스스로 철회(CANCELED)하는 절반을 본다:
+  · 개찰(OPEN_*) 마감 + 본인 마지막 라운드 세션 → 요청 기록(PENDING) + 담당자 알림
+  · 낙찰(AWARDED) 건 → 요청 거부
+  · 남의 공급사 세션 → 거부(FORBIDDEN)
+  · 이미 대기 중인데 재요청 → 거부(중복 방지)
+  · 대기 중 철회 → CANCELED, 이후 재요청 허용
+
+dev negosium_db 를 그대로 쓰므로(APP_ENV=local) 전용 테스트 행만 시드하고 끝나면 지운다.
+"""
+import uuid
+
+import bcrypt
+import pytest_asyncio
+from sqlalchemy import text
+
+from common.enums import CloseReason, QuotationStatus, RenegotiationStatus, SessionStatus
+
+TEST_LOGIN_ID = "pytest_renego_user"
+TEST_PW = "pytest1234"
+TEST_SUPPLIER_NAME = "파이테스트재협상공급사"
+MARK = "PYTESTRENEGO-"  # 시드 식별용 prefix (item code / qt number)
+
+
+@pytest_asyncio.fixture
+async def renego_seed(db_engine):
+    """공급사 + 로그인유저 + 재협상 후보 세션들을 시드하고 (supplier_id, sids, uids) 반환.
+
+    (code, quotation.status, close_reason, 소속 공급사) — 요청 자격은 견적 마감사유·소유로 갈린다.
+    """
+    supplier_id = uuid.uuid4()
+    other_supplier_id = uuid.uuid4()
+    pw_hash = bcrypt.hashpw(TEST_PW.encode("utf-8"), bcrypt.gensalt()).decode("utf-8")
+
+    specs = [
+        ("OPEN", QuotationStatus.CLOSED.value, CloseReason.OPEN_PRICE.value, supplier_id),      # 개찰 → 요청 가능
+        ("AWARD", QuotationStatus.CLOSED.value, CloseReason.AWARDED.value, supplier_id),        # 낙찰 → 불가
+        ("OTHER", QuotationStatus.CLOSED.value, CloseReason.OPEN_PRICE.value, other_supplier_id),  # 남의 공급사
+    ]
+    sids, uids = {}, {}
+
+    async def _cleanup(conn):
+        await conn.execute(text(f"DELETE FROM negotiation.sessions WHERE qt_number LIKE '{MARK}%'"))
+        await conn.execute(text(f"DELETE FROM company.notifications WHERE ref_qt_id IN "
+                                f"(SELECT qt_id FROM quotation.quotations WHERE number LIKE '{MARK}%')"))
+        await conn.execute(text(f"DELETE FROM quotation.quotations WHERE number LIKE '{MARK}%'"))
+        await conn.execute(text(f"DELETE FROM partner.items WHERE code LIKE '{MARK}%'"))
+        await conn.execute(text("DELETE FROM supplier.supplier_users WHERE id = :id"), {"id": TEST_LOGIN_ID})
+        await conn.execute(text("DELETE FROM partner.suppliers WHERE name = :n"), {"n": TEST_SUPPLIER_NAME})
+
+    async with db_engine.begin() as conn:
+        await _cleanup(conn)
+        await conn.execute(
+            text("INSERT INTO partner.suppliers (supplier_id, company_id, user_id, name) "
+                 "VALUES (:sid, gen_random_uuid(), gen_random_uuid(), :name)"),
+            {"sid": supplier_id, "name": TEST_SUPPLIER_NAME},
+        )
+        await conn.execute(
+            text("INSERT INTO supplier.supplier_users (supplier_id, id, password, name, last_accessed_at, status, role) "
+                 "VALUES (:sid, :id, :pw, '협상담당자', now(), 1, 1)"),
+            {"sid": supplier_id, "id": TEST_LOGIN_ID, "pw": pw_hash},
+        )
+        for code, quote_st, close_reason, sup in specs:
+            item_id, qt_id, session_id, user_id = uuid.uuid4(), uuid.uuid4(), uuid.uuid4(), uuid.uuid4()
+            sids[code], uids[code] = session_id, user_id
+            await conn.execute(
+                text("INSERT INTO partner.items (item_id, company_id, user_id, name, code, model_name, manufacturer) "
+                     "VALUES (:iid, gen_random_uuid(), gen_random_uuid(), :name, :code, :model, '테스트제조사')"),
+                {"iid": item_id, "name": f"상품 {code}", "code": f"{MARK}{code}", "model": f"MODEL-{code}"},
+            )
+            await conn.execute(
+                text("INSERT INTO quotation.quotations "
+                     "(qt_id, user_id, qt_setting_id, version_id, name, number, type, status, close_reason, "
+                     " round, start_time, end_time) VALUES "
+                     "(:qid, :uid, gen_random_uuid(), gen_random_uuid(), :name, :num, 2, :st, :cr, "
+                     " 1, now() - make_interval(hours => 2), now() - make_interval(hours => 1))"),
+                {"qid": qt_id, "uid": user_id, "name": f"견적 {code}", "num": f"{MARK}{code}", "st": quote_st, "cr": close_reason},
+            )
+            await conn.execute(
+                text("INSERT INTO negotiation.sessions "
+                     "(session_id, quotation_id, item_id, supplier_id, qt_number, qt_round, qt_type, "
+                     " target_price, status, bid_price, end_time) VALUES "
+                     "(:sesid, :qid, :iid, :sup, :qtn, 1, 2, 100000, :sst, 95000, now() - make_interval(hours => 1))"),
+                {"sesid": session_id, "qid": qt_id, "iid": item_id, "sup": sup, "qtn": f"{MARK}{code}", "sst": SessionStatus.DONE.value},
+            )
+
+    yield {"supplier_id": supplier_id, "sids": sids, "uids": uids}
+
+    async with db_engine.begin() as conn:
+        await _cleanup(conn)
+
+
+async def _login_token(client):
+    r = await client.post("/v1/auth/login", json={"id": TEST_LOGIN_ID, "pw": TEST_PW})
+    return r.json()["access_token"]
+
+
+async def _request(client, token, session_id, *, reason="가격 재검토", desired_price=90000):
+    return await client.post(
+        f"/v1/negotiation/session/{session_id}/renegotiation",
+        headers={"Authorization": f"Bearer {token}"},
+        json={"reason": reason, "desired_price": desired_price},
+    )
+
+
+async def _cancel(client, token, session_id):
+    return await client.delete(
+        f"/v1/negotiation/session/{session_id}/renegotiation",
+        headers={"Authorization": f"Bearer {token}"},
+    )
+
+
+async def _renego(db_engine, session_id):
+    async with db_engine.begin() as conn:
+        row = (await conn.execute(
+            text("SELECT custom FROM negotiation.sessions WHERE session_id = :sid"),
+            {"sid": session_id},
+        )).scalar()
+    return (row or {}).get("renegotiation") or {}
+
+
+async def _notif_count(db_engine, qt_number):
+    async with db_engine.begin() as conn:
+        return (await conn.execute(
+            text("SELECT count(*) FROM company.notifications WHERE ref_qt_id IN "
+                 "(SELECT qt_id FROM quotation.quotations WHERE number = :num)"),
+            {"num": qt_number},
+        )).scalar()
+
+
+# ---- 요청 -------------------------------------------------------------------
+async def test_request_records_pending(client, renego_seed, db_engine):
+    """검증: 개찰(OPEN_PRICE) 마감 + 본인 마지막 라운드 세션에 재협상 요청.
+    기대결과: success + PENDING 기록(사유·희망가 저장) + 담당자 알림 1건."""
+    token = await _login_token(client)
+    sid = renego_seed["sids"]["OPEN"]
+
+    body = (await _request(client, token, sid, reason="원자재 인상 반영", desired_price=88000)).json()
+
+    assert body["result"]["success"] is True
+    assert body["status"] == RenegotiationStatus.PENDING.value
+    saved = await _renego(db_engine, sid)
+    assert saved["status"] == RenegotiationStatus.PENDING.value
+    assert saved["reason"] == "원자재 인상 반영"
+    assert saved["desired_price"] == 88000
+    assert await _notif_count(db_engine, f"{MARK}OPEN") == 1
+
+
+async def test_request_twice_blocked(client, renego_seed, db_engine):
+    """검증: 이미 대기(PENDING) 요청이 있는 세션에 다시 요청.
+    기대결과: 2번째는 거부(중복 방지) + 상태는 여전히 PENDING 1건."""
+    token = await _login_token(client)
+    sid = renego_seed["sids"]["OPEN"]
+
+    first = (await _request(client, token, sid)).json()
+    second = (await _request(client, token, sid)).json()
+
+    assert first["result"]["success"] is True
+    assert second["result"]["success"] is False
+    assert (await _renego(db_engine, sid))["status"] == RenegotiationStatus.PENDING.value
+
+
+async def test_request_blocked_on_awarded(client, renego_seed, db_engine):
+    """검증: 낙찰(AWARDED)로 마감된 건에 재협상 요청.
+    기대결과: 거부(낙찰 건은 재협상 불가) + custom.renegotiation 미기록."""
+    token = await _login_token(client)
+    sid = renego_seed["sids"]["AWARD"]
+
+    body = (await _request(client, token, sid)).json()
+
+    assert body["result"]["success"] is False
+    assert await _renego(db_engine, sid) == {}
+
+
+async def test_request_forbidden_other_supplier(client, renego_seed, db_engine):
+    """검증: 다른 공급사 소유 세션에 재협상 요청.
+    기대결과: 거부 + custom.renegotiation 미기록(소유 가드)."""
+    token = await _login_token(client)
+    sid = renego_seed["sids"]["OTHER"]
+
+    body = (await _request(client, token, sid)).json()
+
+    assert body["result"]["success"] is False
+    assert await _renego(db_engine, sid) == {}
+
+
+# ---- 철회 -------------------------------------------------------------------
+async def test_cancel_sets_canceled_and_allows_rerequest(client, renego_seed, db_engine):
+    """검증: 대기 중 요청을 철회한 뒤 다시 요청.
+    기대결과: 철회 시 CANCELED → 재요청 시 다시 PENDING(철회 건은 재요청 허용)."""
+    token = await _login_token(client)
+    sid = renego_seed["sids"]["OPEN"]
+
+    await _request(client, token, sid)
+    cancelled = (await _cancel(client, token, sid)).json()
+    assert cancelled["result"]["success"] is True
+    assert cancelled["status"] == RenegotiationStatus.CANCELED.value
+    assert (await _renego(db_engine, sid))["status"] == RenegotiationStatus.CANCELED.value
+
+    again = (await _request(client, token, sid)).json()
+    assert again["result"]["success"] is True
+    assert (await _renego(db_engine, sid))["status"] == RenegotiationStatus.PENDING.value
+
+
+async def test_cancel_requires_pending(client, renego_seed, db_engine):
+    """검증: 대기 요청이 없는 세션에 철회 시도.
+    기대결과: 거부(철회할 대기 요청 없음)."""
+    token = await _login_token(client)
+    sid = renego_seed["sids"]["OPEN"]
+
+    body = (await _cancel(client, token, sid)).json()
+
+    assert body["result"]["success"] is False

backend/tests/test_session_result.py

@@ -0,0 +1,51 @@
+"""공급사 관점 협상 결과 파생(SessionResult) 단위 테스트.
+
+목록의 result 코드는 견적 마감상태·마감사유·낙찰자로 파생한다(DDL 무변경). 공급사가 이 배지로
+'내가 낙찰인지 / 결렬이라 재협상 요청 대상인지'를 구분한다. 결렬(3)만 renegotiable 과 짝을 이룬다.
+"""
+import uuid
+
+from common.enums import CloseReason, QuotationStatus
+from services.negotiation_service import NegotiationService
+
+_R = NegotiationService._to_result
+ME = uuid.uuid4()
+OTHER = uuid.uuid4()
+CLOSED = QuotationStatus.CLOSED.value
+
+
+def test_result_undecided_before_close():
+    """검증: 견적이 아직 마감 전(진행중)이면 결과 미정.
+    기대결과: 0(미정)."""
+    assert _R(QuotationStatus.IN_PROGRESS.value, None, None, ME) == 0
+
+
+def test_result_won_when_winner_is_me():
+    """검증: 낙찰(AWARDED) 마감 + 낙찰자가 나.
+    기대결과: 1(낙찰)."""
+    assert _R(CLOSED, CloseReason.AWARDED.value, ME, ME) == 1
+
+
+def test_result_lost_when_winner_is_other():
+    """검증: 낙찰 마감이지만 낙찰자가 남.
+    기대결과: 2(미낙찰)."""
+    assert _R(CLOSED, CloseReason.AWARDED.value, OTHER, ME) == 2
+
+
+def test_result_lost_when_awarded_without_winner_id():
+    """검증: 낙찰인데 낙찰자 id 가 비어 나와 대조 불가.
+    기대결과: 2(미낙찰) — 낙찰이라 단정 못 하면 낙찰로 오인시키지 않는다."""
+    assert _R(CLOSED, CloseReason.AWARDED.value, None, ME) == 2
+
+
+def test_result_open_is_renegotiable():
+    """검증: 개찰(OPEN_*) 4종으로 마감(낙찰자 미정=결렬).
+    기대결과: 전부 3(결렬) — 재협상 요청 대상."""
+    for cr in (CloseReason.OPEN_PRICE, CloseReason.OPEN_EQUAL, CloseReason.OPEN_NOSHOW, CloseReason.OPEN_REJECT):
+        assert _R(CLOSED, cr.value, None, ME) == 3, cr
+
+
+def test_result_none_when_closed_without_reason():
+    """검증: 마감됐지만 close_reason 이 아직 없음(경계).
+    기대결과: 0(미정) — 낙찰/결렬 어느 쪽도 아님."""
+    assert _R(CLOSED, None, None, ME) == 0

docker-compose.prod.landing.yml

@@ -0,0 +1,214 @@
+services:
+  # ── 프론트 (React/Vite → 정적 빌드 → nginx) ──────────────────────────────
+  negodata-front:
+    build:
+      context: ./negodata/front
+      dockerfile: Dockerfile.prod
+    container_name: negodata-front
+    ports:
+      - "${NEGODATA_FRONT_PORT:-30012}:80"
+    depends_on:
+      - negodata-backend          # nginx 가 시작 시 upstream(negodata-backend) 이름을 해석해야 함
+    restart: unless-stopped
+
+  negosium-front:
+    build:
+      context: ./frontend
+      dockerfile: Dockerfile.prod
+    container_name: negosium-front
+    ports:
+      - "${NEGOSIUM_FRONT_PORT:-30010}:80"
+    depends_on:
+      - negosium-backend
+    restart: unless-stopped
+
+  # ── 솔루션 랜딩 (React Router SSG → 정적 빌드 → nginx) ───────────────────
+  landing:
+    build:
+      context: ./landing
+      dockerfile: Dockerfile.prod
+    container_name: negosium-landing
+    ports:
+      - "${LANDING_PORT:-30013}:80"
+    restart: unless-stopped
+
+  # ── 백엔드 (FastAPI, 기존 Dockerfile) ────────────────────────────────────
+  negodata-backend:
+    build: ./negodata/backend
+    container_name: negodata-backend
+    environment:
+      APP_ENV: prod
+      SCHEDULER_ENABLED: "1"        # 견적 자동마감 크론(process_count=1 단일 워커라 중복 없음)
+      PYTHONUNBUFFERED: "1"
+      LPS_BASE_URL: http://lps-api:9600   # 최저가 검색요청 enqueue — 같은 compose 망의 lps-api 컨테이너(미설정 시 localhost:9600 → 연결실패)
+      # LPS 읽기 DB(lps_db)는 config.prod.toml 의 [LpsDBConfig](172.30.1.36/o2o_db_admin) 이 담당 → 별도 env 불필요
+      DB_HOST: ${DB_HOST}           # toml 의 127.0.0.1 을 외부 DB 로 override
+      DB_PORT: ${DB_PORT:-5432}
+      DB_USER: ${DB_USER}
+      DB_PASSWORD: ${DB_PASSWORD}
+      DB_NAME: ${DB_NAME:-negosium_db}
+    volumes:
+      - ./negodata/backend/config/config.prod.toml:/app/config/config.prod.toml:ro
+    # 외부 비노출 — negodata-front 의 nginx 가 /v1 을 내부망으로 프록시.
+    extra_hosts:
+      - "host.docker.internal:host-gateway"   # DB 가 이 서버 호스트면 DB_HOST=host.docker.internal
+    restart: unless-stopped
+
+  negosium-backend:
+    build: ./backend
+    container_name: negosium-backend
+    environment:
+      APP_ENV: prod
+      AGENT_BASE_URL: http://agent:9500   # 내부망으로 agent 호출
+      PYTHONUNBUFFERED: "1"
+      DB_HOST: ${DB_HOST}
+      DB_PORT: ${DB_PORT:-5432}
+      DB_USER: ${DB_USER}
+      DB_PASSWORD: ${DB_PASSWORD}
+      DB_NAME: ${DB_NAME:-negosium_db}
+    volumes:
+      - ./backend/config/config.prod.toml:/app/config/config.prod.toml:ro
+    # 외부 비노출 — negosium-front 의 nginx 가 /v1 을 내부망으로 프록시.
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    restart: unless-stopped
+
+  # ── 협상 에이전트 (Python, 내부 전용) ────────────────────────────────────
+  agent:
+    build: ./agent
+    container_name: negosium-agent
+    environment:
+      APP_ENV: prod
+      PYTHONUNBUFFERED: "1"
+      DB_HOST: ${DB_HOST}
+      DB_PORT: ${DB_PORT:-5432}
+      DB_USER: ${DB_USER}
+      DB_PASSWORD: ${DB_PASSWORD}
+      DB_NAME: ${DB_NAME:-negosium_db}
+    volumes:
+      - ./agent/config/config.prod.toml:/app/config/config.prod.toml:ro
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    restart: unless-stopped
+
+  # ── 앵커링 값 자동 조정 배치 (negosium_db 공유, 포트 없음 — 상주 스케줄러) ──
+  # 이미지는 config.{APP_ENV}.toml 을 읽는다(dev/prod 는 파일 없으면 기동 중단). DB/시크릿은
+  # config.prod.toml(172.30.1.36) 에서 온다 — env(DB_*/REDIS_*) 를 설정하면 파일값을 override.
+  anchoring:
+    build: ./schedules/anchoring
+    container_name: anchoring
+    environment:
+      APP_ENV: prod                    # → config.prod.toml 선택 (local 로 두면 빈 config.local 로 기동 실패)
+      REDIS_HOST: anchoring-redis       # 전용 캐시 컨테이너 사용(config 의 redis host 를 override)
+      TZ: Asia/Seoul
+    volumes:
+      - ./schedules/anchoring/config.prod.toml:/app/config.prod.toml:ro   # DB 접속·시크릿은 파일에서(마운트 필수)
+    depends_on:
+      - anchoring-redis
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    restart: unless-stopped
+    logging:                    # 상주 배치 — 장기 운영 디스크 보호
+      driver: json-file
+      options:
+        max-size: "10m"
+        max-file: "5"
+
+  # 앵커링 조회 캐시 (anchoring 전용)
+  anchoring-redis:
+    image: redis:7-alpine
+    container_name: anchoring-redis
+    ports:
+      - "127.0.0.1:6380:6379"   # 호스트 로컬만 개방 (무인증 Redis). 6380 = 호스트 redis(6379)와 충돌 회피
+    restart: unless-stopped
+    logging:
+      driver: json-file
+      options:
+        max-size: "10m"
+        max-file: "5"
+
+  # ── LPS (인터넷 최저가 검색) ──────────────────────────────────
+  # API(요청 접수) + 워커(크롤, Chromium+Xvfb).
+  # 이미지는 APP_ENV=local 고정 → config.local.toml 을 읽는다. prod 실값(DB 172.30.1.36 /
+  # o2o_db_admin / negosium_db + OpenAI·Naver·Decodo 시크릿)은 config.prod.toml 을 그 경로에
+  # 마운트해 주입한다(다른 prod 서비스와 동일한 파일 기반 방식). DB_* env 는 주지 않는다 —
+  # 주면 파일값을 빈 값/오타로 덮어써 인증 실패(예: 사용자 o2oadmin)한다.
+  lps-api:
+    build:
+      context: ./lps
+      dockerfile: Dockerfile
+    container_name: lps-api
+    environment:
+      APP_ENV: local                   # 이미지 고정값 — 변경 금지(config.prod.toml 을 직접 읽지 않음)
+      PYTHONUNBUFFERED: "1"
+      PROCESS_COUNT: ${LPS_API_PROCESS_COUNT:-1}
+      DB_CONNECTION_BUDGET: ${LPS_DB_CONNECTION_BUDGET:-40}   # 전용 PG(max_connections≈100)면 90 근처로 상향
+    volumes:
+      - ./lps/config/config.prod.toml:/app/config/config.local.toml:ro   # prod DB·시크릿 주입(APP_ENV=local 이 읽는 경로 덮어씀)
+    ports:
+      - "9600:9600"
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    labels:
+      autoheal: "true"                 # HEALTHCHECK 실패 시 autoheal 이 재시작
+    restart: unless-stopped
+    logging:
+      driver: json-file
+      options: { max-size: "10m", max-file: "5" }
+
+  lps-worker:
+    build:
+      context: ./lps
+      dockerfile: Dockerfile.worker   # Chromium + Xvfb (headless 는 안티봇에 탐지됨)
+    container_name: lps-worker
+    environment:
+      APP_ENV: local                   # 이미지 고정값 — 변경 금지
+      PYTHONUNBUFFERED: "1"
+      WORKER_CONCURRENCY: "1"          # 상품 동시 검색 수(워커별 브라우저 세트, Chrome 4×N)
+      LPS_PROFILE_DIR: /profiles       # Chrome 프로필을 영속 볼륨에 → 재시작해도 cf_clearance 유지
+      # DB·시크릿(OpenAI/Naver/Decodo)은 아래 config.prod.toml 마운트에서 온다. env override 는 주지 않는다.
+    volumes:
+      - ./lps/config/config.prod.toml:/app/config/config.local.toml:ro   # prod DB·시크릿 주입(APP_ENV=local 이 읽는 경로 덮어씀)
+      - lps-profiles:/profiles         # Chrome 프로필(쿠키) 영속
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    shm_size: "1gb"                    # Chrome 는 /dev/shm 을 많이 씀 — 부족하면 탭 크래시
+    stop_grace_period: 75s             # graceful 종료 유예 — 기본 10s 면 하던 잡 마무리 전에 SIGKILL
+    labels:
+      autoheal: "true"                 # 하트비트 HEALTHCHECK 실패(행/좀비) 시 autoheal 이 재시작
+    restart: unless-stopped
+    logging:
+      driver: json-file
+      options: { max-size: "10m", max-file: "5" }
+
+  # LPS 관리자 UI (정적 React → nginx). /v1·/healthz·/readyz 는 nginx 가 lps-api:9600 으로 프록시(동일 compose 망).
+  lps-admin:
+    build:
+      context: ./lps-admin
+      dockerfile: Dockerfile
+    container_name: lps-admin
+    ports:
+      - "${LPS_ADMIN_PORT:-30014}:80"
+    depends_on:
+      - lps-api
+    restart: unless-stopped
+    logging:
+      driver: json-file
+      options: { max-size: "10m", max-file: "5" }
+
+  # HEALTHCHECK 실패 컨테이너 자동 재시작 — autoheal 라벨 붙은 컨테이너(lps-api/lps-worker)를 감시해 재시작.
+  # docker.sock 마운트 = 도커 제어 권한이므로 신뢰 환경에서만 사용.
+  autoheal:
+    image: willfarrell/autoheal:latest
+    container_name: autoheal
+    environment:
+      AUTOHEAL_CONTAINER_LABEL: autoheal
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+    restart: unless-stopped
+    logging:
+      driver: json-file
+      options: { max-size: "10m", max-file: "5" }
+
+volumes:
+  lps-profiles:

docker-compose.yml

@@ -7,8 +7,11 @@
 #   negosium 서버:  http://localhost:9300/docs
 #   negosium 프론트: http://localhost:3300
 #   negodata 서버:  http://localhost:9400/docs
+#   솔루션 랜딩:    http://localhost:3100
 #   agent   서버:   http://localhost:9500/docs
 #   anchoring 배치: 포트 없음 — 상주 스케줄러(격주 토 00:00 KST), docker logs anchoring 으로 확인
+#   lps     API:    http://localhost:9600/docs
+#   lps     admin:  http://localhost:3400   (nginx → /v1·/healthz 는 lps-api 로 프록시)
 #
 # DB 준비(최초 1회): postgres-init 의 SQL 을 대상 DB 에 적용한다.
 #   psql -h <host> -p <port> -U <user> -f postgres-init/00-init.sql     (스키마 전체: negosium_db + 도메인·learning·anchoring schema)
@@ -38,6 +41,10 @@ services:
       RELOAD: "1"                      # uvicorn --reload 활성 → 소스 저장 시 자동 재기동(재빌드 불필요)
       SCHEDULER_ENABLED: "1"           # 마감 크론 활성(단일 워커라 중복 없음). 운영 다중 워커면 1개 프로세스에서만 1
       PYTHONUNBUFFERED: "1"            # 컨테이너 로그 실시간 출력(stdout 버퍼링 끔)
+      # ── LPS(인터넷 최저가) 연동 — 미설정이면 연동 비활성으로 조용히 동작 ──
+      LPS_DB_HOST: host.docker.internal          # lps_db 읽기전용(수집 배치·조회 API)
+      LPS_BASE_URL: http://host.docker.internal:9600   # 검색요청 enqueue. lps-api 컨테이너 사용 시 http://lps-api:9600
+      # LPS API guard 키는 negodata 의 config.local.toml [WebServerConfig].lps_api_key 로 관리(개발은 빈값=개방)
     volumes:
       - ./negodata/backend:/app       # 호스트 소스 = 컨테이너 코드. 이게 있어야 수정이 즉시 반영됨
     ports:
@@ -57,6 +64,17 @@ services:
       - /app/node_modules
     restart: unless-stopped
 
+  # 솔루션 랜딩페이지 (react-router dev 서버. 배포는 `npm run build` 산출물 build/client 정적 서빙).
+  landing:
+    build: ./landing
+    container_name: negosium-landing
+    ports:
+      - "3100:3100"
+    volumes:
+      - ./landing:/app
+      - /app/node_modules
+    restart: unless-stopped
+
   # 협상 에이전트 (negosium_db 공유, learning 스키마 사용).
   agent:
     build: ./agent
@@ -113,3 +131,86 @@ services:
       options:
         max-size: "10m"
         max-file: "5"
+
+  # LPS API (인터넷 최저가 검색 — 요청 접수/조회, lean). 설정·시크릿은 config.local.toml 하나(미커밋, 마운트).
+  lps-api:
+    build:
+      context: ./lps
+      dockerfile: Dockerfile
+    container_name: lps-api
+    environment:
+      APP_ENV: local
+      DB_HOST: ${LPS_DB_HOST-host.docker.internal}   # 컨테이너→호스트 DB (config.local.toml 의 127.0.0.1 override)
+      PYTHONUNBUFFERED: "1"
+    volumes:
+      - ./lps/config/config.local.toml:/app/config/config.local.toml:ro
+    ports:
+      - "${LPS_API_BIND:-0.0.0.0}:9600:9600"   # prod 는 LPS_API_BIND=127.0.0.1 로 내부만 개방(리버스프록시 뒤)
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    labels:
+      autoheal: "true"                 # HEALTHCHECK 실패 시 autoheal 이 재시작
+    restart: unless-stopped
+    logging:
+      driver: json-file
+      options: { max-size: "10m", max-file: "5" }
+
+  # LPS 워커 (크롤 — 헤드풀 Chromium+Xvfb, headless 는 안티봇에 탐지됨). config.local.toml 공유.
+  lps-worker:
+    build:
+      context: ./lps
+      dockerfile: Dockerfile.worker
+    # google-chrome-stable(Linux)은 amd64 전용 → 이미지 자체가 amd64. arm64 맥에선 명시 없으면
+    # arm64 로 빌드를 시도하다 Chrome 의존성에서 실패한다(Rosetta 로 에뮬 실행). prod(amd64)에선 무영향.
+    platform: linux/amd64
+    container_name: lps-worker
+    environment:
+      APP_ENV: local
+      DB_HOST: ${LPS_DB_HOST-host.docker.internal}   # 컨테이너→호스트 DB (config.local.toml 의 127.0.0.1 override)
+      PYTHONUNBUFFERED: "1"
+    volumes:
+      - ./lps/config/config.local.toml:/app/config/config.local.toml:ro
+      - lps-profiles:/profiles         # Chrome 프로필(쿠키) 영속
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    shm_size: "1gb"                    # Chrome 는 /dev/shm 을 많이 씀 — 부족하면 탭 크래시
+    stop_grace_period: 75s             # graceful 종료 유예(worker shutdown_grace_sec=60 + 여유)
+    labels:
+      autoheal: "true"                 # 하트비트 실패(행/좀비) 시 autoheal 재시작
+    restart: unless-stopped
+    logging:
+      driver: json-file
+      options: { max-size: "10m", max-file: "5" }
+
+  # LPS 관리자 UI (정적 React → nginx). /v1·/healthz·/readyz 는 nginx 가 lps-api:9600 으로 프록시(앱은 상대경로 호출).
+  lps-admin:
+    build:
+      context: ./lps-admin
+      dockerfile: Dockerfile
+    container_name: lps-admin
+    ports:
+      - "3400:80"
+    depends_on:
+      - lps-api
+    restart: unless-stopped
+    logging:
+      driver: json-file
+      options: { max-size: "10m", max-file: "5" }
+
+  # HEALTHCHECK 실패 컨테이너 자동 재시작 — compose 의 restart 는 '프로세스 종료'만 다루고
+  # unhealthy 는 표시만 하므로, autoheal 라벨 붙은 컨테이너(lps-api/lps-worker)를 감시해 재시작한다.
+  # docker.sock 마운트 = 도커 제어 권한이므로 신뢰 환경에서만 사용.
+  autoheal:
+    image: willfarrell/autoheal:latest
+    container_name: autoheal
+    environment:
+      AUTOHEAL_CONTAINER_LABEL: autoheal
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+    restart: unless-stopped
+    logging:
+      driver: json-file
+      options: { max-size: "10m", max-file: "5" }
+
+volumes:
+  lps-profiles:

docs/aio2o-request-implementation-report.swift

@@ -0,0 +1,157 @@
+import AppKit
+import CoreGraphics
+import Foundation
+
+let output = CommandLine.arguments.count > 1 ? CommandLine.arguments[1] : "docs/AIO2O-요청사항-반영보고서.pdf"
+let W: CGFloat = 595, H: CGFloat = 842, M: CGFloat = 42
+let navy = NSColor(calibratedRed: 0.06, green: 0.08, blue: 0.16, alpha: 1)
+let ink = NSColor(calibratedRed: 0.11, green: 0.13, blue: 0.18, alpha: 1)
+let muted = NSColor(calibratedRed: 0.39, green: 0.43, blue: 0.50, alpha: 1)
+let paper = NSColor(calibratedRed: 0.98, green: 0.985, blue: 0.995, alpha: 1)
+let line = NSColor(calibratedRed: 0.86, green: 0.88, blue: 0.92, alpha: 1)
+let purple = NSColor(calibratedRed: 0.48, green: 0.25, blue: 0.92, alpha: 1)
+let green = NSColor(calibratedRed: 0.08, green: 0.60, blue: 0.37, alpha: 1)
+let orange = NSColor(calibratedRed: 0.94, green: 0.48, blue: 0.10, alpha: 1)
+let red = NSColor(calibratedRed: 0.85, green: 0.24, blue: 0.28, alpha: 1)
+let blue = NSColor(calibratedRed: 0.13, green: 0.39, blue: 0.92, alpha: 1)
+
+func pr(_ r: CGRect) -> CGRect { CGRect(x: r.minX, y: H-r.maxY, width: r.width, height: r.height) }
+func font(_ s: CGFloat, _ w: NSFont.Weight = .regular) -> NSFont {
+    NSFont(name: "Apple SD Gothic Neo", size: s) ?? .systemFont(ofSize: s, weight: w)
+}
+func style(_ s: CGFloat, _ c: NSColor = ink, _ w: NSFont.Weight = .regular,
+           _ a: NSTextAlignment = .left, _ spacing: CGFloat = 2.5) -> [NSAttributedString.Key:Any] {
+    let p = NSMutableParagraphStyle(); p.alignment = a; p.lineSpacing = spacing; p.lineBreakMode = .byWordWrapping
+    return [.font:font(s,w), .foregroundColor:c, .paragraphStyle:p]
+}
+func text(_ t:String,_ r:CGRect,_ s:CGFloat=10,_ c:NSColor=ink,_ w:NSFont.Weight = .regular,
+          _ a:NSTextAlignment = .left,_ spacing:CGFloat=2.5) {
+    NSAttributedString(string:t,attributes:style(s,c,w,a,spacing)).draw(with:pr(r),options:[.usesLineFragmentOrigin,.usesFontLeading])
+}
+func box(_ r:CGRect,_ fill:NSColor = .white,_ stroke:NSColor? = line,_ radius:CGFloat=10) {
+    let p=NSBezierPath(roundedRect:pr(r),xRadius:radius,yRadius:radius); fill.setFill(); p.fill()
+    if let stroke { stroke.setStroke(); p.lineWidth=0.8; p.stroke() }
+}
+func pill(_ t:String,_ r:CGRect,_ c:NSColor) {
+    box(r,c.withAlphaComponent(0.12),nil,r.height/2)
+    text(t,CGRect(x:r.minX,y:r.minY+4,width:r.width,height:r.height-7),8.2,c,.semibold,.center,1)
+}
+func begin(_ ctx:CGContext,_ page:Int,_ title:String) {
+    ctx.beginPDFPage(nil); ctx.saveGState(); NSGraphicsContext.saveGraphicsState()
+    NSGraphicsContext.current=NSGraphicsContext(cgContext:ctx,flipped:false)
+    paper.setFill(); NSBezierPath(rect:pr(CGRect(x:0,y:0,width:W,height:H))).fill()
+    text(title,CGRect(x:M,y:30,width:420,height:16),7.5,muted,.medium)
+    text(String(format:"%02d",page),CGRect(x:W-M-30,y:30,width:30,height:16),8,muted,.medium,.right)
+    let p=NSBezierPath(); p.move(to:CGPoint(x:M,y:31)); p.line(to:CGPoint(x:W-M,y:31))
+    line.setStroke(); p.lineWidth=0.7; p.stroke()
+}
+func end(_ ctx:CGContext) {
+    NSGraphicsContext.restoreGraphicsState(); ctx.restoreGState(); ctx.endPDFPage()
+}
+func heading(_ n:String,_ t:String,_ sub:String) {
+    pill(n,CGRect(x:M,y:54,width:34,height:24),purple)
+    text(t,CGRect(x:86,y:49,width:465,height:30),21,navy,.bold)
+    text(sub,CGRect(x:M,y:87,width:W-2*M,height:31),9.5,muted,.regular,.left,3)
+}
+func statusRow(_ no:String,_ title:String,_ body:String,_ status:String,_ c:NSColor,_ y:CGFloat,_ h:CGFloat=82) {
+    box(CGRect(x:M,y:y,width:W-2*M,height:h),.white,line,9)
+    pill(no,CGRect(x:M+12,y:y+13,width:28,height:20),c)
+    text(title,CGRect(x:M+50,y:y+12,width:338,height:19),10.5,navy,.bold)
+    pill(status,CGRect(x:W-M-102,y:y+12,width:90,height:21),c)
+    text(body,CGRect(x:M+50,y:y+37,width:W-2*M-64,height:h-44),8.8,ink,.regular,.left,2.4)
+}
+func metric(_ value:String,_ label:String,_ x:CGFloat,_ c:NSColor) {
+    box(CGRect(x:x,y:435,width:117,height:96),c.withAlphaComponent(0.08),c.withAlphaComponent(0.3),12)
+    text(value,CGRect(x:x+8,y:454,width:101,height:32),25,c,.bold,.center)
+    text(label,CGRect(x:x+8,y:493,width:101,height:20),9,muted,.medium,.center)
+}
+
+var media=CGRect(x:0,y:0,width:W,height:H)
+guard let consumer=CGDataConsumer(url:URL(fileURLWithPath:output) as CFURL),
+      let ctx=CGContext(consumer:consumer,mediaBox:&media,nil) else { fatalError("PDF 생성 실패") }
+
+// 1. cover
+begin(ctx,1,"AIO2O · 요청사항 반영 보고서")
+box(CGRect(x:0,y:0,width:W,height:H),navy,nil,0)
+pill("IMPLEMENTATION REVIEW",CGRect(x:M,y:112,width:148,height:25),NSColor(calibratedRed:0.42,green:0.78,blue:1,alpha:1))
+text("AIO2O 테스트 및 요청사항\n반영 결과 보고서",CGRect(x:M,y:166,width:510,height:112),34,.white,.bold,.left,7)
+text("260727_AIO2O 테스트 및 요청사항.xlsx 기준\n현재 저장소 구현·커밋·검증 캡처 대조",CGRect(x:M,y:310,width:510,height:60),14,NSColor(calibratedWhite:0.78,alpha:1),.regular,.left,7)
+box(CGRect(x:M,y:435,width:W-2*M,height:176),NSColor.white.withAlphaComponent(0.07),NSColor.white.withAlphaComponent(0.12),16)
+text("결론",CGRect(x:M+22,y:458,width:460,height:25),13,.white,.bold)
+text("핵심 업무 흐름은 대부분 구현되었습니다. 견적 목록·상세, 재협상 접수, 목표가 자동계산, 인터넷 최저가, 종료 의견, 결렬폼 통일, VAT 별도 표기, 10원 반올림은 코드 근거가 확인됩니다.\n\n다만 절충안/자동 제안가의 업무 적정성, SG명·유통레벨의 최종 UX, 최저가 VAT 산식은 추가 확인이 필요합니다.",CGRect(x:M+22,y:495,width:W-2*M-44,height:96),11,NSColor(calibratedWhite:0.88,alpha:1),.regular,.left,5)
+text("작성일 2026.07.31  |  기준 브랜치 feature/negodata  |  HEAD 775984fe",CGRect(x:M,y:758,width:W-2*M,height:18),8.5,NSColor(calibratedWhite:0.60,alpha:1))
+end(ctx)
+
+// 2. summary
+begin(ctx,2,"AIO2O · 요청사항 반영 보고서")
+heading("01","종합 요약","엑셀 RAW 시트의 24개 요청을 현재 저장소 상태로 재판정했습니다. 중복 요청은 원 요청 번호를 유지했습니다.")
+metric("18","완료·반영",M,green); metric("3","부분 반영",M+130,orange); metric("3","확인 필요",M+260,red); metric("24","전체 항목",M+390,blue)
+text("판정 기준",CGRect(x:M,y:566,width:507,height:24),13,navy,.bold)
+statusRow("A","완료·반영","사용자 화면과 처리 로직이 모두 확인되거나, 동일 기능을 제공하는 구현 및 검증 캡처가 존재합니다.","18건",green,603,60)
+statusRow("B","부분 반영","핵심 기능은 있으나 요청한 명칭·선택값·산식 중 일부가 다르거나 배포/운영 확인이 남았습니다.","3건",orange,675,60)
+statusRow("C","확인 필요","코드는 존재하지만 계산 결과의 업무 적정성을 확정할 수 없거나 요청 산식이 명시적으로 확인되지 않습니다.","3건",red,747,60)
+end(ctx)
+
+// 3. system 1
+begin(ctx,3,"AIO2O · 요청사항 반영 보고서")
+heading("02","기본 시스템 반영 내역","견적 생성부터 협력사·최저가·협상 화면까지의 공통 요청입니다.")
+statusRow("01","견적관리 목록·상세/히스토리","견적 목록과 상세 드로어가 있으며, 상세의 채팅 탭·협상카드 탭이 세션 데이터를 연결합니다. 견적번호별 진행/완료 상태와 상세 확인 경로가 마련됐습니다.","완료",green,132)
+statusRow("02","재협상 접수 및 관리","공급사 포털에서 결렬 건 재협상 요청·철회가 가능하고, 구매자 화면에 재협상 요청 목록·검토 시트·승인/반려 및 알림이 구현됐습니다.","완료",green,226)
+statusRow("03","MD 제시가 용어·위치·판매가","‘MD’는 ‘구매담당자’로 통일했고 제시가/산정후보를 ‘3. 낙찰기준’으로 이동했습니다. 판매가 설정은 숨김 처리되어 요청 흐름과 일치합니다.","완료",green,320)
+statusRow("04","목표가 자동 산출","매입가 × (1 − 목표 네고율)로 구매담당자 제시가를 자동 입력합니다. 예: 10,000원, 2% → 9,800원. 프론트 자동계산과 백엔드 가격 처리 근거가 있습니다.","완료",green,414)
+statusRow("05","공급사/매입가 라벨 일원화","상품 및 견적 화면의 회사별 필드 라벨 설정을 연동해 ‘공급사=매입가’ 표기 정책을 적용할 수 있게 했습니다. 실제 운영 회사 설정값 확인은 필요합니다.","부분",orange,508)
+statusRow("06","인터넷 최저가 수집","15%에서 멈추던 Worker/큐 처리 문제를 수정하고, 몰별 결과·진행 상태·이력 화면을 재설계했습니다. 다만 요청 산식 ‘(상품가+배송비)/1.1’의 최종 대표값 적용은 코드에서 확정되지 않습니다.","부분",orange,602)
+statusRow("07","신규 상품 공급사 입력","신규 상품 등록 폼에 공급사 선택기를 추가하고 상품–공급사 매핑을 저장하도록 구현했습니다.","완료",green,696)
+end(ctx)
+
+// 4. system 2
+begin(ctx,4,"AIO2O · 요청사항 반영 보고서")
+heading("03","협력사·협상 화면 반영","용어 통일, 종료 단계, 가격 표기와 협상 지표를 중심으로 확인했습니다.")
+statusRow("08","협력사 SG명·유통레벨","취급상품 기반 분류와 공급유형 선택/저장은 구현되어 있습니다. 다만 요청한 SG명 콤보와 유통레벨 4종(제조·총판·대리점·일반유통), 취급상품 삭제가 그대로 완성됐는지는 추가 UX 확인이 필요합니다.","부분",orange,132)
+statusRow("09","리드타임 → 표준납기","협상 완료 부가정보와 API 설명에 ‘표준납기’가 반영되고 회사 정의 session_fields와 연결됩니다.","완료",green,226)
+statusRow("10","협상 단가 VAT 별도","협상 상품정보·요약·목록/상세의 단가 표기를 VAT 별도로 통일했습니다. 검증 캡처도 존재합니다.","완료",green,320)
+statusRow("11","협상 성공률 기준 안내","성공률은 공급사 제시가를 앵커가·목표가와 비교한 1~99 지표입니다. 100% 미달이 결렬 조건은 아니며, 실제 종료는 별도 낙찰/개찰 규칙이 결정합니다.","완료(안내)",blue,414)
+statusRow("12","협상 종료 추가 의견","타결 부가정보와 결렬 통합폼 모두 ‘기타 의견’을 받으며 sessions.custom.opinion에 저장합니다. 구매자 상세·요약에서 조회되고 완료 후 잠깁니다.","완료",green,508)
+statusRow("13","결렬 사유·희망가격 통일","기존 RejectRSP/RejectCM을 단일 RejectForm으로 교체했습니다. 결렬사유·희망가·의견을 한 흐름에서 받고 reject_reason/reject_price에 저장합니다.","완료",green,602)
+statusRow("14","카드 사용 횟수 제한","견적 설정의 card_count(기본 3)를 컨텍스트에서 읽어 실제 사용 가능한 카드 수와 종료 조건을 제한하도록 반영했습니다. 운영 시 기존 세션 회귀검증을 권장합니다.","완료",green,696)
+end(ctx)
+
+// 5. case-specific
+begin(ctx,5,"AIO2O · 요청사항 반영 보고서")
+heading("04","견적번호별 이슈 반영","EST-202607-05DE·8945·C9D2 사례에서 제기된 가격/종료 흐름을 대조했습니다.")
+statusRow("15","앵커·자동 제안가 10원 반올림","앵커 생성가, 목표가 후보, 협상카드 카운터를 공통으로 10원 단위 반올림합니다. 예: 15,213원 → 15,210원. 관련 커밋과 단위 테스트가 있습니다.","완료",green,132)
+statusRow("16","절충안 계산식","협상카드 전술에는 앵커·목표가·직전 제시가를 이용한 중간값 및 목표가 상한 로직이 존재합니다. 다만 ‘절충안’의 기대 공식이 엑셀에 없어 업무적으로 맞는지 확정할 수 없습니다.","확인 필요",red,226)
+statusRow("17","05DE/C9D2 결렬 희망가격","견적 유형별로 갈리던 결렬 화면을 단일 폼으로 통합해 희망가격 입력 절차를 동일하게 만들었습니다.","완료",green,320)
+statusRow("18","8945 협상 마무리 개편","종료 후 표준납기·MOQ·발주배수·배송유형 등 회사 정의 부가정보를 선택/입력하고, 기타 의견과 함께 최종 요약에 반영합니다. 배송 선택값은 회사 설정에 따라 구성됩니다.","완료",green,414)
+statusRow("19","C9D2 자동 제안가 갭","제안가는 카드 전술과 앵커·목표가·직전 제시가의 조합으로 계산되고 10원 반올림됩니다. 17,500원→15,210원의 10.5% 갭이 정책상 적정한지는 목표/앵커 설정을 포함한 별도 검증이 필요합니다.","확인 필요",red,508)
+statusRow("20","성공/실패 후 의견 조회","협력사가 입력한 종료 의견은 공급사 요약과 구매자 견적 상세 양쪽에서 확인할 수 있고, 종료 후 읽기 전용으로 잠깁니다.","완료",green,602)
+statusRow("21","중복 요청 통합 반영","엑셀 18/22(성공률), 19/25(종료 의견), 5/23(목표가), 14/17/20(결렬폼)은 각각 하나의 공통 구현으로 해소했습니다.","완료",green,696)
+end(ctx)
+
+// 6. evidence
+begin(ctx,6,"AIO2O · 요청사항 반영 보고서")
+heading("05","구현 근거","최근 커밋과 현재 코드에서 확인한 핵심 근거입니다. 커밋 단위로 기능 범위를 추적할 수 있습니다.")
+statusRow("A","b33ae05c · 견적 가격/상품/라벨","목표가 자동입력, 산정후보 위치 이동, 앵커·후보 10원 반올림, 신규 상품 공급사 입력, 회사 설정 라벨 연동.","커밋",purple,132,72)
+statusRow("B","a56589c6 · 종료폼/의견/VAT","결렬폼 통합, 희망가·사유 저장, 타결/결렬 의견 수취, 상품정보 라벨 연동, 협상 단가 VAT 별도 표기.","커밋",purple,216,72)
+statusRow("C","30f13483 · 인터넷 최저가","무한 로딩 버그 수정, Worker 설정 보강, 몰별 최저가·진행/상세 UI 및 이력 저장 개선.","커밋",purple,300,72)
+statusRow("D","9dca78dc · 완료 부가정보","완료 부가정보 수취·요약 표시·잠금, 구매자 상세 노출, VAT 표기 통일.","커밋",purple,384,72)
+statusRow("E","2a004734 · 견적 상세 연결","견적 상세의 채팅·협상카드 탭 연동과 드로어 탐색 개선.","커밋",purple,468,72)
+statusRow("F","775984fe / f554202c · 반올림","협상카드 카운터와 자동 앵커를 10원 단위 반올림으로 통일.","커밋",purple,552,72)
+statusRow("G","화면 검증 캡처","목록/상세, 종료 의견, VAT, 완료 요약, 읽기 전용 잠금 등 12개 캡처가 저장소 루트에 남아 있습니다.","캡처",blue,636,72)
+text("주의: 본 보고서는 2026-07-31 현재 로컬 저장소의 코드·커밋·캡처를 기준으로 합니다. 운영 배포 여부와 기존 데이터 마이그레이션 상태는 별도 확인 대상입니다.",CGRect(x:M,y:742,width:W-2*M,height:42),8.8,muted,.regular,.left,3)
+end(ctx)
+
+// 7. actions
+begin(ctx,7,"AIO2O · 요청사항 반영 보고서")
+heading("06","남은 확인 및 권고","기능 누락이라기보다 업무 규칙·운영 설정을 확정해야 하는 항목입니다.")
+statusRow("1","최저가 VAT 대표값 확정","현재 LPS는 상품가와 배송비를 별도 수집·표시합니다. 대표 최저가를 반드시 (상품가+배송비)/1.1로 저장할지, 화면 표시만 할지 정책을 확정한 뒤 테스트를 추가해야 합니다.","우선순위 높음",red,142,98)
+statusRow("2","절충안/자동 제안가 기준 검증","05DE·C9D2의 실제 앵커가·목표가·직전 제시가를 넣어 계산 결과를 재현하고, 허용 최대 인하폭 또는 목표가 클램프 기준을 업무 담당자와 합의하는 것이 좋습니다.","우선순위 높음",red,254,98)
+statusRow("3","SG명·유통레벨 UX 확정","현행 취급상품 기반 분류/공급유형을 요청한 SG 콤보와 유통레벨 4종으로 대체할지, 데이터 모델을 유지한 채 라벨만 조정할지 결정이 필요합니다.","우선순위 중간",orange,366,98)
+statusRow("4","운영 배포·기존 세션 회귀검증","종료폼, 의견, 카드 횟수 제한은 신규 코드에 반영됐습니다. 운영 컨테이너 재빌드 후 기존 세션과 신규 세션에서 각각 1회 이상 확인해야 합니다.","배포 확인",blue,478,98)
+box(CGRect(x:M,y:612,width:W-2*M,height:118),purple.withAlphaComponent(0.08),purple.withAlphaComponent(0.28),12)
+text("권장 최종 승인 기준",CGRect(x:M+18,y:630,width:470,height:22),12,purple,.bold)
+text("① 운영 배포 버전 확인  ② 대표 견적 3건 시나리오 재실행  ③ 계산식 2건 서면 확정\n④ SG/유통레벨 화면 승인  ⑤ 완료·결렬 의견이 구매자 상세에 저장되는지 확인",CGRect(x:M+18,y:662,width:470,height:50),10,ink,.medium,.left,5)
+text("— End of report —",CGRect(x:M,y:760,width:W-2*M,height:20),8,muted,.medium,.center)
+end(ctx)
+
+ctx.closePDF()

docs/backend_advanced_guide.swift

@@ -0,0 +1,790 @@
+import AppKit
+import CoreGraphics
+import Foundation
+
+let outPath = CommandLine.arguments.count > 1
+    ? CommandLine.arguments[1]
+    : "docs/backend-advanced-concepts-ko.pdf"
+
+let W: CGFloat = 595
+let H: CGFloat = 842
+let margin: CGFloat = 44
+
+let navy = NSColor(calibratedRed: 0.055, green: 0.086, blue: 0.16, alpha: 1)
+let ink = NSColor(calibratedRed: 0.10, green: 0.13, blue: 0.18, alpha: 1)
+let muted = NSColor(calibratedRed: 0.37, green: 0.42, blue: 0.50, alpha: 1)
+let paper = NSColor(calibratedRed: 0.975, green: 0.98, blue: 0.99, alpha: 1)
+let line = NSColor(calibratedRed: 0.86, green: 0.88, blue: 0.92, alpha: 1)
+let blue = NSColor(calibratedRed: 0.16, green: 0.39, blue: 0.93, alpha: 1)
+let cyan = NSColor(calibratedRed: 0.10, green: 0.69, blue: 0.74, alpha: 1)
+let green = NSColor(calibratedRed: 0.10, green: 0.63, blue: 0.39, alpha: 1)
+let orange = NSColor(calibratedRed: 0.94, green: 0.47, blue: 0.12, alpha: 1)
+let red = NSColor(calibratedRed: 0.88, green: 0.25, blue: 0.28, alpha: 1)
+let purple = NSColor(calibratedRed: 0.48, green: 0.32, blue: 0.89, alpha: 1)
+
+func pdfRect(_ r: CGRect) -> CGRect {
+    CGRect(x: r.minX, y: H - r.maxY, width: r.width, height: r.height)
+}
+
+func pdfPoint(_ p: CGPoint) -> CGPoint {
+    CGPoint(x: p.x, y: H - p.y)
+}
+
+func font(_ size: CGFloat, _ weight: NSFont.Weight = .regular) -> NSFont {
+    NSFont(name: "Apple SD Gothic Neo", size: size)
+        ?? NSFont.systemFont(ofSize: size, weight: weight)
+}
+
+func mono(_ size: CGFloat) -> NSFont {
+    NSFont.monospacedSystemFont(ofSize: size, weight: .regular)
+}
+
+func attrs(_ size: CGFloat, color: NSColor = ink, weight: NSFont.Weight = .regular,
+           align: NSTextAlignment = .left, lineSpacing: CGFloat = 3) -> [NSAttributedString.Key: Any] {
+    let p = NSMutableParagraphStyle()
+    p.alignment = align
+    p.lineSpacing = lineSpacing
+    p.lineBreakMode = .byWordWrapping
+    return [.font: font(size, weight), .foregroundColor: color, .paragraphStyle: p]
+}
+
+func drawText(_ text: String, _ rect: CGRect, size: CGFloat = 11, color: NSColor = ink,
+              weight: NSFont.Weight = .regular, align: NSTextAlignment = .left,
+              lineSpacing: CGFloat = 3) {
+    NSAttributedString(string: text, attributes: attrs(size, color: color, weight: weight,
+                                                       align: align, lineSpacing: lineSpacing))
+        .draw(with: pdfRect(rect), options: [.usesLineFragmentOrigin, .usesFontLeading])
+}
+
+func rounded(_ rect: CGRect, radius: CGFloat = 12, fill: NSColor = .white,
+             stroke: NSColor? = line, width: CGFloat = 1) {
+    let p = NSBezierPath(roundedRect: pdfRect(rect), xRadius: radius, yRadius: radius)
+    fill.setFill(); p.fill()
+    if let stroke { stroke.setStroke(); p.lineWidth = width; p.stroke() }
+}
+
+func pill(_ text: String, x: CGFloat, y: CGFloat, w: CGFloat, color: NSColor) {
+    rounded(CGRect(x: x, y: y, width: w, height: 25), radius: 12.5,
+            fill: color.withAlphaComponent(0.12), stroke: nil)
+    drawText(text, CGRect(x: x, y: y + 5, width: w, height: 16), size: 9.5,
+             color: color, weight: .semibold, align: .center)
+}
+
+func arrow(_ from: CGPoint, _ to: CGPoint, color: NSColor = muted) {
+    let from = pdfPoint(from), to = pdfPoint(to)
+    let p = NSBezierPath(); p.move(to: from); p.line(to: to)
+    color.setStroke(); p.lineWidth = 1.8; p.stroke()
+    let a = atan2(to.y - from.y, to.x - from.x)
+    let l: CGFloat = 7
+    let h = NSBezierPath()
+    h.move(to: to)
+    h.line(to: CGPoint(x: to.x - l * cos(a - .pi / 6), y: to.y - l * sin(a - .pi / 6)))
+    h.line(to: CGPoint(x: to.x - l * cos(a + .pi / 6), y: to.y - l * sin(a + .pi / 6)))
+    h.close(); color.setFill(); h.fill()
+}
+
+func node(_ title: String, _ sub: String, rect: CGRect, color: NSColor) {
+    rounded(rect, radius: 10, fill: color.withAlphaComponent(0.10),
+            stroke: color.withAlphaComponent(0.55), width: 1.2)
+    drawText(title, CGRect(x: rect.minX + 8, y: rect.minY + 10, width: rect.width - 16, height: 18),
+             size: 10.5, color: color, weight: .bold, align: .center)
+    drawText(sub, CGRect(x: rect.minX + 8, y: rect.minY + 31, width: rect.width - 16, height: rect.height - 36),
+             size: 8.5, color: muted, align: .center, lineSpacing: 1)
+}
+
+func sectionTitle(_ number: String, _ title: String, _ subtitle: String, color: NSColor) {
+    pill(number, x: margin, y: 48, w: 34, color: color)
+    drawText(title, CGRect(x: 86, y: 46, width: 450, height: 30), size: 22,
+             color: navy, weight: .bold)
+    drawText(subtitle, CGRect(x: margin, y: 82, width: W - 2 * margin, height: 26),
+             size: 10.5, color: muted)
+}
+
+func footer(_ page: Int, _ label: String = "O2O Negosium · Backend Concepts") {
+    let p = NSBezierPath()
+    p.move(to: CGPoint(x: margin, y: H - 34)); p.line(to: CGPoint(x: W - margin, y: H - 34))
+    line.setStroke(); p.lineWidth = 0.7; p.stroke()
+    drawText(label, CGRect(x: margin, y: H - 28, width: 350, height: 14), size: 7.5, color: muted)
+    drawText("\(page)", CGRect(x: W - margin - 35, y: H - 28, width: 35, height: 14),
+             size: 8, color: muted, align: .right)
+}
+
+func callout(_ title: String, _ body: String, rect: CGRect, color: NSColor) {
+    rounded(rect, radius: 12, fill: color.withAlphaComponent(0.08),
+            stroke: color.withAlphaComponent(0.35))
+    rounded(CGRect(x: rect.minX, y: rect.minY, width: 5, height: rect.height),
+            radius: 2.5, fill: color, stroke: nil)
+    drawText(title, CGRect(x: rect.minX + 16, y: rect.minY + 12,
+                           width: rect.width - 28, height: 20),
+             size: 11, color: color, weight: .bold)
+    drawText(body, CGRect(x: rect.minX + 16, y: rect.minY + 37,
+                          width: rect.width - 28, height: rect.height - 45),
+             size: 9.5, color: ink, lineSpacing: 3)
+}
+
+func comparison(_ leftTitle: String, _ left: String, _ rightTitle: String, _ right: String,
+                y: CGFloat, color: NSColor) {
+    let gap: CGFloat = 14
+    let cw = (W - 2 * margin - gap) / 2
+    callout(leftTitle, left, rect: CGRect(x: margin, y: y, width: cw, height: 126), color: red)
+    callout(rightTitle, right, rect: CGRect(x: margin + cw + gap, y: y, width: cw, height: 126), color: color)
+}
+
+func codeBox(_ title: String, _ path: String, _ code: String, rect: CGRect, accent: NSColor) {
+    rounded(rect, radius: 10, fill: navy, stroke: nil)
+    drawText(title, CGRect(x: rect.minX + 14, y: rect.minY + 11,
+                           width: rect.width - 28, height: 17),
+             size: 10, color: .white, weight: .bold)
+    drawText(path, CGRect(x: rect.minX + 14, y: rect.minY + 30,
+                          width: rect.width - 28, height: 14),
+             size: 7.5, color: accent)
+    let p = NSMutableParagraphStyle(); p.lineSpacing = 2; p.lineBreakMode = .byClipping
+    NSAttributedString(string: code, attributes: [.font: mono(7.8), .foregroundColor: NSColor(calibratedWhite: 0.88, alpha: 1), .paragraphStyle: p])
+        .draw(with: pdfRect(CGRect(x: rect.minX + 14, y: rect.minY + 51,
+                           width: rect.width - 28, height: rect.height - 60)),
+              options: [.usesLineFragmentOrigin])
+}
+
+func beginPage(_ ctx: CGContext, page: Int, label: String = "O2O Negosium · Backend Concepts") {
+    ctx.beginPDFPage(nil)
+    ctx.saveGState()
+    NSGraphicsContext.saveGraphicsState()
+    NSGraphicsContext.current = NSGraphicsContext(cgContext: ctx, flipped: false)
+    paper.setFill(); NSBezierPath(rect: pdfRect(CGRect(x: 0, y: 0, width: W, height: H))).fill()
+    footer(page, label)
+}
+
+func endPage(_ ctx: CGContext) {
+    NSGraphicsContext.restoreGraphicsState()
+    ctx.restoreGState()
+    ctx.endPDFPage()
+}
+
+var mediaBox = CGRect(x: 0, y: 0, width: W, height: H)
+guard let consumer = CGDataConsumer(url: URL(fileURLWithPath: outPath) as CFURL),
+      let ctx = CGContext(consumer: consumer, mediaBox: &mediaBox, nil) else {
+    fatalError("PDF context 생성 실패")
+}
+
+// 1 — Cover
+beginPage(ctx, page: 1, label: "O2O Negosium · Backend Field Guide")
+rounded(CGRect(x: 0, y: 0, width: W, height: H), radius: 0, fill: navy, stroke: nil)
+for i in 0..<7 {
+    let x = CGFloat(50 + i * 78)
+    let c = [blue, cyan, green, orange, purple][i % 5]
+    rounded(CGRect(x: x, y: 85 + CGFloat((i % 3) * 28), width: 48, height: 48),
+            radius: 24, fill: c.withAlphaComponent(0.35), stroke: nil)
+}
+drawText("BACKEND", CGRect(x: margin, y: 190, width: 507, height: 35), size: 15,
+         color: cyan, weight: .bold)
+drawText("어려운 개념 5가지,\n코드로 이해하기", CGRect(x: margin, y: 228, width: 507, height: 118),
+         size: 36, color: .white, weight: .bold, lineSpacing: 7)
+drawText("분산 시스템 · 트랜잭션/동시성 · 멀티테넌시\n캐시 정합성 · 스케줄러/배치",
+         CGRect(x: margin, y: 370, width: 507, height: 62), size: 15,
+         color: NSColor(calibratedWhite: 0.80, alpha: 1), lineSpacing: 8)
+rounded(CGRect(x: margin, y: 485, width: 507, height: 154), radius: 18,
+        fill: NSColor.white.withAlphaComponent(0.07),
+        stroke: NSColor.white.withAlphaComponent(0.15))
+drawText("이 문서는 이렇게 읽어요", CGRect(x: 66, y: 510, width: 455, height: 25),
+         size: 14, color: .white, weight: .bold)
+drawText("① 일상 비유로 개념 잡기\n② 실제 서비스 흐름을 그림으로 보기\n③ 프로젝트 코드에서 구현 확인하기\n④ 없을 때 생기는 문제와 비교하기",
+         CGRect(x: 66, y: 548, width: 455, height: 78), size: 11.5,
+         color: NSColor(calibratedWhite: 0.88, alpha: 1), lineSpacing: 6)
+drawText("Generated from the current repository · 2026-07-29",
+         CGRect(x: margin, y: 758, width: 507, height: 18), size: 8.5,
+         color: NSColor(calibratedWhite: 0.62, alpha: 1))
+endPage(ctx)
+
+// 2 — Architecture map
+beginPage(ctx, page: 2)
+drawText("먼저, 서비스 지도를 봅시다", CGRect(x: margin, y: 48, width: 507, height: 34),
+         size: 24, color: navy, weight: .bold)
+drawText("다섯 개념은 따로 노는 것이 아니라, 한 요청이 여러 서비스와 저장소를 지나면서 함께 작동합니다.",
+         CGRect(x: margin, y: 88, width: 507, height: 32), size: 10.5, color: muted)
+node("사용자", "브라우저", rect: CGRect(x: 44, y: 170, width: 90, height: 62), color: purple)
+node("Backend", "채팅·공급사", rect: CGRect(x: 184, y: 145, width: 102, height: 72), color: blue)
+node("Agent", "AI 협상", rect: CGRect(x: 348, y: 145, width: 102, height: 72), color: orange)
+node("Negodata", "견적·관리", rect: CGRect(x: 184, y: 270, width: 102, height: 72), color: cyan)
+node("LPS", "최저가 Worker", rect: CGRect(x: 348, y: 270, width: 102, height: 72), color: green)
+node("PostgreSQL", "업무 원본", rect: CGRect(x: 184, y: 405, width: 130, height: 72), color: purple)
+node("Redis", "앵커링 캐시", rect: CGRect(x: 368, y: 405, width: 100, height: 72), color: red)
+arrow(CGPoint(x: 134, y: 200), CGPoint(x: 184, y: 182), color: purple)
+arrow(CGPoint(x: 286, y: 180), CGPoint(x: 348, y: 180), color: blue)
+arrow(CGPoint(x: 235, y: 217), CGPoint(x: 235, y: 270), color: cyan)
+arrow(CGPoint(x: 286, y: 304), CGPoint(x: 348, y: 304), color: green)
+arrow(CGPoint(x: 235, y: 342), CGPoint(x: 235, y: 405), color: purple)
+arrow(CGPoint(x: 399, y: 342), CGPoint(x: 415, y: 405), color: red)
+callout("① 경계가 생기면 ‘분산 시스템’", "서비스 A가 서비스 B를 네트워크로 호출하는 순간, 지연·타임아웃·부분 실패를 다뤄야 합니다.",
+        rect: CGRect(x: margin, y: 525, width: 246, height: 105), color: blue)
+callout("② 여러 실행자가 만나면 ‘동시성’", "사용자 클릭과 스케줄러가 같은 견적을 동시에 마감할 수 있어, DB가 최종 심판 역할을 합니다.",
+        rect: CGRect(x: 305, y: 525, width: 246, height: 105), color: orange)
+callout("③ 빠르게 읽되 원본을 지키면 ‘캐시’", "Redis와 프로세스 메모리는 복사본입니다. PostgreSQL과 설정 파일이 원본입니다.",
+        rect: CGRect(x: margin, y: 650, width: 246, height: 105), color: red)
+callout("④ 회사별 경계를 지키면 ‘멀티테넌시’", "요청 헤더에서 회사 ID를 결정하고, 회사별 설정·엔진을 선택합니다.",
+        rect: CGRect(x: 305, y: 650, width: 246, height: 105), color: purple)
+endPage(ctx)
+
+// 3 — Distributed systems: concept first
+beginPage(ctx, page: 3)
+sectionTitle("3", "분산 시스템 — 개념부터", "여러 독립 실행 단위가 네트워크를 통해 하나의 업무를 완성하는 시스템", color: blue)
+callout("정확한 정의", "프로세스·컨테이너·서버가 각자 메모리와 실행 상태를 가지고, HTTP나 메시지로 통신하는 구조입니다. 한 서비스의 함수 호출과 달리 상대의 상태를 직접 볼 수 없고, 네트워크 응답만으로 결과를 추론해야 합니다.",
+        rect: CGRect(x: margin, y: 126, width: 507, height: 92), color: blue)
+drawText("왜 어려운가: 네트워크에는 네 가지 결과가 있습니다", CGRect(x: margin, y: 244, width: 507, height: 24),
+         size: 13.5, color: navy, weight: .bold)
+let distCases: [(String, String, NSColor)] = [
+    ("성공", "상대가 처리했고 응답도 받음", green),
+    ("명확한 실패", "상대가 오류 응답을 보냄", red),
+    ("연결 실패", "상대에게 요청이 도착하지 않음", orange),
+    ("애매한 타임아웃", "처리는 됐지만 응답만 늦었을 수도 있음", purple),
+]
+for (i, c) in distCases.enumerated() {
+    let col = i % 2, row = i / 2
+    let x = margin + CGFloat(col) * 260
+    let y = CGFloat(286 + row * 86)
+    callout(c.0, c.1, rect: CGRect(x: x, y: y, width: 247, height: 70), color: c.2)
+}
+drawText("대표적인 대응 수단", CGRect(x: margin, y: 475, width: 507, height: 24),
+         size: 13.5, color: navy, weight: .bold)
+callout("Timeout", "얼마나 기다릴지 상한을 둡니다. 짧으면 정상 요청도 실패하고, 길면 자원이 오래 묶입니다.",
+        rect: CGRect(x: margin, y: 515, width: 159, height: 92), color: blue)
+callout("Retry", "일시 실패를 다시 시도합니다. 단, 중복 처리에 안전한 작업에서만 제한적으로 사용합니다.",
+        rect: CGRect(x: 218, y: 515, width: 159, height: 92), color: orange)
+callout("Idempotency", "같은 요청을 여러 번 보내도 결과가 한 번 처리한 것과 같도록 만듭니다.",
+        rect: CGRect(x: 392, y: 515, width: 159, height: 92), color: purple)
+callout("Fallback", "주 서비스가 실패하면 대체 경로·기본값·이전 데이터를 사용합니다. 대체 결과가 업무적으로 허용될 때만 가능합니다.",
+        rect: CGRect(x: margin, y: 630, width: 247, height: 92), color: green)
+callout("Circuit breaker", "실패가 계속되는 서비스를 잠시 호출하지 않아 연쇄 장애를 막습니다. 현재 프로젝트에는 명시적 구현이 없습니다.",
+        rect: CGRect(x: 304, y: 630, width: 247, height: 92), color: red)
+endPage(ctx)
+
+// 4 distributed concept
+beginPage(ctx, page: 4)
+sectionTitle("3", "분산 시스템과 장애 대응", "한 프로그램이 아니라 여러 서비스가 네트워크로 협력하는 구조", color: blue)
+callout("쉬운 비유", "한 식당 안에서 주방과 홀 직원이 말로 협업하는 것이 단일 시스템이라면, 분산 시스템은 서로 다른 건물의 팀이 전화로 협업하는 것입니다. 전화는 늦거나 끊길 수 있고, 상대가 일을 끝냈는데 답만 못 받을 수도 있습니다.",
+        rect: CGRect(x: margin, y: 130, width: 507, height: 105), color: blue)
+drawText("프로젝트의 대표 흐름", CGRect(x: margin, y: 266, width: 507, height: 24),
+         size: 14, color: navy, weight: .bold)
+node("Backend", "사용자 채팅 요청", rect: CGRect(x: 52, y: 315, width: 110, height: 74), color: blue)
+node("HTTPX", "timeout 설정", rect: CGRect(x: 242, y: 315, width: 110, height: 74), color: cyan)
+node("Agent", "협상 턴 계산", rect: CGRect(x: 432, y: 315, width: 110, height: 74), color: orange)
+arrow(CGPoint(x: 162, y: 352), CGPoint(x: 242, y: 352), color: blue)
+arrow(CGPoint(x: 352, y: 352), CGPoint(x: 432, y: 352), color: cyan)
+drawText("성공", CGRect(x: 394, y: 414, width: 80, height: 18), size: 9, color: green, weight: .bold)
+arrow(CGPoint(x: 485, y: 389), CGPoint(x: 485, y: 458), color: green)
+node("응답 반영", "채팅 상태 저장", rect: CGRect(x: 430, y: 458, width: 112, height: 65), color: green)
+drawText("타임아웃/실패", CGRect(x: 185, y: 414, width: 105, height: 18), size: 9, color: red, weight: .bold)
+arrow(CGPoint(x: 297, y: 389), CGPoint(x: 297, y: 458), color: red)
+node("안전한 실패", "ok=false 반환", rect: CGRect(x: 241, y: 458, width: 112, height: 65), color: red)
+callout("중요한 함정: 타임아웃 ≠ 상대가 아무 일도 안 함", "Agent가 DB 상태를 이미 전진시킨 직후 응답만 늦었을 수 있습니다. 그래서 무조건 재시도하면 같은 턴을 두 번 처리할 위험이 있습니다. 코드가 timed_out을 따로 표시하는 이유입니다.",
+        rect: CGRect(x: margin, y: 566, width: 507, height: 105), color: orange)
+comparison("이 장치가 없으면", "Agent가 느린 순간 Backend 요청도 끝없이 대기합니다. 무작정 재시도하면 협상 step이 두 번 전진할 수 있습니다.",
+           "현재 방식", "HTTP timeout을 두고 성공/일반 실패/타임아웃을 구분합니다. 호출 경계에서 예외를 응답 객체로 변환합니다.",
+           y: 695, color: blue)
+endPage(ctx)
+
+// 5 distributed code
+beginPage(ctx, page: 5)
+sectionTitle("3", "분산 시스템 — 실제 코드", "서비스 경계마다 timeout, fallback, best-effort 정책이 다릅니다.", color: blue)
+codeBox("Agent 호출: 타임아웃을 별도 상태로 반환",
+        "backend/services/agent_client.py · lines 81–91",
+        """
+async with httpx.AsyncClient(
+    base_url=agent_config.base_url,
+    timeout=agent_config.timeout_sec,
+) as cli:
+    resp = await cli.post("/v1/chat", json=body, headers=headers)
+
+except httpx.TimeoutException as ex:
+    # Agent가 이미 처리했을 수 있어 단순 재시도는 위험
+    return AgentTurn(ok=False, timed_out=True)
+except Exception:
+    return AgentTurn(ok=False)
+""",
+        rect: CGRect(x: margin, y: 130, width: 507, height: 245), accent: cyan)
+codeBox("카탈로그 변경 알림: 핵심 업무를 막지 않는 best-effort",
+        "negodata/backend/services/agent_notify.py · lines 15–26",
+        """
+try:
+    async with httpx.AsyncClient(timeout=3.0) as cli:
+        await cli.post(f"{base}/v1/catalog-refresh-all")
+except Exception as ex:
+    # 알림 실패는 카드 작업을 막지 않는다
+    LOG.w(f"[agent_notify] 변경 알림 실패(무시): {ex}")
+""",
+        rect: CGRect(x: margin, y: 395, width: 507, height: 160), accent: green)
+callout("어떻게 정책을 고르나요?", "결제처럼 반드시 성공해야 하는 작업은 실패를 호출자에게 알려 재처리해야 합니다. 반면 ‘캐시 무효화 알림’처럼 보조적인 작업은 실패해도 핵심 카드 변경을 성공시킬 수 있습니다. 모든 외부 호출을 똑같이 재시도하면 안 됩니다.",
+        rect: CGRect(x: margin, y: 580, width: 507, height: 105), color: blue)
+drawText("기억할 단어", CGRect(x: margin, y: 712, width: 120, height: 20), size: 12,
+         color: navy, weight: .bold)
+pill("timeout", x: 150, y: 707, w: 82, color: blue)
+pill("partial failure", x: 242, y: 707, w: 102, color: orange)
+pill("best-effort", x: 354, y: 707, w: 92, color: green)
+pill("idempotency", x: 456, y: 707, w: 90, color: purple)
+endPage(ctx)
+
+// 6 — Transactions and concurrency: concept first
+beginPage(ctx, page: 6)
+sectionTitle("4", "트랜잭션·동시성 — 개념부터", "데이터의 일관성을 지키는 작업 단위와, 동시에 실행되는 요청을 제어하는 방법", color: orange)
+drawText("트랜잭션의 ACID", CGRect(x: margin, y: 126, width: 507, height: 24),
+         size: 14, color: navy, weight: .bold)
+let acid: [(String, String, NSColor)] = [
+    ("A · Atomicity", "전부 성공하거나 전부 취소", orange),
+    ("C · Consistency", "규칙을 만족하는 상태로 이동", green),
+    ("I · Isolation", "동시 작업의 중간 상태를 서로 숨김", purple),
+    ("D · Durability", "COMMIT된 결과는 장애 후에도 보존", blue),
+]
+for (i, a) in acid.enumerated() {
+    let x = margin + CGFloat(i % 2) * 260
+    let y = CGFloat(165 + (i / 2) * 84)
+    callout(a.0, a.1, rect: CGRect(x: x, y: y, width: 247, height: 68), color: a.2)
+}
+drawText("동시성 문제는 어떻게 생기나?", CGRect(x: margin, y: 352, width: 507, height: 24),
+         size: 14, color: navy, weight: .bold)
+node("요청 A", "status=OPEN 읽음", rect: CGRect(x: 48, y: 401, width: 116, height: 64), color: blue)
+node("요청 B", "status=OPEN 읽음", rect: CGRect(x: 48, y: 500, width: 116, height: 64), color: purple)
+node("둘 다 처리", "중복 마감·중복 메일", rect: CGRect(x: 250, y: 449, width: 130, height: 70), color: red)
+arrow(CGPoint(x: 164, y: 433), CGPoint(x: 250, y: 471), color: blue)
+arrow(CGPoint(x: 164, y: 532), CGPoint(x: 250, y: 497), color: purple)
+callout("해결 ① 비관적 잠금", "SELECT ... FOR UPDATE로 먼저 행을 잠급니다. 명확하지만 잠금 대기와 deadlock을 관리해야 합니다.",
+        rect: CGRect(x: 408, y: 391, width: 143, height: 92), color: orange)
+callout("해결 ② 조건부 갱신", "UPDATE ... WHERE status=OPEN 후 rowcount를 확인합니다. 상태 검사와 변경이 원자적으로 일어납니다.",
+        rect: CGRect(x: 408, y: 497, width: 143, height: 92), color: green)
+callout("격리 수준과 잠금은 만능이 아님", "격리를 높이면 안전성은 커지지만 동시 처리량이 줄고 대기·교착 가능성이 커집니다. 업무 규칙에 맞는 최소 범위의 트랜잭션과 조건부 상태 전이가 실용적입니다.",
+        rect: CGRect(x: margin, y: 624, width: 507, height: 92), color: orange)
+callout("COMMIT / ROLLBACK", "COMMIT은 변경 확정, ROLLBACK은 현재 트랜잭션의 미확정 변경 취소입니다. 외부 이메일 발송은 DB rollback으로 되돌릴 수 없다는 점도 중요합니다.",
+        rect: CGRect(x: margin, y: 720, width: 507, height: 72), color: red)
+endPage(ctx)
+
+// 7 transaction concept
+beginPage(ctx, page: 7)
+sectionTitle("4", "DB 트랜잭션과 동시성 제어", "여러 작업을 하나로 묶고, 동시에 온 요청 중 한 명만 통과시키는 기술", color: orange)
+callout("트랜잭션이란?", "은행 이체에서 ‘내 계좌 차감’과 ‘상대 계좌 증가’가 둘 다 성공하거나 둘 다 취소되어야 하듯, 관련 DB 변경을 하나의 작업 단위로 묶는 것입니다. 중간에 실패하면 rollback합니다.",
+        rect: CGRect(x: margin, y: 130, width: 507, height: 92), color: orange)
+drawText("동시 마감 문제", CGRect(x: margin, y: 252, width: 200, height: 24),
+         size: 14, color: navy, weight: .bold)
+node("사용자 클릭", "마감 요청 A", rect: CGRect(x: 50, y: 300, width: 110, height: 66), color: blue)
+node("스케줄러", "마감 요청 B", rect: CGRect(x: 50, y: 405, width: 110, height: 66), color: purple)
+node("조건부 UPDATE", "status != CLOSED", rect: CGRect(x: 243, y: 350, width: 120, height: 74), color: orange)
+node("PostgreSQL", "원자적으로 판정", rect: CGRect(x: 430, y: 350, width: 112, height: 74), color: green)
+arrow(CGPoint(x: 160, y: 333), CGPoint(x: 243, y: 376), color: blue)
+arrow(CGPoint(x: 160, y: 438), CGPoint(x: 243, y: 399), color: purple)
+arrow(CGPoint(x: 363, y: 387), CGPoint(x: 430, y: 387), color: orange)
+callout("승자", "영향받은 행 수(rowcount) = 1\n마감 판정 권한 획득",
+        rect: CGRect(x: 76, y: 518, width: 205, height: 88), color: green)
+callout("패자/재요청", "rowcount = 0\n이미 닫혔으므로 추가 처리 중단",
+        rect: CGRect(x: 314, y: 518, width: 205, height: 88), color: red)
+comparison("단순 SELECT 후 UPDATE", "두 요청이 동시에 OPEN을 읽으면 둘 다 마감·낙찰 로직을 실행할 수 있습니다. 이메일도 두 번 발송될 수 있습니다.",
+           "조건부 UPDATE", "DB가 상태 검사와 변경을 한 문장으로 처리합니다. 먼저 성공한 요청만 rowcount=1을 받습니다.",
+           y: 640, color: orange)
+endPage(ctx)
+
+// 8 transaction code
+beginPage(ctx, page: 8)
+sectionTitle("4", "트랜잭션·동시성 — 실제 코드", "애플리케이션의 if문보다 DB의 원자적 UPDATE가 강한 최종 방어선입니다.", color: orange)
+codeBox("조건부 상태 전이: 마감 권한 선점",
+        "negodata/backend/crud/quotation_crud.py · lines 482–500",
+        """
+query = (
+    update(quotations)
+    .where(
+        quotations.qt_id == qt_id,
+        quotations.status != QuotationStatus.CLOSED.value,
+        quotations.deleted == False,
+    )
+    .values(
+        status=QuotationStatus.CLOSED.value,
+        updated_at=GTime.UTC(),
+    )
+)
+return await DB_SESSION_MNG.add_with_rowcount(cdb, query)
+""",
+        rect: CGRect(x: margin, y: 130, width: 507, height: 235), accent: orange)
+codeBox("트랜잭션 실패 시 rollback",
+        "negodata/backend/common/database/db_session_manager.py · lines 116–127",
+        """
+try:
+    await db.commit()
+    return ErrorType.SUCCESS
+except IntegrityError:
+    await db.rollback()
+    return ErrorType.DB_ALREADY_SAME_KEY
+except Exception:
+    await db.rollback()
+    raise
+""",
+        rect: CGRect(x: margin, y: 390, width: 507, height: 175), accent: red)
+callout("왜 rowcount를 보나요?", "UPDATE가 에러 없이 실행됐다는 사실만으로는 내가 상태를 바꿨는지 알 수 없습니다. WHERE 조건에 맞는 행이 없으면 SQL은 정상 실행되지만 변경 행은 0개입니다. 그래서 1이면 승자, 0이면 이미 다른 요청이 처리한 것으로 판단합니다.",
+        rect: CGRect(x: margin, y: 592, width: 507, height: 108), color: orange)
+callout("실무 체크", "트랜잭션은 짧게 유지하고, 외부 HTTP·이메일처럼 오래 걸리는 작업을 DB 트랜잭션 안에 오래 붙잡아 두지 않습니다.",
+        rect: CGRect(x: margin, y: 720, width: 507, height: 65), color: purple)
+endPage(ctx)
+
+// 9 — Multitenancy: concept first
+beginPage(ctx, page: 9)
+sectionTitle("5", "멀티테넌시 — 개념부터", "하나의 애플리케이션을 여러 고객사가 공유하면서 논리적으로 격리하는 설계", color: purple)
+callout("Tenant란?", "서비스를 사용하는 독립 고객 단위입니다. 이 프로젝트에서는 주로 ‘회사’가 tenant입니다. 같은 API와 서버를 쓰더라도 회사별 데이터, 설정, 권한, 협상 정책이 섞이면 안 됩니다.",
+        rect: CGRect(x: margin, y: 126, width: 507, height: 88), color: purple)
+drawText("대표적인 데이터 격리 모델", CGRect(x: margin, y: 242, width: 507, height: 24),
+         size: 14, color: navy, weight: .bold)
+callout("DB 분리", "회사마다 별도 DB\n격리 강함 · 운영비 높음",
+        rect: CGRect(x: margin, y: 282, width: 159, height: 88), color: blue)
+callout("Schema 분리", "한 DB 안에서 schema 분리\n중간 수준의 격리와 비용",
+        rect: CGRect(x: 218, y: 282, width: 159, height: 88), color: cyan)
+callout("Row 공유", "같은 테이블 + tenant_id\n효율적 · 쿼리 누락 위험",
+        rect: CGRect(x: 392, y: 282, width: 159, height: 88), color: orange)
+drawText("격리는 DB만의 문제가 아닙니다", CGRect(x: margin, y: 404, width: 507, height: 24),
+         size: 14, color: navy, weight: .bold)
+let tenantAxes: [(String, String)] = [
+    ("식별", "이 요청이 어느 회사 것인지 신뢰할 수 있게 결정"),
+    ("인가", "그 사용자가 해당 회사 자원에 접근 가능한지 확인"),
+    ("데이터", "모든 조회·수정 쿼리에 회사 범위 적용"),
+    ("설정", "회사별 정책·브랜딩·카드 선택"),
+    ("캐시", "캐시 key에 tenant를 포함해 회사 간 충돌 방지"),
+    ("자원", "한 회사의 과부하가 다른 회사에 미치는 영향 제한"),
+]
+for (i, t) in tenantAxes.enumerated() {
+    let x = margin + CGFloat(i % 2) * 260
+    let y = CGFloat(444 + (i / 2) * 74)
+    rounded(CGRect(x: x, y: y, width: 247, height: 58), radius: 9,
+            fill: purple.withAlphaComponent(0.06), stroke: purple.withAlphaComponent(0.25))
+    drawText(t.0, CGRect(x: x + 12, y: y + 10, width: 52, height: 18), size: 10,
+             color: purple, weight: .bold)
+    drawText(t.1, CGRect(x: x + 66, y: y + 9, width: 168, height: 38), size: 8.5, color: ink)
+}
+callout("가장 흔한 사고", "쿼리의 WHERE tenant_id 조건 누락, 공유 캐시 key에 tenant_id 누락, 사용자가 body로 보낸 tenant_id를 그대로 신뢰하는 경우입니다. 그래서 tenant context를 요청 초기에 확정하고 자동 전달하는 구조가 중요합니다.",
+        rect: CGRect(x: margin, y: 680, width: 507, height: 105), color: red)
+endPage(ctx)
+
+// 10 multitenancy concept
+beginPage(ctx, page: 10)
+sectionTitle("5", "멀티테넌시", "하나의 시스템을 여러 회사가 쓰되, 설정과 데이터의 경계를 지키는 구조", color: purple)
+callout("쉬운 비유", "한 오피스 빌딩을 여러 회사가 함께 사용하지만 출입카드가 자기 회사 층만 열어주는 구조입니다. 서버는 공유하되, 요청마다 ‘어느 회사의 요청인지’를 먼저 확정해야 합니다.",
+        rect: CGRect(x: margin, y: 130, width: 507, height: 92), color: purple)
+drawText("요청이 회사별 엔진을 찾는 과정", CGRect(x: margin, y: 252, width: 507, height: 24),
+         size: 14, color: navy, weight: .bold)
+node("HTTP 요청", "X-Tenant-ID", rect: CGRect(x: 45, y: 310, width: 100, height: 68), color: blue)
+node("Middleware", "존재·등록 검증", rect: CGRect(x: 195, y: 310, width: 105, height: 68), color: purple)
+node("request.state", "tenant_id 보관", rect: CGRect(x: 350, y: 310, width: 105, height: 68), color: cyan)
+arrow(CGPoint(x: 145, y: 344), CGPoint(x: 195, y: 344), color: blue)
+arrow(CGPoint(x: 300, y: 344), CGPoint(x: 350, y: 344), color: purple)
+node("Registry", "회사별 엔진 선택", rect: CGRect(x: 195, y: 445, width: 105, height: 68), color: orange)
+node("TenantEngine", "회사별 정책·카드", rect: CGRect(x: 350, y: 445, width: 105, height: 68), color: green)
+arrow(CGPoint(x: 402, y: 378), CGPoint(x: 275, y: 445), color: cyan)
+arrow(CGPoint(x: 300, y: 479), CGPoint(x: 350, y: 479), color: orange)
+callout("보안 핵심", "tenant_id를 요청 body에서 받으면 사용자가 다른 회사 ID를 넣어 위조할 수 있습니다. 이 프로젝트는 헤더/경로에서 결정한 값을 middleware가 request.state에 넣고, 뒤의 코드가 그것만 사용합니다.",
+        rect: CGRect(x: margin, y: 558, width: 507, height: 105), color: red)
+comparison("멀티테넌시 경계가 약하면", "A회사 요청이 B회사 카드·설정·협상 엔진을 사용할 수 있습니다. 이는 단순 버그가 아니라 데이터 유출 사고입니다.",
+           "현재 방식", "요청 시작점에서 tenant를 검증하고, Registry가 해당 회사의 설정과 엔진을 해석합니다.",
+           y: 687, color: purple)
+endPage(ctx)
+
+// 11 multitenancy code
+beginPage(ctx, page: 11)
+sectionTitle("5", "멀티테넌시 — 실제 코드", "식별 → 검증 → request.state 전달 → 회사별 엔진 선택의 4단계", color: purple)
+codeBox("Middleware: tenant를 요청 경계에서 확정",
+        "agent/router/middleware/tenant_middleware.py · lines 35–69",
+        """
+tenant_id = request.headers.get("X-Tenant-ID")
+
+if not tenant_id:
+    return JSONResponse(status_code=400, ...)
+
+if not tenant_registry.is_registered(tenant_id):
+    return JSONResponse(status_code=404, ...)
+
+request.state.tenant_id = tenant_id
+return await call_next(request)
+""",
+        rect: CGRect(x: margin, y: 130, width: 507, height: 205), accent: purple)
+codeBox("Dependency: 검증된 tenant로 엔진 조회",
+        "agent/router/deps.py · lines 13–21",
+        """
+async def get_tenant_engine(request: Request) -> TenantEngine:
+    tenant_id = getattr(request.state, "tenant_id", None)
+    if not tenant_id:
+        raise EXCEPTION_TENANT_HEADER_MISSING
+    return await tenant_registry.get_engine(tenant_id)
+""",
+        rect: CGRect(x: margin, y: 360, width: 507, height: 165), accent: cyan)
+codeBox("Registry: 프로세스 메모리에서 회사별 엔진 재사용",
+        "agent/tenancy/registry.py · lines 85–98",
+        """
+cached = self._engines.get(tenant_id)
+if cached is not None:
+    return cached
+
+async with self._locks[tenant_id]:
+    cached = self._engines.get(tenant_id)
+    if cached is not None:
+        return cached
+    engine = await self._build(tenant_id)
+    self._engines[tenant_id] = engine
+    return engine
+""",
+        rect: CGRect(x: margin, y: 550, width: 507, height: 205), accent: orange)
+endPage(ctx)
+
+// 12 — Cache consistency: concept first
+beginPage(ctx, page: 12)
+sectionTitle("8", "캐시 정합성 — 개념부터", "비싼 계산·DB·외부 호출의 결과를 가까운 곳에 복사해 재사용하는 기술", color: red)
+drawText("기본 용어", CGRect(x: margin, y: 126, width: 507, height: 24),
+         size: 14, color: navy, weight: .bold)
+let cacheTerms: [(String, String, NSColor)] = [
+    ("Hit", "캐시에 값이 있어 원본을 읽지 않음", green),
+    ("Miss", "값이 없어 원본을 읽고 캐시를 채움", blue),
+    ("TTL", "값이 자동 만료될 때까지의 시간", orange),
+    ("Stale", "원본은 바뀌었지만 캐시는 옛 값인 상태", red),
+]
+for (i, t) in cacheTerms.enumerated() {
+    let x = margin + CGFloat(i % 2) * 260
+    let y = CGFloat(165 + (i / 2) * 75)
+    callout(t.0, t.1, rect: CGRect(x: x, y: y, width: 247, height: 60), color: t.2)
+}
+drawText("대표적인 읽기·쓰기 패턴", CGRect(x: margin, y: 338, width: 507, height: 24),
+         size: 14, color: navy, weight: .bold)
+callout("Cache-aside", "앱이 캐시를 먼저 조회하고 miss이면 DB를 읽어 캐시에 저장합니다. 단순하고 가장 흔하지만 무효화를 앱이 책임집니다.",
+        rect: CGRect(x: margin, y: 378, width: 247, height: 92), color: blue)
+callout("Write-through", "쓰기 때 캐시와 원본을 함께 갱신합니다. 읽기는 안정적이지만 쓰기 지연과 두 저장소의 부분 실패를 다뤄야 합니다.",
+        rect: CGRect(x: 304, y: 378, width: 247, height: 92), color: purple)
+callout("Write-behind", "캐시에 먼저 쓰고 DB는 나중에 반영합니다. 빠르지만 캐시 장애 시 데이터 유실 위험이 있어 업무 원본에는 신중해야 합니다.",
+        rect: CGRect(x: margin, y: 486, width: 247, height: 92), color: orange)
+callout("Negative cache", "‘결과 없음’도 잠깐 저장합니다. 반복 실패 비용을 줄이지만 너무 긴 TTL은 새로 생긴 데이터를 늦게 발견하게 합니다.",
+        rect: CGRect(x: 304, y: 486, width: 247, height: 92), color: green)
+drawText("캐시에서 자주 생기는 문제", CGRect(x: margin, y: 610, width: 507, height: 24),
+         size: 14, color: navy, weight: .bold)
+callout("Invalidation", "원본 변경 후 어떤 key를 언제 삭제·갱신할지 결정하기 어렵습니다.",
+        rect: CGRect(x: margin, y: 650, width: 159, height: 82), color: red)
+callout("Stampede", "인기 key가 만료되는 순간 많은 요청이 동시에 DB로 몰립니다.",
+        rect: CGRect(x: 218, y: 650, width: 159, height: 82), color: orange)
+callout("Key 설계", "tenant·버전 등이 빠지면 서로 다른 데이터가 같은 key를 공유합니다.",
+        rect: CGRect(x: 392, y: 650, width: 159, height: 82), color: purple)
+endPage(ctx)
+
+// 13 cache concept
+beginPage(ctx, page: 13)
+sectionTitle("8", "캐시 정합성과 무효화", "빠른 복사본이 원본과 다른 값을 갖지 않도록 관리하는 문제", color: red)
+callout("캐시는 복사본", "도서관 검색대의 메모가 캐시이고, 원본 장부가 DB라고 생각하면 쉽습니다. 메모는 빠르지만 오래된 정보일 수 있습니다. 정합성이란 메모와 장부가 의미상 같은 상태를 유지하는 것입니다.",
+        rect: CGRect(x: margin, y: 130, width: 507, height: 95), color: red)
+drawText("앵커링 값의 저장·조회 순서", CGRect(x: margin, y: 252, width: 507, height: 24),
+         size: 14, color: navy, weight: .bold)
+node("1. DB 저장", "조정 이력 COMMIT", rect: CGRect(x: 46, y: 310, width: 118, height: 70), color: purple)
+node("2. Redis SET", "최신값 + TTL 7일", rect: CGRect(x: 238, y: 310, width: 118, height: 70), color: red)
+node("3. 다음 조회", "Redis 우선", rect: CGRect(x: 430, y: 310, width: 118, height: 70), color: blue)
+arrow(CGPoint(x: 164, y: 345), CGPoint(x: 238, y: 345), color: purple)
+arrow(CGPoint(x: 356, y: 345), CGPoint(x: 430, y: 345), color: red)
+drawText("Redis 실패", CGRect(x: 240, y: 417, width: 110, height: 18), size: 9, color: red, weight: .bold)
+arrow(CGPoint(x: 297, y: 380), CGPoint(x: 297, y: 465), color: red)
+node("DB Fallback", "업무는 계속", rect: CGRect(x: 238, y: 465, width: 118, height: 70), color: green)
+callout("stale 데이터란?", "DB에는 새 값 60이 저장됐는데 Redis SET이 실패해 캐시에 옛 값 55가 남은 상태입니다. 캐시 miss와 달리 값이 존재하므로 더 위험합니다. TTL과 주간 re-SET으로 회복합니다.",
+        rect: CGRect(x: margin, y: 574, width: 507, height: 95), color: orange)
+comparison("캐시만 믿으면", "Redis 장애가 업무 장애가 되고, 오래된 값이 실제 제안가를 왜곡할 수 있습니다. Redis 유실 시 원본도 사라집니다.",
+           "원본 DB + 파생 캐시", "Redis 장애 시 DB를 읽고, TTL과 reconciliation으로 오래된 복사본을 교정합니다.",
+           y: 693, color: red)
+endPage(ctx)
+
+// 14 cache code
+beginPage(ctx, page: 14)
+sectionTitle("8", "캐시 정합성 — 실제 코드", "Cache-aside, TTL, DB fallback, reconciliation이 한 세트로 작동합니다.", color: red)
+codeBox("Cache-aside: Redis miss → DB → Redis backfill",
+        "schedules/anchoring/src/anchoring/reader.py · lines 33–42",
+        """
+cached = await get_value(company_id, supplier_type, price_range)
+if cached is not None:
+    return cached
+
+value = await get_latest_adjusted_value(
+    db, company_id, supplier_type, price_range
+)
+if value is None:
+    value = get_base_anchoring_value(price_range)
+
+await set_value(..., value, nx=True)
+return value
+""",
+        rect: CGRect(x: margin, y: 130, width: 507, height: 225), accent: red)
+codeBox("Redis 장애는 cache miss로 취급",
+        "schedules/anchoring/src/anchoring/redis_client.py · lines 69–84",
+        """
+try:
+    raw = await _client.get(anchor_key(...))
+    if raw is None:
+        return None
+    return int(raw)
+except Exception as ex:
+    _note_failure("get", anchor_key(...), ex)
+    return None  # 호출측이 DB fallback
+""",
+        rect: CGRect(x: margin, y: 380, width: 507, height: 180), accent: orange)
+callout("두 겹의 회복 장치", "TTL 7일은 오래된 키가 영원히 남는 것을 막습니다. 주간 reconciliation은 DB의 최신 조정값을 Redis에 다시 SET하여, DB commit 뒤 Redis 갱신에 실패했던 값도 교정합니다.",
+        rect: CGRect(x: margin, y: 585, width: 507, height: 100), color: red)
+callout("현재 견적 생성 경로의 예외", "Negodata의 실제 견적 생성은 Redis를 사용하지 않고 PostgreSQL의 anchoring.current_values View를 일괄 조회합니다. Redis는 현재 anchoring 배치 내부 캐시입니다.",
+        rect: CGRect(x: margin, y: 705, width: 507, height: 72), color: cyan)
+endPage(ctx)
+
+// 15 — Scheduler and batch: concept first
+beginPage(ctx, page: 15)
+sectionTitle("9", "스케줄러·배치 — 개념부터", "시간 규칙으로 작업을 시작하고, 많은 데이터를 사용자 요청 밖에서 처리하는 방식", color: green)
+callout("둘의 차이", "스케줄러는 ‘언제 실행할지’를 결정합니다. 배치 Job은 ‘무엇을 어떻게 처리할지’를 구현합니다. CronTrigger가 알람시계라면 close_expired_quotations는 알람이 울렸을 때 수행할 실제 업무입니다.",
+        rect: CGRect(x: margin, y: 126, width: 507, height: 92), color: green)
+drawText("Job의 생명주기", CGRect(x: margin, y: 248, width: 507, height: 24),
+         size: 14, color: navy, weight: .bold)
+node("Trigger", "실행 시각 도달", rect: CGRect(x: 45, y: 297, width: 94, height: 66), color: green)
+node("Select", "처리 대상 조회", rect: CGRect(x: 181, y: 297, width: 94, height: 66), color: blue)
+node("Process", "개별 업무 수행", rect: CGRect(x: 317, y: 297, width: 94, height: 66), color: orange)
+node("Checkpoint", "결과·진행점 기록", rect: CGRect(x: 453, y: 297, width: 94, height: 66), color: purple)
+arrow(CGPoint(x: 139, y: 330), CGPoint(x: 181, y: 330), color: green)
+arrow(CGPoint(x: 275, y: 330), CGPoint(x: 317, y: 330), color: blue)
+arrow(CGPoint(x: 411, y: 330), CGPoint(x: 453, y: 330), color: orange)
+drawText("운영에서 반드시 결정할 것", CGRect(x: margin, y: 405, width: 507, height: 24),
+         size: 14, color: navy, weight: .bold)
+let jobIssues: [(String, String, NSColor)] = [
+    ("중복 실행", "이전 Job이 안 끝났는데 다음 시각이 오면?", red),
+    ("Misfire", "서버가 꺼져 실행 시각을 놓쳤다면?", orange),
+    ("부분 실패", "100건 중 73번째가 실패하면 어디부터 재개?", purple),
+    ("재시도", "즉시 재시도, 다음 tick, 운영자 재처리 중 무엇?", blue),
+    ("멱등성", "같은 대상을 다시 처리해도 중복 효과가 없는가?", green),
+    ("관측성", "처리량·실패 대상·소요시간을 로그와 지표로 남기는가?", cyan),
+]
+for (i, j) in jobIssues.enumerated() {
+    let x = margin + CGFloat(i % 2) * 260
+    let y = CGFloat(445 + (i / 2) * 73)
+    callout(j.0, j.1, rect: CGRect(x: x, y: y, width: 247, height: 58), color: j.2)
+}
+callout("스케줄러만으로 정확성은 보장되지 않음", "max_instances=1은 한 프로세스 안의 중복을 막을 뿐입니다. 서버가 여러 대면 각 서버가 Job을 실행할 수 있으므로 DB 조건부 갱신, 분산 락, 전용 Worker 같은 추가 방어가 필요합니다.",
+        rect: CGRect(x: margin, y: 680, width: 507, height: 105), color: red)
+endPage(ctx)
+
+// 16 scheduler concept
+beginPage(ctx, page: 16)
+sectionTitle("9", "스케줄러와 배치 안정성", "사용자 요청 없이 정해진 시간마다 반복 업무를 수행하는 백그라운드 실행", color: green)
+callout("쉬운 비유", "API가 손님이 주문할 때 움직이는 직원이라면, 스케줄러는 매 5분마다 마감 시간이 지난 주문을 확인하는 당직자입니다. 사람이 요청하지 않아도 시간이 되면 일을 시작합니다.",
+        rect: CGRect(x: margin, y: 130, width: 507, height: 92), color: green)
+drawText("5분 tick의 세 가지 작업", CGRect(x: margin, y: 252, width: 507, height: 24),
+         size: 14, color: navy, weight: .bold)
+node("CronTrigger", "매 5분", rect: CGRect(x: 48, y: 315, width: 105, height: 68), color: green)
+node("잡 ①", "기한 지난 견적 마감", rect: CGRect(x: 225, y: 280, width: 135, height: 62), color: orange)
+node("잡 ②", "협상 완료 견적 마감", rect: CGRect(x: 225, y: 365, width: 135, height: 62), color: purple)
+node("잡 ③", "LPS 결과 증분 반영", rect: CGRect(x: 225, y: 450, width: 135, height: 62), color: cyan)
+arrow(CGPoint(x: 153, y: 349), CGPoint(x: 225, y: 311), color: green)
+arrow(CGPoint(x: 153, y: 349), CGPoint(x: 225, y: 396), color: green)
+arrow(CGPoint(x: 153, y: 349), CGPoint(x: 225, y: 481), color: green)
+node("PostgreSQL", "조건부 처리·기록", rect: CGRect(x: 430, y: 365, width: 115, height: 72), color: blue)
+arrow(CGPoint(x: 360, y: 311), CGPoint(x: 430, y: 385), color: orange)
+arrow(CGPoint(x: 360, y: 396), CGPoint(x: 430, y: 401), color: purple)
+arrow(CGPoint(x: 360, y: 481), CGPoint(x: 430, y: 420), color: cyan)
+callout("중복 실행 방지 장치", "SCHEDULER_ENABLED=1인 프로세스 하나만 잡을 등록합니다. 각 잡은 max_instances=1이고, 밀린 실행은 coalesce=True로 한 번만 실행합니다. 그래도 다중 서버 가능성을 고려해 DB의 조건부 UPDATE가 마지막 방어선입니다.",
+        rect: CGRect(x: margin, y: 565, width: 507, height: 115), color: green)
+comparison("안정 장치가 없으면", "서버 Worker 수만큼 같은 잡이 실행되고, 같은 견적을 여러 번 마감하거나 알림을 중복 발송할 수 있습니다.",
+           "현재 방식", "실행 프로세스 제한 + 잡 중복 제한 + DB 동시성 가드를 겹쳐 사용합니다.",
+           y: 704, color: green)
+endPage(ctx)
+
+// 17 scheduler code
+beginPage(ctx, page: 17)
+sectionTitle("9", "스케줄러·배치 — 실제 코드", "‘언제 실행할지’와 ‘무엇을 안전하게 처리할지’를 분리합니다.", color: green)
+codeBox("APScheduler 등록: 5분, 중복 방지, 지연 허용",
+        "negodata/backend/scheduler/__init__.py · lines 37–69",
+        """
+_scheduler = AsyncIOScheduler(timezone="Asia/Seoul")
+_scheduler.add_job(
+    jobs.close_expired_quotations,
+    CronTrigger(minute="*/5"),
+    id="close_expired_quotations",
+    coalesce=True,           # 밀린 실행은 1번만
+    misfire_grace_time=600,  # 10분 내 지연 실행 허용
+    max_instances=1,        # 같은 잡 동시 실행 금지
+)
+""",
+        rect: CGRect(x: margin, y: 130, width: 507, height: 215), accent: green)
+codeBox("Job: 대상 조회와 개별 마감 처리를 분리",
+        "negodata/backend/scheduler/jobs.py · lines 39–61",
+        """
+err_type, qt_ids = await DB_SESSION_MNG.execute_lambda(
+    quotations.DBType(),
+    DBWRType.DB_READ.value,
+    lambda s: crud.list_due_for_close(s, now),
+)
+if err_type != ErrorType.SUCCESS:
+    return 0
+
+results = await _close_each(service, qt_ids)
+return sum(results.values())
+""",
+        rect: CGRect(x: margin, y: 370, width: 507, height: 190), accent: cyan)
+callout("멱등성(idempotency)", "같은 잡을 두 번 실행해도 최종 결과가 한 번 실행한 것과 같도록 만드는 성질입니다. 대상 조회가 중복될 수 있어도 claim_for_close의 조건부 UPDATE가 두 번째 처리를 rowcount=0으로 막습니다.",
+        rect: CGRect(x: margin, y: 585, width: 507, height: 105), color: purple)
+callout("실패한 tick은 어떻게 되나요?", "LPS 동기화는 watermark 기반 증분 처리라 실패한 회차의 데이터가 다음 5분 tick에서 다시 대상이 됩니다. 스케줄러 자체 재시도보다 데이터 설계를 통해 회복합니다.",
+        rect: CGRect(x: margin, y: 710, width: 507, height: 72), color: green)
+endPage(ctx)
+
+// 18 combined scenario
+beginPage(ctx, page: 18)
+drawText("다섯 기술이 한 장면에서 만나는 순간", CGRect(x: margin, y: 48, width: 507, height: 34),
+         size: 23, color: navy, weight: .bold)
+drawText("예: 협상이 모두 끝난 견적을 스케줄러가 자동 마감하는 동안 담당자가 수동 마감을 클릭했다.",
+         CGRect(x: margin, y: 88, width: 507, height: 30), size: 10.5, color: muted)
+let rows: [(String, String, NSColor)] = [
+    ("1", "멀티테넌시: 요청의 X-Tenant-ID로 어느 회사의 협상 엔진과 데이터인지 결정", purple),
+    ("2", "분산 시스템: Backend가 Agent를 HTTP로 호출할 때 timeout과 부분 실패를 구분", blue),
+    ("3", "스케줄러: 5분 tick이 동일 견적을 마감 대상으로 발견", green),
+    ("4", "동시성 제어: 수동 요청과 스케줄러 중 조건부 UPDATE를 먼저 성공한 쪽만 처리", orange),
+    ("5", "트랜잭션: 관련 상태 변경을 commit하거나, 실패하면 rollback", cyan),
+    ("6", "캐시 정합성: 원본 DB commit 후 파생 캐시를 갱신하고 실패 시 다음 회차에 회복", red),
+]
+for (i, item) in rows.enumerated() {
+    let y = CGFloat(145 + i * 91)
+    rounded(CGRect(x: margin, y: y, width: 507, height: 70), radius: 12,
+            fill: item.2.withAlphaComponent(0.08), stroke: item.2.withAlphaComponent(0.30))
+    rounded(CGRect(x: 58, y: y + 15, width: 40, height: 40), radius: 20,
+            fill: item.2, stroke: nil)
+    drawText(item.0, CGRect(x: 58, y: y + 24, width: 40, height: 20), size: 13,
+             color: .white, weight: .bold, align: .center)
+    drawText(item.1, CGRect(x: 116, y: y + 15, width: 415, height: 42), size: 10.2,
+             color: ink, weight: .medium, lineSpacing: 3)
+    if i < rows.count - 1 {
+        arrow(CGPoint(x: 78, y: y + 70), CGPoint(x: 78, y: y + 90), color: item.2)
+    }
+}
+callout("핵심 관점", "어려운 백엔드 기술은 ‘라이브러리 이름’보다 경계와 실패를 다루는 방법입니다. 네트워크 경계, 회사 경계, 트랜잭션 경계, 캐시의 원본 경계를 명확하게 설계하는 것이 핵심입니다.",
+        rect: CGRect(x: margin, y: 708, width: 507, height: 78), color: navy)
+endPage(ctx)
+
+// 19 glossary
+beginPage(ctx, page: 19)
+drawText("초보자를 위한 한 줄 사전", CGRect(x: margin, y: 48, width: 507, height: 34),
+         size: 24, color: navy, weight: .bold)
+let glossary: [(String, String)] = [
+    ("분산 시스템", "여러 프로세스·서버가 네트워크로 협력하는 시스템"),
+    ("부분 실패", "전체 중 일부 서비스만 실패한 상태"),
+    ("Timeout", "응답을 무한히 기다리지 않고 정해진 시간에 포기하는 제한"),
+    ("Best-effort", "실패해도 핵심 업무는 성공시키는 보조 작업 정책"),
+    ("트랜잭션", "여러 DB 변경을 모두 성공 또는 모두 취소하는 작업 단위"),
+    ("Rollback", "실패했을 때 트랜잭션의 변경을 되돌리는 것"),
+    ("Race condition", "실행 순서에 따라 결과가 달라지는 동시성 문제"),
+    ("원자적 연산", "중간 상태가 보이지 않도록 한 번에 처리되는 연산"),
+    ("멀티테넌시", "한 시스템을 여러 고객사가 격리된 상태로 공유하는 구조"),
+    ("Cache-aside", "캐시를 먼저 보고, miss이면 원본 조회 후 캐시를 채우는 패턴"),
+    ("TTL", "캐시 값이 자동 만료되기까지의 시간"),
+    ("Stale", "원본보다 오래되어 현재와 맞지 않는 캐시 상태"),
+    ("Invalidation", "원본 변경 시 캐시를 삭제하거나 무효화하는 것"),
+    ("Reconciliation", "원본과 복사본을 비교·재적재해 다시 맞추는 작업"),
+    ("Scheduler", "정해진 시간 규칙에 따라 작업을 실행하는 도구"),
+    ("Batch", "사용자 요청과 별개로 데이터 묶음을 주기적으로 처리하는 작업"),
+    ("멱등성", "같은 작업을 반복해도 최종 결과가 달라지지 않는 성질"),
+]
+for (i, g) in glossary.enumerated() {
+    let col = i < 9 ? 0 : 1
+    let row = col == 0 ? i : i - 9
+    let x = margin + CGFloat(col) * 260
+    let y = CGFloat(128 + row * 69)
+    drawText(g.0, CGRect(x: x, y: y, width: 230, height: 19), size: 10.5,
+             color: [blue, orange, purple, red, green][i % 5], weight: .bold)
+    drawText(g.1, CGRect(x: x, y: y + 23, width: 230, height: 36), size: 8.8,
+             color: ink, lineSpacing: 2)
+}
+callout("추천 복습 순서", "트랜잭션·동시성 → 캐시 정합성 → 스케줄러 → 멀티테넌시 → 분산 시스템 순으로 다시 보면, 작은 DB 작업에서 전체 서비스 구조로 이해가 확장됩니다.",
+        rect: CGRect(x: margin, y: 718, width: 507, height: 74), color: blue)
+endPage(ctx)
+
+ctx.closePDF()
+print(outPath)

docs/negotiation-qa-checklist.md

@@ -0,0 +1,108 @@
+# 협상 QA 체크리스트 (260727 요청 검증)
+
+> 대상: **negodata 어드민**(:3000) + **negosium 공급사 포털**(:3300). 두 앱을 함께 돌려야 하는 플로우라 루트 `docs/`에 둔다.
+> 형식: 케이스별 `~하면 → ~나와야 한다`. 근거는 코드 검증(2026-07-30) 기준. ⚠=현재 알려진 이슈.
+> 런타임 주의: negosium front/backend는 이미지 빌드라 코드 수정은 **재빌드해야 반영**된다.
+
+---
+
+## 0. 요청사항 반영 현황 (코드 검증 결과, Excel 상태열 아님)
+
+| # | 요청 | 판정 | 비고 |
+|---|------|------|------|
+| 2 | 견적관리 리스트+히스토리·상세 | ✅ | /quotation + `?detail=` 시트(협상현황/대화/카드, 라운드 타임라인) |
+| 3 | 재협상 리스트·심사 | ✅ | /renegotiation 대기/승인/반려 |
+| 4 | MD→구매담당자·판매가 미노출·위치 | ✅ | |
+| 5/23 | 목표가=매입가×(1−네고율) 자동 | ✅ | 재/재견적 한정, 네고율=견적세팅 목표마진 |
+| 6 | 공급가=매입가 일원화 | ⚙ 설정 | 코드 지원됨(`hideCls`). IMK `hidden_fields`에 `"price"` 추가하면 매입가만 남음 |
+| 7 | 최저가 크롤 + VAT산식 | ⚠ 인프라 / 논이슈 | VAT는 설정·아이템별 처리(논이슈). 단 dev의 lps-worker 크래시+수집테이블 0행 → 수집 파이프라인 확인 필요 |
+| 8 | 신규 상품 공급사 입력칸 | ✅ | |
+| 9 | SG명/유통레벨 콤보·취급상품 삭제 | ❌ 미구현 | §9 참조 |
+| 10 | 리드타임→표준납기 | ✅ 수정 | Summary.tsx 하드코딩 라벨 회사설정 반영으로 수정(2026-07-30) |
+| 11 | 단가 VAT별도 | ✅ | 회사설정 `item_vat_yn` 동적(IMK는 vat_yn hidden) |
+| 12 | 앵커 10원 반올림 | ✅ | `calc_anchoring_price` + 카드 카운터(`compute_counter`) + 와일드카드 1%(2026-07-31 수정) 모두 10원 반올림 |
+| 13 | 절충안 계산식 | ✅ | `compute_counter` 점검, 버그 없음 |
+| 14/17 | 결렬 희망가 입력란 통일 | ✅ | 단일 RejectForm |
+| 15 | 마무리 배송 콤보/기타의견/투찰요약 | ✅ | ExtraInfoBar가 session_fields select 렌더 → 콤보 [직납/IMK배송/IMK집배송] |
+| 16 | 제안가 갭·반올림 | ✅ | 갭은 정상(목표가=후보 min×수수료). 봇 제안가(카운터·와일드카드 1%)도 10원 반올림 반영(2026-07-31) |
+| 18/22 | 성공률 기준·결렬 무관 | ✅ | 게이지는 참고용, 판정과 무관(§D). 타결=목표가 아래로/봇 카운터 수락, 결렬=카드3+최종제안 소진까지 목표가 위 |
+| 19/25 | 종료 의견 단계 | ✅ | 타결 ExtraInfoBar(custom.opinion)+결렬 RejectForm 의견 |
+| 20 | 결렬사유 상시노출·필수 | ✅ 검증 | 결렬 세션 9/9 사유 존재. §20 참조 |
+| 21 | 카드 3회 초과 | ✅ 정상 | 3회=협상카드 한도. 와일드카드·최종제안은 별도로 붙는 구조라 보이는 카드가 3장을 넘을 수 있음(§21) |
+| 24 | 목표가 필드 1→3.낙찰기준 이동 | ✅ | |
+
+---
+
+## A. 견적 생성 (어드민)
+- **A1** 재/재견적에서 매입가 10,000·네고율(견적세팅 목표마진) 2% 입력 → 목표가(구매담당자 제시가) 필드에 **9,800 자동 채움**(10원 반올림)
+- **A2** 목표가 직접 안 건드리고 생성 → `md_price=null`로 전송, 서버가 후보 최솟값으로 재산정
+- **A3** **신규**협상/신규견적 → 매입가 후보 빠지고 인터넷최저가만 사용 → 자동 목표가가 매입가 기반이 아님(A1과 다른 게 정상)
+- **A4** 1.기본정보엔 목표가 없어야 / **3.낙찰기준** 스텝에 목표가+산정후보 나와야
+- **A5** 판매가 입력칸 없어야 / 라벨 "구매담당자 제시가"
+
+## B. 앵커·제안가
+- **B1** 협상 시작 → 세션 앵커가 = 목표가×(1−1%), **끝자리 0** (예 목표 7,650 → 앵커 7,570)
+- **B2** 봇 재제안가 전부 **끝자리 0** — 카드 카운터(절충가·목표가 제시)와 **와일드카드 1% 인하가** 포함 (예 제시 15,555 → 1% 인하가 15,400). 1원 단위가 보이면 불량
+
+## C. 협상 진행 (실시간 챗, 공급사 포털)
+- **C1** 제시가 **≤ 앵커가** → **즉시 협상완료(투찰 확정)**, 성공률 99
+- **C2** 앵커가 < 제시가 ≤ 앵커×1.02 → **와일드카드 1% 인하 요청**(세션 1회), 성공률 99~80
+- **C3** 앵커×1.02 초과 → **일반 협상카드로 재제안(최대 3번)**, 성공률 표시(제시가 낮을수록↑)
+- **C4** 카드 소진 또는 재제안 3번 후에도 앵커 밑 못 내림 → **협상 실패(결렬, 투찰 없음)**
+- **C5** 카드 사용한도 3은 **협상카드에만** 적용. **와일드카드·최종제안은 별도로 붙어** 공급사가 보는 카드가 3장을 넘을 수 있음(정상, §21)
+- **C6** 단가는 **VAT별도** 표기(IMK는 VAT 라벨 자체 숨김)
+
+## D. 타결/결렬 판정 & 성공률 게이지
+- **판정 규칙**: 유저가 **목표가 아래로 내리거나** 봇이 되받은 제시가(카운터)를 **수락하면 타결**. **카드(3장)+최종제안**까지 다 소진될 때까지 **목표가 위에서 버티면 결렬**.
+- **D1** 성공률 게이지는 **참고용일 뿐 판정과 무관** — 제시가 낮을수록 게이지↑(상한 99, **100% 도달 안 함**).
+- **D2** 성공률 낮아도 무조건 결렬 아님. 최종 마감(낙찰/개찰)은 별도 기준(§G).
+
+## E. 협상 타결(완료) 마무리
+- **E1** 협상완료 → **부가정보 입력 단계 등장** (표준납기·최소주문수량·발주배수·배송유형·의견)
+- **E2** 배송유형 → **콤보 [직납/IMK배송/IMK집배송]**로 떠야 (자유입력·다른 라벨이면 불량)
+- **E3** 의견(선택) 작성 → `custom.opinion` 저장돼야
+- **E4** 입력 완료 → **투찰결과 요약 갱신 후 최종 안내**, 요약에 부가정보·의견 반영
+- **E5** 어드민 상세(협상현황/요약)에서 부가정보 **표시+잠금(읽기전용)**
+
+## F. 협상 결렬(실패)
+- **F1** 결렬 → **결렬 사유 입력 단계 항상 노출 + 필수**(견적/유형 무관 동일 폼)
+- **F2** 사유 프리셋(단가인상/수량/단종/품절)+기타, **기타 선택 시 사유 텍스트 필수**
+- **F3** 희망가격 입력 = **단일 폼**(RSP/CM 동일)
+- **F4** 의견(선택) 작성 가능
+- **F5** 검증: 결렬(협상거부) 세션은 **100% 사유가 기록**돼야 (사유 없는 결렬 세션 = 불량). §20
+
+## G. 마감 · 낙찰/개찰
+- **G1** 투찰가 ≤ 앵커가 → **낙찰**
+- **G2** 앵커~목표가 → 1:1은 **사용자 지정**(mid_action), 1:N은 낙찰
+- **G3** 목표가 초과 → 1:1 **사용자 지정**(over_action, 관례 개찰), 1:N 낙찰
+- **G4** 동가(최저 2곳+)·전원 미응찰·협상거부 → **개찰**(낙찰자 미정, 결렬 아님) / 마감사유 라벨 정확히
+
+## H. 재협상 요청·심사 (공급사→어드민)
+- **H1** 개찰 마감 + 본인 마지막 라운드 → **재협상 요청 가능**(사유+희망가), 담당자 알림 1건
+- **H2** 낙찰건/남의 세션 요청 → **거부**
+- **H3** 같은 세션 2회 요청 → 2번째 **거부**; 철회 후 재요청 가능
+- **H4** 어드민 /renegotiation 대기 탭 접수 → **승인 시 다음 차수 견적 생성**, 반려 시 사유 필수
+
+---
+
+## 알려진 이슈 상세
+
+### §9. 협력사 SG명/유통레벨 콤보·취급상품 삭제 — 미구현
+요청 4가지 모두 현재 구조와 다르다:
+1. **분류카테고리 → SG명**: 지금 '분류카테고리'는 **입력 필드가 아니라 취급상품에서 파생 집계**되는 읽기전용 값(`SupplierItemsManager.tsx`). 회사 라벨(labels.category)로 "SG명" 표기만 되지, 직접 고르는 필드가 아님.
+2. **선택콤보(취급 SG명)**: 등록된 SG명 중 선택하는 콤보 없음.
+3. **유통레벨 콤보(제조/총판/대리점/일반유통)**: 없음. 유사한 건 취급상품별 **공급유형** 콤보인데 값이 다름(유통/제조/총판/없음). '대리점'·'일반유통' 값 자체가 코드에 없음. IMK 설정의 `supplier_fields.distribution_level`은 콤보가 아니라 **텍스트** 커스텀 필드.
+4. **취급상품 칸 삭제**: 삭제 안 됨(등록/수정폼·엑셀업로드에 그대로).
+- 근본: IMK는 SG명·유통레벨을 **협력사 레벨 속성(콤보)**으로 두고 취급상품 목록은 없애길 원함. 현재는 반대로 **취급상품(supplier_items)에서 카테고리·공급유형을 파생**하는 모델. → 데이터 모델 전환이 필요한 작업.
+
+### §20. 결렬 사유 상시 노출·필수 — 검증 완료
+- agent의 모든 실패 경로가 단일 step `"협상실패"`(chat_end)로 수렴 → backend가 rejectRSP/CM로 무조건 매핑 → 프론트 통일 RejectForm(사유 필수). 세션 상태 분기 없음.
+- 실데이터: 협상거부(status=5) 9건 **전부 reject_reason 존재**, 사유 없는 결렬 0건.
+- 원 버그의 "견적마다 상이"는 *대화 중 결렬*(사유 있음) vs *미참여/마감 자동종료*(대화 자체 없음 → 사유 없음)의 구분이었을 뿐, 결렬 플로우는 일관됨.
+
+### §21. 카드 3회 초과 — 정상 동작(버그 아님)
+`card_count=3`은 **협상카드 사용 한도**다. 와일드카드와 최종제안(종결)은 이 한도와 **별개로 각각 붙는** 구조라, 공급사가 보는 카드가 3장을 넘을 수 있다.
+1. **와일드카드 1장**(1% 인하/동적 카운터) — 협상카드 카운트와 별개.
+2. **최종제안 1장**(중간값 절충/최후통첩) — 카드 소진 후 마지막 국면에 별도로 붙음.
+   → 협상카드 3 + 와일드 1 + 최종제안 1 = 최대 5장 노출(예: EST-202607-4DB5).
+- 참고(엣지): 세션에 견적세팅(card_count)이 연결 안 되면 한도가 안 걸릴 수 있으니, 설정이 항상 세션에 물리는지만 확인.

frontend/index.html

@@ -3,7 +3,7 @@
   <head>
     <meta charset="UTF-8" />
     <link rel="icon" type="image/png" href="/bot.png" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, viewport-fit=cover" />
     <title>AI 가격 협상 솔루션</title>
   </head>
   <body>

frontend/src/apis/auth/auth.api.ts

@@ -11,6 +11,7 @@ import type {
   LogoutResponse,
   MeResponse,
   PopupStatusResponse,
+  SessionBrandingResponse,
 } from './auth.type'
 
 export const authApi = {
@@ -26,6 +27,12 @@ export const authApi = {
     return res.data
   },
 
+  /** GET /v1/auth/session-branding/{sessionId} — 로그인 전 화면용 브랜딩(인증 불필요) */
+  sessionBranding: async (sessionId: string): Promise<SessionBrandingResponse> => {
+    const res = await http.get<SessionBrandingResponse>(`/v1/auth/session-branding/${sessionId}`)
+    return res.data
+  },
+
   /** GET /v1/auth/me — 현재 로그인 유저 정보 (access token 필요) */
   me: async (): Promise<MeResponse> => {
     const res = await http.get<MeResponse>('/v1/auth/me')

frontend/src/apis/auth/auth.type.ts

@@ -54,6 +54,28 @@ export interface RefreshTokenResponse {
 }
 
 // --- 내 정보 (GET /v1/auth/me) -------------------------------------------
+export interface Branding {
+  service_name?: string
+  logo_url?: string
+  helpdesk?: string[] // 헬프데스크 연락처 — 한 줄 = 담당자 한 명. 비면 연락처 영역을 렌더하지 않는다
+}
+
+// 로그인 전(초청 링크 진입) 브랜딩 조회 — GET /v1/auth/session-branding/{session_id}, 인증 불필요
+export interface SessionBrandingResponse {
+  result: ApiResult
+  service_name: string
+  logo_url: string
+  helpdesk?: string[]
+}
+
+// 협상완료 부가정보 필드 정의(companies.settings.session_fields)
+export interface SessionField {
+  key: string
+  label: string
+  type: 'text' | 'number' | 'boolean' | 'select'
+  options?: string[] // type='select' 일 때 고를 보기 목록
+}
+
 export interface MeResponse {
   result: ApiResult
   su_id: string
@@ -62,6 +84,9 @@ export interface MeResponse {
   supplier_id: string
   supplier_name: string
   role: number
+  branding?: Branding
+  session_fields?: SessionField[]
+  guide_notices?: string[]
 }
 
 // --- 로그아웃 -------------------------------------------------------------
@@ -94,6 +119,10 @@ export interface AuthUser {
   supplierId: string
   supplierName: string
   role: number
+  branding: Branding
+  sessionFields: SessionField[]
+  /** 협상 유의사항 항목(회사 설정). 비면 포털 기본 문구를 쓴다 */
+  guideNotices: string[]
 }
 
 export function toAuthUser(res: MeResponse): AuthUser {
@@ -104,5 +133,8 @@ export function toAuthUser(res: MeResponse): AuthUser {
     supplierId: res.supplier_id,
     supplierName: res.supplier_name,
     role: res.role,
+    branding: res.branding ?? {},
+    sessionFields: res.session_fields ?? [],
+    guideNotices: res.guide_notices ?? [],
   }
 }

frontend/src/apis/chat/chat.type.ts

@@ -32,6 +32,7 @@ export interface ChatInitResponse {
   session_id: string
   session_status: number
   quotation_id: string
+  qt_number?: string
   quotation_end_time: string
   quotation_memo?: string
   item_id: string
@@ -46,6 +47,10 @@ export interface ChatInitResponse {
   item_min_order_quantity?: string
   item_vat_yn?: boolean
   item_delivery_fee_yn?: boolean
+  custom?: Record<string, unknown>
+  labels?: Record<string, string>
+  reject_reason?: string
+  reject_price?: number | null
 }
 
 export interface ChatMessagesResponse {
@@ -88,6 +93,7 @@ export function mapInit(r: ChatInitResponse): ChatInitData {
     session_status: r.session_status,
     item_id: r.item_id,
     quotation_id: r.quotation_id,
+    qt_number: r.qt_number ?? '',
     item_name: r.item_name,
     item_code: r.item_code ?? '',
     item_image: r.item_image ?? '',
@@ -98,9 +104,13 @@ export function mapInit(r: ChatInitResponse): ChatInitData {
     item_delivery_fee_yn:
       r.item_delivery_fee_yn == null ? '' : r.item_delivery_fee_yn ? '배송비포함' : '배송비별도',
     item_min_order_quantity: r.item_min_order_quantity ?? '',
+    custom: r.custom ?? {},
     item_lead_time: r.item_lead_time ?? '',
     item_spec: r.item_spec ?? '',
     quotation_memo: r.quotation_memo ?? '',
     quotation_end_time: r.quotation_end_time ?? '',
+    labels: r.labels ?? {},
+    reject_reason: r.reject_reason ?? '',
+    reject_price: r.reject_price ?? null,
   }
 }

frontend/src/apis/negotiation/index.ts

@@ -2,5 +2,11 @@
 export { negotiationApi } from './negotiation.api'
 export { negotiationKeys } from './negotiation.keys'
 export { useSessionListQuery } from './negotiation.queries'
-export { useParticipateMutation, useRejectMutation } from './negotiation.mutations'
+export {
+  useCancelRenegotiationMutation,
+  useParticipateMutation,
+  useRejectMutation,
+  useRequestRenegotiationMutation,
+  useSaveExtraInfoMutation,
+} from './negotiation.mutations'
 export * from './negotiation.type'

frontend/src/apis/negotiation/negotiation.api.ts

@@ -1,9 +1,13 @@
 // 협상 엔드포인트 호출 함수 (순수 HTTP 레이어, React 의존 없음).
 import { http } from '@/apis/http'
 import type {
+  ExtraInfoRequest,
+  ExtraInfoResponse,
   ParticipateResponse,
   RejectRequest,
   RejectResponse,
+  RenegotiationRequest,
+  RenegotiationResponse,
   SessionListParams,
   SessionListResponse,
 } from './negotiation.type'
@@ -31,4 +35,30 @@ export const negotiationApi = {
     )
     return res.data
   },
+
+  /** POST /v1/negotiation/session/{id}/renegotiation — 결렬 건 재협상 요청 */
+  requestRenegotiation: async (sessionId: string, body: RenegotiationRequest): Promise<RenegotiationResponse> => {
+    const res = await http.post<RenegotiationResponse>(
+      `/v1/negotiation/session/${sessionId}/renegotiation`,
+      body,
+    )
+    return res.data
+  },
+
+  /** DELETE /v1/negotiation/session/{id}/renegotiation — 심사 대기 중인 요청 철회 */
+  cancelRenegotiation: async (sessionId: string): Promise<RenegotiationResponse> => {
+    const res = await http.delete<RenegotiationResponse>(
+      `/v1/negotiation/session/${sessionId}/renegotiation`,
+    )
+    return res.data
+  },
+
+  /** POST /v1/negotiation/sessions/{id}/extra-info — 협상완료 부가정보 저장 */
+  saveExtraInfo: async (sessionId: string, body: ExtraInfoRequest): Promise<ExtraInfoResponse> => {
+    const res = await http.post<ExtraInfoResponse>(
+      `/v1/negotiation/sessions/${sessionId}/extra-info`,
+      body,
+    )
+    return res.data
+  },
 }

frontend/src/apis/negotiation/negotiation.mutations.ts

@@ -2,7 +2,7 @@
 import { useMutation, useQueryClient } from '@tanstack/react-query'
 import { negotiationApi } from './negotiation.api'
 import { negotiationKeys } from './negotiation.keys'
-import type { RejectRequest } from './negotiation.type'
+import type { ExtraInfoRequest, RejectRequest, RenegotiationRequest } from './negotiation.type'
 
 /**
  * 협상 세션 참여: 성공 시 세션 목록 캐시를 무효화해 상태를 갱신한다.
@@ -30,3 +30,38 @@ export function useRejectMutation() {
     },
   })
 }
+
+/**
+ * 협상완료 부가정보 저장: 성공 시 세션 목록 캐시를 무효화한다.
+ */
+export function useSaveExtraInfoMutation() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: ({ sessionId, request }: { sessionId: string; request: ExtraInfoRequest }) =>
+      negotiationApi.saveExtraInfo(sessionId, request),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: negotiationKeys.sessions() })
+    },
+  })
+}
+
+export function useRequestRenegotiationMutation() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: ({ sessionId, request }: { sessionId: string; request: RenegotiationRequest }) =>
+      negotiationApi.requestRenegotiation(sessionId, request),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: negotiationKeys.sessions() })
+    },
+  })
+}
+
+export function useCancelRenegotiationMutation() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: ({ sessionId }: { sessionId: string }) => negotiationApi.cancelRenegotiation(sessionId),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: negotiationKeys.sessions() })
+    },
+  })
+}

frontend/src/apis/negotiation/negotiation.type.ts

@@ -43,6 +43,8 @@ export interface SessionListParams {
   order?: 'asc' | 'desc' // 생략 시 기본 그룹 정렬('할 일' 우선+임박순, 종료는 하단). 지정 시 그룹 무시하고 전체 마감순(asc=임박/desc=여유)
   page?: number
   page_size?: number
+  keyword?: string // 검색어 — 견적번호·상품명·상품코드 부분일치
+  result?: number // 결과 필터(SessionResult): 1=낙찰 2=미낙찰 3=결렬
 }
 
 export interface SessionListItem {
@@ -55,6 +57,44 @@ export interface SessionListItem {
   item_name: string
   model_name: string
   maker_name: string
+  custom: Record<string, unknown> // 협상완료 부가정보(sessions.custom). 미입력이면 {}
+  renegotiable: boolean // 재협상 요청 가능 여부(서버 판정 — 개찰 마감 + 마지막 차수 + 대기 요청 없음)
+  renegotiation_status: number // 1=심사대기 2=승인 3=반려 4=철회, 이력 없으면 0
+  renegotiation_memo: string // 담당자 심사 메모(반려 사유)
+  result: number // 협상 결과(SessionResult): 0=미정 1=낙찰 2=미낙찰 3=결렬(개찰)
+  has_chat: boolean // 대화 이력 존재 여부 — 종료된 협상의 '결과 보기' 노출 판단용
+  reject_reason: string // 협상 거부 시 제출한 사유. 거부 건이 아니면 ''
+  reject_price?: number | null // 거부와 함께 낸 공급 희망 가격(원). 미입력이면 null
+}
+
+/** 공급사 관점 협상 결과 (sessions 파생) */
+export const SessionResult = { NONE: 0, WON: 1, LOST: 2, OPEN: 3 } as const
+
+export const SESSION_RESULT_LABEL: Record<number, string> = {
+  1: '낙찰',
+  2: '미낙찰',
+  3: '결렬',
+}
+
+// 재협상 요청(IMK #15)
+export interface RenegotiationRequest {
+  reason: string
+  desired_price?: number | null
+}
+
+export interface RenegotiationResponse {
+  result: ApiResult
+  session_id: string
+  status: number
+}
+
+export const RenegoStatus = { NONE: 0, PENDING: 1, APPROVED: 2, REJECTED: 3, CANCELED: 4 } as const
+
+export const RENEGO_STATUS_LABEL: Record<number, string> = {
+  1: '재협상 심사 중',
+  2: '재협상 승인됨',
+  3: '재협상 반려됨',
+  4: '요청 철회됨',
 }
 
 export interface SessionListResponse {
@@ -65,6 +105,15 @@ export interface SessionListResponse {
   page_size: number
 }
 
+// --- 협상완료 부가정보 (POST /v1/negotiation/sessions/{id}/extra-info) -----
+export interface ExtraInfoRequest {
+  custom: Record<string, unknown>
+}
+export interface ExtraInfoResponse {
+  result: ApiResult
+  session_id: string
+}
+
 // --- 참여 (POST /v1/negotiation/sessions/{id}/participate) ----------------
 export interface ParticipateResponse {
   result: ApiResult
@@ -72,10 +121,13 @@ export interface ParticipateResponse {
 }
 
 // --- 거부 (POST /v1/negotiation/sessions/{id}/reject) ---------------------
-// reject_reason: 프리셋(단종/품절) 라벨 또는 '기타' 직접 입력 텍스트.
-// (백엔드 sessions.reject_reason 컬럼에 대응. 엔드포인트는 백엔드 추가 예정)
+// 목록의 협상 거부와 채팅 중 협상 거부가 같은 폼(components/RejectPopup)·같은 엔드포인트를 쓴다.
+// reject_reason: 프리셋(단종/품절) 라벨 또는 '기타' 직접 입력 텍스트. 필수.
+// reject_price/opinion: 선택 입력 — 빈 값이면 아예 보내지 않는다(opinion 은 sessions.custom 에 병합).
 export interface RejectRequest {
   reject_reason: string
+  reject_price?: number
+  opinion?: string
 }
 
 export interface RejectResponse {

frontend/src/components/Button.tsx

@@ -10,18 +10,18 @@ export type ButtonVariant =
 export type ButtonSize = 'sm' | 'md' | 'lg'
 
 const base =
-  'inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md font-medium select-none ' +
+  'inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-xl font-semibold select-none ' +
   interactive +
   ' focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 ' +
   'disabled:pointer-events-none disabled:opacity-50'
 
 const variantClass: Record<ButtonVariant, string> = {
-  primary: 'bg-primary text-primary-foreground',
+  primary: 'bg-primary text-primary-foreground shadow-sm',
   secondary: 'bg-secondary text-secondary-foreground',
-  outline: 'border border-input bg-background',
+  outline: 'border border-border bg-background text-foreground',
   // 투명 배경이라 brightness 무효 → bg 하이라이트
   ghost: 'hover:bg-accent hover:text-accent-foreground',
-  destructive: 'bg-destructive text-white',
+  destructive: 'bg-destructive text-white shadow-sm',
 }
 
 const sizeClass: Record<ButtonSize, string> = {

frontend/src/components/ErrorPage.tsx

@@ -18,13 +18,13 @@ export function ErrorPage({
 }: ErrorPageProps) {
   return (
     <div className="flex h-full w-full items-center justify-center">
-      <div className="flex flex-col items-center gap-6 p-12">
-        <div className="flex size-20 items-center justify-center rounded-full bg-destructive/10">
-          <AlertTriangle className="size-10 text-destructive" />
+      <div className="flex flex-col items-center gap-5 p-12">
+        <div className="flex size-16 items-center justify-center rounded-full bg-destructive/10">
+          <AlertTriangle className="size-8 text-destructive" />
         </div>
-        <div className="flex flex-col items-center gap-2 text-center">
-          <p className="title-2 text-destructive">{message}</p>
-          <p className="body-1 text-neutral-70">{description}</p>
+        <div className="flex flex-col items-center gap-1.5 text-center">
+          <p className="text-lg font-bold text-neutral-90">{message}</p>
+          <p className="text-sm text-neutral-60">{description}</p>
         </div>
         {onRetry && (
           <Button variant="primary" size="lg" onClick={onRetry}>

frontend/src/components/Input.tsx

@@ -6,9 +6,9 @@ export function Input({ type = 'text', className, ...props }: ComponentProps<'in
     <input
       type={type}
       className={cn(
-        'flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm',
+        'flex h-10 w-full rounded-xl border border-input bg-background px-3.5 py-2 text-sm transition-all',
         'placeholder:text-muted-foreground',
-        'focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2',
+        'focus-visible:outline-none focus-visible:border-brand-600 focus-visible:ring-1 focus-visible:ring-brand-600',
         'disabled:cursor-not-allowed disabled:opacity-50',
         className,
       )}

frontend/src/components/Logo.tsx

@@ -1,14 +1,14 @@
 import { type ComponentProps } from 'react'
 import { cn } from '@/lib'
-import logoColor from '@/assets/imarketkorea-logo.png'
-import logoWhite from '@/assets/imarketkorea-logo-white.png'
+import logoDefault from '@/assets/negotium-logo.png'
 
 export type LogoVariant = 'color' | 'white'
 export type LogoSize = 'sm' | 'md' | 'lg'
 
+// 기본 브랜드(회사 설정 미지정 시). 회사 로고가 오면 logoUrl 이 이 값을 덮는다.
 const sources: Record<LogoVariant, string> = {
-  color: logoColor,
-  white: logoWhite,
+  color: logoDefault,
+  white: logoDefault,
 }
 
 const sizes: Record<LogoSize, { img: string; text: string; gap: string }> = {
@@ -17,33 +17,46 @@ const sizes: Record<LogoSize, { img: string; text: string; gap: string }> = {
   lg: { img: 'h-10', text: 'text-2xl', gap: 'gap-2.5' },
 }
 
+// 기본 브랜드 로고는 가로로 긴 워드마크라 같은 높이로 두면 회사 심볼보다 훨씬 커 보인다(랜딩도 h-4 기준).
+const wordmarkSizes: Record<LogoSize, string> = {
+  sm: 'h-3.5',
+  md: 'h-4',
+  lg: 'h-5',
+}
+
 export interface LogoProps extends Omit<ComponentProps<'div'>, 'children'> {
   variant?: LogoVariant
   size?: LogoSize
   withText?: boolean
   alt?: string
+  /** 회사 브랜딩 오버라이드(companies.settings.branding). 없으면 기본 iMarket Korea. */
+  serviceName?: string
+  logoUrl?: string
 }
 
 export function Logo({
   variant = 'color',
   size = 'md',
   withText = true,
-  alt = 'iMarket Korea',
+  alt = 'NEGOTIUM',
+  serviceName,
+  logoUrl,
   className,
   ...props
 }: LogoProps) {
   const s = sizes[size]
+  const name = serviceName || 'negotium'
 
   return (
     <div className={cn('flex items-center', s.gap, className)} {...props}>
       <img
-        src={sources[variant]}
-        alt={withText ? '' : alt}
-        className={cn('w-auto select-none', s.img)}
+        src={logoUrl || sources[variant]}
+        alt={withText ? '' : (serviceName || alt)}
+        className={cn('w-auto select-none', logoUrl ? s.img : wordmarkSizes[size])}
       />
-      {withText && (
+      {withText && serviceName && (
         <span className={cn('font-bold tracking-[-0.4px] text-foreground', s.text)}>
-          iMarket Korea
+          {name}
         </span>
       )}
     </div>

frontend/src/components/Modal.tsx

@@ -21,7 +21,7 @@ export function Modal({ children, onClose }: ModalProps) {
 
   return (
     <div
-      className="fixed inset-0 z-50 flex items-center justify-center bg-[rgba(0,0,0,0.40)]"
+      className="fixed inset-0 z-50 flex items-center justify-center bg-[rgba(0,0,0,0.40)] p-4"
       onClick={handleBackdropClick}
     >
       {children}

frontend/src/components/RejectDetailPopup.tsx

@@ -0,0 +1,81 @@
+import { X } from 'lucide-react'
+import { Modal } from '@/components/Modal'
+import { numberToKorean } from '@/lib'
+
+export interface RejectDetailPopupProps {
+  onClose: () => void
+  /** 어느 건인지 식별용 부제 (견적번호 · 상품명) */
+  subtitle?: string
+  /** sessions.reject_reason — 프리셋 라벨 또는 '기타' 직접 입력 텍스트 */
+  reason: string
+  /** sessions.reject_price — 미입력이면 null */
+  price: number | null
+  /** sessions.custom.opinion */
+  opinion: string
+  /** 'VAT포함'/'VAT별도' — 품목 VAT 를 아는 화면에서만 넘긴다 */
+  vatLabel?: string
+}
+
+// 협상 거부 사유 열람 팝업 — 목록의 '협상완료 부가정보(보기)'와 같은 규격(읽기전용 필드 나열).
+// 거부는 제출 내역이 대화에 남지 않아 세션 컬럼이 유일한 기록이다.
+export function RejectDetailPopup({ onClose, subtitle, reason, price, opinion, vatLabel }: RejectDetailPopupProps) {
+  const priceText = price
+    ? `${price.toLocaleString()}원 (${numberToKorean(price)}원)${vatLabel ? ` ${vatLabel}` : ''}`
+    : '미입력'
+
+  return (
+    <Modal onClose={onClose}>
+      <div className="w-full max-w-md overflow-hidden rounded-2xl border border-border bg-white shadow-xl animate-scale-in">
+        <div className="flex items-center justify-between border-b border-border p-5">
+          <div>
+            <h3 className="text-base font-bold text-neutral-90">협상 거부 사유 (보기)</h3>
+            <p className="mt-0.5 text-xs text-neutral-60">
+              {subtitle}
+              {subtitle ? ' · ' : ''}제출 후에는 수정할 수 없습니다.
+            </p>
+          </div>
+          <button
+            type="button"
+            onClick={onClose}
+            aria-label="닫기"
+            className="flex size-8 items-center justify-center rounded-full text-neutral-60 hover:bg-neutral-10"
+          >
+            <X className="size-4" />
+          </button>
+        </div>
+
+        <div className="space-y-4 p-5">
+          <Field label="거부 사유" value={reason || '-'} />
+          <Field label="공급 희망 가격" value={priceText} />
+          <Field label="의견" value={opinion} rows={2} placeholder="남긴 의견 없음" />
+        </div>
+
+        <div className="flex gap-2 border-t border-border p-5">
+          <button
+            type="button"
+            onClick={onClose}
+            className="h-11 flex-1 rounded-xl border border-border text-sm font-bold text-neutral-70 hover:bg-neutral-10"
+          >
+            닫기
+          </button>
+        </div>
+      </div>
+    </Modal>
+  )
+}
+
+// 부가정보 팝업의 읽기전용 필드와 같은 모양(라벨 + disabled 입력).
+function Field({ label, value, rows, placeholder }: { label: string; value: string; rows?: number; placeholder?: string }) {
+  const style =
+    'w-full rounded-xl border border-border bg-neutral-10 px-3 text-sm text-neutral-60 cursor-not-allowed outline-none'
+  return (
+    <div className="space-y-1.5">
+      <label className="block text-sm font-semibold text-neutral-80">{label}</label>
+      {rows ? (
+        <textarea value={value} rows={rows} disabled placeholder={placeholder} className={`${style} resize-none py-2`} />
+      ) : (
+        <input type="text" value={value} disabled placeholder={placeholder} className={`${style} h-11`} />
+      )}
+    </div>
+  )
+}

frontend/src/components/RejectPopup.tsx

@@ -0,0 +1,200 @@
+import { useState } from 'react'
+import { X } from 'lucide-react'
+import { Modal } from '@/components/Modal'
+import { cn, numberToKorean } from '@/lib'
+
+const MAX_PRICE = 999999999999999
+
+// 거부 사유는 협상을 시작하지 않겠다는 사유(단종/품절/기타)다. 협상해보고 합의가 안 된
+// 결렬 폼(단가인상·수량 포함 5종)과는 성격이 달라 목록을 맞추지 않는다.
+const REASONS = ['단종', '품절', '기타'] as const
+
+export interface RejectSubmitPayload {
+  /** 프리셋 라벨 또는 '기타' 직접 입력 텍스트 */
+  reject_reason: string
+  reject_price?: number
+  opinion?: string
+}
+
+export interface RejectPopupProps {
+  onClose: () => void
+  onSubmit: (payload: RejectSubmitPayload) => void
+  isPending?: boolean
+  /** 가격 옆 'VAT 별도' 표기 — 품목 VAT 를 아는 화면(채팅)에서만 켠다 */
+  isVatExcluded?: boolean
+}
+
+// 협상 거부 팝업 — 목록과 채팅 양쪽이 같은 폼·같은 엔드포인트(/reject)를 쓴다.
+// 사유는 필수, 공급 희망 가격과 의견은 선택.
+export function RejectPopup({ onClose, onSubmit, isPending = false, isVatExcluded = false }: RejectPopupProps) {
+  const [selectedReason, setSelectedReason] = useState<string | null>(null)
+  const [customReason, setCustomReason] = useState('')
+  const [price, setPrice] = useState('')
+  const [opinion, setOpinion] = useState('')
+  const [showError, setShowError] = useState(false)
+
+  const isEtcOpen = selectedReason === '기타'
+  const isSubmitDisabled = !selectedReason || (isEtcOpen && !customReason.trim()) || isPending
+
+  const handleReasonClick = (reason: string) => {
+    setShowError(false)
+    if (selectedReason === reason) {
+      setSelectedReason(null)
+      setCustomReason('')
+    } else {
+      setSelectedReason(reason)
+      if (reason !== '기타') setCustomReason('')
+    }
+  }
+
+  const handlePriceChange = (value: string) => {
+    const numeric = value.replace(/\D/g, '')
+    if (numeric && parseInt(numeric) > MAX_PRICE) return
+    setPrice(numeric)
+  }
+
+  const handleSubmit = () => {
+    if (isEtcOpen && !customReason.trim()) {
+      setShowError(true)
+      return
+    }
+    if (isSubmitDisabled || !selectedReason) return
+    onSubmit({
+      reject_reason: isEtcOpen ? customReason.trim() : selectedReason,
+      // 빈 값이면 아예 보내지 않아 컬럼을 건드리지 않는다.
+      ...(price ? { reject_price: parseInt(price) } : {}),
+      ...(opinion.trim() ? { opinion: opinion.trim() } : {}),
+    })
+  }
+
+  const koreanPrice = price && parseInt(price) > 0 ? `[${numberToKorean(parseInt(price))} 원]` : ''
+
+  return (
+    <Modal onClose={onClose}>
+      <div className="flex max-h-[85vh] w-full max-w-md flex-col overflow-hidden rounded-2xl border border-border bg-white shadow-xl animate-scale-in">
+        {/* 헤더 */}
+        <div className="flex shrink-0 items-center justify-between border-b border-border p-5">
+          <h3 className="text-base font-bold text-neutral-90">거부 사유를 입력해주세요</h3>
+          <button
+            type="button"
+            onClick={onClose}
+            aria-label="닫기"
+            className="flex size-8 items-center justify-center rounded-full text-neutral-60 hover:bg-neutral-10"
+          >
+            <X className="size-4" />
+          </button>
+        </div>
+
+        {/* 본문 */}
+        <div className="min-h-0 flex-1 space-y-4 overflow-y-auto p-5">
+          <div className="grid grid-cols-3 gap-2">
+            {REASONS.map((reason) => (
+              <button
+                key={reason}
+                type="button"
+                onClick={() => handleReasonClick(reason)}
+                disabled={isPending}
+                className={cn(
+                  'h-11 rounded-xl border text-sm font-bold transition-all active:scale-[0.98] disabled:opacity-50',
+                  selectedReason === reason
+                    ? 'border-brand-600 bg-brand-light text-brand-600'
+                    : 'border-border bg-white text-neutral-70 hover:bg-neutral-10',
+                )}
+              >
+                {reason}
+              </button>
+            ))}
+          </div>
+
+          {isEtcOpen && (
+            <div className="animate-fade-in">
+              <textarea
+                placeholder="사유를 입력하여 주십시오"
+                value={customReason}
+                onChange={(e) => {
+                  setCustomReason(e.target.value)
+                  setShowError(false)
+                }}
+                rows={3}
+                disabled={isPending}
+                className={cn(
+                  'w-full resize-none rounded-xl border bg-white p-3 text-sm text-neutral-90 outline-none transition-all',
+                  'placeholder:text-neutral-50 focus:ring-1',
+                  showError
+                    ? 'border-destructive focus:border-destructive focus:ring-destructive'
+                    : 'border-border focus:border-brand-600 focus:ring-brand-600',
+                )}
+              />
+              {showError && <p className="mt-1.5 text-xs font-medium text-destructive">기타 사유를 입력해주세요</p>}
+            </div>
+          )}
+
+          {/* 공급 희망 가격 (선택) — 결렬 폼과 같은 라벨·표기 */}
+          <div className="flex flex-col gap-1.5">
+            <div className="text-sm font-bold text-neutral-90">
+              공급 희망 가격 <span className="font-medium text-neutral-60">(선택)</span>
+            </div>
+            <div className="flex flex-wrap items-center gap-2">
+              <input
+                type="text"
+                className={cn(
+                  'h-10 max-w-[200px] rounded-xl border px-3 text-right text-sm outline-none transition-all placeholder:text-neutral-50',
+                  isPending
+                    ? 'cursor-not-allowed border-border bg-neutral-10 text-neutral-50'
+                    : 'border-border bg-white text-neutral-90 focus:border-brand-600 focus:ring-1 focus:ring-brand-600',
+                )}
+                value={price ? parseInt(price).toLocaleString() : ''}
+                onChange={(e) => handlePriceChange(e.target.value)}
+                placeholder="0"
+                disabled={isPending}
+              />
+              <span className="whitespace-nowrap text-sm text-neutral-70">원{isVatExcluded && '(VAT 별도)'}</span>
+              {koreanPrice && <span className="whitespace-nowrap text-sm text-neutral-50">{koreanPrice}</span>}
+            </div>
+          </div>
+
+          {/* 의견 (선택) — 결렬 폼과 동일 */}
+          <div className="flex flex-col gap-1.5">
+            <div className="text-sm font-bold text-neutral-90">
+              의견 <span className="font-medium text-neutral-60">(선택)</span>
+            </div>
+            <textarea
+              value={opinion}
+              onChange={(e) => setOpinion(e.target.value)}
+              rows={2}
+              maxLength={255}
+              disabled={isPending}
+              placeholder="추가로 남길 의견이 있으면 작성해 주세요."
+              className={cn(
+                'w-full resize-none rounded-xl border px-3 py-2 text-sm outline-none transition-all placeholder:text-neutral-50',
+                isPending
+                  ? 'cursor-not-allowed border-border bg-neutral-10 text-neutral-50'
+                  : 'border-border bg-white text-neutral-90 focus:border-brand-600 focus:ring-1 focus:ring-brand-600',
+              )}
+            />
+          </div>
+        </div>
+
+        {/* 푸터 */}
+        <div className="flex shrink-0 gap-2 border-t border-border p-4">
+          <button
+            type="button"
+            onClick={onClose}
+            disabled={isPending}
+            className="h-11 flex-1 rounded-xl border border-border bg-white text-sm font-bold text-neutral-70 transition-all hover:bg-neutral-10 active:scale-[0.98] disabled:opacity-50"
+          >
+            취소
+          </button>
+          <button
+            type="button"
+            onClick={handleSubmit}
+            disabled={isSubmitDisabled}
+            className="h-11 flex-1 rounded-xl bg-brand-600 text-sm font-bold text-white shadow-sm transition-all hover:bg-brand-700 active:scale-[0.98] disabled:opacity-40"
+          >
+            거부 처리
+          </button>
+        </div>
+      </div>
+    </Modal>
+  )
+}

frontend/src/components/index.ts

@@ -7,3 +7,7 @@ export { Logo } from '@/components/Logo'
 export type { LogoProps, LogoVariant } from '@/components/Logo'
 export { ErrorPage } from '@/components/ErrorPage'
 export type { ErrorPageProps } from '@/components/ErrorPage'
+export { RejectPopup } from '@/components/RejectPopup'
+export type { RejectPopupProps, RejectSubmitPayload } from '@/components/RejectPopup'
+export { RejectDetailPopup } from '@/components/RejectDetailPopup'
+export type { RejectDetailPopupProps } from '@/components/RejectDetailPopup'

frontend/src/features/auth/components/LoginForm.tsx

@@ -1,7 +1,7 @@
 import { Button, Input } from '@/components'
 import { useLogin } from '@/features/auth/hooks/useLogin'
 
-const inputClassName = 'h-12 rounded-md px-4 text-base'
+const inputClassName = 'h-12 rounded-xl px-4 text-base'
 
 export function LoginForm() {
   const {

frontend/src/features/auth/components/RequireAuth.tsx

@@ -6,7 +6,10 @@ import { tokenStorage } from '@/apis'
 // 토큰이 있으나 만료/폐기된 경우는 요청 시 인터셉터가 세션을 종료시킨다.
 export function RequireAuth({ children }: { children: ReactNode }) {
   if (!tokenStorage.hasToken()) {
-    return <Navigate to="/" replace />
+    // 초청 링크(/chat?session_id=...)로 들어온 미로그인 사용자 — session_id 를 넘겨야
+    // 로그인 화면이 그 회사 브랜딩으로 뜬다.
+    const sessionId = new URLSearchParams(window.location.search).get('session_id')
+    return <Navigate to={sessionId ? `/?session_id=${sessionId}` : '/'} replace />
   }
   return <>{children}</>
 }

frontend/src/features/auth/components/SidebarFooter.tsx

@@ -1,6 +1,7 @@
 import { useNavigate } from 'react-router'
+import { LogOut } from 'lucide-react'
 import { useLogoutMutation, useMeQuery } from '@/apis'
-import { Button } from '@/components'
+import { cn, interactive } from '@/lib'
 
 // 사이드바 하단: 공급사명 + 로그아웃
 export function SidebarFooter() {
@@ -15,19 +16,23 @@ export function SidebarFooter() {
   }
 
   return (
-    <div className="flex w-full h-[60px] py-3 px-8 gap-3 items-center">
-      <div className="flex-1 flex items-center min-w-0 text-sm text-foreground">
-        <span className="truncate">{user?.supplierName ?? '-'}</span>
+    <div className="flex w-full shrink-0 items-center gap-2 border-t border-border px-6 py-3">
+      <div className="min-w-0 flex-1">
+        <p className="truncate text-sm font-bold text-neutral-90">{user?.supplierName ?? '-'}</p>
+        <p className="truncate text-xs text-neutral-60">{user?.name ?? '공급 파트너'}</p>
       </div>
-      <Button
-        variant="secondary"
-        size="sm"
-        className="w-[61px] px-2 rounded-[4px] text-xs flex-shrink-0"
+      <button
+        type="button"
         onClick={handleLogout}
         disabled={logout.isPending}
+        className={cn(
+          'flex shrink-0 items-center gap-1.5 rounded-xl border border-border bg-white px-3 py-1.5 text-xs font-bold text-neutral-70 hover:bg-neutral-10 disabled:opacity-50',
+          interactive,
+        )}
       >
+        <LogOut className="size-3.5" />
         로그아웃
-      </Button>
+      </button>
     </div>
   )
 }

frontend/src/features/auth/hooks/usePreLoginBranding.ts

@@ -0,0 +1,61 @@
+import { useEffect, useState } from 'react'
+import { useSearchParams } from 'react-router'
+import { authApi } from '@/apis'
+import type { Branding } from '@/apis/auth/auth.type'
+
+// 로그인 전 화면의 회사 브랜딩을 담아 두는 곳. 로그아웃/토큰 만료와 무관하게 남겨
+// 뒤로가기·재진입으로 session_id 가 없어져도 같은 회사 화면을 유지한다(회사 식별 정보만 담는다).
+const BRANDING_KEY = 'negosium.preLoginBranding'
+
+function readCached(): Branding | null {
+  try {
+    const raw = localStorage.getItem(BRANDING_KEY)
+    return raw ? (JSON.parse(raw) as Branding) : null
+  } catch {
+    return null // 손상된 값은 없는 것으로 본다
+  }
+}
+
+function writeCached(branding: Branding): void {
+  try {
+    localStorage.setItem(BRANDING_KEY, JSON.stringify(branding))
+  } catch {
+    // 저장 불가(프라이빗 모드 등)면 이번 방문에만 적용된다
+  }
+}
+
+// 로그인 전 화면(로그인 페이지)의 회사 브랜딩.
+// 협력사는 초청 메일의 /chat?session_id=... 로 들어오므로, 그 session_id 로 인증 없이 브랜딩만 조회한다.
+// session_id 가 없으면 마지막으로 확인된 회사 브랜딩을 쓰고, 그것도 없으면 기본 브랜드(Negosium).
+export function usePreLoginBranding(): Branding | null {
+  const [searchParams] = useSearchParams()
+  const [branding, setBranding] = useState<Branding | null>(readCached)
+
+  const sessionId = searchParams.get('session_id') ?? ''
+
+  useEffect(() => {
+    if (!sessionId) return
+    let alive = true
+    void authApi
+      .sessionBranding(sessionId)
+      .then((res) => {
+        if (!alive || res.result?.success === false) return
+        const next: Branding = {
+          service_name: res.service_name || undefined,
+          logo_url: res.logo_url || undefined,
+          helpdesk: res.helpdesk?.length ? res.helpdesk : undefined,
+        }
+        if (!next.service_name && !next.logo_url && !next.helpdesk) return
+        setBranding(next)
+        writeCached(next) // 다음 진입에 session_id 가 없어도 이 회사로 보이게 한다
+      })
+      .catch(() => {
+        // 조회 실패 시 캐시(또는 기본 브랜드)를 그대로 둔다
+      })
+    return () => {
+      alive = false
+    }
+  }, [sessionId])
+
+  return branding
+}

frontend/src/features/auth/index.ts

@@ -1,3 +1,4 @@
 export { LoginForm } from '@/features/auth/components/LoginForm'
 export { SidebarFooter } from '@/features/auth/components/SidebarFooter'
 export { RequireAuth } from '@/features/auth/components/RequireAuth'
+export { usePreLoginBranding } from '@/features/auth/hooks/usePreLoginBranding'

frontend/src/features/chat/components/ChatMessage.tsx

@@ -1,5 +1,5 @@
-import { useEffect, useRef, memo } from 'react'
-import { cn } from '@/lib'
+import { useEffect, useRef, memo, type RefObject } from 'react'
+import { useMeQuery } from '@/apis'
 import { useChatStore } from '@/features/chat/stores/useChatStore'
 import { useChatInitStore } from '@/features/chat/stores/useChatInitStore'
 import type { ChatMessage as ChatMessageType } from '@/features/chat/types'
@@ -7,34 +7,49 @@ import { renderEmphasis } from '@/features/chat/lib/emphasis'
 import { Indicator } from '@/features/chat/components/templates/Indicator'
 import { Summary } from '@/features/chat/components/templates/Summary'
 import { BidSummary } from '@/features/chat/components/templates/BidSummary'
-import { RejectRSP } from '@/features/chat/components/templates/RejectRSP'
-import { RejectCM } from '@/features/chat/components/templates/RejectCM'
+import { RejectSummary } from '@/features/chat/components/templates/RejectSummary'
+import { RejectedNotice } from '@/features/chat/components/templates/RejectedNotice'
+
+const AI_LABEL = '아이마켓코리아 (구매담당자)'
 
 export function ChatMessage() {
+  const scrollRef = useRef<HTMLDivElement | null>(null)
   return (
-    <div className="flex-1 w-full min-h-0 pr-[16px]">
-      {/* pt-[64px]: 첫 메시지를 우측 협상절차 카드 상단과 맞추되, 스크롤 시 여백도 함께 밀려 올라가도록 스크롤 컨테이너 안쪽에 둔다 */}
-      <div className="chat-scroll h-full overflow-y-auto flex flex-col pt-[64px] pl-[140px] pr-[126px] max-[1350px]:pl-[80px] max-[1350px]:pr-[72px] max-[1180px]:pl-[48px] max-[1180px]:pr-[40px]">
-        <ChatList />
+    <div className="flex-1 w-full min-h-0">
+      <div
+        ref={scrollRef}
+        className="chat-scroll h-full overflow-y-auto flex flex-col pt-4 pb-6 px-4 sm:px-6 min-[1180px]:pl-[80px] min-[1180px]:pr-[72px] min-[1350px]:pl-[140px] min-[1350px]:pr-[126px]"
+      >
+        <ChatList scrollRef={scrollRef} />
       </div>
     </div>
   )
 }
 
-function ChatList() {
-  const bottomRef = useRef<HTMLDivElement | null>(null)
+function ChatList({ scrollRef }: { scrollRef: RefObject<HTMLDivElement | null> }) {
+  const isFirstRef = useRef(true)
   const chats = useChatStore((s) => s.messages)
   const isLoading = useChatStore((s) => s.isLoading)
 
-  // 메시지 추가/타이핑 표시 시 항상 맨 아래로 스크롤
+  // 메시지 추가/타이핑 표시 시 항상 맨 아래로 스크롤.
+  // 스크롤 컨테이너를 직접 내린다 — scrollIntoView 는 요약/부가정보 폼처럼 큰 블록이 뒤늦게
+  // 레이아웃되면 애니메이션 도중 목표 위치가 밀려 중간에 멈춘다.
+  // 진입 첫 렌더는 즉시(auto) — 히스토리를 복원하며 위에서부터 훑어 내려가는 연출을 막는다.
   useEffect(() => {
-    bottomRef.current?.scrollIntoView({ behavior: 'smooth' })
-  }, [chats, isLoading])
+    const scroller = scrollRef.current
+    if (!scroller) return
+    const behavior: ScrollBehavior = isFirstRef.current ? 'auto' : 'smooth'
+    isFirstRef.current = false
+    const id = requestAnimationFrame(() => {
+      scroller.scrollTo({ top: scroller.scrollHeight, behavior })
+    })
+    return () => cancelAnimationFrame(id)
+  }, [chats, isLoading, scrollRef])
 
   if (!chats || chats.length === 0) {
     return (
       <div className="flex items-center justify-center h-full">
-        <p className="body-1 text-neutral-70">채팅 내역이 없습니다.</p>
+        <p className="text-sm text-neutral-60">채팅 내역이 없습니다.</p>
       </div>
     )
   }
@@ -42,22 +57,23 @@ function ChatList() {
   return (
     <div className="flex flex-col w-full">
       {chats.map((message, index) => (
-        <MessageItem key={message.chat_id || index} message={message} isFirst={index === 0} messages={chats} currentIndex={index} />
+        <MessageItem key={message.chat_id || index} message={message} messages={chats} currentIndex={index} />
       ))}
+      <RejectedNotice />
       {isLoading && <TypingBubble />}
-      <div ref={bottomRef} />
     </div>
   )
 }
 
-// agent 응답을 기다리는 동안(협상 중) 대화 흐름에 표시하는 타이핑 인디케이터.
+// agent 응답을 기다리는 동안(협상 중) 대화 흐름에 표시하는 타이핑 인디케이터(AI 말풍선 톤).
 function TypingBubble() {
   return (
-    <div className="mb-[56px] pt-[36px]" aria-label="협상 중" role="status">
-      <div className="inline-flex items-center gap-[6px]">
-        <span className="size-[8px] rounded-full bg-neutral-50 animate-bounce [animation-delay:-0.3s]" />
-        <span className="size-[8px] rounded-full bg-neutral-50 animate-bounce [animation-delay:-0.15s]" />
-        <span className="size-[8px] rounded-full bg-neutral-50 animate-bounce" />
+    <div className="mb-6 flex flex-col items-start gap-1.5" aria-label="협상 중" role="status">
+      <span className="text-xs font-bold text-neutral-80">{AI_LABEL}</span>
+      <div className="inline-flex items-center gap-1.5 rounded-2xl rounded-tl-none border border-[#D2E6FF] bg-brand-light/70 px-4 py-3.5 shadow-sm">
+        <span className="size-2 rounded-full bg-brand-500 animate-bounce [animation-delay:-0.3s]" />
+        <span className="size-2 rounded-full bg-brand-500 animate-bounce [animation-delay:-0.15s]" />
+        <span className="size-2 rounded-full bg-brand-500 animate-bounce" />
       </div>
     </div>
   )
@@ -65,46 +81,48 @@ function TypingBubble() {
 
 const MessageItem = memo(function MessageItem({
   message,
-  isFirst,
   messages,
   currentIndex,
 }: {
   message: ChatMessageType
-  isFirst: boolean
   messages: ChatMessageType[]
   currentIndex: number
 }) {
   const isBot = message.sender === 'bot'
 
-  // 직전이 reject 폼이면 사용자 답변은 숨기고 구분선만 표시
+  // 결렬 폼 답변은 제출 문자열(공급희망가격-…, 합의불가사유-…)이라 말풍선 대신 요약 카드로 낸다.
+  // 폼은 세션 종료와 함께 사라지므로 이 카드가 없으면 결렬 사유가 대화에 안 남는다.
   if (!isBot && currentIndex > 0) {
     const prev = messages[currentIndex - 1]
     if (prev?.bot_chat_type === 'rejectRSP' || prev?.bot_chat_type === 'rejectCM') {
       return (
-        <>
-          <div className="text-right mb-[56px]" />
-          <div className="flex w-full bg-neutral-30 h-[1px] mb-[20px]" />
-        </>
+        <div className="mb-5 animate-fade-in">
+          <RejectSummary script={message.script || ''} />
+        </div>
       )
     }
   }
 
-  return <div>{isBot ? <BotMessage message={message} isFirst={isFirst} /> : <UserMessage text={message.script || ''} />}</div>
+  return isBot ? <BotMessage message={message} /> : <UserMessage text={message.script || ''} />
 })
 
-const BotMessage = memo(function BotMessage({ message, isFirst }: { message: ChatMessageType; isFirst?: boolean }) {
+const BotMessage = memo(function BotMessage({ message }: { message: ChatMessageType }) {
   // 인디케이터는 이번 방문에서 '협상중'이었던 세션에서만 표시.
-  // 진행 화면에서 실시간으로 완료되면 sticky 플래그로 계속 노출하고,
-  // 완료/거부 세션에 결과 열람 목적으로 재진입한 경우엔 값이 와도 숨긴다.
   const showIndicator = useChatInitStore((s) => s.wasInProgress)
+  const hasScript = Boolean(message.script && message.script.trim())
+
   return (
-    <div className="mb-[56px]">
-      <div className={cn('flex flex-col', !isFirst && 'pt-[36px]')}>
-        {/* 봇 스크립트의 `**굵게**` 경량 마크업 해석 (표현 규칙은 프론트 소유 — emphasis.tsx) */}
-        <div className="body-1-read-r">{renderEmphasis(message.script || '')}</div>
+    <div className="mb-5 animate-fade-in">
+      <div className="flex flex-col items-start gap-1.5">
+        <span className="text-xs font-bold text-neutral-80">{AI_LABEL}</span>
+        {hasScript && (
+          <div className="max-w-[80%] rounded-2xl rounded-tl-none border border-[#D2E6FF] bg-brand-light/70 p-4 text-sm leading-relaxed text-neutral-90 shadow-sm break-keep">
+            {renderEmphasis(message.script || '')}
+          </div>
+        )}
       </div>
 
-      <div className="flex flex-col gap-4 w-full mt-[32px]">
+      <div className="flex flex-col gap-4 w-full mt-4">
         {showIndicator && message.bot_chat_type === 'indicator' && message.indicator_value != null && (
           <Indicator number={message.indicator_value} />
         )}
@@ -114,26 +132,22 @@ const BotMessage = memo(function BotMessage({ message, isFirst }: { message: Cha
             itemName={message.summary.item_name}
             itemCode={message.summary.item_code}
             bidPrice={message.summary.final_price}
-            deliveryType={message.summary.delivery_type || ''}
-            isVAT={message.summary.item_isVAT}
           />
         )}
-        {message.bot_chat_type === 'rejectRSP' && <RejectRSP />}
-        {message.bot_chat_type === 'rejectCM' && <RejectCM />}
       </div>
     </div>
   )
 })
 
 const UserMessage = memo(function UserMessage({ text }: { text: string }) {
+  const { data: user } = useMeQuery()
+  const label = `${user?.supplierName ?? '공급사'} (나)`
   return (
-    <>
-      <div className="text-right mb-[56px]">
-        <div className="inline-block max-w-[87%] bg-neutral-40 text-neutral-90 text-lg leading-[150%] tracking-[-0.18px] px-[20px] py-[10px] rounded-full break-keep">
-          {text}
-        </div>
+    <div className="mb-5 flex flex-col items-end gap-1.5 animate-fade-in">
+      <span className="text-xs font-bold text-neutral-80">{label}</span>
+      <div className="max-w-[80%] rounded-2xl rounded-tr-none border border-border bg-white p-4 text-sm leading-relaxed text-neutral-90 shadow-sm break-keep">
+        {text}
       </div>
-      <div className="flex w-full bg-neutral-30 h-[1px] mb-[20px]" />
-    </>
+    </div>
   )
 })

frontend/src/features/chat/components/ChatSection.tsx

@@ -1,13 +1,43 @@
+import { useState } from 'react'
+import { SessionStatus } from '@/apis'
 import { useChatStore } from '@/features/chat/stores/useChatStore'
+import { useChatInitStore } from '@/features/chat/stores/useChatInitStore'
 import { ChatMessage } from '@/features/chat/components/ChatMessage'
 import { UserButton } from '@/features/chat/components/UserButton'
+import { RejectPopup } from '@/features/chat/components/popup/RejectPopup'
+import { canRejectNegotiation, GO_TO_LIST_TEXT } from '@/features/chat/lib/userButtonConfig'
+import { MobileStepBar } from '@/features/chat/components/MobileStepBar'
+import type { UserButtonConfig } from '@/features/chat/types'
+
+// 미참여·협상거부로 끝난 세션은 '결과 보기'(열람) 진입이라 입력을 잠근다.
+// 마지막 봇 메시지가 입력을 요구하는 상태로 멈춰 있어도(중간 이탈) 서버가 전송을 막으므로 액션바는 복귀 버튼만 둔다.
+const READ_ONLY_STATUSES: number[] = [SessionStatus.NOT_PARTICIPATED, SessionStatus.REJECTED]
+const READ_ONLY_CONFIG: UserButtonConfig = { type: 'one-black', text: GO_TO_LIST_TEXT }
+
+// 거부 가능한 세션 상태 — 백엔드 /reject 가 허용하는 범위(완료/미참여/거부는 불가)와 같다.
+const REJECTABLE_STATUSES: number[] = [SessionStatus.CREATED, SessionStatus.IN_PROGRESS]
 
 export function ChatSection() {
-  const { userButtonConfig } = useChatStore()
+  const { messages, userButtonConfig } = useChatStore()
+  const sessionStatus = useChatInitStore((s) => s.session_status)
+  const [isRejectOpen, setIsRejectOpen] = useState(false)
+
+  const isReadOnly = READ_ONLY_STATUSES.includes(sessionStatus)
+  const config = isReadOnly ? READ_ONLY_CONFIG : userButtonConfig
+  // 단종·품절처럼 대화로 풀 수 없는 사유는 봇의 결렬 선언을 기다릴 수 없다 — 진행 중에도 빠져나갈 길을 둔다.
+  const canReject =
+    !isReadOnly && REJECTABLE_STATUSES.includes(sessionStatus) && canRejectNegotiation(messages, userButtonConfig)
+
   return (
-    <div className="flex flex-1 flex-col w-full h-full bg-surface rounded-bl-[8px]">
+    <div className="flex flex-1 flex-col w-full h-full min-h-0 bg-surface">
+      <MobileStepBar />
       <ChatMessage />
-      <UserButton {...userButtonConfig} />
+      {/* 하단 액션 덱 */}
+      {/* safe-b: 홈 인디케이터에 입력 버튼이 가리지 않도록 하단 안전영역 확보 */}
+      <div className="shrink-0 safe-b border-t border-border bg-white shadow-[0_-4px_20px_rgba(0,0,0,0.03)]">
+        <UserButton {...config} onReject={canReject ? () => setIsRejectOpen(true) : undefined} />
+      </div>
+      {isRejectOpen && <RejectPopup onClose={() => setIsRejectOpen(false)} />}
     </div>
   )
 }

frontend/src/features/chat/components/ExtraInfoBar.tsx

@@ -0,0 +1,126 @@
+import { useState } from 'react'
+import { toast } from 'sonner'
+import { useMeQuery, useSaveExtraInfoMutation, getApiErrorMessage } from '@/apis'
+import type { SessionField } from '@/apis/auth/auth.type'
+import { useChatStore } from '@/features/chat/stores/useChatStore'
+import { useChatInitStore } from '@/features/chat/stores/useChatInitStore'
+
+// 타결 요약의 '동의' 단계 하단 액션바 = 부가정보 입력 + 동의를 한 자리에서.
+// 다른 입력(가격·배송)과 같은 자리에서 받는다. proceedText = 동의 문구(누르면 저장 후 그 텍스트로 협상 종료).
+// 필드 정의(session_fields)가 없으면 폼 없이 동의 버튼만 둔다. 저장 후에도 세션 목록에서 수정할 수 있다.
+export function ExtraInfoBar({ proceedText }: { proceedText: string }) {
+  const sessionId = useChatStore((s) => s.sessionId)
+  const sendMessage = useChatStore((s) => s.sendMessage)
+  const { data: user } = useMeQuery()
+  const fields: SessionField[] = user?.sessionFields ?? []
+  const save = useSaveExtraInfoMutation()
+  const existing = useChatInitStore((s) => s.custom) // 기존 입력값(재진입 프리필)
+  const setInitData = useChatInitStore((s) => s.setInitData)
+  // 의견은 session_fields 와 무관한 공통 필드 — 타결·결렬 모두 항상 받는다. custom.opinion 에 저장.
+  const [opinion, setOpinion] = useState<string | null>(null)
+  const opinionValue = opinion ?? String(existing?.opinion ?? '')
+
+  // 사용자가 건드린 값만 state 로 두고, 나머지는 기존값/기본값에서 렌더마다 파생한다(초기화 effect 불필요).
+  const [overrides, setOverrides] = useState<Record<string, unknown>>({})
+  const values: Record<string, unknown> = {}
+  for (const f of fields) values[f.key] = overrides[f.key] ?? existing?.[f.key] ?? (f.type === 'boolean' ? false : '')
+
+  const proceed = () => sendMessage(proceedText)
+
+  const set = (key: string, value: unknown) => setOverrides((v) => ({ ...v, [key]: value }))
+
+  // 저장 성공 후에만 동의(협상 종료)로 넘어간다 — 저장 실패 시 화면 유지.
+  const handleSaveAndProceed = () => {
+    if (save.isPending) return
+    const custom: Record<string, unknown> = {}
+    for (const f of fields) {
+      const v = values[f.key]
+      if (f.type === 'boolean') custom[f.key] = !!v
+      else if (v !== '' && v != null) custom[f.key] = f.type === 'number' ? Number(v) : v
+    }
+    if (opinionValue.trim()) custom.opinion = opinionValue.trim()
+    if (Object.keys(custom).length === 0) { proceed(); return } // 입력 없음 → 저장 생략하고 종료
+    save.mutate(
+      { sessionId, request: { custom } },
+      {
+        onSuccess: () => {
+          setInitData({ custom: { ...existing, ...custom } }) // 요약 카드가 방금 입력값을 즉시 반영하도록 store 갱신
+          proceed()
+        },
+        onError: (error) => toast.error(getApiErrorMessage(error, '부가정보 저장에 실패했습니다.')),
+      },
+    )
+  }
+
+  return (
+    <div className="w-full">
+      <p className="mb-3 text-sm font-semibold text-neutral-90">아래 정보를 입력하고 협상을 마무리해 주세요.</p>
+      {/* overflow-y-auto 는 overflow-x 도 auto 로 만들어(스펙상) 인풋 focus ring 을 좌우로 잘라낸다.
+          p-1 로 링 여백을 주고 -m-1 로 원래 정렬(버튼과 좌우폭)을 유지한다. */}
+      <div className="max-h-[36vh] space-y-3 overflow-y-auto p-1 -m-1">
+        {fields.map((f) => (
+          <div key={f.key} className="flex items-center gap-3">
+            <label className="w-28 shrink-0 text-sm font-semibold text-neutral-80">{f.label}</label>
+            {f.type === 'boolean' ? (
+              <button
+                type="button"
+                role="switch"
+                aria-checked={!!values[f.key]}
+                onClick={() => set(f.key, !values[f.key])}
+                className={`relative inline-flex h-6 w-11 shrink-0 items-center rounded-full transition-colors ${
+                  values[f.key] ? 'bg-brand-600' : 'bg-neutral-30'
+                }`}
+              >
+                <span
+                  className={`inline-block size-5 transform rounded-full bg-white shadow transition-transform ${
+                    values[f.key] ? 'translate-x-5' : 'translate-x-0.5'
+                  }`}
+                />
+              </button>
+            ) : f.type === 'select' ? (
+              <select
+                value={String(values[f.key] ?? '')}
+                onChange={(e) => set(f.key, e.target.value)}
+                className="h-10 w-full rounded-xl border border-border bg-white px-3 text-sm outline-none focus:border-brand-600 focus:ring-1 focus:ring-brand-600"
+              >
+                <option value="">선택</option>
+                {(f.options ?? []).map((o) => (
+                  <option key={o} value={o}>{o}</option>
+                ))}
+              </select>
+            ) : (
+              <input
+                type={f.type === 'number' ? 'number' : 'text'}
+                value={String(values[f.key] ?? '')}
+                onChange={(e) => set(f.key, e.target.value)}
+                onKeyDown={(e) => e.key === 'Enter' && !e.nativeEvent.isComposing && handleSaveAndProceed()}
+                className="h-10 w-full rounded-xl border border-border bg-white px-3 text-sm outline-none focus:border-brand-600 focus:ring-1 focus:ring-brand-600"
+                placeholder={f.label}
+              />
+            )}
+          </div>
+        ))}
+        {/* 의견 — 타결·결렬 공통 필드(IMK #18). custom.opinion 저장. */}
+        <div className="flex flex-col gap-1">
+          <label className="text-sm font-semibold text-neutral-80">
+            의견 <span className="font-normal text-neutral-50">(선택)</span>
+          </label>
+          <textarea
+            value={opinionValue}
+            onChange={(e) => setOpinion(e.target.value)}
+            rows={2}
+            maxLength={255}
+            placeholder="추가로 남길 의견이 있으면 작성해 주세요."
+            className="w-full resize-none rounded-xl border border-border bg-white px-3 py-2 text-sm outline-none focus:border-brand-600 focus:ring-1 focus:ring-brand-600"
+          />
+        </div>
+      </div>
+      <button type="button" onClick={handleSaveAndProceed} disabled={save.isPending} className={`${PRIMARY} mt-3 w-full`}>
+        {save.isPending ? '저장 중…' : proceedText || '저장하고 마무리'}
+      </button>
+    </div>
+  )
+}
+
+const PRIMARY =
+  'h-[46px] min-w-[120px] rounded-xl bg-brand-600 px-6 text-sm font-bold text-white shadow-sm transition-all hover:bg-brand-700 active:scale-[0.98] disabled:opacity-50'

frontend/src/features/chat/components/ItemImage.tsx

@@ -8,34 +8,33 @@ export function ItemImage() {
   const [isOpen, setIsOpen] = useState(false)
 
   return (
-    <div className="flex flex-col w-full items-center justify-center pt-16 pr-8 pb-8 pl-8">
+    <div className="px-5 pt-5 pb-3">
       <button
         type="button"
         onClick={() => setIsOpen(true)}
         aria-label="이미지 크게 보기"
-        className="relative cursor-pointer group"
+        className="group relative block aspect-square w-full overflow-hidden rounded-2xl border border-border bg-neutral-10 shadow-inner"
       >
-        <Thumb src={item_image} />
-        <div className="absolute inset-0 flex items-center justify-center rounded-[16px] bg-neutral-40 opacity-0 transition-opacity duration-300 group-hover:opacity-90">
-          <span className="text-neutral-00 text-base font-medium">이미지 크게 보기</span>
-        </div>
+        {item_image ? (
+          <img
+            src={item_image}
+            alt="상품 이미지"
+            className="h-full w-full object-cover transition-transform duration-300 group-hover:scale-105"
+          />
+        ) : (
+          <div className="flex h-full w-full items-center justify-center text-neutral-40">
+            <ImageIcon size={40} strokeWidth={1.5} />
+          </div>
+        )}
+        <span className="absolute left-2 top-2 rounded-md bg-neutral-90/65 px-2 py-0.5 text-[10px] font-bold text-white backdrop-blur-sm">
+          상세 품목
+        </span>
       </button>
       {isOpen && <ImageModal src={item_image} onClose={() => setIsOpen(false)} />}
     </div>
   )
 }
 
-function Thumb({ src }: { src: string }) {
-  if (src) {
-    return <img src={src} alt="상품 이미지" className="rounded-[16px] w-[220px] h-[220px] max-[1180px]:w-[200px] max-[1180px]:h-[200px] object-cover" />
-  }
-  return (
-    <div className="flex w-[220px] h-[220px] max-[1180px]:w-[200px] max-[1180px]:h-[200px] items-center justify-center rounded-[16px] bg-neutral-20 text-neutral-60">
-      <ImageIcon size={48} strokeWidth={1.5} />
-    </div>
-  )
-}
-
 function ImageModal({ src, onClose }: { src: string; onClose: () => void }) {
   useEffect(() => {
     const onKey = (e: KeyboardEvent) => e.key === 'Escape' && onClose()
@@ -53,9 +52,9 @@ function ImageModal({ src, onClose }: { src: string; onClose: () => void }) {
     >
       <div className="relative" onClick={(e) => e.stopPropagation()}>
         {src ? (
-          <img src={src} alt="상품 이미지" className="rounded-[16px] max-w-[42rem] max-h-[90vh] object-contain" />
+          <img src={src} alt="상품 이미지" className="max-h-[90vh] max-w-[42rem] rounded-2xl object-contain" />
         ) : (
-          <div className="flex w-[60vmin] h-[60vmin] max-w-[42rem] max-h-[90vh] items-center justify-center rounded-[16px] bg-neutral-20 text-neutral-60">
+          <div className="flex h-[60vmin] max-h-[90vh] w-[60vmin] max-w-[42rem] items-center justify-center rounded-2xl bg-neutral-20 text-neutral-50">
             <ImageIcon size={96} strokeWidth={1.25} />
           </div>
         )}
@@ -63,9 +62,9 @@ function ImageModal({ src, onClose }: { src: string; onClose: () => void }) {
           type="button"
           onClick={onClose}
           aria-label="닫기"
-          className="absolute top-4 right-4 flex items-center justify-center w-9 h-9 rounded-full bg-white border border-neutral-30 text-neutral-80 cursor-pointer hover:bg-neutral-10 transition-colors"
+          className="absolute right-3 top-3 flex size-9 items-center justify-center rounded-full border border-border bg-white text-neutral-80 transition-colors hover:bg-neutral-10"
         >
-          <X size={20} />
+          <X size={18} />
         </button>
       </div>
     </div>,

frontend/src/features/chat/components/ItemSection.tsx

@@ -1,6 +1,5 @@
 import { useState, useCallback, useRef, useEffect } from 'react'
 import { createPortal } from 'react-dom'
-import { cn } from '@/lib'
 import { ItemImage } from '@/features/chat/components/ItemImage'
 import { useChatInitStore } from '@/features/chat/stores/useChatInitStore'
 import { formatLeadTime } from '@/features/chat/lib/format'
@@ -39,14 +38,17 @@ function ItemInfo() {
   const {
     item_code,
     item_price,
-    item_vat_yn,
     item_model_name,
     item_maker_name,
     item_min_order_quantity,
     item_lead_time,
     item_spec,
     item_name,
+    item_vat_yn,
+    labels,
   } = useChatInitStore()
+  // 회사 설정 라벨(companies.settings.labels)로 필드명 치환. 미설정 시 기본 라벨.
+  const fieldLabel = (key: string, fallback: string) => labels?.[key] || fallback
 
   const [tooltip, setTooltip] = useState<TooltipState | null>(null)
   const hideTimer = useRef<ReturnType<typeof setTimeout> | null>(null)
@@ -72,21 +74,21 @@ function ItemInfo() {
   const formatPrice = (price: number) => price.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',')
   const isNewItem = !item_code && !item_price
   const priceText = isNewItem ? '신규' : `${formatPrice(item_price)}원`
-  const formattedPrice = `${priceText}(${item_vat_yn || 'VAT별도'})`
+  // VAT 표기는 회사 설정 기준(item_vat_yn). vat_yn 미관리(hidden)면 값이 비어 라벨을 생략한다.
+  const formattedPrice = item_vat_yn ? `${priceText}(${item_vat_yn})` : priceText
 
-  const renderRow = (title: string, data: string, important = false) => {
-    const textClass = important ? 'title-3 text-neutral-90' : 'body-3 text-neutral-70'
+  const renderRow = (title: string, data: string) => {
     const displayData = data || '-'
     return (
-      <div className="flex items-start self-stretch gap-1 min-w-0">
-        <div className={cn(textClass, 'w-[100px]')}>{title}</div>
-        <div
-          className={cn(textClass, 'flex-1 min-w-0 break-words break-keep cursor-default')}
+      <div className="flex items-start justify-between gap-3 self-stretch border-b border-border/60 py-2 last:border-0 min-w-0">
+        <span className="shrink-0 text-[13px] text-neutral-60">{title}</span>
+        <span
+          className="min-w-0 flex-1 break-words break-keep text-right text-[13px] font-semibold text-neutral-90 cursor-default"
           onMouseEnter={(e) => displayData !== '-' && showTooltip(e, displayData)}
           onMouseLeave={hideTooltip}
         >
           {displayData}
-        </div>
+        </span>
       </div>
     )
   }
@@ -94,31 +96,36 @@ function ItemInfo() {
   return (
     <div className="flex flex-col w-full flex-1 overflow-hidden min-h-0">
       <div
-        className="text-center headline-3 text-neutral-90 mb-4 truncate px-8 flex-shrink-0 cursor-default"
+        className="mb-3 flex-shrink-0 truncate px-6 text-left text-sm font-bold text-neutral-90 cursor-default"
         onMouseEnter={(e) => item_name && showTooltip(e, item_name)}
         onMouseLeave={hideTooltip}
       >
         {item_name}
       </div>
 
-      <div className="flex flex-1 items-start self-stretch mr-2 overflow-y-auto overflow-x-hidden pr-6 pl-8 min-h-0">
-        <div className="flex flex-col items-start self-stretch flex-1 gap-2 min-w-0">
-          {renderRow('상품코드', item_code, true)}
-          {renderRow('단가', formattedPrice, true)}
-          {renderRow('모델명', item_model_name, true)}
-          {renderRow('제조사', item_maker_name)}
-          {renderRow('최소주문수량', item_min_order_quantity)}
-          {renderRow('리드타임', formatLeadTime(item_lead_time))}
+      <div className="mb-2 flex-shrink-0 border-b border-border px-6 pb-2">
+        <span className="text-[11px] font-extrabold tracking-wider text-neutral-50">품목 정보</span>
+      </div>
 
-          <div className="flex items-start self-stretch gap-1 flex-[1_0]">
-            <div className="body-3 text-neutral-70 w-[100px]">규격</div>
-            <div
-              className="body-3 text-neutral-70 self-stretch w-0 flex-[1_0] overflow-hidden whitespace-normal break-words break-keep cursor-default"
+      <div className="flex flex-1 items-start self-stretch overflow-y-auto overflow-x-hidden px-6 min-h-0">
+        <div className="flex flex-col items-start self-stretch flex-1 gap-2 min-w-0">
+          {renderRow(fieldLabel('item.code', '상품코드'), item_code)}
+          {/* 값은 회사가 고른 협상 기준가(item_price), 호칭은 공급사 화면 고정 용어 — 회사 용어 사전을 타지 않는다. */}
+          {renderRow('공급가', formattedPrice)}
+          {renderRow(fieldLabel('item.model_name', '모델명'), item_model_name)}
+          {renderRow(fieldLabel('item.manufacturer', '제조사'), item_maker_name)}
+          {renderRow(fieldLabel('item.moq', '최소주문수량'), item_min_order_quantity)}
+          {renderRow(fieldLabel('lead_time', '리드타임'), formatLeadTime(item_lead_time))}
+
+          <div className="flex items-start justify-between gap-3 self-stretch py-2">
+            <span className="shrink-0 text-sm text-neutral-60">{fieldLabel('item.spec', '규격')}</span>
+            <span
+              className="min-w-0 flex-1 overflow-hidden whitespace-normal break-words break-keep text-right text-[13px] font-semibold text-neutral-90 cursor-default"
               onMouseEnter={(e) => item_spec && showTooltip(e, item_spec, true)}
               onMouseLeave={hideTooltip}
             >
               {item_spec || '-'}
-            </div>
+            </span>
           </div>
         </div>
       </div>

frontend/src/features/chat/components/MobileDrawer.tsx

@@ -0,0 +1,50 @@
+import { type ReactNode, useEffect } from 'react'
+import { createPortal } from 'react-dom'
+import { X } from 'lucide-react'
+import { cn } from '@/lib'
+
+interface MobileDrawerProps {
+  open: boolean
+  onClose: () => void
+  side?: 'left' | 'right'
+  title: string
+  children: ReactNode
+}
+
+// 모바일 전용 슬라이드 드로어(lg 미만). 데스크톱에선 절대 노출되지 않도록 lg:hidden 을 강제한다.
+export function MobileDrawer({ open, onClose, side = 'left', title, children }: MobileDrawerProps) {
+  useEffect(() => {
+    if (!open) return
+    const onKey = (e: KeyboardEvent) => e.key === 'Escape' && onClose()
+    window.addEventListener('keydown', onKey)
+    return () => window.removeEventListener('keydown', onKey)
+  }, [open, onClose])
+
+  if (!open) return null
+
+  return createPortal(
+    <div className="fixed inset-0 z-[60] lg:hidden">
+      <div className="absolute inset-0 bg-black/50 animate-fade-in" onClick={onClose} />
+      <div
+        className={cn(
+          'absolute top-0 bottom-0 flex w-[88%] max-w-[360px] flex-col bg-white shadow-xl',
+          side === 'left' ? 'left-0' : 'right-0',
+        )}
+      >
+        <div className="flex h-14 box-content safe-t shrink-0 items-center justify-between border-b border-border px-5">
+          <span className="text-base font-bold text-neutral-90">{title}</span>
+          <button
+            type="button"
+            onClick={onClose}
+            aria-label="닫기"
+            className="flex size-8 items-center justify-center rounded-full text-neutral-60 hover:bg-neutral-10"
+          >
+            <X className="size-4" />
+          </button>
+        </div>
+        <div className="flex min-h-0 flex-1 flex-col overflow-y-auto safe-b">{children}</div>
+      </div>
+    </div>,
+    document.body,
+  )
+}

frontend/src/features/chat/components/MobileStepBar.tsx

@@ -0,0 +1,46 @@
+import { Check } from 'lucide-react'
+import { cn } from '@/lib'
+import { useChatStore } from '@/features/chat/stores/useChatStore'
+import { STEPS } from '@/features/chat/lib/negoSteps'
+
+// 모바일 전용: 협상절차를 채팅 상단에 가로 스텝바로 항상 표시한다. (데스크톱은 우측 패널 사용)
+export function MobileStepBar() {
+  const chats = useChatStore((s) => s.messages)
+  const currentStep = chats[chats.length - 1]?.display_step || STEPS[0].name
+  const idx = Math.max(
+    0,
+    STEPS.findIndex((s) => s.name === currentStep),
+  )
+
+  return (
+    <div className="shrink-0 border-b border-border bg-white px-4 py-2.5 lg:hidden">
+      <div className="flex items-center">
+        {STEPS.map((step, i) => {
+          const done = i < idx
+          const current = i === idx
+          return (
+            <div key={step.name} className={cn('flex items-center', i < STEPS.length - 1 && 'flex-1')}>
+              <div
+                className={cn(
+                  'flex size-5 shrink-0 items-center justify-center rounded-full text-[10px] font-bold transition-colors',
+                  done && 'bg-success text-white',
+                  current && 'bg-brand-600 text-white ring-4 ring-brand-light',
+                  !done && !current && 'border border-border bg-white text-neutral-50',
+                )}
+              >
+                {done ? <Check className="size-3" strokeWidth={3} /> : i + 1}
+              </div>
+              {i < STEPS.length - 1 && (
+                <div className={cn('mx-1 h-0.5 flex-1 rounded-full', i < idx ? 'bg-success' : 'bg-neutral-20')} />
+              )}
+            </div>
+          )
+        })}
+      </div>
+      <p className="mt-1.5 truncate text-[11px] font-bold text-brand-600">
+        {idx + 1}. {STEPS[idx].name}
+        <span className="ml-1 font-normal text-neutral-50">{STEPS[idx].desc}</span>
+      </p>
+    </div>
+  )
+}

frontend/src/features/chat/components/RejectForm.tsx

@@ -0,0 +1,184 @@
+import { useState, useMemo } from 'react'
+import { AlertTriangle } from 'lucide-react'
+import { cn } from '@/lib'
+import { numberToKorean } from '@/lib'
+import { useChatStore } from '@/features/chat/stores/useChatStore'
+import { useChatInitStore } from '@/features/chat/stores/useChatInitStore'
+import { SelectRadio, SubmitButton } from '@/features/chat/components/templates/rejectControls'
+import { OtherReason } from '@/features/chat/components/templates/OtherReason'
+import {
+  findRestoreScript,
+  restoreRejectRSP,
+  extractPart,
+  REJECT_REASONS,
+} from '@/features/chat/lib/rejectForm'
+
+const MAX_PRICE = 999999999999999
+
+// 통일된 협상 결렬 폼 — 최종 제안 단가 + 합의 불가 사유 + 의견.
+// rejectRSP / rejectCM 두 유형 모두 이 폼 하나로 받는다(액션바 렌더).
+export function RejectForm() {
+  const isLoading = useChatStore((s) => s.isLoading)
+  const sendMessage = useChatStore((s) => s.sendMessage)
+  const messages = useChatStore((s) => s.messages)
+  const item_vat_yn = useChatInitStore((s) => s.item_vat_yn)
+  const isVAT = item_vat_yn === 'VAT별도'
+
+  // 직전 제출 내역에서 1회 복원 (rejectRSP/rejectCM 어느 유형이든).
+  const priorScript = useState(
+    () => findRestoreScript(messages, 'rejectRSP') ?? findRestoreScript(messages, 'rejectCM'),
+  )[0]
+  const restored = useState(() => restoreRejectRSP(priorScript))[0]
+  const [price, setPrice] = useState(restored.price)
+  const [selectedReason, setSelectedReason] = useState(restored.selectedReason)
+  const [reason, setReason] = useState(restored.reason)
+  const [opinion, setOpinion] = useState(() => extractPart(priorScript, '의견-'))
+  const [otherErrorMessage, setOtherErrorMessage] = useState('')
+  const [priceErrorMessage, setPriceErrorMessage] = useState('')
+  const [radioErrorMessage, setRadioErrorMessage] = useState('')
+
+  const isSubmitted = useMemo(
+    () => Boolean(findRestoreScript(messages, 'rejectRSP') ?? findRestoreScript(messages, 'rejectCM')),
+    [messages],
+  )
+  // 사유는 필수(20번), 의견은 선택(18번).
+  const isValid =
+    Boolean(price && parseInt(price) > 0) &&
+    Boolean(selectedReason) &&
+    (selectedReason !== '기타' || reason.trim() !== '')
+
+  const handlePriceChange = (value: string) => {
+    const numeric = value.replace(/\D/g, '')
+    if (numeric && parseInt(numeric) > MAX_PRICE) return
+    setPrice(numeric)
+    if (numeric) setPriceErrorMessage('')
+  }
+
+  const handleRadioChange = (value: string) => {
+    setSelectedReason(value)
+    setRadioErrorMessage('')
+    if (value !== '기타') {
+      setReason('')
+      setOtherErrorMessage('')
+    }
+  }
+
+  const koreanPrice = (() => {
+    if (!price) return '영'
+    const n = parseInt(price)
+    return Number.isNaN(n) || n === 0 ? '영' : numberToKorean(n)
+  })()
+
+  const handleSubmit = () => {
+    setPriceErrorMessage(!price || parseInt(price) === 0 ? '가격을 입력해주세요.' : '')
+    setRadioErrorMessage(!selectedReason ? '사유를 선택해주세요.' : '')
+    setOtherErrorMessage(selectedReason === '기타' && !reason.trim() ? '기타 사유를 입력해주세요.' : '')
+    if (isValid && !isLoading && !isSubmitted) {
+      const reasonPart =
+        selectedReason === '기타' ? `합의불가사유-기타-${reason.trim()}` : `합의불가사유-${selectedReason}`
+      const script = `공급희망가격-${price}, ${reasonPart}, 의견-${opinion.trim()}`
+      sendMessage(script, 'text')
+    }
+  }
+
+  const isDisabled = isLoading || isSubmitted
+
+  return (
+    <div className="w-full">
+      <div className="flex flex-col w-full gap-2">
+        <div className="flex w-full items-center justify-center gap-2 rounded-xl bg-[#FFF1F1] px-4 py-3 text-sm font-bold text-[#E5484D]">
+          <AlertTriangle className="size-5 shrink-0" />
+          협상 합의 불가 사유 및 최종 제안 단가 입력
+        </div>
+
+        <div className="max-h-[42vh] space-y-2 overflow-y-auto p-1 -m-1">
+          {/* 공급 희망 가격 */}
+          <div className="flex flex-col w-full gap-1">
+            <div className="flex w-full items-start gap-3">
+              <div className="w-[100px] shrink-0 pt-2.5 text-sm font-bold text-neutral-90">공급 희망 가격</div>
+              <div className="flex w-full flex-wrap items-center gap-2 pt-2">
+                <div className="flex items-center gap-2">
+                  <input
+                    type="text"
+                    className={cn(
+                      'h-10 max-w-[200px] rounded-xl border px-3 text-right text-sm outline-none transition-all placeholder:text-neutral-50',
+                      isDisabled
+                        ? 'cursor-not-allowed border-border bg-neutral-10 text-neutral-50'
+                        : 'border-border bg-white text-neutral-90 focus:border-brand-600 focus:ring-1 focus:ring-brand-600',
+                    )}
+                    value={price ? parseInt(price).toLocaleString() : ''}
+                    onChange={(e) => handlePriceChange(e.target.value)}
+                    onKeyDown={(e) => e.key === 'Enter' && !e.nativeEvent.isComposing && handleSubmit()}
+                    placeholder="0"
+                    disabled={isDisabled}
+                  />
+                  <div className="whitespace-nowrap text-sm text-neutral-70">원{isVAT && '(VAT 별도)'}</div>
+                </div>
+                <div className="whitespace-nowrap text-sm text-neutral-50">[{koreanPrice} 원]</div>
+              </div>
+            </div>
+            {priceErrorMessage && (
+              <div className="pl-[112px] text-xs font-medium text-negative">{priceErrorMessage}</div>
+            )}
+          </div>
+
+          {/* 합의 불가 사유 (필수) */}
+          <div className="flex w-full gap-3">
+            <div className="w-[100px] shrink-0 pt-2 text-sm font-bold text-neutral-90">합의 불가 사유</div>
+            <div className="flex w-full flex-col mt-2 gap-2">
+              {REJECT_REASONS.map((r) => (
+                <SelectRadio
+                  key={r.value}
+                  text={r.text}
+                  value={r.value}
+                  name="rejectform"
+                  selectedValue={selectedReason}
+                  onChange={handleRadioChange}
+                  errorMessage={radioErrorMessage}
+                  disabled={isDisabled}
+                />
+              ))}
+              <OtherReason
+                inputValue={reason}
+                setInputValue={(v) => {
+                  if (selectedReason !== '기타') return
+                  setReason(v)
+                  if (v.trim()) setOtherErrorMessage('')
+                }}
+                errorMessage={otherErrorMessage}
+                selectedValue={selectedReason}
+                onChange={handleRadioChange}
+                isError={!!radioErrorMessage}
+                disabled={isDisabled}
+                onSubmit={handleSubmit}
+              />
+            </div>
+          </div>
+
+          {/* 의견 (선택) — 타결·결렬 공통 */}
+          <div className="flex w-full items-start gap-3">
+            <div className="w-[100px] shrink-0 pt-2 text-sm font-bold text-neutral-90">의견</div>
+            <textarea
+              value={opinion}
+              onChange={(e) => setOpinion(e.target.value)}
+              rows={2}
+              maxLength={255}
+              disabled={isDisabled}
+              placeholder="추가로 남길 의견이 있으면 작성해 주세요. (선택)"
+              className={cn(
+                'mt-2 w-full resize-none rounded-xl border px-3 py-2 text-sm outline-none transition-all placeholder:text-neutral-50',
+                isDisabled
+                  ? 'cursor-not-allowed border-border bg-neutral-10 text-neutral-50'
+                  : 'border-border bg-white text-neutral-90 focus:border-brand-600 focus:ring-1 focus:ring-brand-600',
+              )}
+            />
+          </div>
+        </div>
+
+        <div className="flex w-full items-center justify-center mt-2">
+          <SubmitButton isValid={isValid} isLoading={isLoading} isSubmitted={isSubmitted} onSubmit={handleSubmit} />
+        </div>
+      </div>
+    </div>
+  )
+}

frontend/src/features/chat/components/RemainingTime.tsx

@@ -1,8 +1,10 @@
 import { useState, useEffect } from 'react'
+import { Clock } from 'lucide-react'
+import { cn } from '@/lib'
 import { getTimeRemaining } from '@/features/chat/lib/remainingTime'
 import { useChatInitStore } from '@/features/chat/stores/useChatInitStore'
 
-// 헤더의 협상 잔여 시간. 1초마다 tick 을 올려 렌더 중 남은 시간을 다시 계산한다.
+// 헤더의 협상 잔여 시간 칩. 1초마다 tick 을 올려 렌더 중 남은 시간을 다시 계산한다.
 export function RemainingTime() {
   const { quotation_end_time } = useChatInitStore()
   const [, setTick] = useState(0)
@@ -13,6 +15,28 @@ export function RemainingTime() {
   }, [])
 
   const remaining = quotation_end_time ? getTimeRemaining(quotation_end_time) : '-'
+  const ended = remaining === '종료되었습니다.' || remaining === '-'
 
-  return <span className="title-1">협상 잔여 시간 : {remaining}</span>
+  return (
+    <span
+      className={cn(
+        // min-w-0 + truncate: 헤더가 좁아도 잘려나가지 않고 말줄임으로 접힌다.
+        'inline-flex min-w-0 shrink items-center gap-1.5 rounded-full px-3 py-1 text-xs font-bold tabular-nums',
+        ended ? 'bg-neutral-20 text-neutral-60' : 'bg-brand-light text-brand-600',
+      )}
+    >
+      <Clock className="size-3.5 shrink-0" />
+      <span className="truncate">
+        {ended ? (
+          // 종료 시엔 어느 폭에서도 긴 문장('종료되었습니다.')을 쓰지 않는다 — 헤더에서 잘리던 원인.
+          '마감 종료'
+        ) : (
+          <>
+            <span className="hidden sm:inline">협상 마감 </span>
+            {remaining}
+          </>
+        )}
+      </span>
+    </span>
+  )
 }

frontend/src/features/chat/components/UserButton.tsx

@@ -1,45 +1,77 @@
+import { useEffect } from 'react'
 import { useNavigate } from 'react-router'
-import { List } from 'lucide-react'
 import { cn } from '@/lib'
 import { useChatStore } from '@/features/chat/stores/useChatStore'
 import { Percent, Price } from '@/features/chat/components/userInputs'
+import { ExtraInfoBar } from '@/features/chat/components/ExtraInfoBar'
+import { RejectForm } from '@/features/chat/components/RejectForm'
 import { GO_TO_LIST_TEXT } from '@/features/chat/lib/userButtonConfig'
 import type { UserButtonConfig } from '@/features/chat/types'
 
 // max-[1180px]: 채팅 폭이 좁아지면 버튼 패딩·최소폭 축소, 상품목록은 아이콘만 남긴다
 const style = {
-  goToList:
-    'flex w-[159px] max-[1180px]:w-[48px] h-[48px] bg-neutral-40 hover:brightness-[0.97] rounded-[999px] items-center justify-center title-2 text-neutral-80 cursor-pointer gap-2 max-[1180px]:gap-0 transition-all ease-out hover:scale-[1.01]',
   black:
-    'flex min-w-[120px] px-[32px] max-[1180px]:min-w-[100px] max-[1180px]:px-[20px] h-[48px] bg-primary hover:brightness-[0.97] rounded-[999px] items-center justify-center title-2 text-primary-foreground cursor-pointer whitespace-nowrap transition-all duration-200 ease-out hover:scale-[1.01]',
-  gray: 'flex min-w-[120px] px-[32px] max-[1180px]:min-w-[100px] max-[1180px]:px-[20px] h-[48px] bg-neutral-60 rounded-[999px] items-center justify-center title-2 text-neutral-00 cursor-pointer whitespace-nowrap transition-all ease-out hover:scale-[1.01]',
+    'flex min-w-[120px] px-[28px] max-[1180px]:min-w-[100px] max-[1180px]:px-[20px] h-[46px] bg-brand-600 hover:bg-brand-700 rounded-xl items-center justify-center text-sm font-bold text-white shadow-sm cursor-pointer whitespace-nowrap transition-all duration-200 ease-out active:scale-[0.98]',
+  gray: 'flex min-w-[120px] px-[28px] max-[1180px]:min-w-[100px] max-[1180px]:px-[20px] h-[46px] bg-neutral-60 hover:brightness-[0.97] rounded-xl items-center justify-center text-sm font-bold text-white cursor-pointer whitespace-nowrap transition-all ease-out active:scale-[0.98]',
   white:
-    'flex min-w-[120px] px-[32px] max-[1180px]:min-w-[100px] max-[1180px]:px-[20px] h-[48px] bg-neutral-00 rounded-[999px] items-center justify-center title-2 text-neutral-80 border border-neutral-80 cursor-pointer whitespace-nowrap transition-all ease-out hover:scale-[1.01]',
+    'flex min-w-[120px] px-[28px] max-[1180px]:min-w-[100px] max-[1180px]:px-[20px] h-[46px] bg-white hover:bg-neutral-10 rounded-xl items-center justify-center text-sm font-bold text-neutral-80 border border-border cursor-pointer whitespace-nowrap transition-all ease-out active:scale-[0.98]',
 }
 
-export function UserButton({ type, text, textList, priceErrorMessage }: UserButtonConfig) {
+// onReject: 협상 거부 진입점. 넘어오면 버튼 덱 끝에 붙는다(입력 단계는 인풋이 넓어 좁은 화면에서 아랫줄로 wrap).
+export function UserButton({ type, text, textList, priceErrorMessage, onReject }: UserButtonConfig & { onReject?: () => void }) {
   if (type === '') return null
 
-  return (
-    // pr-[16px]: 채팅 스크롤 영역(ChatMessage 바깥 pr-[16px])과 오른쪽 끝 정렬
-    <div className="flex w-full pb-[52px] pr-[16px]">
-      <div className="grid grid-cols-[1fr_auto_1fr] items-center w-full">
-        <div />
-        <div className="flex justify-center">
-          {type === 'one-black' && <OneBlack text={text || '확인'} />}
-          {type === 'one-gray' && <OneGray text={text || '확인'} />}
-          {type === 'black-white' && <BlackWhite textList={[textList?.[0] || '예', textList?.[1] || '아니오']} />}
-          {type === 'percent' && <Percent />}
-          {type === 'three-black' && (
-            <ThreeBlack textList={[textList?.[0] || '협력사배송', textList?.[1] || '지정택배배송', textList?.[2] || '픽업배송']} />
-          )}
-          {type === 'price' && <Price priceErrorMessage={priceErrorMessage} />}
-          {type === 'loading' && <LoadingDots />}
-        </div>
-        <div className="flex justify-end">
-          <GoToList />
-        </div>
+  // 부가정보 입력은 폼이라 가운데정렬 덱이 아니라 전체폭으로 편다. text = 저장 후 보낼 동의 문구.
+  if (type === 'extra-info') {
+    return (
+      <div className="w-full px-6 py-4 max-[1180px]:px-4">
+        <ExtraInfoBar proceedText={text || ''} />
       </div>
+    )
+  }
+
+  // 결렬 통일 폼 — 부가정보와 같은 자리(액션바)에서 전체폭으로.
+  if (type === 'reject') {
+    return (
+      <div className="w-full px-6 py-4 max-[1180px]:px-4">
+        <RejectForm />
+      </div>
+    )
+  }
+
+  // 입력 단계는 에러 말풍선이 위로 삐져나가야 해서 overflow 클리핑 제외 (버튼 덱만 가로 스크롤 허용)
+  const isInputStep = type === 'percent' || type === 'price'
+  return (
+    <div
+      className={cn(
+        'relative flex w-full flex-wrap items-center justify-center gap-3 px-6 py-4 max-[1180px]:px-4',
+        !isInputStep && 'overflow-x-auto',
+      )}
+    >
+      <div className="flex items-center justify-center gap-3">
+        {type === 'one-black' && <OneBlack text={text || '확인'} />}
+        {type === 'one-gray' && <OneGray text={text || '확인'} />}
+        {type === 'black-white' && <BlackWhite textList={[textList?.[0] || '예', textList?.[1] || '아니오']} />}
+        {type === 'percent' && <Percent />}
+        {type === 'three-black' && (
+          <ThreeBlack textList={[textList?.[0] || '협력사배송', textList?.[1] || '지정택배배송', textList?.[2] || '픽업배송']} />
+        )}
+        {type === 'price' && <Price priceErrorMessage={priceErrorMessage} />}
+        {type === 'loading' && <LoadingDots />}
+      </div>
+      {/* 오클릭 방지: 주 CTA 와 붙이지 않는다. 넓은 화면은 우측 끝 고정(가운데 CTA 는 그대로),
+          좁은 화면은 인풋 폭 때문에 같은 줄이 안 나오므로 wrap 되어 아랫줄로 내려간다. */}
+      {onReject && (
+        <button
+          className={cn(
+            style.white,
+            'min-[1180px]:absolute min-[1180px]:right-8 min-[1180px]:top-1/2 min-[1180px]:-translate-y-1/2',
+          )}
+          onClick={onReject}
+        >
+          협상 거부
+        </button>
+      )}
     </div>
   )
 }
@@ -57,16 +89,6 @@ function LoadingDots() {
   )
 }
 
-function GoToList() {
-  const navigate = useNavigate()
-  return (
-    <button className={style.goToList} onClick={() => navigate('/list')} aria-label="상품 목록으로 이동" title="상품 목록">
-      <List size={24} className="shrink-0" />
-      <span className="max-[1180px]:hidden">상품 목록</span>
-    </button>
-  )
-}
-
 function OneBlack({ text }: { text: string }) {
   const navigate = useNavigate()
   const sendMessage = useChatStore((s) => s.sendMessage)
@@ -102,6 +124,18 @@ function ThreeBlack({ textList }: { textList: [string, string, string] }) {
 
 function BlackWhite({ textList }: { textList: [string, string] }) {
   const sendMessage = useChatStore((s) => s.sendMessage)
+  // Enter = 첫 버튼(예). 입력창이 없는 선택 단계라 전역 Enter 를 잡아도 안전하다.
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === 'Enter' && !e.isComposing) {
+        e.preventDefault()
+        sendMessage(textList[0])
+      }
+    }
+    window.addEventListener('keydown', onKey)
+    return () => window.removeEventListener('keydown', onKey)
+  }, [sendMessage, textList])
+
   return (
     <div className="flex gap-3">
       <button className={style.black} onClick={() => sendMessage(textList[0])}>

frontend/src/features/chat/components/menu/Contact.tsx

@@ -1,28 +1,22 @@
-import { useState } from 'react'
-import { interactive, cn } from '@/lib'
-import { ServiceGuidePopup } from '@/features/chat/components/popup/ServiceGuidePopup'
+import { useMeQuery } from '@/apis'
 
-// 헬프데스크 — 이용 가이드 버튼 클릭 시 안내 팝업을 연다.
+// 헬프데스크 — 연락처. (안내 팝업 진입은 상단 '유의사항 및 이용방법' 섹션으로 일원화)
+// 연락처는 회사 설정(companies.settings.branding.helpdesk)에서 온다. 미등록이면 섹션 자체를 숨긴다.
 export function Contact() {
-  const [isOpen, setIsOpen] = useState(false)
+  const { data: user } = useMeQuery()
+  const helpdesk = user?.branding?.helpdesk ?? []
+  if (helpdesk.length === 0) return null
 
   return (
-    <div className="flex flex-col w-full pl-[24px] pb-[24px]">
-      <div className="flex flex-col w-full gap-2">
-        <div className="title-5 text-neutral-80">헬프 데스크</div>
-        <button
-          type="button"
-          onClick={() => setIsOpen(true)}
-          className={cn('body-5 text-neutral-80 bg-neutral-40 rounded-[8px] px-[12px] py-[6px] w-fit', interactive)}
-        >
-          이용 가이드
-        </button>
-        <div className="flex flex-col gap-1">
-          <div className="body-5 text-neutral-60">010-0000-0000</div>
-          <div className="body-5 text-neutral-60">o2odev@o2o.kr</div>
-        </div>
+    <section className="w-full pt-4">
+      <div className="border-b border-border pb-2">
+        <span className="text-[11px] font-bold tracking-wide text-neutral-60">헬프데스크</span>
       </div>
-      {isOpen && <ServiceGuidePopup onClose={() => setIsOpen(false)} />}
-    </div>
+      <div className="flex flex-col gap-1 pt-3 text-sm text-neutral-60">
+        {helpdesk.map((line) => (
+          <span key={line}>{line}</span>
+        ))}
+      </div>
+    </section>
   )
 }

frontend/src/features/chat/components/menu/Guide.tsx

@@ -1,6 +1,5 @@
 import { useState } from 'react'
 import { ChevronRight } from 'lucide-react'
-import { interactive, cn } from '@/lib'
 import { ServiceGuidePopup } from '@/features/chat/components/popup/ServiceGuidePopup'
 
 // 유의사항 및 이용방법 — 클릭 시 안내 팝업을 연다.
@@ -12,13 +11,12 @@ export function Guide() {
       <button
         type="button"
         onClick={() => setIsOpen(true)}
-        className={cn(
-          'flex w-full bg-white rounded-[28px] py-[20px] pl-[24px] pr-[16px] justify-between items-center text-left',
-          interactive,
-        )}
+        className="flex w-full items-center justify-between border-b border-border pb-2 text-left transition-colors hover:border-neutral-40"
       >
-        <span className="menu-title text-neutral-80 break-keep">유의사항 및 이용방법</span>
-        <ChevronRight size={20} className="text-neutral-70" />
+        <span className="text-[11px] font-bold tracking-wide text-neutral-60 break-keep">
+          유의사항 및 이용방법
+        </span>
+        <ChevronRight size={16} className="text-neutral-50" />
       </button>
       {isOpen && <ServiceGuidePopup onClose={() => setIsOpen(false)} />}
     </>

frontend/src/features/chat/components/menu/MDInformation.tsx

@@ -22,39 +22,33 @@ export function MDInformation({ isOpen, setIsOpen }: Props) {
   if (memoArray.length === 0) return null
 
   return (
-    <div className="flex flex-col w-full min-w-[200px]">
-      <div className="bg-white rounded-[28px]">
-        <div className={cn('flex items-center w-full h-[4.75rem] px-4 pl-6', isOpen ? 'pt-6 pb-3' : 'py-6')}>
-          <div className="flex items-center flex-1 justify-between">
-            <div className="menu-title text-neutral-80">MD 안내사항</div>
-            <button
-              type="button"
-              aria-expanded={isOpen}
-              onClick={() => setIsOpen(!isOpen)}
-              className="flex items-center justify-center w-10 h-10 cursor-pointer text-neutral-70"
-            >
-              <ChevronDown size={20} className={cn('transition-transform duration-300', !isOpen && 'rotate-180')} />
-            </button>
-          </div>
-        </div>
+    <section className="w-full">
+      <button
+        type="button"
+        aria-expanded={isOpen}
+        onClick={() => setIsOpen(!isOpen)}
+        className="flex w-full items-center justify-between border-b border-border pb-2"
+      >
+        <span className="text-[11px] font-bold tracking-wide text-neutral-60">구매담당자 안내사항</span>
+        <ChevronDown
+          size={16}
+          className={cn('text-neutral-50 transition-transform duration-300', !isOpen && '-rotate-90')}
+        />
+      </button>
 
-        <div
-          className={cn(
-            'flex flex-col items-start gap-[19px] w-full px-6 overflow-hidden transition-all duration-300 ease-in-out',
-            isOpen ? 'max-h-[200px] pb-8 opacity-100' : 'max-h-0 pb-0 opacity-0',
-          )}
-        >
-          <div className={cn('flex flex-col gap-2 items-start self-stretch max-h-[200px] break-keep', isOpen ? 'overflow-y-auto' : 'overflow-hidden')}>
+      {isOpen && (
+        <div className="max-h-[220px] animate-fade-in overflow-y-auto pt-3">
+          <div className="flex flex-col gap-2 break-keep">
             {memoArray.map((item, i) => (
-              <div key={i} className="flex items-start gap-2 body-3 text-neutral-70">
-                <span className="flex-shrink-0">•</span>
+              <div key={i} className="flex items-start gap-2 text-sm text-neutral-70">
+                <span className="shrink-0 text-neutral-50">•</span>
                 <div className="flex-1 whitespace-pre-wrap">{linkText(item)}</div>
               </div>
             ))}
           </div>
         </div>
-      </div>
-    </div>
+      )}
+    </section>
   )
 }
 
@@ -63,7 +57,7 @@ function linkText(text: string) {
   const isUrl = (s: string) => /^https?:\/\/[^\s]+$/.test(s)
   const parts = text.split(urlRegex)
   return (
-    <div className="body-3 text-neutral-70">
+    <div className="text-sm text-neutral-70">
       {parts.map((part, i) =>
         isUrl(part) ? (
           <a
@@ -71,7 +65,7 @@ function linkText(text: string) {
             href={part}
             target="_blank"
             rel="noopener noreferrer"
-            className="block text-info underline cursor-pointer hover:brightness-95 transition-all"
+            className="block text-brand-600 underline transition-all hover:brightness-95"
           >
             상품 사이트로 이동
           </a>

frontend/src/features/chat/components/menu/MenuSection.tsx

@@ -1,16 +1,24 @@
 import { useState } from 'react'
+import { cn } from '@/lib'
 import { MDInformation } from '@/features/chat/components/menu/MDInformation'
 import { NegoStep } from '@/features/chat/components/menu/NegoStep'
 import { Guide } from '@/features/chat/components/menu/Guide'
 import { Contact } from '@/features/chat/components/menu/Contact'
 
-export function MenuSection() {
+// rail = 데스크톱 우측 고정 패널(lg+), drawer = 모바일 드로어 내부.
+// 보고서식: 박스 카드가 아니라 하나의 흰 패널 안에 납작한 섹션들을 쌓는다.
+export function MenuSection({ variant = 'rail' }: { variant?: 'rail' | 'drawer' }) {
   const [isMDOpen, setIsMDOpen] = useState(true)
   const [isStepOpen, setIsStepOpen] = useState(true)
 
+  const wrap =
+    variant === 'rail'
+      ? 'hidden lg:flex flex-col w-[300px] max-[1350px]:w-[280px] max-[1180px]:w-[260px] h-full overflow-y-auto bg-white border-l border-border px-5 pt-6 pb-4'
+      : 'flex flex-col w-full p-5'
+
   return (
-    <div className="flex flex-col w-[360px] max-[1350px]:w-[320px] max-[1180px]:w-[280px] h-full pt-[64px] pr-[24px]">
-      <div className="flex flex-col flex-1 gap-[28px]">
+    <div className={cn(wrap)}>
+      <div className="flex flex-1 flex-col gap-6">
         <MDInformation isOpen={isMDOpen} setIsOpen={setIsMDOpen} />
         <NegoStep isOpen={isStepOpen} setIsOpen={setIsStepOpen} />
         <Guide />

frontend/src/features/chat/components/menu/NegoStep.tsx

@@ -1,52 +1,77 @@
-import { ChevronDown } from 'lucide-react'
+import { Check, ChevronDown } from 'lucide-react'
 import { cn } from '@/lib'
 import { useChatStore } from '@/features/chat/stores/useChatStore'
+import { STEPS } from '@/features/chat/lib/negoSteps'
 
 interface Props {
   isOpen: boolean
   setIsOpen: (isOpen: boolean) => void
 }
 
-const STEPS = ['서비스안내', '담당자확인', '협상품목안내', '가격협상', '협상종료']
-
 export function NegoStep({ isOpen, setIsOpen }: Props) {
   const chats = useChatStore((s) => s.messages)
   const currentStep = chats[chats.length - 1]?.display_step || '서비스안내'
+  const currentIndex = Math.max(
+    0,
+    STEPS.findIndex((s) => s.name === currentStep),
+  )
 
   return (
-    <div className="flex flex-col w-full min-w-[200px]">
-      <div className="bg-white rounded-[28px]">
-        <div className={cn('flex items-center w-full h-[4.75rem] px-4 pl-6', isOpen ? 'pt-6 pb-3' : 'py-6')}>
-          <div className="flex items-center flex-1 justify-between">
-            <div className="menu-title text-neutral-80">협상절차</div>
-            <button
-              type="button"
-              aria-expanded={isOpen}
-              onClick={() => setIsOpen(!isOpen)}
-              className="flex items-center justify-center w-10 h-10 cursor-pointer text-neutral-70"
-            >
-              <ChevronDown size={20} className={cn('transition-transform duration-300', !isOpen && 'rotate-180')} />
-            </button>
-          </div>
-        </div>
+    <section className="w-full">
+      <button
+        type="button"
+        aria-expanded={isOpen}
+        onClick={() => setIsOpen(!isOpen)}
+        className="flex w-full items-center justify-between border-b border-border pb-2"
+      >
+        <span className="text-[11px] font-bold tracking-wide text-neutral-60">협상절차</span>
+        <ChevronDown
+          size={16}
+          className={cn('text-neutral-50 transition-transform duration-300', !isOpen && '-rotate-90')}
+        />
+      </button>
 
-        <div
-          className={cn(
-            'flex flex-col items-start gap-[19px] w-full px-6 overflow-hidden transition-all duration-300 ease-in-out',
-            isOpen ? 'max-h-[200px] pb-8 opacity-100' : 'max-h-0 pb-0 opacity-0',
-          )}
-        >
-          <div className="flex flex-col gap-2 items-start self-stretch break-keep">
-            {STEPS.map((step, i) => (
-              <div key={step} className="flex items-start gap-2">
-                <div className={cn('body-3 text-neutral-80', currentStep === step && 'font-bold')}>
-                  {i + 1}. {step}
+      {isOpen && (
+        <div className="animate-fade-in pt-4">
+          <div className="relative">
+            {/* 세로 레일 */}
+            <span className="absolute left-[9px] top-3 bottom-3 w-0.5 bg-neutral-20" />
+            {STEPS.map((step, i) => {
+              const done = i < currentIndex
+              const current = i === currentIndex
+              return (
+                <div key={step.name} className="relative flex items-start gap-3 py-1.5">
+                  <div
+                    className={cn(
+                      'z-10 mt-0.5 flex size-5 shrink-0 items-center justify-center rounded-full text-[10px] font-bold transition-all',
+                      done && 'bg-success text-white',
+                      current && 'scale-110 bg-brand-600 text-white ring-4 ring-brand-light',
+                      !done && !current && 'border border-border bg-white text-neutral-50',
+                    )}
+                  >
+                    {done ? <Check className="size-3" strokeWidth={3} /> : i + 1}
+                  </div>
+                  <div className="min-w-0">
+                    <p
+                      className={cn(
+                        'text-xs leading-tight',
+                        current && 'font-extrabold text-brand-600',
+                        done && 'font-semibold text-success',
+                        !done && !current && 'font-medium text-neutral-80',
+                      )}
+                    >
+                      {step.name}
+                    </p>
+                    <p className={cn('mt-0.5 text-[10px] leading-snug', current ? 'text-brand-600/80' : 'text-neutral-50')}>
+                      {step.desc}
+                    </p>
+                  </div>
                 </div>
-              </div>
-            ))}
+              )
+            })}
           </div>
         </div>
-      </div>
-    </div>
+      )}
+    </section>
   )
 }

frontend/src/features/chat/components/popup/GuideContent.tsx

@@ -1,91 +1,69 @@
 import type { ReactNode } from 'react'
-import { useChatInitStore } from '@/features/chat/stores/useChatInitStore'
+import { useMeQuery } from '@/apis'
 
 // 협상 유의사항 및 서비스 이용 방법 안내 — 팝업 2종(자동 안내/메뉴 가이드)이 공유하는 본문.
-// VAT/배송비 문구는 채팅 init 메타(useChatInitStore)를 읽어 상품별로 동적 표시한다.
-// break-keep: 한국어 단어가 중간에서 잘려 줄바꿈되지 않도록 한다.
-const textStyle = 'text-[17px] font-normal leading-[150%] tracking-[-0.34px] text-neutral-90 break-keep'
+// 항목은 회사 설정(companies.settings.guide_notices)에서 오고, 비어 있으면 아래 기본 문구를 쓴다.
+const bodyStyle = 'text-sm font-normal leading-relaxed text-neutral-70 break-keep'
+
+// negodata 회사 설정의 "기본 문구 불러오기" 값과 동일해야 한다
+// (원본: negodata/front/src/features/settings/catalog.ts DEFAULT_GUIDE_NOTICES).
+// VAT·배송비 조건은 상품마다 달라 기본 문구에서 뺐다 — 필요한 회사가 항목으로 직접 넣는다.
+const DEFAULT_NOTICES = [
+  '협상 개시는 협상 참여 버튼을 클릭하는 순간부터 시작됩니다.',
+  '부여된 협상 시간에 응찰하지 않는 경우, 협상 참여의사가 없는 것으로 간주하여 재견적으로 진행될 수 있습니다.',
+  '본 협상 결과에 대해서는 협상자와 협상대상자 간의 비밀 유지 조건으로 진행되고, 협상에서 얻어진 결과나 내용에 대해서는 당사자를 제외하고 제 3자에 공유할 수 없으며, 비밀 유지를 전제로 진행됩니다.',
+  '협상이 종결되면 특별한 사유 없이 취소 변경이 불가하니, 신중하게 협상에 참여해 주시기 바랍니다.',
+  '안내된 사항 외 부분은 기존 견적 프로세스와 동일한 부분 유의 바랍니다.',
+]
 
 function Bullet({ children }: { children: ReactNode }) {
   return (
-    <div className="flex items-start py-[6px]">
-      <p className="ml-[8px] mr-[6px] flex-shrink-0">•</p>
-      <div className={`${textStyle} flex-1`}>{children}</div>
+    <div className="flex items-start gap-2.5 py-1.5">
+      <span className="mt-[7px] size-1.5 shrink-0 rounded-full bg-brand-600" />
+      <div className={`${bodyStyle} flex-1`}>{children}</div>
     </div>
   )
 }
 
 export function GuideContent() {
-  const { item_vat_yn, item_delivery_fee_yn } = useChatInitStore()
-  // init 미로드/값 없음 → 보수적 기본값 (KT-NEGOWIZ 와 동일한 폴백 규칙)
-  const vat = item_vat_yn || 'VAT별도'
-  const deliveryFee = item_delivery_fee_yn || '배송비별도'
+  const { data: user } = useMeQuery()
+  const notices = user?.guideNotices?.length ? user.guideNotices : DEFAULT_NOTICES
 
   return (
     <div className="flex w-full flex-col">
-      <div className="headline-3 mb-10 break-keep text-center text-neutral-90">
+      <div className="mb-5 break-keep text-center text-base font-bold text-neutral-90">
         협상 유의 사항 및 서비스 이용 방법 안내
       </div>
 
-      <div className="flex flex-col items-start">
-        <div className={`${textStyle} mb-2`}>
-          협상과 관련하여 다음 사항을 참고하여 견적에 참여해 주시기 바랍니다.
-        </div>
+      <div className={`${bodyStyle} mb-2`}>
+        협상과 관련하여 다음 사항을 참고하여 견적에 참여해 주시기 바랍니다.
+      </div>
 
-        <Bullet>
-          협상 개시는&nbsp;
-          <span className="font-bold">Negosium 시스템의 협상 참여 버튼을 클릭하는 순간부터 시작</span>
-          됩니다.
-        </Bullet>
-
-        <Bullet>
-          부여된 협상 시간에&nbsp;
-          <span className="font-bold">
-            응찰하지 않는 경우, 협상 참여의사가 없는 것으로 간주하여 재견적으로 진행
-          </span>
-          될 수 있습니다.
-        </Bullet>
-
-        <Bullet>
-          협상에 입력되는 모든 가격은&nbsp;
-          <span className="font-bold text-negative">
-            {vat} 및 {deliveryFee}
-          </span>
-          &nbsp;기준이며,&nbsp;
-          <span className="font-bold">
-            할인을 요청하는 경우 기존 공급가격에 할인율이 적용된 가격으로 환산
-          </span>
-          되어 제시됩니다.
-        </Bullet>
-
-        <Bullet>
-          본 협상 결과에 대해서는 협상자와 협상대상자 간의 비밀 유지 조건으로 진행되고, 협상에서
-          얻어진 결과나 내용에 대해서는 당사자를 제외하고 제 3자에 공유할 수 없으며, 비밀 유지를
-          전제로 진행됩니다.
-        </Bullet>
-
-        <Bullet>
-          협상이 종결되면 특별한 사유 없이 취소 변경이 불가하니, 신중하게 협상에 참여해 주시기
-          바랍니다.
-        </Bullet>
-
-        <Bullet>안내된 사항 외 부분은 기존 견적 프로세스와 동일한 부분 유의 바랍니다.</Bullet>
+      <div className="flex flex-col divide-y divide-border/60 rounded-xl border border-border px-4 py-1">
+        {notices.map((notice) => (
+          <Bullet key={notice}>{notice}</Bullet>
+        ))}
       </div>
     </div>
   )
 }
 
-// 하단 문의 안내 박스
+// 하단 문의 안내 박스 — 연락처는 회사 설정(branding.helpdesk). 미등록이면 박스를 통째로 숨긴다.
 export function GuideContactBox() {
+  const { data: user } = useMeQuery()
+  const helpdesk = user?.branding?.helpdesk ?? []
+  if (helpdesk.length === 0) return null
+
   return (
-    <div className="flex w-full flex-col items-center gap-2 rounded-[16px] bg-neutral-10 p-6">
-      <div className={`${textStyle} text-center`}>
-        기타 협상과정에서 궁금한 사항이나 문의하실 사항은 아래의 연락처로 상담을 부탁드립니다.
-      </div>
-      {/* textStyle 의 font-normal 과 같은 요소에서 충돌하지 않도록 bold 는 별도 조합으로 준다 */}
-      <div className="break-keep text-center text-[17px] font-bold leading-[150%] tracking-[-0.34px] text-neutral-90">
-        헬프데스크 010-0000-0000, 이메일: o2odev@o2o.kr
+    <div className="flex w-full flex-col items-center gap-1.5 rounded-xl bg-neutral-10 p-4">
+      <div className={`${bodyStyle} text-center`}>
+        기타 협상 과정에서 궁금하거나 문의하실 사항은 아래 연락처로 상담 부탁드립니다.
       </div>
+      {helpdesk.map((line) => (
+        <div key={line} className="break-keep text-center text-sm font-bold text-neutral-90">
+          {line}
+        </div>
+      ))}
     </div>
   )
 }

frontend/src/features/chat/components/popup/RejectPopup.tsx

@@ -0,0 +1,35 @@
+import { useNavigate } from 'react-router'
+import { RejectPopup as RejectPopupForm } from '@/components'
+import { getApiErrorMessage, useRejectMutation } from '@/apis'
+import { toast } from '@/lib'
+import { useChatStore } from '@/features/chat/stores/useChatStore'
+import { useChatInitStore } from '@/features/chat/stores/useChatInitStore'
+
+// 협상 진행 중 거부 — 폼은 목록 거부와 공용이고, 여기서는 대화 세션에 붙여 제출·이탈만 처리한다.
+export function RejectPopup({ onClose }: { onClose: () => void }) {
+  const navigate = useNavigate()
+  const reject = useRejectMutation()
+  const sessionId = useChatStore((s) => s.sessionId)
+  const itemVatYn = useChatInitStore((s) => s.item_vat_yn)
+
+  return (
+    <RejectPopupForm
+      onClose={onClose}
+      isPending={reject.isPending}
+      isVatExcluded={itemVatYn === 'VAT별도'}
+      onSubmit={(request) =>
+        reject.mutate(
+          { sessionId, request },
+          {
+            onSuccess: () => {
+              onClose()
+              toast.warning('협상 거부가 완료되었습니다.')
+              navigate('/list')
+            },
+            onError: (error) => toast.error(getApiErrorMessage(error, '거부 처리에 실패했습니다.')),
+          },
+        )
+      }
+    />
+  )
+}

frontend/src/features/chat/components/popup/ServiceGuidePopup.tsx

@@ -7,19 +7,19 @@ import { GuideContent, GuideContactBox } from './GuideContent'
 export function ServiceGuidePopup({ onClose }: { onClose: () => void }) {
   return (
     <Modal onClose={onClose}>
-      <div className="flex max-h-[90vh] w-full max-w-[1000px] flex-col items-end gap-6 overflow-y-auto rounded-3xl bg-white px-12 pb-[56px] pt-8">
+      <div className="m-4 flex max-h-[90vh] w-full max-w-[720px] flex-col items-end gap-4 overflow-y-auto rounded-2xl border border-border bg-white px-6 pb-10 pt-6 shadow-xl animate-scale-in sm:px-12">
         <button
           type="button"
           aria-label="닫기"
           onClick={onClose}
           className={cn(
-            'flex size-10 flex-shrink-0 items-center justify-center rounded-full bg-neutral-10',
+            'flex size-9 flex-shrink-0 items-center justify-center rounded-full bg-neutral-10 text-neutral-70 hover:bg-neutral-20',
             interactive,
           )}
         >
-          <X size={20} className="text-neutral-80" />
+          <X size={20} />
         </button>
-        <div className="flex w-full flex-col gap-6 px-[40px]">
+        <div className="flex w-full flex-col gap-6">
           <GuideContent />
           <GuideContactBox />
         </div>

frontend/src/features/chat/components/popup/ServiceInfoPopup.tsx

@@ -10,8 +10,8 @@ interface ServiceInfoPopupProps {
 }
 
 const buttonStyle = cn(
-  'flex h-[50px] w-[168px] items-center justify-center rounded-full',
-  'border border-neutral-30 bg-white title-5 text-neutral-70',
+  'flex h-[46px] flex-1 sm:flex-none sm:w-[168px] items-center justify-center rounded-xl',
+  'border border-border bg-white text-sm font-bold text-neutral-70 hover:bg-neutral-10',
   interactive,
 )
 
@@ -20,13 +20,13 @@ export function ServiceInfoPopup({ isOpen, onNeverShowAgain, onCloseToday }: Ser
   if (!isOpen) return null
 
   return (
-    <div className="fixed inset-0 z-50 flex items-center justify-center bg-[rgba(0,0,0,0.40)] p-4">
-      <div className="flex max-h-[90vh] w-full max-w-[1000px] flex-col overflow-y-auto rounded-[24px] bg-white px-[80px] pb-[48px] pt-[56px]">
+    <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/50 p-4 backdrop-blur-[2px]">
+      <div className="flex max-h-[90vh] w-full max-w-[720px] flex-col overflow-y-auto rounded-2xl border border-border bg-white px-6 pb-6 pt-8 shadow-xl animate-scale-in sm:px-12 sm:pt-10">
         <div className="mb-6 flex w-full flex-col gap-5">
           <GuideContent />
           <GuideContactBox />
         </div>
-        <div className="flex w-full justify-center gap-3">
+        <div className="flex w-full justify-center gap-2 sm:gap-3">
           <button type="button" className={buttonStyle} onClick={onNeverShowAgain}>
             안내 보지 않기
           </button>

frontend/src/features/chat/components/templates/BidSummary.tsx

@@ -1,61 +1,77 @@
-import { numberToKorean } from '@/features/chat/lib/koreanNumber'
+import { CheckCircle2 } from 'lucide-react'
+import { numberToKorean } from '@/lib'
+import { useMeQuery } from '@/apis'
+import type { SessionField } from '@/apis/auth/auth.type'
+import { useChatInitStore } from '@/features/chat/stores/useChatInitStore'
 
 interface BidSummaryProps {
   itemName: string
   itemCode: string
   bidPrice: number
-  deliveryType: string
-  isVAT: boolean
 }
 
-// 투찰 결과 요약 카드
-export function BidSummary({ itemName, itemCode, bidPrice, deliveryType, isVAT }: BidSummaryProps) {
-  return (
-    <div className="flex flex-col w-full p-10 bg-neutral-00 rounded-[28px] gap-4">
-      <h1 className="headline-3 text-neutral-90">투찰 결과 요약</h1>
-      <BidItem title="상품명" value={itemName || '-'} />
-      <BidItem title="상품 코드" value={itemCode || '-'} />
-      <BidPrice title="투찰 가격" number={bidPrice || 0} isVAT={isVAT} />
-      <BidItem title="배송형태" value={deliveryType || '-'} />
-    </div>
-  )
+// 부가정보 값 표시 포맷(불리언→예/아니오, 숫자→천단위, 그 외→문자열)
+function formatFieldValue(type: SessionField['type'], value: unknown): string {
+  if (type === 'boolean') return value ? '예' : '아니오'
+  if (type === 'number') return Number(value).toLocaleString()
+  return String(value)
 }
 
-function BidItem({ title, value }: { title: string; value: string }) {
+// 투찰 결과 요약 카드 (보고서식 final-summary)
+// 공급사가 마무리에서 입력한 부가정보(회사설정 session_fields + 의견)가 있으면 함께 표시한다(입력완료 시 요약 갱신).
+export function BidSummary({ itemName, itemCode, bidPrice }: BidSummaryProps) {
+  // VAT 표기는 회사 설정 기준(item_vat_yn). vat_yn 미관리(hidden)면 비어 라벨을 생략한다.
+  const item_vat_yn = useChatInitStore((s) => s.item_vat_yn)
+  const custom = useChatInitStore((s) => s.custom)
+  const { data: user } = useMeQuery()
+  const fields: SessionField[] = user?.sessionFields ?? []
+  const priceStr = (bidPrice || 0).toLocaleString()
+
+  // 부가정보(회사설정 session_fields) — 완료 요약엔 구조를 항상 노출(미입력 값은 '-')
+  const extraRows = fields.map((f) => {
+    const v = custom?.[f.key]
+    const has = v !== undefined && v !== null && v !== ''
+    return { key: f.key, label: f.label, value: has ? formatFieldValue(f.type, v) : '-' }
+  })
+  const opinion = custom?.opinion ? String(custom.opinion) : ''
+
   return (
-    <div className="flex items-start gap-2">
-      <Dot />
-      <div className="flex flex-1 whitespace-pre-wrap">
-        <span className="body-1-read-b">{title} :</span>
-        <div className="flex body-1-read-r">&nbsp;{value}</div>
+    <div className="w-full rounded-2xl border-2 border-brand-light bg-white p-5 shadow-md">
+      <div className="mb-4 flex items-center gap-2">
+        <CheckCircle2 className="size-5 text-success" />
+        <h3 className="text-sm font-bold text-neutral-90">투찰 결과 요약</h3>
       </div>
-    </div>
-  )
-}
 
-function BidPrice({ number, isVAT, title }: { number: number; isVAT: boolean; title: string }) {
-  const numberString = number.toLocaleString()
-  return (
-    <div className="flex items-start gap-2">
-      <Dot />
-      <div className="flex flex-1">
-        <div className="body-1-read-b flex flex-shrink-0">{title} :</div>
-        <div className="flex flex-1 flex-wrap">
-          <span className="body-1-read-b text-negative break-keep">&nbsp;{numberString}원</span>
-          <span className="body-1-read-b text-neutral-90 break-keep">
-            &nbsp;({numberToKorean(parseInt(numberString.replace(/,/g, '')))}원)
+      <div className="divide-y divide-border/60 rounded-xl border border-border">
+        <Row label="상품명" value={itemName || '-'} />
+        <Row label="상품 코드" value={itemCode || '-'} mono />
+        <div className="flex items-start justify-between gap-3 px-4 py-3">
+          <span className="shrink-0 text-sm text-neutral-60">투찰 가격</span>
+          <span className="min-w-0 flex-1 break-keep text-right text-sm">
+            <span className="font-bold text-[#E5484D]">{priceStr}원</span>
+            <span className="text-neutral-70"> ({numberToKorean(bidPrice || 0)}원)</span>
+            {item_vat_yn ? <span className="text-neutral-70"> {item_vat_yn}</span> : null}
           </span>
-          <span className="body-1-read-b text-neutral-90 break-keep">&nbsp;{isVAT ? 'VAT포함' : 'VAT별도'}</span>
         </div>
+        {extraRows.map((r) => (
+          <Row key={r.key} label={r.label} value={r.value} />
+        ))}
+        {/* 의견은 타결·결렬 공통 기본 필드 — 값이 없어도 항상 표시 */}
+        <Row label="의견" value={opinion || '-'} />
       </div>
     </div>
   )
 }
 
-function Dot() {
+function Row({ label, value, mono }: { label: string; value: string; mono?: boolean }) {
   return (
-    <div className="flex justify-end items-center w-[26px] h-[30px]">
-      <p className="body-1-read-r">•</p>
+    <div className="flex items-start justify-between gap-3 px-4 py-3">
+      <span className="shrink-0 text-sm text-neutral-60">{label}</span>
+      <span
+        className={`min-w-0 flex-1 break-keep text-right text-sm font-semibold text-neutral-90 ${mono ? 'font-mono' : ''}`}
+      >
+        {value}
+      </span>
     </div>
   )
 }

frontend/src/features/chat/components/templates/Indicator.tsx

@@ -1,78 +1,31 @@
-import { cn } from '@/lib'
-
-// 협상 성공률 바 (0~100%). 구간별 색: 빨강(~30) / 주황(~70) / 초록(70~)
-function selectBgColor(index: number, currentStep: number): string {
-  let fill = '#E71C3B'
-  if (currentStep > 3 && currentStep <= 7) fill = '#FDB21C'
-  if (currentStep > 7) fill = '#16BD14'
-  return index <= currentStep ? fill : '#ddd'
-}
-
-function UnitBlock({ blockIndex, percent }: { blockIndex: number; percent: number }) {
-  const minBlockPercent = blockIndex * 10
-  const maxBlockPercent = (blockIndex + 1) * 10
-  const remindCount = percent - minBlockPercent
-
-  let nodeType: 'fill' | 'empty' | 'half' = 'empty'
-  if (maxBlockPercent < percent) nodeType = 'fill'
-  else if (minBlockPercent <= percent) nodeType = 'half'
-
-  return (
-    <div className="flex flex-col items-center flex-1">
-      <div className="flex w-full h-3">
-        {Array.from({ length: 10 }).map((_, i) => {
-          let color = selectBgColor(blockIndex, Math.floor(percent / 10))
-          if (nodeType === 'half' && i >= remindCount) color = '#ddd'
-
-          const subBlockPercent = blockIndex * 10 + i + 1
-          const isTarget = subBlockPercent === percent
-          const isLeftAlign = percent < 90
-
-          return (
-            <div key={i} className="flex-1 h-full rounded-[1px] relative" style={{ backgroundColor: color }}>
-              {isTarget && (
-                <div className="pointer-events-none absolute bottom-full -top-4 left-1/2 -translate-x-1/2 z-10">
-                  <div className="relative w-0 h-0">
-                    <div className="absolute -top-2 left-[calc(50%+4px)] -translate-x-1/2 w-0 h-0 border-l-[8px] border-r-[8px] border-t-[14px] border-l-transparent border-r-transparent border-t-black" />
-                    <span
-                      className={cn(
-                        'absolute top-[calc(50%-2px)] -translate-y-1/2 text-[24px] leading-none font-bold tabular-nums text-black whitespace-nowrap',
-                        isLeftAlign ? 'left-[18px]' : 'right-[10px]',
-                      )}
-                    >
-                      {percent}%
-                    </span>
-                  </div>
-                </div>
-              )}
-            </div>
-          )
-        })}
-      </div>
-    </div>
-  )
-}
-
+// 협상 성공률 카드 (0~100%). 10칸 컬러 블록바 — 구간별 색(빨강→주황→초록)으로 채운다.
 export function Indicator({ number }: { number: number }) {
   const percent = Math.min(Math.max(number, 0), 100)
+  const filled = Math.round(percent / 10) // 0~10칸
+  const color = percent < 40 ? '#F04452' : percent < 70 ? '#F5A623' : '#0B8F57'
 
   return (
-    <div className="flex w-full flex-col gap-3 bg-neutral-00 rounded-[28px] px-10 py-[36px]">
-      <h1 className="title-1 text-neutral-90">협상 성공률</h1>
-      <div className="flex flex-col gap-2">
-        {percent === 0 ? (
-          <div className="relative h-6">
-            <div className="absolute left-[20px] -translate-x-1/2 text-xl text-black font-bold">▼&nbsp;0%</div>
-          </div>
-        ) : (
-          <div className="h-6" />
-        )}
-        <div className="flex gap-1">
-          {Array.from({ length: 10 }).map((_, i) => (
-            <UnitBlock key={i} blockIndex={i} percent={percent} />
-          ))}
-        </div>
+    <div className="w-full rounded-2xl border border-border bg-white p-5 shadow-sm">
+      <div className="flex items-center justify-between">
+        <h3 className="text-sm font-bold text-neutral-90">협상 성공률</h3>
+        <span className="font-mono text-base font-extrabold" style={{ color }}>
+          {percent}%
+        </span>
       </div>
+
+      <div className="mt-3 flex gap-1">
+        {Array.from({ length: 10 }).map((_, i) => (
+          <div
+            key={i}
+            className="h-3.5 flex-1 rounded-[3px] transition-colors duration-300"
+            style={{ backgroundColor: i < filled ? color : 'var(--neutral-20)' }}
+          />
+        ))}
+      </div>
+
+      <p className="mt-2 text-xs text-neutral-60">
+        협상이 진행될수록 성공률이 실시간으로 갱신됩니다.
+      </p>
     </div>
   )
 }

frontend/src/features/chat/components/templates/OtherReason.tsx

@@ -10,6 +10,7 @@ export function OtherReason({
   onChange,
   isError,
   disabled,
+  onSubmit,
 }: {
   inputValue: string
   setInputValue: (value: string) => void
@@ -18,6 +19,7 @@ export function OtherReason({
   onChange: (value: string) => void
   isError: boolean
   disabled?: boolean
+  onSubmit?: () => void
 }) {
   const isChecked = selectedValue === '기타'
   const ref = useRef<HTMLTextAreaElement>(null)
@@ -39,19 +41,20 @@ export function OtherReason({
   const isTextareaDisabled = disabled || !isChecked
 
   return (
-    <div className="flex flex-col gap-1">
-      <div className="flex items-start gap-2">
-        <label className={cn('flex items-start gap-2 flex-shrink-0', disabled ? 'cursor-not-allowed' : 'cursor-pointer')}>
-          <input
+    <div className="flex flex-col gap-1.5">
+      <div className="flex items-start gap-2.5">
+        <label className={cn('flex shrink-0 items-start gap-2.5', disabled ? 'cursor-not-allowed' : 'cursor-pointer')}>
+          <span
             className={cn(
-              'appearance-none w-[16px] h-[16px] mt-[10px] flex-shrink-0 rounded-full border-[1.5px]',
-              disabled ? 'cursor-not-allowed' : 'cursor-pointer',
-              isChecked
-                ? 'border-neutral-70 bg-[radial-gradient(circle,var(--neutral-70)_40%,white_40%)]'
-                : isError
-                  ? 'border-negative bg-white'
-                  : 'border-neutral-60 bg-white',
+              'mt-0.5 flex size-[18px] shrink-0 items-center justify-center rounded-full border-2 transition-colors',
+              isChecked ? 'border-brand-600' : isError ? 'border-negative' : 'border-neutral-40',
+              disabled && 'opacity-60',
             )}
+          >
+            {isChecked && <span className="size-2.5 rounded-full bg-brand-600" />}
+          </span>
+          <input
+            className="sr-only"
             type="radio"
             name="rejectrsp"
             value="기타"
@@ -59,26 +62,33 @@ export function OtherReason({
             onChange={(e) => onChange(e.target.value)}
             disabled={disabled}
           />
-          <div className={cn('reject break-keep whitespace-nowrap mt-[4px] flex', disabled && 'text-neutral-60')}>
-            기타
-          </div>
+          <span className={cn('text-sm text-neutral-80', disabled && 'text-neutral-50')}>기타</span>
         </label>
         <textarea
           ref={ref}
           className={cn(
-            'w-full px-3 py-2 body-3 resize-none border border-neutral-40 rounded-[8px] outline-none transition-all duration-200 placeholder:text-neutral-60 focus:border-neutral-70 focus:outline-none',
-            isTextareaDisabled ? 'bg-neutral-10 text-neutral-60 cursor-not-allowed' : 'bg-white text-neutral-90',
+            'w-full resize-none rounded-xl border px-3 py-2 text-sm outline-none transition-all placeholder:text-neutral-50',
+            isTextareaDisabled
+              ? 'cursor-not-allowed border-border bg-neutral-10 text-neutral-50'
+              : 'border-border bg-white text-neutral-90 focus:border-brand-600 focus:ring-1 focus:ring-brand-600',
             errorMessage && 'border-negative',
           )}
           value={inputValue}
           onChange={(e) => setInputValue(e.target.value)}
+          onKeyDown={(e) => {
+            // Enter=제출, Shift+Enter=줄바꿈. 한글 조합 중 Enter 는 무시.
+            if (e.key === 'Enter' && !e.shiftKey && !e.nativeEvent.isComposing && onSubmit) {
+              e.preventDefault()
+              onSubmit()
+            }
+          }}
           placeholder="제시한 가격을 수용할 수 없는 이유를 작성해주세요."
           disabled={isTextareaDisabled}
           rows={1}
-          style={{ minHeight: '35px', lineHeight: '20px' }}
+          style={{ minHeight: '38px', lineHeight: '20px' }}
         />
       </div>
-      {errorMessage && <div className="body-5 text-negative pl-[65px]">{errorMessage}</div>}
+      {errorMessage && <div className="pl-[30px] text-xs font-medium text-negative">{errorMessage}</div>}
     </div>
   )
 }

frontend/src/features/chat/components/templates/RejectCM.tsx

@@ -1,115 +0,0 @@
-import { useState, useMemo } from 'react'
-import { cn } from '@/lib'
-import { numberToKorean } from '@/features/chat/lib/koreanNumber'
-import { findRestoreScript, extractPart } from '@/features/chat/lib/rejectForm'
-import { SelectRadio, SubmitButton } from '@/features/chat/components/templates/rejectControls'
-import { useChatStore } from '@/features/chat/stores/useChatStore'
-import { useChatInitStore } from '@/features/chat/stores/useChatInitStore'
-
-const MAX_PRICE = 999999999999999
-
-// 재견적 실패 시: 최종 공급 희망 가격 + 배송 형태 입력 폼
-export function RejectCM() {
-  const isLoading = useChatStore((s) => s.isLoading)
-  const sendMessage = useChatStore((s) => s.sendMessage)
-  const messages = useChatStore((s) => s.messages)
-  const item_vat_yn = useChatInitStore((s) => s.item_vat_yn)
-  const isVAT = item_vat_yn === 'VAT별도'
-
-  // 폼 값은 이전 제출 내역에서 1회만 복원 (setter 미사용 = lazy 초기화 전용)
-  const restored = useState(() => findRestoreScript(messages, 'rejectCM'))[0]
-  const [price, setPrice] = useState(() => extractPart(restored, '공급희망가격-'))
-  const [selectedReason, setSelectedReason] = useState(() => extractPart(restored, '배송형태-'))
-  const [priceErrorMessage, setPriceErrorMessage] = useState('')
-  const [radioErrorMessage, setRadioErrorMessage] = useState('')
-
-  // 제출 완료 여부는 messages 변화에 반응해야 함 (제출 후 갱신 반영)
-  const isSubmitted = useMemo(() => Boolean(findRestoreScript(messages, 'rejectCM')), [messages])
-  const isValid = Boolean(price && parseInt(price) > 0) && Boolean(selectedReason)
-
-  const handlePriceChange = (value: string) => {
-    const numeric = value.replace(/\D/g, '')
-    if (numeric && parseInt(numeric) > MAX_PRICE) return
-    setPrice(numeric)
-    if (numeric) setPriceErrorMessage('')
-  }
-
-  const koreanPrice = (() => {
-    if (!price) return '영'
-    const n = parseInt(price)
-    return Number.isNaN(n) || n === 0 ? '영' : numberToKorean(n)
-  })()
-
-  const handleSubmit = () => {
-    setPriceErrorMessage(!price || parseInt(price) === 0 ? '가격을 입력해주세요.' : '')
-    setRadioErrorMessage(!selectedReason ? '배송 형태를 선택해주세요.' : '')
-    if (isValid && !isLoading && !isSubmitted) {
-      sendMessage(`공급희망가격-${price}, 배송형태-${selectedReason}`, 'text')
-    }
-  }
-
-  const isDisabled = isLoading || isSubmitted
-
-  return (
-    <div className="flex flex-col w-full p-10 bg-neutral-00 rounded-[28px] gap-2 transition-all duration-300">
-      <div className="flex w-full h-[48px] bg-[#CD2A2D] headline-3 text-neutral-00 rounded-[12px] items-center justify-center">
-        최종 공급 희망 가격 입력
-      </div>
-
-      <div className="reject break-keep py-2">
-        최종 공급 희망 가격과 배송 형태를 입력하여 주시기 바랍니다.
-        <br />
-        가격 검토를 통해 경쟁력 있는 가격일 경우 다시 협상에 참여할 기회가 주어지오니 신중한 가격 제안 부탁드립니다.
-      </div>
-
-      <div className="flex flex-col w-full gap-1">
-        <div className="flex w-full items-start gap-4">
-          <div className="flex reject-2 whitespace-nowrap pt-2 flex-shrink-0 w-[110px]">공급 희망 가격</div>
-          <div className="flex flex-wrap w-full items-center pt-2">
-            <div className="flex items-center gap-2">
-              <input
-                type="text"
-                className={cn(
-                  'text-right max-w-[220px] h-full max-h-[35px] border p-2 body-3 placeholder:text-neutral-60 focus:border-neutral-70 rounded-[8px] outline-none border-neutral-40',
-                  isDisabled ? 'bg-neutral-10 text-neutral-60 cursor-not-allowed' : 'bg-white text-neutral-90',
-                )}
-                value={price ? parseInt(price).toLocaleString() : ''}
-                onChange={(e) => handlePriceChange(e.target.value)}
-                placeholder="0"
-                disabled={isDisabled}
-              />
-              <div className="reject whitespace-nowrap mr-2">원{isVAT && '(VAT 별도)'}</div>
-            </div>
-            <div className="reject-gray whitespace-nowrap">[{koreanPrice} 원]</div>
-          </div>
-        </div>
-        {priceErrorMessage && <div className="body-5 text-negative pl-[126px]">{priceErrorMessage}</div>}
-      </div>
-
-      <div className="flex w-full gap-4">
-        <div className="flex reject-2 whitespace-nowrap pt-2 flex-shrink-0 w-[110px]">배송 형태</div>
-        <div className="flex w-full items-center justify-between pr-20 flex-wrap">
-          {['협력사배송', '지정택배배송', '픽업배송'].map((opt) => (
-            <SelectRadio
-              key={opt}
-              text={opt === '협력사배송' ? '협력사 배송' : opt}
-              value={opt}
-              name="rejectcm"
-              selectedValue={selectedReason}
-              onChange={(v) => {
-                setSelectedReason(v)
-                setRadioErrorMessage('')
-              }}
-              errorMessage={radioErrorMessage}
-              disabled={isDisabled}
-            />
-          ))}
-        </div>
-      </div>
-
-      <div className="flex w-full items-center justify-center mt-4">
-        <SubmitButton isValid={isValid} isLoading={isLoading} isSubmitted={isSubmitted} onSubmit={handleSubmit} />
-      </div>
-    </div>
-  )
-}

frontend/src/features/chat/components/templates/RejectRSP.tsx

@@ -1,155 +0,0 @@
-import { useState, useMemo } from 'react'
-import { cn } from '@/lib'
-import { numberToKorean } from '@/features/chat/lib/koreanNumber'
-import { useChatStore } from '@/features/chat/stores/useChatStore'
-import { useChatInitStore } from '@/features/chat/stores/useChatInitStore'
-import { SelectRadio, SubmitButton } from '@/features/chat/components/templates/rejectControls'
-import { OtherReason } from '@/features/chat/components/templates/OtherReason'
-import { findRestoreScript, restoreRejectRSP } from '@/features/chat/lib/rejectForm'
-
-const MAX_PRICE = 999999999999999
-
-const REASONS = [
-  { value: '단가인상', text: "'원재료 가격 상승' 또는 '제조사 가격 인상'으로 요청한 공급가격을 맞출 수 없습니다." },
-  { value: '수량', text: '주문 수량이 적어, 소량 생산 시 발생하는 제조비용으로 맞출 수 없습니다.' },
-  { value: '단종', text: '현재 단종된 제품으로 물량 수급이 원활하지 않아 가격을 맞출 수 없습니다.' },
-  { value: '품절', text: '해당 상품이 품절되어 납품할 수 없습니다.' },
-]
-
-// 협상 합의 불가 시: 최종 제안 단가 + 합의 불가 사유 입력 폼
-export function RejectRSP() {
-  const isLoading = useChatStore((s) => s.isLoading)
-  const sendMessage = useChatStore((s) => s.sendMessage)
-  const messages = useChatStore((s) => s.messages)
-  const item_vat_yn = useChatInitStore((s) => s.item_vat_yn)
-  const isVAT = item_vat_yn === 'VAT별도'
-
-  // 폼 값은 이전 제출 내역에서 1회만 복원 (setter 미사용 = lazy 초기화 전용)
-  const restored = useState(() => restoreRejectRSP(findRestoreScript(messages, 'rejectRSP')))[0]
-  const [price, setPrice] = useState(restored.price)
-  const [selectedReason, setSelectedReason] = useState(restored.selectedReason)
-  const [reason, setReason] = useState(restored.reason)
-  const [otherErrorMessage, setOtherErrorMessage] = useState('')
-  const [priceErrorMessage, setPriceErrorMessage] = useState('')
-  const [radioErrorMessage, setRadioErrorMessage] = useState('')
-
-  const isSubmitted = useMemo(
-    () => Boolean(findRestoreScript(messages, 'rejectRSP')),
-    [messages],
-  )
-  const isValid =
-    Boolean(price && parseInt(price) > 0) &&
-    Boolean(selectedReason) &&
-    (selectedReason !== '기타' || reason.trim() !== '')
-
-  const handlePriceChange = (value: string) => {
-    const numeric = value.replace(/\D/g, '')
-    if (numeric && parseInt(numeric) > MAX_PRICE) return
-    setPrice(numeric)
-    if (numeric) setPriceErrorMessage('')
-  }
-
-  const handleRadioChange = (value: string) => {
-    setSelectedReason(value)
-    setRadioErrorMessage('')
-    if (value !== '기타') {
-      setReason('')
-      setOtherErrorMessage('')
-    }
-  }
-
-  const koreanPrice = (() => {
-    if (!price) return '영'
-    const n = parseInt(price)
-    return Number.isNaN(n) || n === 0 ? '영' : numberToKorean(n)
-  })()
-
-  const handleSubmit = () => {
-    setPriceErrorMessage(!price || parseInt(price) === 0 ? '가격을 입력해주세요.' : '')
-    setRadioErrorMessage(!selectedReason ? '사유를 선택해주세요.' : '')
-    setOtherErrorMessage(selectedReason === '기타' && !reason.trim() ? '기타 사유를 입력해주세요.' : '')
-    if (isValid && !isLoading && !isSubmitted) {
-      const script =
-        selectedReason === '기타'
-          ? `공급희망가격-${price}, 합의불가사유-기타-${reason.trim()}`
-          : `공급희망가격-${price}, 합의불가사유-${selectedReason}`
-      sendMessage(script, 'text')
-    }
-  }
-
-  const isDisabled = isLoading || isSubmitted
-
-  return (
-    <div className="flex flex-col w-full p-10 bg-neutral-00 rounded-[28px] gap-2 transition-all duration-300">
-      <div className="flex w-full h-[48px] bg-[#CD2A2D] headline-3 text-neutral-00 rounded-[12px] items-center justify-center">
-        협상 합의 불가 사유 및 최종 제안 단가 입력
-      </div>
-
-      <div className="reject break-keep py-2">
-        협상이 합의에 도달하지 못하였습니다. 최종 희망하는 가격을 입력해주시기 바랍니다.
-        <br />
-        추가로 제시한 가격을 수용할 수 없는 이유를 선택하여 주시기 바라며, 목록에 없는 경우 기타 항목 선택 후 간단한 사유를
-        기재하여 주시기 바랍니다.
-      </div>
-
-      <div className="flex flex-col w-full gap-1">
-        <div className="flex w-full items-start gap-4">
-          <div className="flex reject-2 whitespace-nowrap pt-2 flex-shrink-0 w-[110px]">공급 희망 가격</div>
-          <div className="flex flex-wrap w-full items-center pt-2">
-            <div className="flex items-center gap-2">
-              <input
-                type="text"
-                className={cn(
-                  'text-right max-w-[220px] h-full max-h-[35px] border p-2 body-3 placeholder:text-neutral-60 focus:border-neutral-70 rounded-[8px] outline-none border-neutral-40',
-                  isDisabled ? 'bg-neutral-10 text-neutral-60 cursor-not-allowed' : 'bg-white text-neutral-90',
-                )}
-                value={price ? parseInt(price).toLocaleString() : ''}
-                onChange={(e) => handlePriceChange(e.target.value)}
-                placeholder="0"
-                disabled={isDisabled}
-              />
-              <div className="reject whitespace-nowrap mr-2">원{isVAT && '(VAT 별도)'}</div>
-            </div>
-            <div className="reject-gray whitespace-nowrap">[{koreanPrice} 원]</div>
-          </div>
-        </div>
-        {priceErrorMessage && <div className="body-5 text-negative pl-[126px]">{priceErrorMessage}</div>}
-      </div>
-
-      <div className="flex w-full gap-4">
-        <div className="flex reject-2 whitespace-nowrap pt-2 pb-2 flex-shrink-0 w-[110px]">합의 불가 사유</div>
-        <div className="flex w-full flex-col mt-2 gap-2">
-          {REASONS.map((r) => (
-            <SelectRadio
-              key={r.value}
-              text={r.text}
-              value={r.value}
-              name="rejectrsp"
-              selectedValue={selectedReason}
-              onChange={handleRadioChange}
-              errorMessage={radioErrorMessage}
-              disabled={isDisabled}
-            />
-          ))}
-          <OtherReason
-            inputValue={reason}
-            setInputValue={(v) => {
-              if (selectedReason !== '기타') return
-              setReason(v)
-              if (v.trim()) setOtherErrorMessage('')
-            }}
-            errorMessage={otherErrorMessage}
-            selectedValue={selectedReason}
-            onChange={handleRadioChange}
-            isError={!!radioErrorMessage}
-            disabled={isDisabled}
-          />
-        </div>
-      </div>
-
-      <div className="flex w-full items-center justify-center mt-6">
-        <SubmitButton isValid={isValid} isLoading={isLoading} isSubmitted={isSubmitted} onSubmit={handleSubmit} />
-      </div>
-    </div>
-  )
-}

frontend/src/features/chat/components/templates/RejectSummary.tsx

@@ -0,0 +1,52 @@
+import { AlertTriangle } from 'lucide-react'
+import { numberToKorean } from '@/lib'
+import { useChatInitStore } from '@/features/chat/stores/useChatInitStore'
+import { parseRejectSubmission } from '@/features/chat/lib/rejectForm'
+
+// 결렬 제출 요약 — 타결의 BidSummary 와 대칭.
+export function RejectSummary({ script }: { script: string }) {
+  // VAT 표기는 회사 설정 기준(item_vat_yn). 미관리(hidden)면 비어 라벨을 생략한다.
+  const item_vat_yn = useChatInitStore((s) => s.item_vat_yn)
+  const { price, reasonLabel, reasonDetail, opinion, extras } = parseRejectSubmission(script)
+
+  return (
+    <div className="w-full rounded-2xl border-2 border-[#FFD9D9] bg-white p-5 shadow-md">
+      <div className="mb-4 flex items-center gap-2">
+        <AlertTriangle className="size-5 text-[#E5484D]" />
+        <h3 className="text-sm font-bold text-neutral-90">협상 결렬 사유</h3>
+      </div>
+
+      <div className="divide-y divide-border/60 rounded-xl border border-border">
+        <div className="flex items-start justify-between gap-3 px-4 py-3">
+          <span className="shrink-0 text-sm text-neutral-60">공급 희망 가격</span>
+          <span className="min-w-0 flex-1 break-keep text-right text-sm">
+            <span className="font-bold text-[#E5484D]">{price.toLocaleString()}원</span>
+            <span className="text-neutral-70"> ({numberToKorean(price)}원)</span>
+            {item_vat_yn ? <span className="text-neutral-70"> {item_vat_yn}</span> : null}
+          </span>
+        </div>
+        <div className="flex items-start justify-between gap-3 px-4 py-3">
+          <span className="shrink-0 text-sm text-neutral-60">합의 불가 사유</span>
+          <span className="min-w-0 flex-1 break-keep text-right">
+            <span className="text-sm font-semibold text-neutral-90">{reasonLabel || '-'}</span>
+            {reasonDetail && <span className="mt-1 block text-xs text-neutral-70">{reasonDetail}</span>}
+          </span>
+        </div>
+        {extras.map((e) => (
+          <Row key={e.label} label={e.label} value={e.value} />
+        ))}
+        {/* 의견은 타결·결렬 공통 기본 필드 — 값이 없어도 항상 표시 */}
+        <Row label="의견" value={opinion || '-'} />
+      </div>
+    </div>
+  )
+}
+
+function Row({ label, value }: { label: string; value: string }) {
+  return (
+    <div className="flex items-start justify-between gap-3 px-4 py-3">
+      <span className="shrink-0 text-sm text-neutral-60">{label}</span>
+      <span className="min-w-0 flex-1 break-keep text-right text-sm font-semibold text-neutral-90">{value}</span>
+    </div>
+  )
+}

frontend/src/features/chat/components/templates/RejectedNotice.tsx

@@ -0,0 +1,56 @@
+import { AlertTriangle } from 'lucide-react'
+import { SessionStatus } from '@/apis'
+import { numberToKorean } from '@/lib'
+import { useChatInitStore } from '@/features/chat/stores/useChatInitStore'
+
+// 협상 거부로 끝난 세션의 제출 내역 — 결렬의 RejectSummary 와 같은 카드 규격.
+// 거부는 팝업으로 내 대화에 남지 않아 대화 끝에 따로 붙인다.
+export function RejectedNotice() {
+  const sessionStatus = useChatInitStore((s) => s.session_status)
+  const reason = useChatInitStore((s) => s.reject_reason)
+  const price = useChatInitStore((s) => s.reject_price)
+  const custom = useChatInitStore((s) => s.custom)
+  const item_vat_yn = useChatInitStore((s) => s.item_vat_yn)
+
+  if (sessionStatus !== SessionStatus.REJECTED || !reason) return null
+
+  const opinion = String(custom?.opinion ?? '')
+
+  return (
+    <div className="mb-6 w-full rounded-2xl border-2 border-[#FFD9D9] bg-white p-5 shadow-md">
+      <div className="mb-4 flex items-center gap-2">
+        <AlertTriangle className="size-5 text-[#E5484D]" />
+        <h3 className="text-sm font-bold text-neutral-90">협상 거부 사유</h3>
+      </div>
+
+      <div className="divide-y divide-border/60 rounded-xl border border-border">
+        <div className="flex items-start justify-between gap-3 px-4 py-3">
+          <span className="shrink-0 text-sm text-neutral-60">공급 희망 가격</span>
+          <span className="min-w-0 flex-1 break-keep text-right text-sm">
+            {price ? (
+              <>
+                <span className="font-bold text-[#E5484D]">{price.toLocaleString()}원</span>
+                <span className="text-neutral-70"> ({numberToKorean(price)}원)</span>
+                {item_vat_yn ? <span className="text-neutral-70"> {item_vat_yn}</span> : null}
+              </>
+            ) : (
+              <span className="font-semibold text-neutral-90">미입력</span>
+            )}
+          </span>
+        </div>
+        <Row label="거부 사유" value={reason} />
+        {/* 의견은 타결·결렬·거부 공통 기본 필드 — 값이 없어도 항상 표시 */}
+        <Row label="의견" value={opinion || '-'} />
+      </div>
+    </div>
+  )
+}
+
+function Row({ label, value }: { label: string; value: string }) {
+  return (
+    <div className="flex items-start justify-between gap-3 px-4 py-3">
+      <span className="shrink-0 text-sm text-neutral-60">{label}</span>
+      <span className="min-w-0 flex-1 break-keep text-right text-sm font-semibold text-neutral-90">{value}</span>
+    </div>
+  )
+}