536 changed files with 6609 additions and 36219 deletions
--- a/.env.example
+++ b/.env.example
@ -0,0 +1,21 @@
 # docker compose 용 환경변수 템플릿 — 복사해서 사용: cp .env.example .env
 # 실제 값(.env)은 커밋하지 않는다(.gitignore). 이미지에는 시크릿이 없으므로(lps 는 example
 # config 로 빌드) 아래 값이 없으면 해당 기능이 꺼진 채 뜬다(주석 참고).
 # ── LPS DB (미설정 시 postgres/postgres) ──
 LPS_DB_USER=postgres
 LPS_DB_PASSWORD=postgres
 # ── LPS API 스케일 (미설정 시 1 / 40 — 단일 프로세스로도 ~1,100 RPS) ──
 LPS_API_PROCESS_COUNT=1        # uvicorn 프로세스 수(=사용 코어 수). 커넥션 풀은 예산에서 자동 역산
 LPS_DB_CONNECTION_BUDGET=40    # lps API 커넥션 총예산. 공유 PG=40, 전용 PG(max_conn≈100)=90
 # ── LPS 워커 시크릿 ──
 OPENAI_API_KEY=            # 비면 AI 유사도 판정 OFF
 NAVER_KEYS=                # "id1:secret1,id2:secret2" — 네이버 쇼핑 오픈API 키(여러 개면 로테이션)
 DECODO_HOST=               # 예: gate.decodo.com — DECODO 4종이 비면 프록시 미사용(직접 연결)
 DECODO_USERNAME=
 DECODO_PASSWORD=
 DECODO_PORT_START=0        # 예: 10001
 DECODO_PORT_END=0          # 예: 10010
 DECODO_COST_PER_GB=0       # 요금($/GB) — 검색 원가 계측용(예: 3.0)
--- a/.gitignore
+++ b/.gitignore
@ -28,7 +28,3 @@ CLAUDE.md
 # 로컬 리서치 노트(크롤링 라이브러리·안티스크래핑 조사) — 추적 안 함, 로컬 참고용
 /Temp.md
 /new.md
 /mobile.mov
 .gstack/
 .playwright-mcp/
--- a/0729~30_테스트.xlsx
+++ b/0729~30_테스트.xlsx
--- a/정리.xlsx
+++ b/정리.xlsx
--- a/요청사항.xlsx
+++ b/요청사항.xlsx
--- a/README.md
+++ b/README.md
@ -1,198 +1,63 @@
 # O2O Negosium
-AI 협상 솔루션. 여러 백엔드·프론트·배치가 **하나의 PostgreSQL 인스턴스**를 공유하고,
+동일 구조의 두 서비스(**negosium**, **negodata**)가 **하나의 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           # 전체 서비스 (DB 는 compose 밖, config 로 외부 연결)
+├── docker-compose.yml          # 두 backend (DB 는 외부)
-├── postgres-init/               # DB·스키마·시드 SQL (대상 DB 에 1회 적용)
+├── postgres-init/        # DB·테이블 셋업 SQL (대상 DB 에 1회 적용)
-│
+├── backend/                     # negosium 백엔드 (포트 9300)
-├── backend/                     # negosium 백엔드 — 공급사/협상 API (:9300)
+├── negodata/backend/            # negodata 백엔드 (포트 9400)
-├── frontend/                    # negosium 공급사 프론트 (:3300, 프로덕션 빌드 정적 서빙)
+├── agent/  front/               # (예정)
-├── agent/                       # 협상 에이전트 — RL(learning 스키마) (:9500)
+└── negodata/front/              # (예정)
 │
 ├── 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)
 ```
-negosium·negodata·agent 백엔드는 같은 코드 골격(MVC · 람다 DB · Depends 주입 · JWT 로그인)을 쓴다.
+두 백엔드는 같은 코드 골격(MVC · 람다 DB · Depends 주입 · JWT 로그인)을 쓴다.
-아키텍처/패턴 상세는 각 서브 README 참고:
+아키텍처/패턴 상세는 각 서버 README 참고: [backend](backend/README.md) · [negodata/backend](negodata/backend/README.md)
 - 백엔드: [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-backend · agent · anchoring 공유
+├── negosium_db     ← negosium-backend
-│   ├── company / supplier / partner  : 회사·유저·협력사·상품
+└── negodata_db     ← negodata-backend
 │   ├── card / quotation / negotiation: 협상 카드·견적·협상 세션
 │   ├── learning                      : RL 자산 (agent 소유)
 │   └── anchoring                     : 앵커링 조정 (schedules/anchoring 소유)
 └── lps_db                            ← lps-api · lps-worker
 ```
- 컨테이너(docker env)에서 호스트 DB 접근: `host.docker.internal:5432` (compose 가 `DB_HOST` 로 override)
+- 컨테이너(docker env)에서 호스트 DB 접근: `host.docker.internal:5432` (`config.docker.toml`)
 - 로컬 실행/테스트(local·test env): `127.0.0.1:5432` (`config.local/test.toml`)
 - 계정/database 명은 config 에 맞춘다 (기본 `postgres` / `password`).
-## 핵심 플로우
+| 서비스 | 서버 | docs | database |
-
+|---|---|---|---|
-### 1. 견적 라이프사이클 (전체 개요)
+| negosium-backend | http://localhost:9300 | /docs | negosium_db |
-
+| negodata-backend | http://localhost:9400 | /docs | negodata_db |
 바이어가 견적을 열고 → 협력사가 협상에 참여 → 마감 시각에 판정되는 큰 흐름.
 견적 유형은 두 축(재/신규 × 협상 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 에 스키마 + 시드 적용
-#    스키마 DDL (구 01~05 통합, 전부 IF NOT EXISTS 라 재실행 안전)
+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 -d negosium_db -f postgres-init/init-data/init.sql
+psql -h 127.0.0.1 -p 5432 -U postgres -f postgres-init/temp-data.sql   # 임시 데이터 시드 (admin / admin1234)
 #    로컬/개발 시드 (admin / admin1234, 회사·유저·협상 카드)
 psql -h 127.0.0.1 -p 5432 -U postgres -d negosium_db -f postgres-init/init-data/init-data.sql
-# (DBeaver 로 처음부터 새로 깔 때는 postgres-init/dbeaver/ 의 0~5 순서 스크립트를 쓴다:
+# 2) 백엔드 기동
-#  0 drop&create → 1 스키마 → 2 시드 → 3 lps_db → 4 카드 리셋 → 5 o2o OWNER 유저)
+docker compose up -d            # 두 backend (DB 는 config 대로 외부 연결)
-
+docker compose logs -f
 # 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, agent, lps ...
+cd backend            # 또는 negodata/backend
 pip install pytest pytest-asyncio httpx
 python -m pytest
 ```
- httpx `ASGITransport` 로 네트워크 없이 앱을 직접 호출하는 e2e.
+- httpx `ASGITransport` 로 네트워크 없이 앱을 직접 호출하는 e2e (각 5개).
 - `DB_SESSION_MNG` 싱글톤의 커넥션 풀이 첫 이벤트 루프에 묶이므로, 모든 테스트가 단일 session 루프를 공유한다(`pytest.ini`).
 - ⚠️ 테스트는 `APP_ENV=test` 로 격리한다(테스트 DB). dev DB(`negosium_db`)에 대고 돌리면 데이터가 날아간다.
 ## 성능 / 벤치마크
@ -234,9 +99,4 @@ python -m locust -f loadtest/locustfile.py --host http://localhost:9300 --headle
 ```
 ## 기술 스택
- **백엔드**: FastAPI · SQLAlchemy(async) · asyncpg · PostgreSQL 16 · python-jose(JWT) · bcrypt · uvicorn
+FastAPI · SQLAlchemy(async) · asyncpg · PostgreSQL 16 · python-jose(JWT) · bcrypt · uvicorn · Docker Compose
 - **프론트**: React · react-router v7 · Vite · TanStack Query (negosium-front 는 프로덕션 빌드 정적 서빙)
 - **에이전트**: 강화학습(Q-learning, learning 스키마) · OpenAI
 - **LPS**: 헤드풀 Chromium + Patchright(스텔스 Playwright 포크, 크롤) · autoheal
 - **배치**: Redis(anchoring 캐시) · 상주 스케줄러
 - **공통**: Docker Compose
--- a/agent/negotiation/cards/domain/tactics.py
+++ b/agent/negotiation/cards/domain/tactics.py
@ -1,240 +1,120 @@
-"""협상카드 전술 — "스크립트에 꽂힌 변수가 곧 전술" 계층.
+"""협상카드 전술 레지스트리 — "멘트 카드 → 전술 카드" 승격 (가격 행동 실행 계층).
-카드 멘트가 제시하는 가격({target_price}·{middle_price} 등)을 파싱해 시스템 상태로 실행한다:
+카드 멘트에 이미 설계된 카운터 가격 제시({target_price}·{middle_price} 등)를 시스템 상태로
-카드가 제안가를 제시하면 pending_counter_price 로 적재되고, 협력사가 수락하면 그 가격으로 타결된다.
+실행한다: 카드가 카운터가를 제시하면 pending_counter_price 로 적재되고, 협력사가 수락하면
 그 가격으로 즉시 타결된다(기존 wild_card_1pct 의 offer_1pct 패턴을 일반화).
-세 계층으로 나뉜다.
+원칙:
-  1) 스크립트 파싱  — 이 카드가 부를 금액이 무엇인지 (parse_offer_variable)
+- 구매자(갑) 대리이므로 카운터는 항상 min(counter, target_price) 클램프 — 목표가 초과 제시 금지.
-  2) 변수 정의      — 그 금액을 지금 쓸 수 있는지 (OFFER_VARIABLES 의 계산식 + 유효조건)
+- 협력사 제시가가 이미 카운터 이하면 카운터가 무의미 → None(HOLD 강등, 순수 설득).
-  3) tactic JSONB   — 문장으로 알 수 없는 운영 규칙 (min_round·closing)
+- 미등록 카드번호(테넌트 데모 NGC-B*, 회사 커스텀 COMP-* 등)는 HOLD 폴백 → 기존 동작 그대로.
-유효 조건은 카드가 아니라 '변수'에 붙인다 — 금액이 성립하는지는 계산식의 성질이지 카드의
+전술 정본은 이 코드 레지스트리다(v1). negodata 카드 편집은 멘트만 담당하고, 전술을 negodata
-성질이 아니다. 새 변수는 OFFER_VARIABLES 에 한 줄 추가하면 코드 분기 없이 끝난다.
+에서 편집할 필요가 생기면 v2 에서 card.nego_cards 컬럼로 승격해 "DB 우선, 코드 폴백"으로 바꾼다.
 """
 import re
 from dataclasses import dataclass
-from typing import Any, Callable, Dict, Optional
+from enum import Enum
-
+from typing import Any, 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"                            # 카운터 없음 — 재제안 요구(순수 설득, 기존 동작)
-# {internet_lowest_price} 토큰이 원형 노출된다(vars_for 가 미수집이면 키를 안 만드는 것과 짝).
+    COUNTER_TARGET = "counter_target"        # 목표가 제시
-# 견적 생성 화면 게이팅(useCardGating)이 1차 방어, 여기가 2차(런타임) 방어다.
+    COUNTER_ANCHOR = "counter_anchor"        # 앵커가 제시 (예산 상한 프레이밍)
-_CONTEXT_REQUIRED_VARIABLES = {
+    COUNTER_TARGET_MID = "counter_target_mid"  # (anchor+target)/2 — 시드 {target_mid_price}
-    "internet_lowest_price": "internet_lowest_price",
+    COUNTER_MID = "counter_mid"              # (갑 직전 포지션+협력사 제시가)/2 — 시드 {middle_price}
-    "internet_min_price": "internet_lowest_price",
+    ONE_PCT = "one_pct"                      # 제시가 1% 인하 (기존 offer_1pct)
 }
@dataclass(frozen=True)
-class CardSpec:
+class TacticSpec:
-    """카드 1장의 전술. 스크립트 파싱 결과 + tactic JSONB 를 합친 값.
+    """카드 1장의 전술 명세.
    offer_variable: 이 카드가 제시할 금액의 변수명. None 이면 순수 설득 카드(HOLD).
    min_round: 발동 가능 최소 라운드(협력사 가격 입력 횟수 기준).
-    closing: 종결 국면 전용 — 라운드 상한·카드 소진 시의 마지막 한 방으로만 쓴다.
+    max_price_ratio: input_price ≤ anchor×ratio 일 때만 발동 (None=무제한).
-    requires: 스크립트가 인용한 세션-의존 변수의 컨텍스트 키 — 값이 없으면 미발동(토큰 노출 방지).
+    closing: 종결 국면(라운드 만료·카드 소진) 우선 전술.
    """
-    offer_variable: Optional[str] = None
+    price_action: PriceAction = PriceAction.HOLD
    min_round: int = 1
    max_price_ratio: Optional[float] = None
    closing: bool = False
    requires: tuple = ()
-HOLD = CardSpec()  # 스펙을 못 찾은 카드(테넌트 데모·회사 커스텀)의 폴백 — 기존 동작(설득만) 유지
+_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),              # 중간값 절충(종결)
 }
-def settle_ceiling(context: Dict[str, Any]) -> float:
+def tactic_for(card_number: Optional[str]) -> TacticSpec:
-    """이 협상에서 받아줄 수 있는 최고가 — 타결 판정선이자 카드 제안가의 상한.
+    """카드번호의 전술. 미등록/None 은 HOLD(기존 동작)."""
    return _TACTICS.get(str(card_number), _DEFAULT) if card_number else _DEFAULT
-    견적 생성 시 세션에 박제한 done_ceiling_price(= 목표가 × (1 + 타결상한율)) — 목표가를 조금
+
-    넘더라도 기존 단가보다 인하됐으면 타결시키기 위한 값. 박제가 없으면 목표가로 폴백한다.
+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 로 강등.
    """
-    return float(context.get("done_ceiling_price") or context.get("target_price") or 0)
+    action = spec.price_action
-
+    if action is PriceAction.HOLD:
 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  # 목표가·제시가 없이는 어떤 변수도 판정 불가
    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} 등 저장 원값이 그대로 나가므로, 반올림하면
+    if action is PriceAction.COUNTER_TARGET:
-        # 표시가≠타결가 미스매치가 난다(목표가 7652 멘트 → 7650 타결). 저장값 그대로 제시.
+        counter = target
-        offer = int(value)
+    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
    else:
-        offer = int(value / 10 + 0.5) * 10  # 파생가(절충·중간) 10원 반올림 — 앵커·목표가 산정과 표기 통일
+        return None
    if offer >= price:
        return None  # 제시가가 이미 그 값 이하 → 부를 이유 없음
    if prev_customer and offer < prev_customer:
        return None  # 역행 금지 — 한번 부른 금액 아래로 되돌아가지 않는다(같은 금액 재제시는 허용)
    return offer
-
+    if counter <= 0:
-def available(spec: CardSpec, context: Dict[str, Any], *, closing_phase: bool = False) -> bool:
+        return None
-    """지금 이 카드를 꺼낼 수 있는지 — 금액과 무관한 조건들.
+    counter = min(counter, target)          # 목표가 초과 제시 금지 (가드레일)
-
+    counter_i = int(round(counter))
-    · 이미 쓴 카드는 다시 안 나간다(전 카드 공통 규칙 — 협상카드/와일드카드 구분 없음)
+    if counter_i >= price:
-    · 종결 전용 카드는 종결 국면에서만, 종결 국면에선 종결 전용 카드만
+        return None                          # 제시가가 이미 카운터 이하 → 카운터 무의미
-    · min_round 미만이면 아직 이르다
+    return counter_i
    · 스크립트가 인용한 세션-의존 변수(인터넷 최저가 등)가 결측이면 미발동 — 토큰 원형 노출 방지
    """
    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
--- a/agent/negotiation/chat/infra/repository/nego_context_crud.py
+++ b/agent/negotiation/chat/infra/repository/nego_context_crud.py
@ -23,7 +23,6 @@ _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",
@ -34,32 +33,8 @@ _QUOTATION_SETTINGS = table(
    column("qt_setting_id"), column("card_count"), column("deleted"),
    schema="quotation",
 )
-_ITEMS = table("items", column("item_id"), column("name"), column("price"), column("purchase_price"),
+_ITEMS = table("items", column("item_id"), column("name"), column("price"),
-               column("company_id"), column("internet_lowest_price"), column("deleted"), schema="partner")
+               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",
@ -78,13 +53,12 @@ _VERSION_WILD_CARDS = table(
 )
 _NEGO_CARDS = table(
    "nego_cards",
-    column("nego_card_id"), column("number"), column("script"), column("tactic"), column("deleted"),
+    column("nego_card_id"), column("number"), column("deleted"),
    schema="card",
 )
 _WILD_CARDS = table(
    "wild_cards",
-    column("wild_card_id"), column("number"), column("script"), column("tactic"), column("deleted"),
+    column("wild_card_id"), column("number"), column("deleted"),
    column("available"),
    schema="card",
 )
 # 상품↔협력사 매핑 (2026-07-07 신설): supply_type = 이 협력사가 이 상품을 공급하는 방식(SupplierType).
@ -98,16 +72,12 @@ _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, done_ceiling_price, item_id, quotation_id, supplier_id). 없으면 None."""
+        """세션 행 (qt_type, target_price, anchoring_price, item_id, quotation_id, supplier_id). 없으면 None."""
        pass
    @abstractmethod
-    async def get_item_baseline(self, cdb: AsyncSession, item_id) -> Tuple[ErrorType, Tuple[int, str, dict]]:
+    async def get_item_price(self, cdb: AsyncSession, item_id) -> Tuple[ErrorType, int]:
-        """협상 기준가·그 호칭·회사 용어 사전 (가격, 호칭, labels).
+        """품목 기준가(items.price). 없으면 0."""
        어느 컬럼을 기준가로 쓰는지는 회사 설정(features.nego_baseline_field)이 정한다.
        labels 는 companies.settings.labels 원본 — 협상 스크립트의 용어 토큰 치환에 쓴다.
        값이 없으면 (0, 호칭, {})."""
        pass
    @abstractmethod
@ -154,9 +124,8 @@ class INegoContextCRUD(ABC):
        pass
    @abstractmethod
-    async def get_quotation_card_numbers(self, cdb: AsyncSession, quotation_id) -> Tuple[ErrorType, tuple[list[tuple], list[tuple]]]:
+    async def get_quotation_card_numbers(self, cdb: AsyncSession, quotation_id) -> Tuple[ErrorType, tuple[list[str], list[str]]]:
-        """견적 version_id 에 연결된 (일반카드 행 목록, 와일드카드 행 목록). 없으면 빈 목록.
+        """견적 version_id 에 연결된 (일반카드 번호 목록, 와일드카드 번호 목록). 없으면 빈 목록."""
        행 = (number, script, tactic) — 스크립트 파싱 + tactic JSONB 로 카드 전술(CardSpec)을 만든다."""
        pass
@ -165,7 +134,6 @@ 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)
@ -178,29 +146,20 @@ class NegoContextCRUD(INegoContextCRUD):
            LOG.e_no_callstack(ex)
            return ErrorType.DB_RUN_FAILED, None
-    async def get_item_baseline(self, cdb: AsyncSession, item_id) -> Tuple[ErrorType, Tuple[int, str, dict]]:
+    async def get_item_price(self, cdb: AsyncSession, item_id) -> Tuple[ErrorType, int]:
        _fallback = (0, _SUPPLIER_PRICE_LABEL, {})
        try:
            # 상품 + 소속 고객사 설정 한 번에. 회사가 없어도(데이터 이상) 상품 행은 나오도록 outer join.
            query = (
-                select(_ITEMS.c.price, _ITEMS.c.purchase_price, _COMPANIES.c.settings)
+                select(_ITEMS.c.price)
                .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_baseline failed.", raise_error=False)
+            err_type, rows = await DB_SESSION_MNG.execute(cdb, query, "get_item_price failed.", raise_error=False)
-            if err_type != ErrorType.SUCCESS or not rows:
+            if err_type != ErrorType.SUCCESS or not rows or not rows[0]:
-                return err_type, _fallback
+                return err_type, 0
-            # 컬럼이 2개 이상이면 execute 가 행 리스트를 준다(1개일 때만 스칼라 리스트).
+            return ErrorType.SUCCESS, int(rows[0])
            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
+            return ErrorType.DB_RUN_FAILED, 0
    async def get_card_count(self, cdb: AsyncSession, session_id) -> Tuple[ErrorType, Optional[int]]:
        try:
@ -330,7 +289,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[tuple], list[tuple]]]:
+    async def get_quotation_card_numbers(self, cdb: AsyncSession, quotation_id) -> Tuple[ErrorType, tuple[list[str], list[str]]]:
        try:
            version_q = (
                select(_QUOTATIONS.c.version_id)
@ -345,7 +304,7 @@ class NegoContextCRUD(INegoContextCRUD):
            version_id = rows[0]
            nego_q = (
-                select(_NEGO_CARDS.c.number, _NEGO_CARDS.c.script, _NEGO_CARDS.c.tactic)
+                select(_NEGO_CARDS.c.number)
                .select_from(
                    _VERSION_NEGO_CARDS.join(
                        _NEGO_CARDS,
@ -364,7 +323,7 @@ class NegoContextCRUD(INegoContextCRUD):
                return n_err, ([], [])
            wild_q = (
-                select(_WILD_CARDS.c.number, _WILD_CARDS.c.script, _WILD_CARDS.c.tactic)
+                select(_WILD_CARDS.c.number)
                .select_from(
                    _VERSION_WILD_CARDS.join(
                        _WILD_CARDS,
@ -375,8 +334,6 @@ 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)
            )
@ -385,8 +342,8 @@ class NegoContextCRUD(INegoContextCRUD):
                return w_err, ([], [])
            return ErrorType.SUCCESS, (
-                [(str(r[0]), r[1], r[2]) for r in n_rows if r[0] is not None],
+                [str(r) for r in n_rows if r is not None],
-                [(str(r[0]), r[1], r[2]) for r in w_rows if r[0] is not None],
+                [str(r) for r in w_rows if r is not None],
            )
        except Exception as ex:
            LOG.e_no_callstack(ex)
--- a/agent/negotiation/chat/service/chat_engine.py
+++ b/agent/negotiation/chat/service/chat_engine.py
@ -10,16 +10,10 @@ import re
 from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional
-from negotiation.cards.domain.tactics import (
+from negotiation.cards.domain.tactics import compute_counter, tactic_for
    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")
@ -49,39 +43,6 @@ 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
@ -135,9 +96,8 @@ 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)
@ -155,7 +115,6 @@ 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)
@ -210,15 +169,6 @@ 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":   # = 우선협상: 제시가가 앵커가 이하
@ -231,27 +181,13 @@ 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 (ceiling > 0 and price <= ceiling) else c.get("next")
+                    return "협상완료" if (target > 0 and price <= target) else c.get("next")
                ok = False
            elif cond == "default":
                ok = True
@ -261,42 +197,32 @@ 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:
-            offer_1pct = int(price * 0.99 / 10 + 0.5) * 10  # 1% 인하가 — 10원 반올림(앵커·카운터와 통일)
+            # 와일드카드는 실제로 노출할 때만 '사용됨'으로 마킹한다 — 가격협상으로 돌아가는
-            # 제안가 공통 유효조건(≤목표가 · <제시가 · 직전 당사 제안 이상=역행 금지)은 시스템 1% 카드에도
+            # 경우에도 마킹하면 이후 라운드에서 정당한 1% 카드까지 억제된다.
-            # 동일하게 건다. 기본 앵커 밴드에선 수학적으로 항상 통과하지만 극단 데이터를 방어한다.
+            ctx["wildcard_used"] = True
-            prev_customer = ctx.get("prev_customer_price") or 0
+            ctx["offer_1pct"] = int(round(price * 0.99))  # 1% 인하가 (멘트 변수)
-            if 0 < offer_1pct < price and (target <= 0 or offer_1pct <= target) and offer_1pct >= prev_customer:
+            ctx["pending_counter_price"] = ctx["offer_1pct"]  # 수락 시 이 가격으로 타결
-                # 와일드카드는 실제로 노출할 때만 '사용됨'으로 마킹한다 — 가격협상으로 돌아가는
+            return "wild_card_1pct"
                # 경우에도 마킹하면 이후 라운드에서 정당한 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 []):
-                number = str(number)
+                counter = compute_counter(tactic_for(str(number)), ctx)
-                spec = spec_from_context(ctx, number)
+                if counter is not None:
                # 종결 전용 카드(최종 통보·중간값 절충)는 여기서 안 꺼낸다 — 종결 국면의 마지막 한 방으로 예약.
                # 이미 쓴 카드도 제외(같은 멘트 반복 방지).
                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
-                    record_offer(ctx, offer)
+                    ctx["pending_counter_price"] = counter
-                    ctx["active_wild_card_number"] = number
+                    ctx["active_wild_card_number"] = str(number)
                    mark_played(ctx, number)
                    return "wild_card_dynamic"
        return "가격협상"
@ -314,19 +240,6 @@ 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"])
@ -340,51 +253,43 @@ class ChatEngine:
        ilp = ctx.get("internet_lowest_price") or 0
        if ilp > 0:
            out["internet_lowest_price"] = out["internet_min_price"] = int(ilp)
-        # 전술 카운터 변수(카드 시드 멘트의 가격 변수) — tactics.OFFER_VARIABLES 산식과 동일 정의.
+        # 전술 카운터 변수(카드 시드 멘트의 가격 변수) — tactics.compute_counter 산식과 동일 정의.
        anchor = ctx.get("anchor_price") or 0
        target = ctx.get("target_price") or 0
-        # 표시 기준값 — 제안이 확정된 턴이면 그 계산에 쓴 재료(pending_offer)를 쓴다.
+        if "input_price" in ctx:
-        #   prev_customer_price 는 확정 즉시 새 제안가로 갱신되므로, 그대로 읽으면 멘트가
+            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 = 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"] = prev_customer
+            out["prev_customer_price"] = int(prev_customer)
-        if partner_price:
+        if anchor and target:
-            out["prev_partner_price"] = partner_price
+            out["target_mid_price"] = int(round((anchor + target) / 2))
-        if offer_price:
+        if prev_customer and "input_price" in ctx:
-            out["counter_price"] = offer_price
+            out["middle_price"] = int(round((prev_customer + ctx["input_price"]) / 2))
-        # 파생 가격(절충가·중간가) — 제안가로 확정된 변수는 그 금액을 그대로 쓴다(멘트에 보이는 금액과
+        if ctx.get("pending_counter_price"):
-        #   수락 시 타결가는 항상 같아야 한다). 나머지는 참고 인용이므로 tactics 산식으로 채운다.
+            # 카운터 제시 중: 멘트에 보이는 제시가와 수락 시 타결가(pending)를 반드시 일치시킨다.
-        #   산식을 여기 복사해 두면 갱신 시점 차이로 표시가와 제안가가 갈라지므로 정의를 호출만 한다.
+            #   절충/중간 변수(middle_price·target_mid_price)는 vars_for 재계산 값이 compute_counter 의
-        #   어느 변수가 제안가인지 모르는 진행 중 세션(구버전 기록)은 종전대로 전부 제안가로 고정한다.
+            #   target 클램프·prev_customer 갱신과 어긋나, 멘트엔 1,740,000 이 보이는데 실제로는
-        for name in _DERIVED_PRICE_VARIABLES:
+            #   1,700,000 으로 타결되던 버그(표시가≠투찰가)가 있었다. pending 은 이 시점 유일한 '제안가'이므로
-            if offer_price and (name == offer_variable or not offer_variable):
+            #   세 변수 모두 pending 으로 고정한다(카운터 제시 턴에만 적용 — 비-카운터 렌더는 원 계산값 유지).
-                out[name] = offer_price
+            pending_i = int(ctx["pending_counter_price"])
-                continue
+            out["counter_price"] = pending_i
-            value = OFFER_VARIABLES[name](target, anchor, partner_price, prev_customer)
+            out["middle_price"] = pending_i
-            if value:
+            out["target_mid_price"] = pending_i
-                out[name] = int(value / 10 + 0.5) * 10  # 10원 반올림 — compute_offer 와 동일
+        # 인하율 = (기존 공급가(상품단가) - 제시가) / 기존 공급가 * 100. 기존가 없으면 미표시(0.0).
-        # 인하율 = (협상 기준가 - 제시가) / 기준가 * 100. 기준가 없으면 미표시(0.0).
+        #   제시가가 기존가보다 높으면(인상 제시) 음수가 나오는데, "-1.3% 인하된 금액" 같은
        #   제시가가 기준가보다 높으면(인상 제시) 음수가 나오는데, "-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"기존 {label} 대비 약 **{rate:.1f}%** 인하된 금액입니다. "
+                out["discount_phrase"] = f"기존 공급가 대비 약 **{rate:.1f}%** 인하된 금액입니다. "
            elif rate <= -0.05:
                out["discount_phrase"] = (
-                    f"기존 {label}(**{int(base)}원**)보다 약 **{abs(rate):.1f}%** 높은 금액입니다. ")
+                    f"기존 공급가(**{int(base)}원**)보다 약 **{abs(rate):.1f}%** 높은 금액입니다. ")
            else:
-                out["discount_phrase"] = f"기존 {_josa(label, '와')} 동일한 수준의 금액입니다. "
+                out["discount_phrase"] = "기존 공급가와 동일한 수준의 금액입니다. "
        else:
            out["discount_rate"] = "0.0"
            out["discount_phrase"] = ""
@ -401,14 +306,13 @@ 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
-            ceiling = settle_ceiling(ctx)
+            target = ctx.get("target_price") or 0
-            if ceiling > 0 and ctx.get("input_price", 0) > ceiling:
+            if target > 0 and ctx.get("input_price", 0) > target:
                step_key = "협상실패"
        node = self.scripts[step_key]
        session.step = step_key
@ -422,14 +326,11 @@ 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", ""), step_vars),
+            script=self.repo.format_script(node.get("script", ""), self._vars(session)),
            input_mode=node.get("next_input_mode", "null"),
-            input_options=[self.repo.format_script(o, step_vars) for o in node.get("input_options", [])],
+            input_options=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 == "가격협상"),
@ -438,13 +339,9 @@ 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=self.repo.format_script(node.get("script", ""), step_vars),
+            step=session.step, script=node.get("script", ""),
-            input_mode=node.get("next_input_mode", "null"),
+            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=session.ended, client_step=self.step_map.get(session.step, session.step), error=msg,
        )
--- a/agent/negotiation/chat/service/negotiation_context_loader.py
+++ b/agent/negotiation/chat/service/negotiation_context_loader.py
@ -19,7 +19,6 @@ 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
@ -39,10 +38,7 @@ 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(무할인 폴백)
-    done_ceiling_price: int      # 타결 상한가 — sessions.done_ceiling_price(생성 시 박제). 없으면 target
+    item_price: int              # 기존 공급가(품목 기준가, items.price) — 인하율 멘트용. 없으면 0
    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
@ -52,9 +48,6 @@ class NegotiationDbContext:
    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:
@ -74,10 +67,8 @@ 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, done_ceiling_price, item_id, quotation_id, supplier_id = row
+            qt_type, target_price, anchoring_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 정책상
@ -94,9 +85,8 @@ class NegotiationContextLoader:
            #   매핑이 없거나 미지정이면 None → 호출부 기본값.
            _, supplier_type = await self.crud.get_supply_type(s, supplier_id, item_id)
-            # 협상 기준가 + 그 호칭 — 어느 컬럼을 쓸지는 고객사 설정(hidden_fields)이 정한다(crud).
+            # 기존 공급가(품목 기준가) — 없으면 0(인하율 멘트 미표시).
-            #   없으면 0(인하율 멘트 미표시).
+            _, item_price = await self.crud.get_item_price(s, item_id)
            _, (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)
@ -116,19 +106,7 @@ class NegotiationContextLoader:
            # 견적 생성 모달에서 고른 카드셋. 값이 없으면 운영 DB 기준으로 "선택 카드 없음"이다.
            # 데모/직접호출 경로(DB context 없음)만 ChatService 에서 기존 기본 카드셋으로 폴백한다.
            _, selected_cards = await self.crud.get_quotation_card_numbers(s, quotation_id)
-            nego_rows, wild_rows = selected_cards
+            selected_nego_cards, selected_wild_cards = 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)
@ -137,10 +115,7 @@ class NegotiationContextLoader:
                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,
@ -150,7 +125,6 @@ class NegotiationContextLoader:
                selected_nego_card_numbers=selected_nego_cards,
                selected_wild_card_numbers=selected_wild_cards,
                card_count=card_count,
                card_specs=card_specs,
            )
        try:
--- a/agent/negotiation/chat/service/script_naturalizer.py
+++ b/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
--- a/agent/services/chat_service.py
+++ b/agent/services/chat_service.py
@ -13,9 +13,7 @@ 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 (
+from negotiation.cards.domain.tactics import compute_counter, tactic_available, tactic_for
    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,
 )
@ -43,8 +41,6 @@ _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:
@ -112,19 +108,12 @@ 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,
@ -134,9 +123,6 @@ class ChatService:
                    "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),
                },
            )
@ -304,24 +290,20 @@ 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 의 수락 메커니즘).
-        #   유효조건(≤목표가 · <제시가) 미달이면 None → 금액 없이 설득 멘트만 나간다(HOLD 강등).
+        spec = tactic_for(card_id)
-        spec = spec_from_context(session.context, card_id)
+        counter = compute_counter(spec, session.context) if tactic_available(spec, session.context) else None
-        offer = compute_offer_detail(spec, session.context) if available(spec, session.context) else None
+        if counter is not None:
-        counter = offer.price if offer else None
+            session.context["pending_counter_price"] = counter
-        if offer is not None:
+            session.context["prev_customer_price"] = counter   # 갑의 최신 포지션(middle_price 기준)
            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, done=False,
+        await self._log(repo, session, idx, decision.action_id, card_id, snap, reward, decision.propensity, done=False)
                        decision=decision, policy=policy)
        res.card_id = card_id
        res.policy = policy.name
@ -370,31 +352,20 @@ class ChatService:
        규칙층의 강제 결정이므로 RL 선택/학습을 우회한다."""
        ctx = session.context
        ctx["closing_played"] = True
-        # 선택 와일드카드 중 종결 전용 카드(closing) — 이미 쓴 카드는 건너뛰고(같은 멘트 반복 방지),
+        # 선택 와일드카드 중 종결 전술 (WC-05/WC-03) — 순서대로 첫 매치.
-        # 제안가 유효조건(≤목표가 · <제시가) 미달 카드도 건너뛴다(예: 절충가가 목표가 초과 → 미발동).
+        closing_number = next(
-        closing_number, closing_offer = None, None
+            (str(n) for n in (ctx.get("selected_wild_card_numbers") or []) if tactic_for(str(n)).closing),
-        for n in (ctx.get("selected_wild_card_numbers") or []):
+            None,
-            n = str(n)
+        )
-            spec = spec_from_context(ctx, n)
+        counter = compute_counter(tactic_for(closing_number), ctx) if closing_number else None
-            if not available(spec, ctx, closing_phase=True) or is_played(ctx, n):
+        if counter is None:
                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)
-            price = int(ctx.get("input_price") or 0)
+            counter = target if 0 < target < ctx.get("input_price", 0) else None
-            if 0 < target < price:
+        if counter is None:
                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  # 컨텍스트 이상 — 기존 가격협상 스텝 그대로(재제안 요구)
-        mark_played(ctx, closing_number)  # None(폴백 최후통첩)이면 no-op
+        ctx["pending_counter_price"] = counter
-        record_offer(ctx, closing_offer)
+        ctx["prev_customer_price"] = counter
        template = None
        if closing_number:
@ -421,7 +392,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, done=True)
+                        self._card_id_for_action(engine, session, last_action), snap, reward, None, done=True)
        res.updated_q = float(policy.qtable.q[last_state, last_action])
    @staticmethod
@ -470,12 +441,10 @@ class ChatService:
    @staticmethod
    def _tactic_mask(engine: TenantEngine, session: ChatSession) -> Optional[np.ndarray]:
-        """지금 플레이 가능한 action 만 True. HOLD(설득)는 발동조건만, 금액 카드는 제안가 유효까지
+        """전술 발동조건(min_round·가격구간)을 만족하는 action 만 True. HOLD(설득)는 항상 True.
        본다(playable) — 무효 금액(역행·목표가 초과 등)이 멘트 글자로 나가는 것 자체를 막는다.
        전부 True 면 None(마스크 불필요)."""
        ctx = session.context
        mask = np.array(
-            [playable(spec_from_context(ctx, engine.mapper.get_card_id(a)), ctx)
+            [tactic_available(tactic_for(engine.mapper.get_card_id(a)), session.context)
             for a in range(engine.action_space_size)],
            dtype=bool,
        )
@ -500,26 +469,13 @@ 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, done,
+    async def _log(self, repo: LearningRepository, session, state_index, action_id, card_id, snap, reward, propensity, 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(),
+            "card_id": card_id, "snapshot": snap.to_dict(), "propensity": propensity,
            "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:
--- a/agent/services/negotiation_service.py
+++ b/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, policy)
+            res.logged = await self._log(engine, session_id, idx, decision, snap, reward)
        return res
-    async def _log(self, engine, session_id, idx, decision, snap, reward, policy) -> bool:
+    async def _log(self, engine, session_id, idx, decision, snap, reward) -> bool:
        repo = LearningRepository(engine.company_id)
        data = {
            "session_id": session_id, "state_index": idx, "action_id": decision.action_id,
@ -108,8 +108,6 @@ 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:
--- a/agent/tenants/_base/resources/scripts_cards.json
+++ b/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": "적극적으로 협조해 주셔서 감사합니다. 현재 제시가는 {label_target_price}(**{target}원**)와는 아직 차이가 있습니다. 조금만 더 좁혀 주시면 우선협상 대상으로 검토하겠습니다.",
+    "1": "적극적으로 협조해 주셔서 감사합니다. 현재 제시가는 목표 매입가(**{target}원**)와는 아직 차이가 있습니다. 조금만 더 좁혀 주시면 우선협상 대상으로 검토하겠습니다.",
-    "2": "좋은 제안 감사합니다. 다른 {label_supplier}들의 제안 수준을 고려할 때, 현재 금액으로는 경쟁력이 다소 부족합니다. 재검토된 가격을 부탁드립니다.",
+    "2": "좋은 제안 감사합니다. 다른 협력사들의 제안 수준을 고려할 때, 현재 금액으로는 경쟁력이 다소 부족합니다. 재검토된 가격을 부탁드립니다.",
    "3": "협상에 성실히 임해 주셔서 감사합니다. 내부 승인 기준에 맞추려면 앵커가({anchor}원) 수준에 가까운 제안이 필요합니다. 가능하신 범위에서 다시 제안해 주세요.",
-    "4": "제시해 주신 조건은 의미 있는 진전입니다. 다만 거래를 확정하려면 조금 더 협조가 필요합니다. 한 차례 더 조정해 주시겠어요?",
+    "4": "제시해 주신 인하율 약 {discount_rate}%는 의미 있는 진전입니다. 다만 거래를 확정하려면 조금 더 협조가 필요합니다. 한 차례 더 조정해 주시겠어요?",
    "5": "장기적인 협력 관계를 고려해 최대한 반영하고자 합니다. 현재 제시가에서 추가로 조정해 주시면 즉시 검토를 진행하겠습니다. 다시 제안 부탁드립니다.",
    "6": "검토 결과, 현재 제시가는 우리 기준을 충족하기 직전 단계입니다. 마지막으로 한 번 더 조정된 가격을 제안해 주시면 협상을 마무리할 수 있습니다.",
-    "7": "성의 있는 제안 감사합니다. 다만 물량과 납기 조건을 함께 고려하면 {input_price}원은 다소 높습니다. {label_target_price}({target}원)에 가까운 금액을 제안해 주세요.",
+    "7": "성의 있는 제안 감사합니다. 다만 물량과 납기 조건을 함께 고려하면 {input_price}원은 다소 높습니다. 목표 매입가({target}원)에 가까운 금액을 제안해 주세요.",
    "8": "긍정적으로 검토되고 있습니다. 내부 결재를 위해 명분이 조금 더 필요한 상황입니다. 가능하신 선에서 한 번 더 인하된 가격을 제안해 주시겠어요?"
 }
--- a/agent/tenants/_base/resources/scripts_renegotiation.json
+++ b/agent/tenants/_base/resources/scripts_renegotiation.json
@ -12,7 +12,7 @@
        "chat_end": false
    },
    "서비스안내": {
-        "script": "안녕하세요. {company_name} {service_name}입니다. 본 서비스는 {company_name}와 {label_supplier} 간 물품 공급 가격 협상을 위한 것으로, 귀사가 공급 중인 품목의 새로운 가격 협상을 진행합니다. 안내 사항을 확인하신 뒤, 다음 단계로 넘어가려면 [확인]을 눌러 주세요.",
+        "script": "안녕하세요. {company_name} {service_name}입니다. 본 서비스는 {company_name}와 협력사 간 물품 공급 가격 협상을 위한 것으로, 귀사가 공급 중인 품목의 새로운 가격 협상을 진행합니다. 안내 사항을 확인하신 뒤, 다음 단계로 넘어가려면 [확인]을 눌러 주세요.",
        "editor_script_id": "서비스안내",
        "next_input_mode": "confirm",
        "input_options": [
@ -25,7 +25,7 @@
        "chat_end": false
    },
    "담당자확인": {
-        "script": "본 안내는 {label_supplier} 포털에 등록된 담당자에게 발송되었습니다. 구매 협상 담당자가 맞는지 다시 한 번 확인 부탁드립니다. 담당자가 맞다면 [예], 맞지 않다면 [아니오]를 선택해 주세요.",
+        "script": "본 안내는 협력사 포털에 등록된 담당자에게 발송되었습니다. 구매 협상 담당자가 맞는지 다시 한 번 확인 부탁드립니다. 담당자가 맞다면 [예], 맞지 않다면 [아니오]를 선택해 주세요.",
        "editor_script_id": "담당자확인",
        "next_input_mode": "yes_no",
        "input_options": [
@ -55,7 +55,7 @@
        "chat_end": false
    },
    "정보변경_완료": {
-        "script": "[정보변경]을 선택하셨습니다. {label_supplier} 관리 시스템에서 담당자 정보를 변경하신 뒤, 고객센터로 새 견적 생성을 요청해 주세요. 24시간 이내에 갱신되지 않으면 참여 의사가 없는 것으로 간주되어 해당 견적 건이 미참여로 처리될 수 있습니다.",
+        "script": "[정보변경]을 선택하셨습니다. 협력사 관리 시스템에서 담당자 정보를 변경하신 뒤, 고객센터로 새 견적 생성을 요청해 주세요. 24시간 이내에 갱신되지 않으면 참여 의사가 없는 것으로 간주되어 해당 견적 건이 미참여로 처리될 수 있습니다.",
        "editor_script_id": "정보변경_완료",
        "next_input_mode": "null",
        "input_options": [],
--- a/agent/tenants/_base/resources/scripts_requote.json
+++ b/agent/tenants/_base/resources/scripts_requote.json
@ -10,7 +10,7 @@
        "chat_end": false
    },
    "서비스안내": {
-        "script": "안녕하세요. {company_name} {service_name}입니다. 본 서비스는 {company_name}와 {label_supplier} 간 신규 물품 공급 협상을 위한 것으로, 귀사에 새로운 공급 기회를 제공하고자 합니다. 이용 방법 안내를 확인하신 뒤 [확인]을 눌러 주세요.",
+        "script": "안녕하세요. {company_name} {service_name}입니다. 본 서비스는 {company_name}와 협력사 간 신규 물품 공급 협상을 위한 것으로, 귀사에 새로운 공급 기회를 제공하고자 합니다. 이용 방법 안내를 확인하신 뒤 [확인]을 눌러 주세요.",
        "editor_script_id": "서비스안내",
        "next_input_mode": "confirm",
        "input_options": ["확인"],
@ -19,7 +19,7 @@
        "chat_end": false
    },
    "담당자확인": {
-        "script": "본 안내는 {label_supplier} 포털에 등록된 담당자에게 발송되었습니다. 구매 협상 담당자가 맞는지 확인 부탁드립니다. 담당자가 맞다면 [예], 맞지 않다면 [아니오]를 선택해 주세요.",
+        "script": "본 안내는 협력사 포털에 등록된 담당자에게 발송되었습니다. 구매 협상 담당자가 맞는지 확인 부탁드립니다. 담당자가 맞다면 [예], 맞지 않다면 [아니오]를 선택해 주세요.",
        "editor_script_id": "담당자확인",
        "next_input_mode": "yes_no",
        "input_options": ["예", "아니오"],
@ -37,7 +37,7 @@
        "chat_end": false
    },
    "정보변경_완료": {
-        "script": "[정보변경]을 선택하셨습니다. {label_supplier} 관리 시스템에서 담당자 정보를 변경하신 뒤 고객센터로 새 견적 생성을 요청해 주세요. 24시간 이내 갱신되지 않으면 미참여로 처리될 수 있습니다.",
+        "script": "[정보변경]을 선택하셨습니다. 협력사 관리 시스템에서 담당자 정보를 변경하신 뒤 고객센터로 새 견적 생성을 요청해 주세요. 24시간 이내 갱신되지 않으면 미참여로 처리될 수 있습니다.",
        "editor_script_id": "정보변경_완료",
        "next_input_mode": "null",
        "input_options": [],
@ -46,7 +46,7 @@
        "chat_end": true
    },
    "협상품목안내": {
-        "script": "{company_name}는 아래 상품에 대해 신규 {label_supplier_를} 선정하고 있으며, 귀사를 초대하여 견적을 요청드립니다. 제출하신 견적은 복수 업체와의 비교 평가를 통해 {label_supplier} 선정에 반영됩니다. 상품 정보를 확인해 주세요.",
+        "script": "{company_name}는 아래 상품에 대해 신규 공급사를 선정하고 있으며, 귀사를 초대하여 견적을 요청드립니다. 제출하신 견적은 복수 업체와의 비교 평가를 통해 공급사 선정에 반영됩니다. 상품 정보를 확인해 주세요.",
        "editor_script_id": "협상품목안내",
        "next_input_mode": "confirm",
        "input_options": ["네, 알겠습니다."],
@ -73,10 +73,10 @@
        "chat_end": false
    },
    "배송형태선택": {
-        "script": "{label_delivery_type_를} 선택해 주세요.",
+        "script": "배송 형태를 선택해 주세요.",
        "editor_script_id": "배송형태선택",
        "next_input_mode": "delivery_type",
-        "input_options": ["{label_delivery_type_1}", "{label_delivery_type_2}", "{label_delivery_type_3}"],
+        "input_options": ["협력사배송", "지정택배배송", "픽업배송"],
        "next_step": { "default": "가격협상_입력" },
        "type": "text",
        "chat_end": false
--- a/agent/tenants/_base/resources/scripts_wildcard.json
+++ b/agent/tenants/_base/resources/scripts_wildcard.json
@ -15,7 +15,7 @@
        "editor_script_id": "wild_card_1pct"
    },
    "wild_card_budget": {
-        "script": "솔직히 말씀드리면 현재 내부 예산(재원) 사정상 제안을 그대로 수용하기 어렵습니다. 당사 {label_target_price}는 **{target}원**입니다. 이 가격에 맞춰 주신다면 즉시 계약을 진행하고자 합니다. 마지막으로 한 번 더 제안 부탁드립니다.",
+        "script": "솔직히 말씀드리면 현재 내부 예산(재원) 사정상 제안을 그대로 수용하기 어렵습니다. 목표 매입가는 **{target}원**입니다. 이 가격에 맞춰 주신다면 즉시 계약을 진행하고자 합니다. 마지막으로 한 번 더 제안 부탁드립니다.",
        "type": "text",
        "chat_end": false,
        "next_input_mode": "price",
--- a/agent/tests/fuzz_negotiation.py
+++ b/agent/tests/fuzz_negotiation.py
@ -1,157 +0,0 @@
 """협상 퍼즈 하네스 — 랜덤 조건·랜덤 협력사 행동으로 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())
--- a/agent/tests/test_agent_integration.py
+++ b/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 == 9               # DB 카탈로그 9장(NGC-006·009 소프트삭제)
+    assert eng.action_space_size == 11              # base 기본 카드(162×11 정합)
    assert eng.state_space_size == 162
--- a/agent/tests/test_card_selection_e2e.py
+++ b/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 == 9                # 카탈로그 9장(NGC-006·009 소프트삭제)
+        assert eng.action_space_size == 11               # 카탈로그 11장(NGC-001~011)
        svc = ChatService()
        played = []
--- a/agent/tests/test_card_tactics.py
+++ b/agent/tests/test_card_tactics.py
@ -1,12 +1,11 @@
-"""카드 전술 검증 — "스크립트에 꽂힌 변수가 곧 전술" (파싱 + 변수별 유효조건 + tactic JSONB).
+"""카드 전술 재설계 검증 — "멘트 카드 → 전술 카드" (가격 행동 실행 계층).
-① 제안가 파싱(마지막 제안가 변수) + 변수별 계산식 결정론
+① 카운터 산식 결정론 + min(counter, target) 클램프 + 무의미 카운터(HOLD 강등)
-② 변수 공통 유효조건 — 목표가 초과·제시가 이상이면 미발동(클램프 아님 — IMK 8AB0 회귀)
+② 카운터 수락 = 즉시 타결 / 거절 = 재입력 + pending 폐기
-③ 카운터 수락 = 즉시 타결 / 거절 = 재입력 + pending 폐기
+③ 목표가 초과 타결 금지 가드(성공 스텝 진입 차단)
-④ 목표가 초과 타결 금지 가드(성공 스텝 진입 차단)
+④ 선택형 와일드카드(WC-05 중간값 절충) 발동 — 1.02~1.05 구간 갭 해소
-⑤ 와일드 진입 — 종결 전용 카드 예약(중반 미발동) + 카드 이력 공유(중복 발동 차단, IMK BB9A 회귀)
+⑤ E2E: 견적 선택 카드(NGC-009 조건부 가격 조정)의 카운터를 수락하면 settled=target
-⑥ E2E: 견적 선택 카드(NGC-010 목표가 제안)의 카운터를 수락하면 settled=target
+⑥ E2E: 협력사가 target 초과를 고수하면 종결 전술(최후통첩) 후 결렬 — 고객사 이득 가드레일
 ⑦ E2E: 협력사가 target 초과를 고수하면 종결 전술(최후통첩) 후 결렬 — 고객사 이득 가드레일
 """
 import os
@ -16,8 +15,7 @@ from datetime import datetime, timedelta, timezone
 import pytest
 from negotiation.cards.domain.tactics import (
-    CardSpec, HOLD, available, build_card_spec, compute_offer,
+    PriceAction, TacticSpec, compute_counter, tactic_available, tactic_for,
    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
@ -25,12 +23,6 @@ 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")
@ -39,134 +31,47 @@ def _engine() -> ChatEngine:
 def _session(step="가격협상_확인", **ctx_over):
    ctx = {"input_price": 10300, "anchor_price": 10000, "target_price": 10100,
-           "round": 1, "allow_selected_wildcards": False, "card_specs": dict(_SPECS)}
+           "round": 1, "allow_selected_wildcards": False}
    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_parse_offer_variable_last_offer_wins():
+def test_counter_formulas_and_clamp():
    """제안가 변수가 여럿이면 마지막 것 — 카드 문장은 배경을 먼저, 제안을 마지막에 한다(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}
-    offer = lambda var, c=None: compute_offer(CardSpec(offer_variable=var), c or ctx)  # noqa: E731
+    assert compute_counter(tactic_for("NGC-009"), ctx) == 10000        # COUNTER_TARGET
-    assert offer("target_price") == 10000
+    assert compute_counter(tactic_for("NGC-007"), ctx) == 9900         # COUNTER_ANCHOR
-    assert offer("anchoring_price") == 9900
+    assert compute_counter(tactic_for("WC-02"), ctx) == 9950           # (anchor+target)/2
-    assert offer("target_mid_price") == 9950                       # (anchor+target)/2
+    # COUNTER_MID: 갑 직전 포지션 폴백 = anchor → (9900+11000)/2 = 10450 → target 클램프
-    # 절충가: 갑 직전 포지션 폴백 = anchor → (8900+9500)/2 = 9200
+    assert compute_counter(tactic_for("WC-05"), ctx) == 10000
-    assert offer("middle_price", dict(ctx, input_price=9500, anchor_price=8900)) == 9200
+    # 갑 직전 포지션이 있으면 그 기준: (9800+11000)/2 = 10400 → 역시 클램프 10000
-    # 갑 직전 포지션이 있으면 그 기준: (9000+9500)/2 = 9250
+    assert compute_counter(tactic_for("WC-05"), dict(ctx, prev_customer_price=9800)) == 10000
-    assert offer("middle_price", dict(ctx, input_price=9500, prev_customer_price=9000)) == 9250
+    # 클램프 미발동 구간: (9900+10050)/2 = 9975 ≤ target
    assert compute_counter(tactic_for("WC-05"), dict(ctx, input_price=10050)) == 9975
-# ---- ② 변수 공통 유효조건 — 미발동(클램프 아님) --------------------------------
+def test_counter_meaningless_degrades_to_hold():
-def test_offer_over_target_does_not_fire_imk_8ab0():
+    """협력사 제시가가 이미 카운터 이하면 카운터가 무의미 → None(순수 설득 유지)."""
    """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_offer(CardSpec(offer_variable="target_price"), ctx) is None      # target ≥ 제시가
+    assert compute_counter(tactic_for("NGC-009"), ctx) is None         # target(10000) ≥ 제시가
-    assert compute_offer(CardSpec(offer_variable="anchoring_price"), dict(ctx, input_price=9900)) is None
+    assert compute_counter(TacticSpec(PriceAction.COUNTER_ANCHOR), dict(ctx, input_price=9900)) is None
-def test_offer_without_materials_does_not_fire():
+def test_unknown_card_falls_back_to_hold():
-    """재료 결측(목표가·제시가·앵커) — 어떤 변수도 미발동."""
+    """미등록 카드번호(데모 NGC-B*, 커스텀 COMP-*)는 HOLD — 기존 동작 그대로."""
-    assert compute_offer(CardSpec(offer_variable="target_price"), {"input_price": 11000}) is None   # 목표가 없음
+    spec = tactic_for("NGC-B003")
-    assert compute_offer(CardSpec(offer_variable="anchoring_price"),
+    assert spec.price_action is PriceAction.HOLD
-                         {"input_price": 11000, "target_price": 10000}) is None                     # 앵커 없음
+    assert compute_counter(spec, {"input_price": 11000, "target_price": 10000}) is None
-    assert compute_offer(HOLD, {"input_price": 11000, "target_price": 10000}) is None               # 설득 카드
+    assert tactic_available(spec, {}) is True
    assert compute_offer(CardSpec(offer_variable="없는변수"), {"input_price": 11000, "target_price": 10000}) is None
-def test_available_min_round_and_closing_phase():
+def test_tactic_availability_conditions():
-    spec2 = CardSpec(offer_variable="target_price", min_round=2)
+    assert tactic_available(tactic_for("WC-04"), {"round": 1}) is False   # min_round=2
-    assert available(spec2, {"round": 1}) is False                  # min_round 미만
+    assert tactic_available(tactic_for("WC-04"), {"round": 2}) is True
    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)
@ -197,7 +102,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)
@ -205,46 +110,20 @@ def test_success_step_guard_rejects_over_target():
    assert view.step == "협상실패"                          # 초과가 성공 진입 → 결렬 강제
-# ---- ⑤ 와일드 진입 — 종결 예약 + 중복 차단 (IMK BB9A 회귀) ---------------------
+# ---- ④ 선택형 와일드카드 발동 (1.02~1.05 구간 갭 해소) -------------------------
-def test_selected_wildcard_fires_in_entry_zone_and_records_position():
+def test_selected_wildcard_fires_in_entry_zone():
    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 == "가격협상"                          # 종결 카드뿐 → 일반 카드 플레이로
+    assert view.step == "wild_card_dynamic"
-    assert "active_wild_card_number" not in s.context
+    # 카운터 = (anchor 10000 + 10300)/2 = 10150 → target(10100) 클램프
-    assert not is_played(s.context, "WC-05")                # 안 나갔으니 이력도 없음
+    assert s.context["pending_counter_price"] == 10100
-    # 종결 국면에선 발동 가능 + 이력 없음 — 서비스 종결 루프가 이 카드를 쓴다
+    assert s.context["active_wild_card_number"] == "WC-05"
-    spec = spec_from_context(s.context, "WC-05")
+    # 수락 → 그 가격으로 타결
-    assert available(spec, s.context, closing_phase=True) is True
+    view = eng.advance(s, "수락")
-
+    assert view.step == "협상완료" and s.context["input_price"] == 10100
 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():
@ -307,7 +186,7 @@ def test_vars_for_supplies_tactic_variables():
    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
@ -332,30 +211,24 @@ _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, *, wild=False):
+async def _card_uuid(number: str):
    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(pk).where(tbl.c.number == number, tbl.c.deleted == False).limit(1))  # noqa: E712
+            s, select(_T_NEGO.c.nego_card_id).where(
                _T_NEGO.c.number == number, _T_NEGO.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, wild_numbers=(), target=10000, anchor=9900):
+async def _seed_quote_session(sid, selected_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, wild_ids = {}, {}
+    card_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):
@ -370,11 +243,6 @@ async def _seed_quote_session(sid, selected_numbers, wild_numbers=(), target=100
                    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,
@ -392,18 +260,17 @@ 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-010(향후 거래 연계 — 스크립트 {target_price} 파싱 → 목표가 제안)의
+    """견적 선택 카드 NGC-009(조건부 가격 조정 → COUNTER_TARGET)의 카운터를 수락하면
-    카운터를 수락하면 합의가 = 목표가(10000) — '수락 즉시 타결' 기획 결정의 E2E 검증."""
+    합의가 = 목표가(10000) — '수락 즉시 타결' 기획 결정의 E2E 검증."""
    reset_sessions()
    sid = _uuid.uuid4()
-    qid, ver_id = await _seed_quote_session(sid, ["NGC-010"])
+    qid, ver_id = await _seed_quote_session(sid, ["NGC-009"])
    try:
        reg = TenantEngineRegistry(loader=TenantConfigLoader(tenants_dir=_TENANTS_DIR, cache_ttl_seconds=0))
        eng = await reg.get_engine(str(_uuid.uuid4()))
@ -412,9 +279,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-010 카운터(target) 제시 스텝
+        # 가격협상 카드 턴 → NGC-009 카운터(target) 제시 스텝
        assert r.step == "가격협상_카운터", f"카운터 스텝 기대, 실제 {r.step}"
-        assert r.card_id == "NGC-010"
+        assert r.card_id == "NGC-009"
        assert r.input_options == ["수락", "다른 가격 제시"]
        r = await svc.chat(eng, Req_Chat(session_id=session_id, user_input="수락"))
@ -430,7 +297,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"])   # 설득 카드 1장 → 빠른 소진
+    qid, ver_id = await _seed_quote_session(sid, ["NGC-003"])   # HOLD 카드 1장 → 빠른 소진
    try:
        reg = TenantEngineRegistry(loader=TenantConfigLoader(tenants_dir=_TENANTS_DIR, cache_ttl_seconds=0))
        eng = await reg.get_engine(str(_uuid.uuid4()))
@ -454,46 +321,3 @@ 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)
--- a/agent/tests/test_context_loader.py
+++ b/agent/tests/test_context_loader.py
@ -186,14 +186,11 @@ 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, done_ceiling_price, item_id, quotation_id, supplier_id)
+            # (qt_type, target, anchoring_price, item_id, quotation_id, supplier_id) — 재견적(2)·앵커 미박제
-            #   — 재견적(2)·앵커 미박제·타결상한 52,500(목표가 +5%)
+            return ErrorType.SUCCESS, (2, 50000, None, uuid.uuid4(), uuid.uuid4(), uuid.uuid4())
            return ErrorType.SUCCESS, (2, 50000, None, 52500, uuid.uuid4(), uuid.uuid4(), uuid.uuid4())
-        async def get_item_baseline(self, cdb, item_id):
+        async def get_item_price(self, cdb, item_id):
-            # 기준가를 매입가로 고른 회사 + 거래상대 호칭을 '공급업체'로 바꾼 용어 사전.
+            return ErrorType.SUCCESS, 7000
            # 호칭은 crud 가 어떤 회사든 '공급가'(공급사 화면 고정 용어)로 내려준다.
            return ErrorType.SUCCESS, (7000, "공급가", {"supplier": "공급업체"})
        async def get_item_lowest_price(self, cdb, item_id):
            return ErrorType.SUCCESS, 6300  # 인터넷 최저가(items.internet_lowest_price)
@ -220,22 +217,14 @@ async def test_loader_with_crud_double(db_engine):
            return ErrorType.SUCCESS, 0  # 이력도 없음 → NONE
        async def get_quotation_card_numbers(self, cdb, quotation_id):
-            # 행 = (number, script, tactic) — 스크립트 파싱 + tactic JSONB 로 card_specs 를 만든다
+            return ErrorType.SUCCESS, (["NGC-003", "NGC-008"], ["WC-02"])  # 견적 선택 카드
            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 == "테스트협력사"
@ -245,14 +234,6 @@ 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
--- a/agent/tests/test_decision_rules.py
+++ b/agent/tests/test_decision_rules.py
@ -49,14 +49,9 @@ def test_wildcard_threshold_is_config_driven():
    # 기본(1.02): anchor 10000, 제시 10800 → 임계 밖 → 일반 가격협상
    view = _engine().advance(_session(10800), "예")
    assert view.step == "가격협상"
-    # 임계를 1.10 으로 완화한 테넌트 → 같은 가격에서 1% 인하 와일드카드 발동.
+    # 임계를 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 == "가격협상"
+    assert view.step == "wild_card_1pct"
 def test_max_counter_rounds_is_config_driven():
--- a/agent/tests/test_negotiation_invariants.py
+++ b/agent/tests/test_negotiation_invariants.py
@ -1,190 +0,0 @@
 """협상 불변식 시나리오 하네스 — 실서비스 스택(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)
--- a/agent/tests/test_p4_registry_middleware.py
+++ b/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 == 9  # 카탈로그 9장(NGC-006·009 소프트삭제)
+    assert e1.state_space_size == 162 and e1.action_space_size == 11
@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 == 9 and eng.state_space_size == 162  # DB 카탈로그 9장
+    assert eng.action_space_size == 11 and eng.state_space_size == 162
    assert eng.company_id == "00000000-0000-0000-0000-000000000001"
    assert reg.is_registered("imarketkorea") is True
    # 빈 키만 미등록 → KeyError
--- a/agent/tests/test_p5_warmstart.py
+++ b/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):
-    """카탈로그 카드 수 변경(7→9) 시 학습 보존 마이그레이션 — 겹치는 셀 복사 + 새 카드 fresh."""
+    """카탈로그 카드 수 변경(9→11) 시 학습 보존 마이그레이션 — 겹치는 셀 복사 + 새 카드 fresh."""
    import uuid as _uuid
    cid = str(_uuid.uuid4())
-    # 이 회사 활성 버전을 A=7 로 시드 + 셀 (5,2)=0.9
+    # 이 회사 활성 버전을 A=9 로 시드 + 셀 (5,2)=0.9
    repo = LearningRepository(cid)
    vid = await repo.get_or_create_active_version(
-        state_space_size=162, action_space_size=7, learning_rate=0.1, discount_factor=0.95,
+        state_space_size=162, action_space_size=9, learning_rate=0.1, discount_factor=0.95,
-        scope=2, version_name="old_v7")
+        scope=2, version_name="old_v9")
    await repo.upsert_cell(vid, state_index=5, action_id=2, q_value=0.9, count=7)
-    # 엔진(_base type:db → 카탈로그 9장) 로드 → 7≠9 감지 → 마이그레이션
+    # 엔진(_base type:db → 카탈로그 11장) 로드 → 9≠11 감지 → 마이그레이션
    eng = await _reg().get_engine(cid)
-    assert eng.action_space_size == 9
+    assert eng.action_space_size == 11
    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, 8] == 0.0        # 새 카드(action 8) fresh
+    assert policy.qtable.q[5, 10] == 0.0       # 새 카드(action 10) 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 == 9
+    assert str(active.version_id) == str(new_vid) and active.action_space_size == 11
@pytest.mark.asyncio
--- a/agent/tests/test_scripts_resources.py
+++ b/agent/tests/test_scripts_resources.py
@ -42,10 +42,7 @@ def test_requote_structure_preserved():
    for key in ["서비스안내", "가격제안", "배송형태선택", "가격협상_확인", "결과안내", "결과제출", "협상종료"]:
        assert key in s
    assert s["배송형태선택"]["next_input_mode"] == "delivery_type"
-    # 리소스 원본은 회사 용어 토큰({label_*}) — 렌더 시 회사 라벨(없으면 기본값)로 치환된다.
+    assert s["배송형태선택"]["input_options"] == ["협력사배송", "지정택배배송", "픽업배송"]
    assert s["배송형태선택"]["input_options"] == [
        "{label_delivery_type_1}", "{label_delivery_type_2}", "{label_delivery_type_3}",
    ]
 def test_wildcard_present_and_merged():
@ -173,24 +170,3 @@ 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 == ["협력사배송", "지정택배배송", "픽업배송"]
--- a/backend/common/database/model/models.py
+++ b/backend/common/database/model/models.py
@ -173,7 +173,6 @@ 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)
@ -181,28 +180,6 @@ 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
--- a/backend/common/enums.py
+++ b/backend/common/enums.py
@ -130,41 +130,6 @@ 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 """
--- a/backend/crud/session_crud.py
+++ b/backend/crud/session_crud.py
@ -1,40 +1,24 @@
 from abc import ABC, abstractmethod
-from typing import Optional, Tuple
+from typing import Tuple
-from sqlalchemy import and_, case, cast, func, nulls_last, or_, select, text, update
+from sqlalchemy import case, func, nulls_last, select, 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 chats, items, quotations, sessions
+from common.database.model.models import items, quotations, sessions
-from common.enums import CloseReason, ErrorType, QuotationStatus, RENEGOTIABLE_CLOSE_REASONS, SessionStatus
+from common.enums import ErrorType, 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, keyword=None, result=None) -> Tuple[ErrorType, list]:
+    async def list_by_supplier(self, cdb: AsyncSession, supplier_id, status, qt_type, order, offset, limit) -> Tuple[ErrorType, list]:
        pass
    @abstractmethod
-    async def count_by_supplier(self, cdb: AsyncSession, supplier_id, status, qt_type, keyword=None, result=None) -> Tuple[ErrorType, int]:
+    async def count_by_supplier(self, cdb: AsyncSession, supplier_id, status, qt_type) -> Tuple[ErrorType, int]:
        pass
    @abstractmethod
@ -54,56 +38,27 @@ class ISessionCRUD(ABC):
        pass
    @abstractmethod
-    async def update_session_reject(
+    async def update_session_reject(self, cdb: AsyncSession, session_id, status: int, reject_reason: str) -> ErrorType:
        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, keyword=None, result=None):
+    def __filters(supplier_id, status, qt_type):
        conds = [sessions.supplier_id == supplier_id, sessions.deleted == False]  # noqa: E712
        if status is not None:
-            # 표시 상태로 필터 — 탭/KPI 카운트가 목록 배지와 어긋나지 않게 파생값을 그대로 쓴다.
+            conds.append(sessions.status == status)
            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, keyword=None, result=None) -> Tuple[ErrorType, list]:
+    async def list_by_supplier(self, cdb: AsyncSession, supplier_id, status, qt_type, order, offset, limit) -> Tuple[ErrorType, list]:
        try:
-            conds = self.__filters(supplier_id, status, qt_type, keyword, result)
+            conds = self.__filters(supplier_id, status, qt_type)
            # 정렬 규칙:
            #  - order 를 명시(asc/desc)하면 그룹 구분 없이 전체를 마감 기준 한 줄로 정렬(전체 정렬).
@ -118,7 +73,7 @@ class SessionCRUD(ISessionCRUD):
            else:
                # 그룹별로 정렬 방향이 달라, case 로 '자기 그룹 행만 end_time' 을 갖는 키를 만들고
                # 반대 그룹은 NULL 로 눌러 간섭을 없앤다. status_rank 가 1차 키라 그룹 경계는 항상 유지.
-                actionable = _effective_status().in_((SessionStatus.CREATED.value, SessionStatus.IN_PROGRESS.value))
+                actionable = sessions.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()
@ -127,7 +82,7 @@ class SessionCRUD(ISessionCRUD):
            query = (
                select(
                    sessions.session_id,
-                    _effective_status(),  # 마감 후 남은 협상생성은 미참여로 내린다
+                    sessions.status,
                    sessions.qt_type,
                    sessions.qt_number,
                    quotations.end_time,  # qt_end_time = 견적 마감 시각
@ -136,16 +91,6 @@ class SessionCRUD(ISessionCRUD):
                    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)
@ -162,9 +107,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, keyword=None, result=None) -> Tuple[ErrorType, int]:
+    async def count_by_supplier(self, cdb: AsyncSession, supplier_id, status, qt_type) -> Tuple[ErrorType, int]:
        try:
-            conds = self.__filters(supplier_id, status, qt_type, keyword, result)
+            conds = self.__filters(supplier_id, status, qt_type)
            query = (
                select(func.count())
                .select_from(sessions)
@ -222,45 +167,12 @@ class SessionCRUD(ISessionCRUD):
            LOG.e_no_callstack(ex)
            return ErrorType.DB_RUN_FAILED
-    async def update_session_reject(
+    async def update_session_reject(self, cdb: AsyncSession, session_id, status: int, reject_reason: str) -> ErrorType:
        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(**values)
+                .values(status=status, reject_reason=reject_reason)
            )
            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:
--- a/backend/router/v1/auth/protocol.py
+++ b/backend/router/v1/auth/protocol.py
@ -50,7 +50,6 @@ class Res_Me(Res_WebPacketProtocol):
    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):
@ -72,4 +71,4 @@ class Res_HidePopup(Res_WebPacketProtocol):
 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). 한 줄 = 담당자 한 명")
+    primary_color: str = Field("", description="브랜드 색상(hex)")
--- a/backend/router/v1/chat/protocol.py
+++ b/backend/router/v1/chat/protocol.py
@ -63,7 +63,6 @@ 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")
@ -79,9 +78,6 @@ class Res_ChatInit(Res_WebPacketProtocol):
    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) 치환용. 없으면 프론트 기본값")
 # 대화 히스토리(재진입 복원)
--- a/backend/router/v1/negotiation/protocol.py
+++ b/backend/router/v1/negotiation/protocol.py
@ -1,5 +1,3 @@
 from typing import Optional
 from pydantic import Field
 from common.models.gmodel import Res_WebPacketProtocol, WebPacketProtocol
@ -17,13 +15,6 @@ class ListItem(WebPacketProtocol):
    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):
@ -39,8 +30,6 @@ 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):
@ -53,13 +42,3 @@ class Req_ExtraInfo(WebPacketProtocol):
 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=철회")
--- a/backend/router/v1/negotiation/session.py
+++ b/backend/router/v1/negotiation/session.py
@ -6,16 +6,7 @@ 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 (
+from .protocol import Req_ExtraInfo, Req_Reject, Res_ExtraInfo, Res_Participate, Res_Reject, Res_SessionList
    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"}})
@ -35,11 +26,9 @@ 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, keyword, result)
+        await service.list_sessions(user_info, credentials.credentials, status, qt_type, order, page, page_size)
    )
@ -62,7 +51,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"),
@ -71,11 +60,7 @@ async def reject(
    credentials: HTTPAuthorizationCredentials = Depends(security),
    service: NegotiationService = Depends(),
 ):
-    return RemoveNoneResponse(
+    return RemoveNoneResponse(await service.reject(user_info, credentials.credentials, session_id, req.reject_reason))
        await service.reject(
            user_info, credentials.credentials, session_id, req.reject_reason, req.reject_price, req.opinion,
        )
    )
@router.post(
@ -92,38 +77,3 @@ async def save_extra_info(
    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)
    )
--- a/backend/services/auth_service.py
+++ b/backend/services/auth_service.py
@ -260,7 +260,6 @@ class AuthService:
        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:
@ -279,7 +278,7 @@ class AuthService:
        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 []
+        res.primary_color = branding.get("primary_color") or ""
        return res
    async def popup_status(self, user_info: UserInfo, access_token: str) -> Res_PopupStatus:
--- a/backend/services/chat_service.py
+++ b/backend/services/chat_service.py
@ -24,7 +24,6 @@ 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
@ -45,13 +44,11 @@ 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 불필요, 상단 집약) ----
@ -62,35 +59,6 @@ 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:
@ -235,15 +203,17 @@ class ChatService:
            )
            sess.status = SessionStatus.NOT_PARTICIPATED.value
-        # 미참여/협상거부 세션도 '결과 보기'로 지난 대화를 열람할 수 있다(중간 이탈·거부로 끝난 건).
+        # 미참여/협상거부 상태는 진입(열람) 불가 (participate/reject 와 동일 규칙).
-        # 대화 재개는 send() 가 협상중(2)만 허용하므로 여기서 막지 않아도 읽기 전용이다.
+        # 위 마감 변환으로 미참여가 된 세션도 여기서 함께 막힌다.
        if sess.status in (SessionStatus.NOT_PARTICIPATED.value, SessionStatus.REJECTED.value):
            res.result.SetResult(ErrorType.NEGO_NOT_PARTICIPABLE)
            return res
        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)
@ -259,35 +229,6 @@ class ChatService:
        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:
@ -474,40 +415,24 @@ 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)로 종류를 가르고,
+        # 카드 번호(turn.card_id) → UUID 변환. step 으로 nego/wild 갈라 각 테이블 조회(번호가 겹칠 수 있어 종류로 구분).
        # 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)
+            is_wild = bool(turn.step and turn.step.startswith("wild"))
-            if number.startswith("WC"):
+            if is_wild:
-                wild_first = True
+                card_uuid = await DB_SESSION_MNG.execute_lambda(
            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),
+                    lambda s: self.chat_crud.get_wild_card_id_by_number(s, str(turn.card_id)),
                )
-                return found, 1
+                card_type = 2
-
+            else:
-            card_uuid, card_type = await _lookup(wild_first)
+                card_uuid = await DB_SESSION_MNG.execute_lambda(
-            if card_uuid is None:
+                    chats.DBType(), DBWRType.DB_READ.value,
-                card_uuid, card_type = await _lookup(not wild_first)
+                    lambda s: self.chat_crud.get_nego_card_id_by_number(s, str(turn.card_id)),
-            if card_uuid is None:
+                )
-                card_type = None
+                card_type = 1
        # 봇 메시지 + 종료 시 확정(성공=DONE+입찰가 / 실패=REJECTED+거부사유·제시가). 한 트랜잭션.
        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)
@ -530,15 +455,10 @@ 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=parsed["reason"], reject_price=parsed["offer_price"],
+                    reject_reason=(user_input or None), reject_price=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:
@ -648,17 +568,7 @@ class ChatService:
        # 배송형태: 재견적(CM)의 '배송형태선택' 단계에서 공급사가 고른 라벨. 재협상엔 단계가 없어 None.
        delivery_label = await self._delivery_choice(sess) if sess.qt_type == 2 else None
        # 상품 기본 배송유형(코드→라벨). 선택값이 없으면 표시에 폴백으로 쓸 수 있다.
-        #   회사가 배송유형 보기를 자기 용어로 바꿨으면(settings.labels['delivery_type.N']) 그 단어를 쓴다 —
+        item_delivery_label = DeliveryType.label_of(item.delivery_type) if item and item.delivery_type is not None else ""
        #   협상 중 공급사가 고른 보기와 요약 표기가 갈리지 않도록.
        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:
--- a/backend/services/negotiation_service.py
+++ b/backend/services/negotiation_service.py
@ -1,35 +1,15 @@
 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 chats, notifications, sessions
+from common.database.model.models import chats, sessions
-from common.enums import (
+from common.enums import DBWRType, ErrorType, QuotationStatus, SessionStatus
    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 (
+from router.v1.negotiation.protocol import ListItem, Req_ExtraInfo, Res_ExtraInfo, Res_Participate, Res_Reject, Res_SessionList
    ListItem,
    Req_ExtraInfo,
    Req_Renegotiation,
    Res_ExtraInfo,
    Res_Participate,
    Res_Reject,
    Res_Renegotiation,
    Res_SessionList,
 )
 from services.auth_service import AuthService
@ -52,7 +32,7 @@ class NegotiationService:
        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, keyword: str = None, result: int = None) -> Res_SessionList:
+    async def list_sessions(self, user_info: UserInfo, access_token: str, status, qt_type, order: str, page: int, page_size: int) -> Res_SessionList:
        res = Res_SessionList()
        # 1) 인증 (활성 + 저장된 access 토큰 대조)
@ -68,7 +48,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, keyword, result),
+            lambda s: self.session_crud.list_by_supplier(s, supplier_id, status, qt_type, order, offset, page_size),
        )
        if err_type != ErrorType.SUCCESS:
            res.result.SetResult(err_type)
@ -78,22 +58,27 @@ 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, keyword, result),
+            lambda s: self.session_crud.count_by_supplier(s, supplier_id, status, qt_type),
        )
        if err_type != ErrorType.SUCCESS:
            res.result.SetResult(err_type)
            return res
-        # 같은 견적번호(체인)의 최대 차수 — 이미 다음 라운드가 있으면 재협상 요청 대상이 아니다.
+        res.items = [
-        max_rounds: dict = {}
+            ListItem(
-        for number in {r[3] for r in rows if r[3]}:
+                session_id=str(r[0]),
-            _e, mx = await DB_SESSION_MNG.execute_lambda(
+                session_status=r[1],
-                sessions.DBType(), DBWRType.DB_READ.value,
+                qt_type=r[2],
-                lambda s, n=number: self.session_crud.chain_max_round(s, n),
+                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=r[9] or {},
            )
-            max_rounds[number] = mx or 0
+            for r in rows
-
+        ]
        res.items = [self._to_list_item(r, max_rounds) for r in rows]
        res.total = total
        res.page = page
        res.page_size = page_size
@ -149,193 +134,6 @@ class NegotiationService:
        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(
@ -438,10 +236,7 @@ class NegotiationService:
        res.session_id = str(sess.session_id)
        return res
-    async def reject(
+    async def reject(self, user_info: UserInfo, access_token: str, session_id_str: str, reject_reason: str) -> Res_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()
        # 거부 사유 필수
@ -461,19 +256,11 @@ class NegotiationService:
            res.result.SetResult(err_type)
            return res
-        # 거부 처리 — 세션을 협상거부로 전이하고 사유·공급 희망 가격 저장.
+        # 거부 처리 — 세션을 협상거부로 전이하고 사유 저장
-        # 의견은 부가정보와 같은 custom 컬럼이라 병합(덮어쓰기 금지) — 채팅 결렬 폼과 같은 자리.
+        err_type = await DB_SESSION_MNG.execute_lambda_run(
-        funcs = [
+            [sessions.DBType()],
-            lambda s: self.session_crud.update_session_reject(
+            [lambda s: self.session_crud.update_session_reject(s, sess.session_id, SessionStatus.REJECTED.value, reason)],
-                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
--- a/backend/tests/test_chat.py
+++ b/backend/tests/test_chat.py
@ -220,58 +220,12 @@ 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)
@ -397,28 +351,23 @@ 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()
-    assert body["result"]["success"] is True
+    # 마감된 협상생성은 DB 상 미참여로 정리되고, 미참여는 진입 불가라 init 은 에러로 막는다.
-    assert body["session_status"] == 4
+    assert body["result"]["code"] == 1301           # NEGO_NOT_PARTICIPABLE
-    assert await _session_status(db_engine, sid) == 4  # DB 도 미참여로 전이
+    assert await _session_status(db_engine, sid) == 4  # DB 는 미참여로 전이됨
-async def test_init_allows_viewing_rejected_session(client, chat_seed, db_engine):
+async def test_init_blocks_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"]["success"] is True and body["session_status"] == 5
+    assert body["result"]["code"] == 1301           # NEGO_NOT_PARTICIPABLE — 거부 세션 진입 차단
    assert (await _send(client, token, sid, "네")).json()["result"]["code"] == 1400  # CHAT_NOT_IN_PROGRESS
 # ---- 순수 헬퍼 단위 테스트 (DB 불필요, ChatService @staticmethod) ----------
--- a/backend/tests/test_negotiation.py
+++ b/backend/tests/test_negotiation.py
@ -16,35 +16,6 @@ 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 를 반환."""
@ -62,11 +33,6 @@ 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}%'"))
@ -86,9 +52,31 @@ async def nego_seed(db_engine):
            ),
            {"sid": supplier_id, "id": TEST_LOGIN_ID, "pw": pw_hash},
        )
-        for spec in specs:
+        for code, sess_st, qt_type, hrs, quote_st, sup in specs:
-            code = spec[0]
+            item_id, qt_id, session_id = uuid.uuid4(), uuid.uuid4(), uuid.uuid4()
-            sids[code], qids[code] = await _seed_case(conn, *spec)
+            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},
            )
    yield {"supplier_id": supplier_id, "sids": sids, "qids": qids}
@ -153,63 +141,6 @@ 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()
@ -246,56 +177,6 @@ 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)
@ -385,65 +266,6 @@ 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"], "   ")  # 공백만 → 사유 없음
@ -472,76 +294,3 @@ 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
--- a/backend/tests/test_renegotiation.py
+++ b/backend/tests/test_renegotiation.py
@ -1,215 +0,0 @@
 """공급사 재협상 요청/철회(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
--- a/backend/tests/test_session_result.py
+++ b/backend/tests/test_session_result.py
@ -1,51 +0,0 @@
 """공급사 관점 협상 결과 파생(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
--- a/dev-settings.png
+++ b/dev-settings.png
--- a/docker-compose.prod.landing.yml
+++ b/docker-compose.prod.landing.yml
@ -1,214 +0,0 @@
 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:
--- a/docker-compose.yml
+++ b/docker-compose.yml
@ -10,8 +10,6 @@
 #   솔루션 랜딩:    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)
@ -44,7 +42,6 @@ services:
      # ── 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:
@ -132,7 +129,10 @@ services:
        max-size: "10m"
        max-file: "5"
-  # LPS API (인터넷 최저가 검색 — 요청 접수/조회, lean). 설정·시크릿은 config.local.toml 하나(미커밋, 마운트).
+  # ── LPS (인터넷 최저가 검색) ──────────────────────────────────
  # API(요청 접수, lean) + 워커(크롤, 헤드풀 Chromium+Xvfb). DB 는 외부(host.docker.internal).
  # 이미지엔 시크릿이 없다(example config 로 빌드) — 실값은 아래 env 로 주입.
  # 시크릿 값은 리포 루트 .env 파일에 채운다(.env.example 참고, .env 는 미커밋).
  lps-api:
    build:
      context: ./lps
@ -140,12 +140,18 @@ services:
    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)
+      DB_HOST: host.docker.internal   # 컨테이너→호스트 DB (example toml 의 127.0.0.1 override)
      DB_USER: ${LPS_DB_USER:-postgres}
      DB_PASSWORD: ${LPS_DB_PASSWORD:-postgres}
      PYTHONUNBUFFERED: "1"
-    volumes:
+      # 멀티코어: PROCESS_COUNT(uvicorn 워커=코어수)를 올리면 커넥션 풀은 자동 산정된다.
-      - ./lps/config/config.local.toml:/app/config/config.local.toml:ro
+      # (pool+overflow)×2엔진×PROCESS_COUNT ≤ DB_CONNECTION_BUDGET 를 config 가 스스로 보장.
      # 값은 .env 에서 서버별로 조정(compose 수정 불필요). API 병목은 드묾 — 기본 1이면 충분,
      # 부하테스트/대량 폴링 대비 시에만 코어 수만큼 상향(예: 4).
      PROCESS_COUNT: ${LPS_API_PROCESS_COUNT:-1}
      DB_CONNECTION_BUDGET: ${LPS_DB_CONNECTION_BUDGET:-40}   # 전용 PG(max_connections≈100)면 90 근처로 상향
    ports:
-      - "${LPS_API_BIND:-0.0.0.0}:9600:9600"   # prod 는 LPS_API_BIND=127.0.0.1 로 내부만 개방(리버스프록시 뒤)
+      - "9600:9600"
    extra_hosts:
      - "host.docker.internal:host-gateway"
    labels:
@ -155,43 +161,38 @@ services:
      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
+      dockerfile: Dockerfile.worker   # Chromium + Xvfb (headless 는 안티봇에 탐지됨)
    # 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)
+      DB_HOST: host.docker.internal
      DB_USER: ${LPS_DB_USER:-postgres}
      DB_PASSWORD: ${LPS_DB_PASSWORD:-postgres}
      PYTHONUNBUFFERED: "1"
      WORKER_CONCURRENCY: "1"          # 상품 동시 검색 수(워커별 브라우저 세트, Chrome 4×N)
      LPS_PROFILE_DIR: /profiles       # Chrome 프로필을 영속 볼륨에 → 재시작해도 cf_clearance 유지(재웜업 회피)
      # LPS_FALLBACKS: "gmarket,auction,st11"  # 오픈마켓 폴백(기본 OFF — 켜기 전 라이브 스모크로 셀렉터 점검)
      # LPS_JOB_DEADLINE_SEC: "300"    # 잡 1건 처리 상한(행 방어) — 기본 300s
      # ── 시크릿 주입(이미지엔 없음 — 필수). 리포 루트 .env 에 값 채움(.env.example 참고) ──
      OPENAI_API_KEY: ${OPENAI_API_KEY:-}          # 비면 AI 판정 OFF
      NAVER_KEYS: ${NAVER_KEYS:-}                  # "id1:secret1,id2:secret2" — 비면 네이버 검색 실패
      DECODO_HOST: ${DECODO_HOST:-}                # DECODO 4종 비면 프록시 미사용(직접 연결)
      DECODO_USERNAME: ${DECODO_USERNAME:-}
      DECODO_PASSWORD: ${DECODO_PASSWORD:-}
      DECODO_PORT_START: ${DECODO_PORT_START:-0}
      DECODO_PORT_END: ${DECODO_PORT_END:-0}
      DECODO_COST_PER_GB: ${DECODO_COST_PER_GB:-0}
    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 + 여유)
+    stop_grace_period: 75s             # graceful 종료 유예(LPS_SHUTDOWN_GRACE_SEC=60 + 정리 여유) — 기본 10s 면 하던 잡 마무리 전에 SIGKILL
    labels:
-      autoheal: "true"                 # 하트비트 실패(행/좀비) 시 autoheal 재시작
+      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 으로 프록시(앱은 상대경로 호출).
  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
--- a/docs/AIO2O-요청사항-반영보고서.pdf
+++ b/docs/AIO2O-요청사항-반영보고서.pdf
--- a/docs/aio2o-request-implementation-report.swift
+++ b/docs/aio2o-request-implementation-report.swift
@ -1,157 +0,0 @@
 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()
--- a/docs/backend-advanced-concepts-ko.pdf
+++ b/docs/backend-advanced-concepts-ko.pdf
--- a/docs/backend_advanced_guide.swift
+++ b/docs/backend_advanced_guide.swift
@ -1,790 +0,0 @@
 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)
--- a/docs/negotiation-qa-checklist.md
+++ b/docs/negotiation-qa-checklist.md
@ -1,108 +0,0 @@
 # 협상 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)이 연결 안 되면 한도가 안 걸릴 수 있으니, 설정이 항상 세션에 물리는지만 확인.
--- a/frontend/src/apis/auth/auth.type.ts
+++ b/frontend/src/apis/auth/auth.type.ts
@ -57,7 +57,8 @@ export interface RefreshTokenResponse {
 export interface Branding {
  service_name?: string
  logo_url?: string
-  helpdesk?: string[] // 헬프데스크 연락처 — 한 줄 = 담당자 한 명. 비면 연락처 영역을 렌더하지 않는다
+  primary_color?: string
  email_header?: string
 }
 // 로그인 전(초청 링크 진입) 브랜딩 조회 — GET /v1/auth/session-branding/{session_id}, 인증 불필요
@ -65,15 +66,14 @@ export interface SessionBrandingResponse {
  result: ApiResult
  service_name: string
  logo_url: string
-  helpdesk?: string[]
+  primary_color: string
 }
 // 협상완료 부가정보 필드 정의(companies.settings.session_fields)
 export interface SessionField {
  key: string
  label: string
-  type: 'text' | 'number' | 'boolean' | 'select'
+  type: 'text' | 'number' | 'boolean'
  options?: string[] // type='select' 일 때 고를 보기 목록
 }
 export interface MeResponse {
@ -86,7 +86,6 @@ export interface MeResponse {
  role: number
  branding?: Branding
  session_fields?: SessionField[]
  guide_notices?: string[]
 }
 // --- 로그아웃 -------------------------------------------------------------
@ -121,8 +120,6 @@ export interface AuthUser {
  role: number
  branding: Branding
  sessionFields: SessionField[]
  /** 협상 유의사항 항목(회사 설정). 비면 포털 기본 문구를 쓴다 */
  guideNotices: string[]
 }
 export function toAuthUser(res: MeResponse): AuthUser {
@ -135,6 +132,5 @@ export function toAuthUser(res: MeResponse): AuthUser {
    role: res.role,
    branding: res.branding ?? {},
    sessionFields: res.session_fields ?? [],
    guideNotices: res.guide_notices ?? [],
  }
 }
--- a/frontend/src/apis/chat/chat.type.ts
+++ b/frontend/src/apis/chat/chat.type.ts
@ -32,7 +32,6 @@ 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
@ -48,9 +47,6 @@ export interface ChatInitResponse {
  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 {
@ -93,7 +89,6 @@ 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 ?? '',
@ -109,8 +104,5 @@ export function mapInit(r: ChatInitResponse): ChatInitData {
    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,
  }
 }
--- a/frontend/src/apis/negotiation/index.ts
+++ b/frontend/src/apis/negotiation/index.ts
@ -2,11 +2,5 @@
 export { negotiationApi } from './negotiation.api'
 export { negotiationKeys } from './negotiation.keys'
 export { useSessionListQuery } from './negotiation.queries'
-export {
+export { useParticipateMutation, useRejectMutation, useSaveExtraInfoMutation } from './negotiation.mutations'
  useCancelRenegotiationMutation,
  useParticipateMutation,
  useRejectMutation,
  useRequestRenegotiationMutation,
  useSaveExtraInfoMutation,
 } from './negotiation.mutations'
 export * from './negotiation.type'
--- a/frontend/src/apis/negotiation/negotiation.api.ts
+++ b/frontend/src/apis/negotiation/negotiation.api.ts
@ -6,8 +6,6 @@ import type {
  ParticipateResponse,
  RejectRequest,
  RejectResponse,
  RenegotiationRequest,
  RenegotiationResponse,
  SessionListParams,
  SessionListResponse,
 } from './negotiation.type'
@ -36,23 +34,6 @@ 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>(
--- a/frontend/src/apis/negotiation/negotiation.mutations.ts
+++ b/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 { ExtraInfoRequest, RejectRequest, RenegotiationRequest } from './negotiation.type'
+import type { ExtraInfoRequest, RejectRequest } from './negotiation.type'
 /**
 * 협상 세션 참여: 성공 시 세션 목록 캐시를 무효화해 상태를 갱신한다.
@ -44,24 +44,3 @@ export function useSaveExtraInfoMutation() {
    },
  })
 }
 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() })
    },
  })
 }
--- a/frontend/src/apis/negotiation/negotiation.type.ts
+++ b/frontend/src/apis/negotiation/negotiation.type.ts
@ -43,8 +43,6 @@ export interface SessionListParams {
  order?: 'asc' | 'desc' // 생략 시 기본 그룹 정렬('할 일' 우선+임박순, 종료는 하단). 지정 시 그룹 무시하고 전체 마감순(asc=임박/desc=여유)
  page?: number
  page_size?: number
  keyword?: string // 검색어 — 견적번호·상품명·상품코드 부분일치
  result?: number // 결과 필터(SessionResult): 1=낙찰 2=미낙찰 3=결렬
 }
 export interface SessionListItem {
@ -58,43 +56,6 @@ export interface SessionListItem {
  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 {
@ -121,13 +82,10 @@ export interface ParticipateResponse {
 }
 // --- 거부 (POST /v1/negotiation/sessions/{id}/reject) ---------------------
-// 목록의 협상 거부와 채팅 중 협상 거부가 같은 폼(components/RejectPopup)·같은 엔드포인트를 쓴다.
+// reject_reason: 프리셋(단종/품절) 라벨 또는 '기타' 직접 입력 텍스트.
-// reject_reason: 프리셋(단종/품절) 라벨 또는 '기타' 직접 입력 텍스트. 필수.
+// (백엔드 sessions.reject_reason 컬럼에 대응. 엔드포인트는 백엔드 추가 예정)
 // reject_price/opinion: 선택 입력 — 빈 값이면 아예 보내지 않는다(opinion 은 sessions.custom 에 병합).
 export interface RejectRequest {
  reject_reason: string
  reject_price?: number
  opinion?: string
 }
 export interface RejectResponse {
--- a/frontend/src/components/Modal.tsx
+++ b/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)] p-4"
+      className="fixed inset-0 z-50 flex items-center justify-center bg-[rgba(0,0,0,0.40)]"
      onClick={handleBackdropClick}
    >
      {children}
--- a/frontend/src/components/RejectDetailPopup.tsx
+++ b/frontend/src/components/RejectDetailPopup.tsx
@ -1,81 +0,0 @@
 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>
  )
 }
--- a/frontend/src/components/RejectPopup.tsx
+++ b/frontend/src/components/RejectPopup.tsx
@ -1,200 +0,0 @@
 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>
  )
 }
--- a/frontend/src/components/index.ts
+++ b/frontend/src/components/index.ts
@ -7,7 +7,3 @@ 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'
--- a/frontend/src/features/auth/hooks/usePreLoginBranding.ts
+++ b/frontend/src/features/auth/hooks/usePreLoginBranding.ts
@ -43,9 +43,9 @@ export function usePreLoginBranding(): Branding | null {
        const next: Branding = {
          service_name: res.service_name || undefined,
          logo_url: res.logo_url || undefined,
-          helpdesk: res.helpdesk?.length ? res.helpdesk : undefined,
+          primary_color: res.primary_color || undefined,
        }
-        if (!next.service_name && !next.logo_url && !next.helpdesk) return
+        if (!next.service_name && !next.logo_url) return
        setBranding(next)
        writeCached(next) // 다음 진입에 session_id 가 없어도 이 회사로 보이게 한다
      })
--- a/frontend/src/features/chat/components/ChatMessage.tsx
+++ b/frontend/src/features/chat/components/ChatMessage.tsx
@ -6,19 +6,23 @@ import type { ChatMessage as ChatMessageType } from '@/features/chat/types'
 import { renderEmphasis } from '@/features/chat/lib/emphasis'
 import { Indicator } from '@/features/chat/components/templates/Indicator'
 import { Summary } from '@/features/chat/components/templates/Summary'
 import { ExtraInfoForm } from '@/features/chat/components/templates/ExtraInfoForm'
 import { BidSummary } from '@/features/chat/components/templates/BidSummary'
-import { RejectSummary } from '@/features/chat/components/templates/RejectSummary'
+import { RejectRSP } from '@/features/chat/components/templates/RejectRSP'
-import { RejectedNotice } from '@/features/chat/components/templates/RejectedNotice'
+import { RejectCM } from '@/features/chat/components/templates/RejectCM'
-const AI_LABEL = '아이마켓코리아 (구매담당자)'
+const AI_LABEL = '아이마켓코리아 (구매 MD)'
 export function ChatMessage() {
  const scrollRef = useRef<HTMLDivElement | null>(null)
  return (
    <div className="flex-1 w-full min-h-0">
      {/* lg:pt-[64px]: 첫 메시지를 우측 협상절차 카드 상단과 맞추는 값 — 그 카드가 없는 lg 미만에선
          스텝바 바로 아래 여백으로만 남아 첫 메시지가 위로 안 붙으므로 뺀다.
          스크롤 시 여백도 함께 밀려 올라가도록 스크롤 컨테이너 안쪽에 둔다 */}
      <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]"
+        className="chat-scroll h-full overflow-y-auto flex flex-col pt-0 lg:pt-[64px] 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>
@ -44,7 +48,7 @@ function ChatList({ scrollRef }: { scrollRef: RefObject<HTMLDivElement | null> }
      scroller.scrollTo({ top: scroller.scrollHeight, behavior })
    })
    return () => cancelAnimationFrame(id)
-  }, [chats, isLoading, scrollRef])
+  }, [chats, isLoading])
  if (!chats || chats.length === 0) {
    return (
@ -59,7 +63,6 @@ function ChatList({ scrollRef }: { scrollRef: RefObject<HTMLDivElement | null> }
      {chats.map((message, index) => (
        <MessageItem key={message.chat_id || index} message={message} messages={chats} currentIndex={index} />
      ))}
      <RejectedNotice />
      {isLoading && <TypingBubble />}
    </div>
  )
@ -90,16 +93,11 @@ const MessageItem = memo(function MessageItem({
 }) {
  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 (
+      return null
        <div className="mb-5 animate-fade-in">
          <RejectSummary script={message.script || ''} />
        </div>
      )
    }
  }
@ -126,14 +124,23 @@ const BotMessage = memo(function BotMessage({ message }: { message: ChatMessageT
        {showIndicator && message.bot_chat_type === 'indicator' && message.indicator_value != null && (
          <Indicator number={message.indicator_value} />
        )}
-        {message.bot_chat_type === 'summaryRSP' && message.summary && <Summary data={message.summary} />}
+        {message.bot_chat_type === 'summaryRSP' && message.summary && (
          <>
            <Summary data={message.summary} />
            <ExtraInfoForm />
          </>
        )}
        {message.bot_chat_type === 'summaryCM' && message.summary && (
          <BidSummary
            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>
  )
--- a/frontend/src/features/chat/components/ChatSection.tsx
+++ b/frontend/src/features/chat/components/ChatSection.tsx
@ -1,33 +1,10 @@
 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 { messages, userButtonConfig } = useChatStore()
+  const { 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 min-h-0 bg-surface">
      <MobileStepBar />
@ -35,9 +12,8 @@ export function ChatSection() {
      {/* 하단 액션 덱 */}
      {/* 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} />
+        <UserButton {...userButtonConfig} />
      </div>
      {isRejectOpen && <RejectPopup onClose={() => setIsRejectOpen(false)} />}
    </div>
  )
 }
--- a/frontend/src/features/chat/components/ExtraInfoBar.tsx
+++ b/frontend/src/features/chat/components/ExtraInfoBar.tsx
@ -1,126 +0,0 @@
 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'
--- a/frontend/src/features/chat/components/ItemSection.tsx
+++ b/frontend/src/features/chat/components/ItemSection.tsx
@ -38,17 +38,14 @@ 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)
@ -74,8 +71,7 @@ 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)}원`
-  // VAT 표기는 회사 설정 기준(item_vat_yn). vat_yn 미관리(hidden)면 값이 비어 라벨을 생략한다.
+  const formattedPrice = `${priceText}(${item_vat_yn || 'VAT별도'})`
  const formattedPrice = item_vat_yn ? `${priceText}(${item_vat_yn})` : priceText
  const renderRow = (title: string, data: string) => {
    const displayData = data || '-'
@ -109,16 +105,15 @@ function ItemInfo() {
      <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)}
+          {renderRow('상품코드', item_code)}
-          {/* 값은 회사가 고른 협상 기준가(item_price), 호칭은 공급사 화면 고정 용어 — 회사 용어 사전을 타지 않는다. */}
+          {renderRow('단가', formattedPrice)}
-          {renderRow('공급가', formattedPrice)}
+          {renderRow('모델명', item_model_name)}
-          {renderRow(fieldLabel('item.model_name', '모델명'), item_model_name)}
+          {renderRow('제조사', item_maker_name)}
-          {renderRow(fieldLabel('item.manufacturer', '제조사'), item_maker_name)}
+          {renderRow('최소주문수량', item_min_order_quantity)}
-          {renderRow(fieldLabel('item.moq', '최소주문수량'), item_min_order_quantity)}
+          {renderRow('리드타임', formatLeadTime(item_lead_time))}
          {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="shrink-0 text-sm text-neutral-60">규격</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)}
--- a/frontend/src/features/chat/components/MobileStepBar.tsx
+++ b/frontend/src/features/chat/components/MobileStepBar.tsx
@ -1,7 +1,7 @@
 import { Check } from 'lucide-react'
 import { cn } from '@/lib'
 import { useChatStore } from '@/features/chat/stores/useChatStore'
-import { STEPS } from '@/features/chat/lib/negoSteps'
+import { STEPS } from '@/features/chat/components/menu/NegoStep'
 // 모바일 전용: 협상절차를 채팅 상단에 가로 스텝바로 항상 표시한다. (데스크톱은 우측 패널 사용)
 export function MobileStepBar() {
--- a/frontend/src/features/chat/components/RejectForm.tsx
+++ b/frontend/src/features/chat/components/RejectForm.tsx
@ -1,184 +0,0 @@
 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>
  )
 }
--- a/frontend/src/features/chat/components/UserButton.tsx
+++ b/frontend/src/features/chat/components/UserButton.tsx
@ -1,10 +1,7 @@
 import { useEffect } from 'react'
 import { useNavigate } from 'react-router'
 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'
@ -17,38 +14,12 @@ const style = {
    '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]',
 }
-// onReject: 협상 거부 진입점. 넘어오면 버튼 덱 끝에 붙는다(입력 단계는 인풋이 넓어 좁은 화면에서 아랫줄로 wrap).
+export function UserButton({ type, text, textList, priceErrorMessage }: UserButtonConfig) {
 export function UserButton({ type, text, textList, priceErrorMessage, onReject }: UserButtonConfig & { onReject?: () => void }) {
  if (type === '') return null
  // 부가정보 입력은 폼이라 가운데정렬 덱이 아니라 전체폭으로 편다. 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
+    <div className="flex w-full justify-center overflow-x-auto px-6 py-4 max-[1180px]:px-4">
-      className={cn(
+      <div className="flex justify-center">
        '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] || '아니오']} />}
@ -59,19 +30,6 @@ export function UserButton({ type, text, textList, priceErrorMessage, onReject }
        {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>
  )
 }
@ -124,18 +82,6 @@ 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])}>
--- a/frontend/src/features/chat/components/menu/Contact.tsx
+++ b/frontend/src/features/chat/components/menu/Contact.tsx
@ -1,21 +1,13 @@
 import { useMeQuery } from '@/apis'
 // 헬프데스크 — 연락처. (안내 팝업 진입은 상단 '유의사항 및 이용방법' 섹션으로 일원화)
 // 연락처는 회사 설정(companies.settings.branding.helpdesk)에서 온다. 미등록이면 섹션 자체를 숨긴다.
 export function Contact() {
  const { data: user } = useMeQuery()
  const helpdesk = user?.branding?.helpdesk ?? []
  if (helpdesk.length === 0) return null
  return (
    <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>
      <div className="flex flex-col gap-1 pt-3 text-sm text-neutral-60">
-        {helpdesk.map((line) => (
+        <span>010-0000-0000</span>
-          <span key={line}>{line}</span>
+        <span>o2odev@o2o.kr</span>
        ))}
      </div>
    </section>
  )
--- a/frontend/src/features/chat/components/menu/MDInformation.tsx
+++ b/frontend/src/features/chat/components/menu/MDInformation.tsx
@ -29,7 +29,7 @@ export function MDInformation({ isOpen, setIsOpen }: Props) {
        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>
+        <span className="text-[11px] font-bold tracking-wide text-neutral-60">MD 안내사항</span>
        <ChevronDown
          size={16}
          className={cn('text-neutral-50 transition-transform duration-300', !isOpen && '-rotate-90')}
--- a/frontend/src/features/chat/components/menu/NegoStep.tsx
+++ b/frontend/src/features/chat/components/menu/NegoStep.tsx
@ -1,13 +1,20 @@
 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
 }
 export const STEPS = [
  { name: '서비스안내', desc: '협상 방식과 유의사항을 확인합니다.' },
  { name: '담당자확인', desc: '협상 담당자 본인 여부를 확인합니다.' },
  { name: '협상품목안내', desc: '대상 품목과 기준 단가를 확인합니다.' },
  { name: '가격협상', desc: '공급 단가를 제안하고 조율합니다.' },
  { name: '협상종료', desc: '최종 합의 후 결과를 확인합니다.' },
 ]
 export function NegoStep({ isOpen, setIsOpen }: Props) {
  const chats = useChatStore((s) => s.messages)
  const currentStep = chats[chats.length - 1]?.display_step || '서비스안내'
--- a/frontend/src/features/chat/components/popup/GuideContent.tsx
+++ b/frontend/src/features/chat/components/popup/GuideContent.tsx
@ -1,21 +1,10 @@
 import type { ReactNode } from 'react'
-import { useMeQuery } from '@/apis'
+import { useChatInitStore } from '@/features/chat/stores/useChatInitStore'
 // 협상 유의사항 및 서비스 이용 방법 안내 — 팝업 2종(자동 안내/메뉴 가이드)이 공유하는 본문.
-// 항목은 회사 설정(companies.settings.guide_notices)에서 오고, 비어 있으면 아래 기본 문구를 쓴다.
+// VAT/배송비 문구는 채팅 init 메타(useChatInitStore)를 읽어 상품별로 동적 표시한다.
 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 gap-2.5 py-1.5">
@ -26,8 +15,10 @@ function Bullet({ children }: { children: ReactNode }) {
 }
 export function GuideContent() {
-  const { data: user } = useMeQuery()
+  const { item_vat_yn, item_delivery_fee_yn } = useChatInitStore()
-  const notices = user?.guideNotices?.length ? user.guideNotices : DEFAULT_NOTICES
+  // init 미로드/값 없음 → 보수적 기본값 (KT-NEGOWIZ 와 동일한 폴백 규칙)
  const vat = item_vat_yn || 'VAT별도'
  const deliveryFee = item_delivery_fee_yn || '배송비별도'
  return (
    <div className="flex w-full flex-col">
@ -40,30 +31,59 @@ export function GuideContent() {
      </div>
      <div className="flex flex-col divide-y divide-border/60 rounded-xl border border-border px-4 py-1">
-        {notices.map((notice) => (
+        <Bullet>
-          <Bullet key={notice}>{notice}</Bullet>
+          협상 개시는&nbsp;
-        ))}
+          <span className="font-semibold text-neutral-90">
            Negosium 시스템의 협상 참여 버튼을 클릭하는 순간부터 시작
          </span>
          됩니다.
        </Bullet>
        <Bullet>
          부여된 협상 시간에&nbsp;
          <span className="font-semibold text-neutral-90">
            응찰하지 않는 경우, 협상 참여의사가 없는 것으로 간주하여 재견적으로 진행
          </span>
          될 수 있습니다.
        </Bullet>
        <Bullet>
          협상에 입력되는 모든 가격은&nbsp;
          <span className="font-semibold text-negative">
            {vat} 및 {deliveryFee}
          </span>
          &nbsp;기준이며,&nbsp;
          <span className="font-semibold text-neutral-90">
            할인을 요청하는 경우 기존 공급가격에 할인율이 적용된 가격으로 환산
          </span>
          되어 제시됩니다.
        </Bullet>
        <Bullet>
          본 협상 결과에 대해서는 협상자와 협상대상자 간의 비밀 유지 조건으로 진행되고, 협상에서 얻어진 결과나 내용에
          대해서는 당사자를 제외하고 제 3자에 공유할 수 없으며, 비밀 유지를 전제로 진행됩니다.
        </Bullet>
        <Bullet>
          협상이 종결되면 특별한 사유 없이 취소 변경이 불가하니, 신중하게 협상에 참여해 주시기 바랍니다.
        </Bullet>
        <Bullet>안내된 사항 외 부분은 기존 견적 프로세스와 동일한 부분 유의 바랍니다.</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-1.5 rounded-xl bg-neutral-10 p-4">
      <div className={`${bodyStyle} text-center`}>
        기타 협상 과정에서 궁금하거나 문의하실 사항은 아래 연락처로 상담 부탁드립니다.
      </div>
-      {helpdesk.map((line) => (
+      <div className="break-keep text-center text-sm font-bold text-neutral-90">
-        <div key={line} className="break-keep text-center text-sm font-bold text-neutral-90">
+        헬프데스크 010-0000-0000 · o2odev@o2o.kr
-          {line}
+      </div>
        </div>
      ))}
    </div>
  )
 }
--- a/frontend/src/features/chat/components/popup/RejectPopup.tsx
+++ b/frontend/src/features/chat/components/popup/RejectPopup.tsx
@ -1,35 +0,0 @@
 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, '거부 처리에 실패했습니다.')),
          },
        )
      }
    />
  )
 }
--- a/frontend/src/features/chat/components/templates/BidSummary.tsx
+++ b/frontend/src/features/chat/components/templates/BidSummary.tsx
@ -1,40 +1,17 @@
 import { CheckCircle2 } from 'lucide-react'
-import { numberToKorean } from '@/lib'
+import { numberToKorean } from '@/features/chat/lib/koreanNumber'
 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
 // 부가정보 값 표시 포맷(불리언→예/아니오, 숫자→천단위, 그 외→문자열)
 function formatFieldValue(type: SessionField['type'], value: unknown): string {
  if (type === 'boolean') return value ? '예' : '아니오'
  if (type === 'number') return Number(value).toLocaleString()
  return String(value)
 }
 // 투찰 결과 요약 카드 (보고서식 final-summary)
-// 공급사가 마무리에서 입력한 부가정보(회사설정 session_fields + 의견)가 있으면 함께 표시한다(입력완료 시 요약 갱신).
+export function BidSummary({ itemName, itemCode, bidPrice, deliveryType, isVAT }: BidSummaryProps) {
 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="w-full rounded-2xl border-2 border-brand-light bg-white p-5 shadow-md">
      <div className="mb-4 flex items-center gap-2">
@ -50,14 +27,10 @@ export function BidSummary({ itemName, itemCode, bidPrice }: BidSummaryProps) {
          <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 className="text-neutral-70"> {isVAT ? 'VAT포함' : 'VAT별도'}</span>
          </span>
        </div>
-        {extraRows.map((r) => (
+        <Row label="배송형태" value={deliveryType || '-'} />
          <Row key={r.key} label={r.label} value={r.value} />
        ))}
        {/* 의견은 타결·결렬 공통 기본 필드 — 값이 없어도 항상 표시 */}
        <Row label="의견" value={opinion || '-'} />
      </div>
    </div>
  )
--- a/frontend/src/features/chat/components/templates/ExtraInfoForm.tsx
+++ b/frontend/src/features/chat/components/templates/ExtraInfoForm.tsx
@ -0,0 +1,109 @@
 import { useEffect, useState } from 'react'
 import { CheckCircle2 } from 'lucide-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'
 // 협상 타결(Summary) 직후 부가정보 입력 폼. 필드 정의(session_fields)는 회사 설정(/me)에서 온다.
 // 저장하면 sessions.custom 에 기록되고 negodata 견적상세에 표시된다. 정의가 없으면 렌더하지 않는다.
 export function ExtraInfoForm() {
  const sessionId = useChatStore((s) => s.sessionId)
  const { data: user } = useMeQuery()
  const fields: SessionField[] = user?.sessionFields ?? []
  const save = useSaveExtraInfoMutation()
  const existing = useChatInitStore((s) => s.custom) // 기존 입력값(재진입 프리필)
  const [values, setValues] = useState<Record<string, unknown>>({})
  const [inited, setInited] = useState(false)
  const [saved, setSaved] = useState(false)
  // fields(회사 설정)와 기존값(sessions.custom)이 준비된 첫 시점에 프리필 — 이후 사용자 편집은 보존.
  useEffect(() => {
    if (inited || fields.length === 0) return
    const init: Record<string, unknown> = {}
    for (const f of fields) init[f.key] = existing?.[f.key] ?? (f.type === 'boolean' ? false : '')
    setValues(init)
    setInited(true)
  }, [inited, fields, existing])
  if (fields.length === 0) return null
  const set = (key: string, value: unknown) => setValues((v) => ({ ...v, [key]: value }))
  const handleSave = () => {
    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
    }
    save.mutate(
      { sessionId, request: { custom } },
      {
        onSuccess: () => {
          setSaved(true)
          toast.success('부가정보가 저장되었습니다.')
        },
        onError: (error) => toast.error(getApiErrorMessage(error, '부가정보 저장에 실패했습니다.')),
      },
    )
  }
  return (
    <div className="w-full rounded-2xl border border-border bg-white p-5 shadow-sm">
      <div className="mb-3 flex items-center gap-2">
        <CheckCircle2 className="size-5 text-brand-600" />
        <h3 className="text-sm font-bold text-neutral-90">부가정보 입력</h3>
      </div>
      <p className="text-sm leading-relaxed text-neutral-70 break-keep">
        협상이 완료되었습니다. 아래 정보를 입력해 주세요. (저장 후에도 세션 목록에서 수정할 수 있습니다.)
      </p>
      <div className="mt-4 space-y-4">
        {fields.map((f) => (
          <div key={f.key} className="space-y-1.5">
            <label className="block 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])}
                disabled={saved}
                className={`relative inline-flex h-6 w-11 items-center rounded-full transition-colors disabled:opacity-50 ${
                  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>
            ) : (
              <input
                type={f.type === 'number' ? 'number' : 'text'}
                value={String(values[f.key] ?? '')}
                onChange={(e) => set(f.key, e.target.value)}
                disabled={saved}
                className="h-11 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 disabled:bg-neutral-10"
                placeholder={f.label}
              />
            )}
          </div>
        ))}
      </div>
      <button
        type="button"
        onClick={handleSave}
        disabled={save.isPending || saved}
        className="mt-4 h-11 w-full rounded-xl bg-brand-600 text-sm font-bold text-white transition-colors hover:bg-brand-700 disabled:opacity-50"
      >
        {saved ? '저장 완료' : save.isPending ? '저장 중…' : '부가정보 저장'}
      </button>
    </div>
  )
 }
--- a/frontend/src/features/chat/components/templates/OtherReason.tsx
+++ b/frontend/src/features/chat/components/templates/OtherReason.tsx
@ -10,7 +10,6 @@ export function OtherReason({
  onChange,
  isError,
  disabled,
  onSubmit,
 }: {
  inputValue: string
  setInputValue: (value: string) => void
@ -19,7 +18,6 @@ export function OtherReason({
  onChange: (value: string) => void
  isError: boolean
  disabled?: boolean
  onSubmit?: () => void
 }) {
  const isChecked = selectedValue === '기타'
  const ref = useRef<HTMLTextAreaElement>(null)
@ -75,13 +73,6 @@ export function OtherReason({
          )}
          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}
--- a/frontend/src/features/chat/components/templates/RejectCM.tsx
+++ b/frontend/src/features/chat/components/templates/RejectCM.tsx
@ -0,0 +1,119 @@
 import { useState, useMemo } from 'react'
 import { AlertTriangle } from 'lucide-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-8 bg-white rounded-2xl border border-border shadow-sm gap-2 transition-all duration-300">
      <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="py-2 text-sm leading-relaxed text-neutral-70 break-keep">
        최종 공급 희망 가격과 배송 형태를 입력하여 주시기 바랍니다.
        <br />
        가격 검토를 통해 경쟁력 있는 가격일 경우 다시 협상에 참여할 기회가 주어지오니 신중한 가격 제안 부탁드립니다.
      </div>
      <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)}
                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-wrap items-center gap-x-6 gap-y-2">
          {['협력사배송', '지정택배배송', '픽업배송'].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>
  )
 }
--- a/frontend/src/features/chat/components/templates/RejectRSP.tsx
+++ b/frontend/src/features/chat/components/templates/RejectRSP.tsx
@ -0,0 +1,159 @@
 import { useState, useMemo } from 'react'
 import { AlertTriangle } from 'lucide-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-8 bg-white rounded-2xl border border-border shadow-sm gap-2 transition-all duration-300">
      <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="py-2 text-sm leading-relaxed text-neutral-70 break-keep">
        협상이 합의에 도달하지 못하였습니다. 최종 희망하는 가격을 입력해주시기 바랍니다.
        <br />
        추가로 제시한 가격을 수용할 수 없는 이유를 선택하여 주시기 바라며, 목록에 없는 경우 기타 항목 선택 후 간단한 사유를
        기재하여 주시기 바랍니다.
      </div>
      <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)}
                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">
          {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>
  )
 }
--- a/frontend/src/features/chat/components/templates/RejectSummary.tsx
+++ b/frontend/src/features/chat/components/templates/RejectSummary.tsx
@ -1,52 +0,0 @@
 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>
  )
 }
--- a/frontend/src/features/chat/components/templates/RejectedNotice.tsx
+++ b/frontend/src/features/chat/components/templates/RejectedNotice.tsx
@ -1,56 +0,0 @@
 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>
  )
 }
--- a/frontend/src/features/chat/components/templates/Summary.tsx
+++ b/frontend/src/features/chat/components/templates/Summary.tsx
@ -1,20 +1,11 @@
 import { CheckCircle2 } from 'lucide-react'
-import { numberToKorean } from '@/lib'
+import { numberToKorean } from '@/features/chat/lib/koreanNumber'
 import { formatLeadTime } from '@/features/chat/lib/format'
 import { useChatInitStore } from '@/features/chat/stores/useChatInitStore'
 import type { ChatSummary } from '@/features/chat/types'
 // 협상 결과 요약 카드
 export function Summary({ data }: { data: ChatSummary }) {
  const priceStr = (data.final_price || 0).toLocaleString()
  // VAT 표기는 회사 설정 기준(item_vat_yn). vat_yn 미관리(hidden)면 비어 라벨을 생략한다.
  const item_vat_yn = useChatInitStore((s) => s.item_vat_yn)
  // 공급사가 마무리에서 남긴 의견(있을 때만 표시)
  const custom = useChatInitStore((s) => s.custom)
  const opinion = custom?.opinion ? String(custom.opinion) : ''
  // 납기 라벨은 회사 설정(labels.lead_time) 기준 — IMK 등은 '표준납기'. 미설정 시 기본 '배송 리드타임'.
  const labels = useChatInitStore((s) => s.labels)
  const leadTimeLabel = labels?.['lead_time'] || '배송 리드타임'
  return (
    <div className="w-full rounded-2xl border border-border bg-white p-5 shadow-sm">
@ -46,24 +37,22 @@ export function Summary({ data }: { data: ChatSummary }) {
        <Row label="제품 규격" value={data.item_spec || '-'} />
        <Row label="최소 주문" value={data.item_moq || '-'} />
        <Row label="배송 형태" value={data.item_delivery_type || '-'} />
-        <Row label={leadTimeLabel} value={formatLeadTime(data.item_lead_time) || '-'} />
+        <Row label="배송 리드타임" value={formatLeadTime(data.item_lead_time) || '-'} />
        <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(data.final_price || 0)}원)</span>
-            {item_vat_yn ? <span className="text-neutral-70"> {item_vat_yn}</span> : null}
+            <span className="text-neutral-70"> {data.item_isVAT ? 'VAT포함' : 'VAT별도'}</span>
          </span>
        </div>
        {/* 의견은 타결·결렬 공통 기본 필드 — 값이 없어도 항상 표시 */}
        <Row label="의견" value={opinion || '-'} />
      </div>
-      {/* 계약 / 구매담당자 */}
+      {/* 계약 / 담당 MD */}
      <div className="mt-3 space-y-1 text-xs text-neutral-70">
        <p>공급 계약 기간: 협상 완료일로부터 1년 ({addOneYear(data.nego_end_date)})까지</p>
        <p>
-          구매담당자: {data.md_name || '-'} ({data.md_phone_number || '-'}) {data.md_email || '-'}
+          담당 MD: {data.md_name || '-'} ({data.md_phone_number || '-'}) {data.md_email || '-'}
        </p>
      </div>
--- a/frontend/src/features/chat/components/userInputs.tsx
+++ b/frontend/src/features/chat/components/userInputs.tsx
@ -1,4 +1,4 @@
-import { useState, useRef, useId, useEffect } from 'react'
+import { useState, useRef, useId } from 'react'
 import { useChatStore } from '@/features/chat/stores/useChatStore'
 // 단위(원/%) 오버레이 + 전송 버튼이 붙은 값 입력 (Percent / Price 공용)
@ -22,22 +22,8 @@ function InputWithUnit({
  ariaLabel: string
 }) {
  const errorId = useId()
  // 입력 단계(percent/price)로 바뀌어 마운트될 때마다 바로 타이핑 가능하게
  useEffect(() => {
    inputRef.current?.focus()
  }, [inputRef])
  return (
-    <div className="relative">
+    <div className="relative flex flex-col gap-3">
      {/* 레이아웃 밖(absolute)에 띄워 에러가 떠도 input 위치가 안 변한다 */}
      {error && (
        <div
          id={errorId}
          role="alert"
          className="absolute bottom-full left-1/2 -translate-x-1/2 mb-3 whitespace-nowrap rounded-full bg-white border border-border shadow-md px-4 py-1.5 text-sm font-semibold text-negative"
        >
          {error}
        </div>
      )}
      <div className="relative flex items-center min-w-[220px] sm:min-w-[360px] min-[1180px]:min-w-[420px] min-[1350px]:min-w-[480px]">
        <input
          ref={inputRef}
@ -65,6 +51,11 @@ function InputWithUnit({
          전송
        </button>
      </div>
      {error && (
        <div id={errorId} role="alert" className="absolute top-[62px] left-1/2 -translate-x-1/2 text-sm font-semibold text-negative w-full text-center">
          {error}
        </div>
      )}
    </div>
  )
 }
--- a/frontend/src/features/chat/hooks/useChatController.ts
+++ b/frontend/src/features/chat/hooks/useChatController.ts
@ -24,9 +24,8 @@ const TERMINAL_CODES = new Set<number>([
  ErrorCode.NEGO_NOT_FOUND,
 ])
-// 진입 로드(init/messages) 시 '잘못된 접근'으로 볼 코드 → 권한 없음 / 없는(또는 남의) 세션 / 진입 불가 상태.
+// 진입 로드(init/messages) 시 '잘못된 접근'으로 볼 코드 → 권한 없음 / 없는(또는 남의) 세션 /
-// 토스트 안내 후 목록으로 복귀시킨다. (인증≠인가 — 로그아웃하지 않는다)
+// 진입 불가 상태(미참여·거부). 토스트 안내 후 목록으로 복귀시킨다. (인증≠인가 — 로그아웃하지 않는다)
 // 종료된 세션(완료·미참여·거부)은 열람 진입이 허용되므로 여기 걸리지 않는다 — 입력만 잠긴다(ChatSection).
 const INVALID_ACCESS_CODES = new Set<number>([
  ErrorCode.NEGO_FORBIDDEN,
  ErrorCode.NEGO_NOT_FOUND,
@ -116,8 +115,8 @@ export function useChatController(sessionId: string) {
            if (data.message) s.appendMessage(mapMessage(data.message))
            s.setIsLoading(false)
            // 협상 종료 전이(완료/거부 등): 목록 캐시만 무효화해 /list 복귀 시 최신 상태를 보장한다.
-            // init 은 '진입 메타'라 화면에서 재조회하지 않는다 — 방금 종료한 화면의 입력이 열람 모드로
+            // init 은 '진입 메타'라 화면에서 재조회하지 않는다 — 재조회하면 미참여/거부 진입 게이트(1301)에
-            // 갈아치워지지 않게 한다. 재진입 시 최신 status 는 언마운트의 removeQueries 가 보장한다.
+            // 걸려 방금 정상 종료한 사용자가 튕겨난다. 재진입 시 최신 status 는 언마운트의 removeQueries 가 보장한다.
            if (data.session_status !== SessionStatus.IN_PROGRESS || data.message?.chat_end) {
              queryClient.invalidateQueries({ queryKey: negotiationKeys.sessions() })
            }
--- a/frontend/src/features/chat/lib/koreanNumber.ts
+++ b/frontend/src/features/chat/lib/koreanNumber.ts
--- a/frontend/src/features/chat/lib/negoSteps.ts
+++ b/frontend/src/features/chat/lib/negoSteps.ts
@ -1,8 +0,0 @@
 // 협상 절차 5단계 — NegoStep(사이드) · MobileStepBar(모바일 상단)가 공유.
 export const STEPS = [
  { name: '서비스안내', desc: '협상 방식과 유의사항을 확인합니다.' },
  { name: '담당자확인', desc: '협상 담당자 본인 여부를 확인합니다.' },
  { name: '협상품목안내', desc: '대상 품목과 기준 단가를 확인합니다.' },
  { name: '가격협상', desc: '공급 단가를 제안하고 조율합니다.' },
  { name: '협상종료', desc: '최종 합의 후 결과를 확인합니다.' },
 ]
--- a/frontend/src/features/chat/lib/rejectForm.ts
+++ b/frontend/src/features/chat/lib/rejectForm.ts
@ -1,13 +1,5 @@
 import type { ChatMessage } from '@/features/chat/types'
 // value = sessions.reject_reason 에 저장되는 값
 export const REJECT_REASONS = [
  { value: '단가인상', text: "'원재료 가격 상승' 또는 '제조사 가격 인상'으로 요청한 공급가격을 맞출 수 없습니다." },
  { value: '수량', text: '주문 수량이 적어, 소량 생산 시 발생하는 제조비용으로 맞출 수 없습니다.' },
  { value: '단종', text: '현재 단종된 제품으로 물량 수급이 원활하지 않아 가격을 맞출 수 없습니다.' },
  { value: '품절', text: '해당 상품이 품절되어 납품할 수 없습니다.' },
 ] as const
 // reject 폼 직전 사용자 답변(script)을 찾아 복원용으로 반환
 export function findRestoreScript(messages: ChatMessage[], type: 'rejectCM' | 'rejectRSP'): string | null {
  const reversed = [...messages].reverse()
@ -30,28 +22,3 @@ export function restoreRejectRSP(script: string | null) {
  if (reasonRaw.startsWith('기타-')) return { price, selectedReason: '기타', reason: reasonRaw.replace('기타-', '') }
  return { price, selectedReason: reasonRaw, reason: '' }
 }
 // 제출 script → 표시값
 export function parseRejectSubmission(script: string | null) {
  const { price, selectedReason, reason } = restoreRejectRSP(script)
  const preset = REJECT_REASONS.find((r) => r.value === selectedReason)
  return {
    price: price ? parseInt(price) : 0,
    reasonLabel: selectedReason,
    reasonDetail: selectedReason === '기타' ? reason : (preset?.text ?? ''),
    opinion: extractPart(script, '의견-'),
    extras: extraParts(script),
  }
 }
 // 통합 폼 이전 제출분의 '배송형태-' 등. 사유 뒤는 자유서술이 섞여 앞 구간만 훑는다.
 function extraParts(script: string | null): { label: string; value: string }[] {
  const head = (script ?? '').split(', 의견-')[0].split(', 합의불가사유-')[0]
  return head
    .split(', ')
    .filter((p) => p && !p.startsWith('공급희망가격-'))
    .map((p) => {
      const i = p.indexOf('-')
      return i > 0 ? { label: p.slice(0, i), value: p.slice(i + 1) } : { label: '항목', value: p }
    })
 }
--- a/frontend/src/features/chat/lib/userButtonConfig.ts
+++ b/frontend/src/features/chat/lib/userButtonConfig.ts
@ -2,17 +2,6 @@ import type { ChatMessage, UserButtonConfig } from '@/features/chat/types'
 export const GO_TO_LIST_TEXT = '상품 목록으로 가기'
 // 협상 거부 진입점을 숨기는 액션바 상태.
 // reject=봇이 이미 결렬을 선언(그 폼이 최종가를 받는다) / extra-info=타결 후 동의 단계 / loading=응답 대기.
 const NO_REJECT_TYPES = ['', 'loading', 'reject', 'extra-info']
 // 채팅 안에서 협상을 거부할 수 있는 상태인지 — 대화가 끝나지 않고 협력사 입력을 기다리는 동안만.
 export function canRejectNegotiation(messages: ChatMessage[], config: UserButtonConfig): boolean {
  if (!messages || messages.length === 0) return false
  if (messages[messages.length - 1].chat_end) return false
  return !NO_REJECT_TYPES.includes(config.type)
 }
 // 마지막 봇 메시지의 next_input_mode 로 하단 입력 UI 구성을 결정한다.
 export function deriveUserButtonConfig(
  messages: ChatMessage[],
@ -27,14 +16,7 @@ export function deriveUserButtonConfig(
  const options = last.next_input_type
  if (last.chat_end) return { type: 'one-black', text: GO_TO_LIST_TEXT }
-  // 결렬 폼(rejectRSP/rejectCM)은 통일된 RejectForm 을 액션바에서 받는다(메시지 카드 아님).
+  if (mode === 'confirm') return { type: 'one-black', text: options?.[0] || '' }
  if (last.bot_chat_type === 'rejectRSP' || last.bot_chat_type === 'rejectCM') return { type: 'reject' }
  // 타결 요약이 뜬 뒤의 '동의' 단계 = 부가정보 입력 + 동의를 한 자리(액션바)에서 받는다.
  // (요약 이후 confirm 단계에만 적용 — 재견적의 투찰확정/정보수정 같은 선택 단계는 그대로 둔다.)
  const dealt = messages.some((m) => m.bot_chat_type === 'summaryRSP' || m.bot_chat_type === 'summaryCM')
  if (mode === 'confirm') {
    return dealt ? { type: 'extra-info', text: options?.[0] || '' } : { type: 'one-black', text: options?.[0] || '' }
  }
  if (mode === 'yes_no') return { type: 'black-white', textList: options || [] }
  if (mode === 'percent') return { type: 'percent' }
  if (mode === 'price') return { type: 'price', priceErrorMessage: priceErrorMessage || undefined }
--- a/frontend/src/features/chat/stores/useChatInitStore.ts
+++ b/frontend/src/features/chat/stores/useChatInitStore.ts
@ -16,7 +16,6 @@ const initialState: ChatInitData = {
  session_status: 0,
  item_id: '',
  quotation_id: '',
  qt_number: '',
  item_name: '',
  item_code: '',
  item_image: '',
@ -31,9 +30,6 @@ const initialState: ChatInitData = {
  quotation_memo: '',
  quotation_end_time: '',
  custom: {},
  labels: {},
  reject_reason: '',
  reject_price: null,
 }
 export const useChatInitStore = create<ChatInitStore>((set) => ({
--- a/frontend/src/features/chat/types.ts
+++ b/frontend/src/features/chat/types.ts
@ -53,8 +53,6 @@ export type UserButtonType =
  | 'percent'
  | 'three-black'
  | 'price'
  | 'extra-info'
  | 'reject'
  | 'loading'
  | ''
@ -70,7 +68,6 @@ export type ChatInitData = {
  session_status: number // SessionStatus 코드 (진입 시점 기준)
  item_id: string
  quotation_id: string
  qt_number: string
  item_name: string
  item_code: string
  item_image: string
@ -85,7 +82,4 @@ export type ChatInitData = {
  quotation_memo: string
  quotation_end_time: string
  custom: Record<string, unknown> // 협상완료 부가정보 기존 입력값(프리필용)
  labels: Record<string, string> // 회사 커스텀 라벨(companies.settings.labels). 상품 상세 필드명 치환용
  reject_reason: string // 협상 거부로 끝난 세션의 제출 사유(의견은 custom.opinion)
  reject_price: number | null // 거부와 함께 낸 공급 희망 가격(원)
 }
--- a/frontend/src/features/list/components/ExtraInfoPopup.tsx
+++ b/frontend/src/features/list/components/ExtraInfoPopup.tsx
@ -22,9 +22,6 @@ export function ExtraInfoPopup({ target, onClose, onSubmit }: ExtraInfoPopupProp
    for (const f of fields) init[f.key] = target.custom?.[f.key] ?? (f.type === 'boolean' ? false : '')
    return init
  })
  const [opinion, setOpinion] = useState<string>(() => String(target.custom?.opinion ?? ''))
  // 부가정보는 협상 완료(동의) 시점에 확정 — 리스트에서는 항상 읽기전용(보기). 입력은 완료 챗에서만.
  const readOnly = true
  const set = (key: string, value: unknown) => setValues((v) => ({ ...v, [key]: value }))
@ -36,7 +33,6 @@ export function ExtraInfoPopup({ target, onClose, onSubmit }: ExtraInfoPopupProp
      if (f.type === 'boolean') out[f.key] = !!v
      else if (v !== '' && v != null) out[f.key] = f.type === 'number' ? Number(v) : v
    }
    if (opinion.trim()) out.opinion = opinion.trim()
    onSubmit(out)
    onClose()
  }
@ -46,11 +42,8 @@ export function ExtraInfoPopup({ target, onClose, onSubmit }: ExtraInfoPopupProp
      <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">협상완료 부가정보{readOnly ? ' (보기)' : ''}</h3>
+            <h3 className="text-base font-bold text-neutral-90">협상완료 부가정보</h3>
-            <p className="mt-0.5 text-xs text-neutral-60">
+            <p className="mt-0.5 text-xs text-neutral-60">{target.qt_number} · {target.item_name}</p>
              {target.qt_number} · {target.item_name}
              {readOnly ? ' · 제출 후에는 수정할 수 없습니다.' : ''}
            </p>
          </div>
          <button
            type="button"
@ -63,7 +56,10 @@ export function ExtraInfoPopup({ target, onClose, onSubmit }: ExtraInfoPopupProp
        </div>
        <div className="space-y-4 p-5">
-          {fields.map((f) => (
+          {fields.length === 0 ? (
            <p className="py-6 text-center text-sm text-neutral-60">입력할 부가정보 항목이 없습니다.</p>
          ) : (
            fields.map((f) => (
              <div key={f.key} className="space-y-1.5">
                <label className="block text-sm font-semibold text-neutral-80">{f.label}</label>
                {f.type === 'boolean' ? (
@ -71,9 +67,8 @@ export function ExtraInfoPopup({ target, onClose, onSubmit }: ExtraInfoPopupProp
                    type="button"
                    role="switch"
                    aria-checked={!!values[f.key]}
                    disabled={readOnly}
                    onClick={() => set(f.key, !values[f.key])}
-                    className={`relative inline-flex h-6 w-11 items-center rounded-full transition-colors disabled:opacity-60 disabled:cursor-not-allowed ${
+                    className={`relative inline-flex h-6 w-11 items-center rounded-full transition-colors ${
                      values[f.key] ? 'bg-brand-600' : 'bg-neutral-30'
                    }`}
                  >
@ -83,73 +78,36 @@ export function ExtraInfoPopup({ target, onClose, onSubmit }: ExtraInfoPopupProp
                      }`}
                    />
                  </button>
                ) : f.type === 'select' ? (
                  <select
                    value={String(values[f.key] ?? '')}
                    onChange={(e) => set(f.key, e.target.value)}
                    disabled={readOnly}
                    className="h-11 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 disabled:cursor-not-allowed disabled:bg-neutral-10 disabled:text-neutral-60"
                  >
                    <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)}
-                    disabled={readOnly}
+                    className="h-11 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"
                    className="h-11 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 disabled:cursor-not-allowed disabled:bg-neutral-10 disabled:text-neutral-60"
                    placeholder={f.label}
                  />
                )}
              </div>
-            ))}
+            ))
-          <div className="space-y-1.5">
+          )}
            <label className="block text-sm font-semibold text-neutral-80">
              의견 <span className="font-normal text-neutral-50">(선택)</span>
            </label>
            <textarea
              value={opinion}
              onChange={(e) => setOpinion(e.target.value)}
              rows={2}
              maxLength={255}
              disabled={readOnly}
              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 disabled:cursor-not-allowed disabled:bg-neutral-10 disabled:text-neutral-60"
            />
          </div>
        </div>
        <div className="flex gap-2 border-t border-border p-5">
-          {readOnly ? (
+          <button
-            <button
+            type="button"
-              type="button"
+            onClick={onClose}
-              onClick={onClose}
+            className="h-11 flex-1 rounded-xl border border-border text-sm font-bold text-neutral-70 hover:bg-neutral-10"
-              className="h-11 flex-1 rounded-xl border border-border text-sm font-bold text-neutral-70 hover:bg-neutral-10"
+          >
-            >
+            취소
-              닫기
+          </button>
-            </button>
+          <button
-          ) : (
+            type="button"
-            <>
+            onClick={handleSubmit}
-              <button
+            disabled={fields.length === 0}
-                type="button"
+            className="h-11 flex-1 rounded-xl bg-brand-600 text-sm font-bold text-white hover:bg-brand-700 disabled:opacity-40"
-                onClick={onClose}
+          >
-                className="h-11 flex-1 rounded-xl border border-border text-sm font-bold text-neutral-70 hover:bg-neutral-10"
+            저장
-              >
+          </button>
                취소
              </button>
              <button
                type="button"
                onClick={handleSubmit}
                className="h-11 flex-1 rounded-xl bg-brand-600 text-sm font-bold text-white hover:bg-brand-700 disabled:opacity-40"
              >
                저장
              </button>
            </>
          )}
        </div>
      </div>
    </Modal>
--- a/frontend/src/features/list/components/GuidePopup.tsx
+++ b/frontend/src/features/list/components/GuidePopup.tsx
@ -1,92 +0,0 @@
 import { X } from 'lucide-react'
 import { Modal } from '@/components'
 import { cn, interactive } from '@/lib'
 // 공급사 포털 목록 화면 이용안내. 상태(진행)·결과(마감)·재협상 3파트로 최근 추가된 용어를 설명한다.
 // 헤더의 '이용안내' 버튼으로 여는 수동형 팝업. X·배경 클릭·ESC 로 닫는다.
 export function GuidePopup({ onClose }: { onClose: () => void }) {
  return (
    <Modal onClose={onClose}>
      <div className="m-4 flex max-h-[90vh] w-full max-w-[560px] flex-col overflow-y-auto rounded-2xl border border-border bg-white p-6 shadow-xl animate-scale-in sm:p-8">
        <div className="mb-5 flex items-start justify-between gap-4">
          <div>
            <h2 className="text-lg font-extrabold text-neutral-90">이용안내</h2>
            <p className="mt-1 text-[13px] text-neutral-60">협상 목록의 상태·결과·재협상을 안내합니다.</p>
          </div>
          <button
            type="button"
            aria-label="닫기"
            onClick={onClose}
            className={cn('flex size-9 shrink-0 items-center justify-center rounded-full bg-neutral-10 text-neutral-70 hover:bg-neutral-20', interactive)}
          >
            <X size={18} />
          </button>
        </div>
        <div className="flex flex-col gap-6">
          <Section title="진행 상태" desc="협상 세션이 지금 어느 단계인지 — 내가 무엇을 할지 알려줍니다.">
            <Row badge="협상 대기" tone="wait" text="초청받은 협상. 입장해서 가격 협상을 시작하세요." />
            <Row badge="협상 중" tone="prog" text="가격을 조율하는 중입니다. 이어서 진행하세요." />
            <Row badge="협상 완료" tone="done" text="가격 제출을 마쳤습니다. 최종 결과는 견적 마감 후 아래 '결과'로 표시됩니다." />
            <Row badge="협상 미참여" tone="none" text="기한 내 참여하지 않아 종료된 건입니다." />
            <Row badge="협상 거부" tone="reject" text="내가 거부한 건입니다." />
          </Section>
          <Section title="협상 결과" desc="견적이 마감된 뒤 정해지는 낙찰 결과입니다. 마감 전에는 표시되지 않습니다.">
            <Row badge="낙찰" tone="win" text="내가 낙찰되어 계약 대상이 된 건입니다." />
            <Row badge="미낙찰" tone="lost" text="다른 공급사가 낙찰되어 이번 계약에서는 제외된 건입니다." />
            <Row badge="결렬" tone="open" text="낙찰자 없이 마감된 건입니다. 조건이 바뀌었다면 재협상을 요청할 수 있습니다." />
          </Section>
          <Section title="재협상 요청" desc="결렬(낙찰자 미정 마감) 건에 한해 가능합니다.">
            <p className="text-[13px] leading-relaxed text-neutral-70">
              결렬 건의 <b className="font-bold text-neutral-90">재협상 요청</b> 버튼으로 사유·희망가를 담아 요청하면,
              구매 담당자 검토 후 <b className="font-bold text-neutral-90">승인 시 다음 차수 협상</b>이 새로 열립니다.
              요청 상태(심사 중·승인·반려)는 목록에서 확인할 수 있습니다.
            </p>
          </Section>
        </div>
        <button
          type="button"
          onClick={onClose}
          className="mt-7 h-11 w-full rounded-xl bg-brand-600 text-sm font-bold text-white transition-colors hover:bg-brand-700"
        >
          확인했어요
        </button>
      </div>
    </Modal>
  )
 }
 function Section({ title, desc, children }: { title: string; desc: string; children: React.ReactNode }) {
  return (
    <section>
      <h3 className="text-sm font-extrabold text-neutral-90">{title}</h3>
      <p className="mb-3 mt-0.5 text-xs text-neutral-60">{desc}</p>
      <div className="flex flex-col gap-2.5">{children}</div>
    </section>
  )
 }
 const TONE: Record<string, string> = {
  wait: 'bg-brand-light text-brand-700',
  prog: 'bg-[#FFF3E5] text-[#F5A623]',
  done: 'bg-[#EAFDF3] text-success',
  none: 'bg-neutral-20 text-neutral-60',
  reject: 'bg-[#FFEBEB] text-[#FF4D4F]',
  win: 'bg-[#EAFDF3] text-success',
  lost: 'bg-neutral-20 text-neutral-60',
  open: 'bg-[#FFF3E5] text-[#F5A623]',
 }
 function Row({ badge, tone, text }: { badge: string; tone: string; text: string }) {
  return (
    <div className="flex items-start gap-2.5">
      <span className={cn('mt-0.5 inline-flex shrink-0 items-center rounded-full px-2.5 py-1 text-xs font-bold', TONE[tone])}>
        {badge}
      </span>
      <p className="text-[13px] leading-relaxed text-neutral-70">{text}</p>
    </div>
  )
 }
--- a/frontend/src/features/list/components/KpiCards.tsx
+++ b/frontend/src/features/list/components/KpiCards.tsx
@ -1,85 +1,54 @@
-import type { ReactNode } from 'react'
+import { AlertTriangle, CheckCircle2, FileText, RefreshCw } from 'lucide-react'
 import { cn } from '@/lib'
 import { useSessionCounts, type KpiCount } from '@/features/list/hooks/useSessionCounts'
-// 목업(claude artifact) 그대로: 진행(내가 할 일=상태축) / 결과(마감 후=결과축) 두 묶음.
+// key → 아이콘/색 스타일 (콕핏 카드)
-// 모든 카드 동일 크기·높이 — 강조는 색·CTA 로만. 낙찰=초록, 결렬=amber(재협상 가능), 미낙찰=회색.
+const STYLE: Record<string, { icon: typeof FileText; tile: string; iconColor: string; spin?: boolean }> = {
  created: { icon: FileText, tile: 'bg-brand-light', iconColor: 'text-brand-600' },
  progress: { icon: RefreshCw, tile: 'bg-sky-50', iconColor: 'text-sky-500', spin: true },
  done: { icon: CheckCircle2, tile: 'bg-emerald-50', iconColor: 'text-success' },
  rejected: { icon: AlertTriangle, tile: 'bg-red-50', iconColor: 'text-[#FF4D4F]' },
 }
 interface KpiCardsProps {
  selectedStatus: string | null
-  selectedResult: number | null
+  onSelect: (status: string) => void
  onSelectStatus: (status: string) => void
  onSelectResult: (code: number) => void
 }
-// key → 배지 점 색 / 숫자 색 / 카드 배경·테두리 / CTA.
+export function KpiCards({ selectedStatus, onSelect }: KpiCardsProps) {
-const STYLE: Record<string, { dot?: string; num: string; card?: string; cta?: string; ctaText?: string }> = {
+  const counts = useSessionCounts()
  created: { num: 'text-brand-600' },
  progress: { num: 'text-neutral-90' },
  won: { dot: 'bg-success', num: 'text-success', card: 'border-success/40 bg-gradient-to-b from-emerald-50 to-white', cta: 'text-success', ctaText: '★ 계약 대상' },
  open: { dot: 'bg-warning', num: 'text-warning', card: 'border-warning/40', cta: 'text-warning', ctaText: '▲ 재협상 요청 가능' },
  lost: { dot: 'bg-neutral-50', num: 'text-neutral-70' },
 }
 export function KpiCards({ selectedStatus, selectedResult, onSelectStatus, onSelectResult }: KpiCardsProps) {
  const { progress, result } = useSessionCounts()
  const isActive = (c: KpiCount) =>
    c.kind === 'status' ? selectedStatus === c.statusLabel : selectedResult === c.resultCode
  const onClick = (c: KpiCount) =>
    c.kind === 'status' ? onSelectStatus(c.statusLabel!) : onSelectResult(c.resultCode!)
  return (
-    <div className="grid gap-4 lg:grid-cols-[2fr_3fr]">
+    <div className="grid grid-cols-2 gap-3 sm:gap-4 lg:grid-cols-4">
-      <Cluster label="진행 · 내가 할 일" dot="bg-brand-600" cols="grid-cols-2">
+      {counts.map((c) => (
-        {progress.map((c) => (
+        <Card key={c.key} data={c} active={selectedStatus === c.status} onClick={() => onSelect(c.status)} />
-          <Card key={c.key} data={c} active={isActive(c)} onClick={() => onClick(c)} />
+      ))}
        ))}
      </Cluster>
      <Cluster label="결과 · 마감 후" dot="bg-success" cols="grid-cols-3">
        {result.map((c) => (
          <Card key={c.key} data={c} active={isActive(c)} onClick={() => onClick(c)} />
        ))}
      </Cluster>
    </div>
  )
 }
 function Cluster({ label, dot, cols, children }: { label: string; dot: string; cols: string; children: ReactNode }) {
  return (
    <div>
      <div className="mb-2 flex items-center gap-1.5 px-0.5 text-[11px] font-extrabold uppercase tracking-wider text-neutral-60">
        <span className={cn('size-1.5 rounded-full', dot)} />
        {label}
      </div>
      <div className={cn('grid gap-2.5', cols)}>{children}</div>
    </div>
  )
 }
 function Card({ data, active, onClick }: { data: KpiCount; active: boolean; onClick: () => void }) {
-  const s = STYLE[data.key] ?? STYLE.created
+  const s = STYLE[data.key]
-  const ctaText = s.ctaText ?? ' ' // 빈 카드도 CTA 줄 높이를 확보(nbsp) → 5개 카드 높이 완전 동일
+  const Icon = s.icon
  return (
    <button
      type="button"
      onClick={onClick}
      className={cn(
-        'flex h-full flex-col rounded-2xl border bg-white p-4 text-left shadow-sm transition-all hover:-translate-y-0.5 hover:shadow-md active:scale-[0.99]',
+        'flex items-center gap-3.5 rounded-2xl border bg-white p-4 text-left transition-all sm:p-5',
-        s.card ?? 'border-border',
+        'hover:shadow-md active:scale-[0.99]',
-        // 오프셋 링이라 카드 배경색(낙찰 초록·결렬 amber)과 무관하게 선택이 또렷하게 보인다.
+        active ? 'border-brand-600 ring-2 ring-brand-600/10 shadow-sm' : 'border-border shadow-sm',
        active && 'ring-2 ring-brand-600 ring-offset-2 ring-offset-surface',
      )}
    >
-      <p className="mb-2 flex items-center gap-1.5 whitespace-nowrap text-xs font-bold text-neutral-70">
+      <div className={cn('flex size-10 shrink-0 items-center justify-center rounded-xl', s.tile)}>
-        {s.dot && <span className={cn('size-1.5 rounded-full', s.dot)} />}
+        <Icon className={cn('size-5', s.iconColor, s.spin && 'animate-spin-slow')} />
-        {data.label}
+      </div>
-      </p>
+      <div className="min-w-0">
-      <p className={cn('text-2xl font-extrabold tabular-nums', s.num)}>
+        <p className="truncate text-[11px] font-bold text-neutral-60">{data.label}</p>
-        {data.isLoading ? '–' : data.count.toLocaleString()}
+        <p className="text-lg font-extrabold tabular-nums text-neutral-90">
-        <span className="ml-0.5 text-xs font-bold text-neutral-60">건</span>
+          {data.isLoading ? '–' : data.count.toLocaleString()}
-      </p>
+          <span className="ml-0.5 text-xs font-bold text-neutral-60">건</span>
-      {/* CTA 는 좁은 카드(모바일 3열)에서 nowrap 이면 넘치므로 단어 단위로만 줄바꿈 */}
+        </p>
-      <p className={cn('mt-1.5 break-keep text-[11px] font-extrabold', s.cta)}>{ctaText}</p>
+      </div>
    </button>
  )
 }
--- a/frontend/src/features/list/components/RejectPopup.tsx
+++ b/frontend/src/features/list/components/RejectPopup.tsx
@ -0,0 +1,124 @@
 import { useState } from 'react'
 import { X } from 'lucide-react'
 import { Modal } from '@/components'
 import { cn } from '@/lib'
 const REASONS = ['단종', '품절', '기타'] as const
 export interface RejectPopupProps {
  onClose: () => void
  /** 최종 거부 사유 (프리셋 라벨 또는 기타 입력 텍스트) */
  onSubmit: (reason: string) => void
 }
 // 거부 사유 입력 팝업 (단종/품절/기타).
 export function RejectPopup({ onClose, onSubmit }: RejectPopupProps) {
  const [selectedReason, setSelectedReason] = useState<string | null>(null)
  const [customReason, setCustomReason] = useState('')
  const [showError, setShowError] = useState(false)
  const isEtcOpen = selectedReason === '기타'
  const isSubmitDisabled = !selectedReason || (isEtcOpen && !customReason.trim())
  const handleReasonClick = (reason: string) => {
    setShowError(false)
    if (selectedReason === reason) {
      setSelectedReason(null)
      setCustomReason('')
    } else {
      setSelectedReason(reason)
      if (reason !== '기타') setCustomReason('')
    }
  }
  const handleSubmit = () => {
    if (isEtcOpen && !customReason.trim()) {
      setShowError(true)
      return
    }
    if (isSubmitDisabled || !selectedReason) return
    onSubmit(isEtcOpen ? customReason.trim() : selectedReason)
    onClose()
  }
  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">
          <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="space-y-4 p-5">
          <div className="grid grid-cols-3 gap-2">
            {REASONS.map((reason) => (
              <button
                key={reason}
                type="button"
                onClick={() => handleReasonClick(reason)}
                className={cn(
                  'h-11 rounded-xl border text-sm font-bold transition-all active:scale-[0.98]',
                  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}
                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>
        {/* 푸터 */}
        <div className="flex gap-2 border-t border-border p-4">
          <button
            type="button"
            onClick={onClose}
            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]"
          >
            취소
          </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>
  )
 }
--- a/frontend/src/features/list/components/RenegotiationMemoPopup.tsx
+++ b/frontend/src/features/list/components/RenegotiationMemoPopup.tsx
@ -1,54 +0,0 @@
 import { X } from 'lucide-react'
 import { Modal } from '@/components'
 import { RENEGO_STATUS_LABEL } from '@/apis/negotiation/negotiation.type'
 import type { ListItem } from '../types'
 export interface RenegotiationMemoPopupProps {
  target: ListItem
  onClose: () => void
 }
 // 재협상 심사 결과의 담당자 메모 열람 팝업. 목록에는 상태 배지만 두고 메모 전문은 여기서 보여준다.
 export function RenegotiationMemoPopup({ target, onClose }: RenegotiationMemoPopupProps) {
  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">
              {RENEGO_STATUS_LABEL[target.renegotiationStatus] ?? '재협상 심사 결과'}
            </h3>
            <p className="mt-0.5 text-xs text-neutral-60">
              {target.qt_number} · {target.item_name}
            </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="p-5">
          <p className="text-sm font-semibold text-neutral-80">담당자 메모</p>
          <p className="mt-1.5 max-h-64 overflow-y-auto whitespace-pre-wrap break-keep rounded-xl bg-neutral-10 p-3 text-sm leading-relaxed text-neutral-80">
            {target.renegotiationMemo}
          </p>
        </div>
        <div className="border-t border-border p-5">
          <button
            type="button"
            onClick={onClose}
            className="w-full rounded-xl bg-brand-600 py-3 text-sm font-bold text-white shadow-sm transition-all hover:bg-brand-700 active:scale-[0.98]"
          >
            확인
          </button>
        </div>
      </div>
    </Modal>
  )
 }
--- a/frontend/src/features/list/components/RenegotiationPopup.tsx
+++ b/frontend/src/features/list/components/RenegotiationPopup.tsx
@ -1,122 +0,0 @@
 import { useState } from 'react'
 import { X } from 'lucide-react'
 import { Modal } from '@/components'
 import type { ListItem } from '../types'
 export interface RenegotiationPopupProps {
  target: ListItem
  onClose: () => void
  onSubmit: (reason: string, desiredPrice: number | null) => void
 }
 // 재협상 요청 팝업. 결렬(낙찰자 미정) 건에만 열리며, 담당자 승인 시 다음 차수가 생성된다.
 // 사유는 자주 쓰는 것을 프리셋으로 두고, 직접 입력도 허용한다.
 const PRESETS = ['가격 조건 재검토', '재고·납기 확보', '단가 정정', '수량 조건 변경'] as const
 export function RenegotiationPopup({ target, onClose, onSubmit }: RenegotiationPopupProps) {
  const [preset, setPreset] = useState<string>(PRESETS[0])
  const [custom, setCustom] = useState('')
  const [price, setPrice] = useState('')
  const isDirect = preset === '직접 입력'
  const reason = isDirect ? custom.trim() : preset
  const canSubmit = reason.length > 0
  const handleSubmit = () => {
    if (!canSubmit) return
    const parsed = Number(price.replace(/[^0-9]/g, ''))
    onSubmit(reason, parsed > 0 ? parsed : null)
    onClose()
  }
  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">
              {target.qt_number} · {target.item_name}
            </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">
          <p className="rounded-xl bg-neutral-10 p-3 text-xs leading-relaxed text-neutral-70">
            이 건은 낙찰자 없이 마감되었습니다. 요청하면 구매 담당자가 검토 후 승인 시
            <b> 다시 협상할 기회</b>가 열립니다. 승인·반려 결과는 목록에서 확인할 수 있습니다.
          </p>
          <div className="space-y-1.5">
            <label className="block text-sm font-semibold text-neutral-80">요청 사유</label>
            <div className="flex flex-wrap gap-1.5">
              {[...PRESETS, '직접 입력'].map((p) => (
                <button
                  key={p}
                  type="button"
                  onClick={() => setPreset(p)}
                  className={`rounded-lg border px-3 py-1.5 text-xs font-bold transition-all active:scale-[0.98] ${
                    preset === p
                      ? 'border-brand-600 bg-brand-50 text-brand-700'
                      : 'border-border text-neutral-70 hover:bg-neutral-10'
                  }`}
                >
                  {p}
                </button>
              ))}
            </div>
            {isDirect && (
              <input
                value={custom}
                onChange={(e) => setCustom(e.target.value)}
                maxLength={255}
                placeholder="요청 사유를 입력해 주세요"
                className="mt-1.5 h-11 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"
              />
            )}
          </div>
          <div className="space-y-1.5">
            <label className="block text-sm font-semibold text-neutral-80">
              희망 공급가 <span className="font-medium text-neutral-60">(선택)</span>
            </label>
            <input
              inputMode="numeric"
              value={price}
              onChange={(e) => setPrice(e.target.value)}
              placeholder="예: 14,500,000"
              className="h-11 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"
            />
            <p className="text-xs text-neutral-60">담당자 검토 참고용입니다. 실제 가격은 재협상에서 다시 조율합니다.</p>
          </div>
        </div>
        <div className="flex gap-2 border-t border-border p-5">
          <button
            type="button"
            onClick={onClose}
            className="flex-1 rounded-xl border border-border py-3 text-sm font-bold text-neutral-70 transition-all hover:bg-neutral-10 active:scale-[0.98]"
          >
            취소
          </button>
          <button
            type="button"
            onClick={handleSubmit}
            disabled={!canSubmit}
            className="flex-[2] rounded-xl bg-brand-600 py-3 text-sm font-bold text-white shadow-sm transition-all hover:bg-brand-700 active:scale-[0.98] disabled:opacity-50"
          >
            요청 보내기
          </button>
        </div>
      </div>
    </Modal>
  )
 }
--- a/frontend/src/features/list/components/SortControl.tsx
+++ b/frontend/src/features/list/components/SortControl.tsx
@ -1,37 +0,0 @@
 import { cn } from '@/lib'
 // 마감 기준 정렬. value(null=기본 그룹정렬)는 store.selectedDeadline 로 그대로 전달되고,
 // adapter.deadlineToOrder 가 '남은 시간 적은 순'=asc(임박), 그 외=desc(여유) 로 매핑한다.
 const SORT_OPTIONS: { label: string; value: string | null }[] = [
  { label: '기본순', value: null },
  { label: '마감임박순', value: '남은 시간 적은 순' },
  { label: '여유순', value: '남은 시간 긴 순' },
 ]
 interface SortControlProps {
  selected: string | null
  onSelect: (value: string | null) => void
 }
 export function SortControl({ selected, onSelect }: SortControlProps) {
  return (
    <div className="flex items-center gap-0.5 rounded-xl border border-border bg-neutral-10 p-0.5">
      {SORT_OPTIONS.map((o) => {
        const active = selected === o.value
        return (
          <button
            key={o.label}
            type="button"
            onClick={() => onSelect(o.value)}
            className={cn(
              'whitespace-nowrap rounded-[10px] px-2.5 py-[6px] text-xs font-bold transition-all active:scale-[0.98]',
              active ? 'bg-white text-brand-700 shadow-sm' : 'text-neutral-60 hover:text-neutral-80',
            )}
          >
            {o.label}
          </button>
        )
      })}
    </div>
  )
 }
--- a/frontend/src/features/list/components/StatusTabs.tsx
+++ b/frontend/src/features/list/components/StatusTabs.tsx
@ -18,7 +18,7 @@ interface StatusTabsProps {
 export function StatusTabs({ selected, onSelect }: StatusTabsProps) {
  return (
-    <div className="flex flex-wrap items-center gap-1">
+    <div className="flex flex-wrap items-center gap-1 rounded-xl bg-neutral-20 p-1">
      {TABS.map((t) => {
        const active = selected === t.value
        return (
@ -27,8 +27,8 @@ export function StatusTabs({ selected, onSelect }: StatusTabsProps) {
            type="button"
            onClick={() => onSelect(t.value)}
            className={cn(
-              'whitespace-nowrap rounded-[10px] px-3 py-[7px] text-[13px] font-bold transition-all active:scale-[0.98]',
+              'rounded-lg px-3.5 py-1.5 text-[13px] font-bold transition-all active:scale-[0.98]',
-              active ? 'bg-brand-light text-brand-700' : 'text-neutral-60 hover:text-neutral-80',
+              active ? 'bg-white text-neutral-90 shadow-sm' : 'text-neutral-60 hover:text-neutral-80',
            )}
          >
            {t.label}
--- a/frontend/src/features/list/components/WorkspaceCards.tsx
+++ b/frontend/src/features/list/components/WorkspaceCards.tsx
@ -1,8 +1,7 @@
-import { Loader2, MessageSquareText } from 'lucide-react'
+import { Loader2 } from 'lucide-react'
 import { cn, formatKstDateTime } from '@/lib'
 import { RENEGO_STATUS_LABEL } from '@/apis/negotiation/negotiation.type'
 import type { ListItem } from '@/features/list/types'
-import { statusMeta, canEnterChat, isEndedStatus, RESULT_META } from '@/features/list/lib/status'
+import { statusMeta } from '@/features/list/lib/status'
 interface WorkspaceCardsProps {
  items: ListItem[]
@ -11,13 +10,10 @@ interface WorkspaceCardsProps {
  onEnter: (item: ListItem) => void
  onReject: (item: ListItem) => void
  onExtraInfo: (item: ListItem) => void
  onRenegotiate: (item: ListItem) => void
  onMemo: (item: ListItem) => void
  onRejectDetail: (item: ListItem) => void
 }
 // 모바일(lg 미만) 협상 목록: 테이블 대신 카드 스택.
-export function WorkspaceCards({ items, isLoading, busyId, onEnter, onReject, onExtraInfo, onRenegotiate, onMemo, onRejectDetail }: WorkspaceCardsProps) {
+export function WorkspaceCards({ items, isLoading, busyId, onEnter, onReject, onExtraInfo }: WorkspaceCardsProps) {
  if (isLoading) {
    return (
      <div className="flex items-center justify-center py-16">
@ -32,7 +28,7 @@ export function WorkspaceCards({ items, isLoading, busyId, onEnter, onReject, on
  return (
    <div className="divide-y divide-border">
      {items.map((item) => (
-        <Card key={item.session_id} item={item} busy={busyId === item.session_id} onEnter={onEnter} onReject={onReject} onExtraInfo={onExtraInfo} onRenegotiate={onRenegotiate} onMemo={onMemo} onRejectDetail={onRejectDetail} />
+        <Card key={item.session_id} item={item} busy={busyId === item.session_id} onEnter={onEnter} onReject={onReject} onExtraInfo={onExtraInfo} />
      ))}
    </div>
  )
@ -44,29 +40,19 @@ function Card({
  onEnter,
  onReject,
  onExtraInfo,
  onRenegotiate,
  onMemo,
  onRejectDetail,
 }: {
  item: ListItem
  busy: boolean
  onEnter: (item: ListItem) => void
  onReject: (item: ListItem) => void
  onExtraInfo: (item: ListItem) => void
  onRenegotiate: (item: ListItem) => void
  onMemo: (item: ListItem) => void
  onRejectDetail: (item: ListItem) => void
 }) {
  const meta = statusMeta(item.session_status)
-  const ended = isEndedStatus(item.session_status)
+  const canEnter = !['미참여', '협상거부'].includes(item.session_status)
  const canEnter = canEnterChat(item.session_status, item.hasChat)
  const canReject = ['협상생성', '협상중'].includes(item.session_status)
  // 거부 건은 제출 내역이 대화에 남지 않는다 — 세션에 적힌 사유를 여기서만 다시 볼 수 있다.
  const isRejected = item.session_status === '협상거부'
  const isDone = item.session_status === '협상완료'
-  const enterLabel = ended ? '결과 보기' : '협상 입장'
+  const enterLabel = isDone ? '결과 보기' : '협상 입장'
-  // 재협상: 요청 가능하면 버튼, 이미 요청했으면 진행 상태를 보여준다.
+  const hasExtra = item.custom && Object.keys(item.custom).length > 0
  const renegoLabel = RENEGO_STATUS_LABEL[item.renegotiationStatus] ?? ''
  return (
    <div className="p-4">
@ -81,17 +67,10 @@ function Card({
            {item.model_name && <span> · {item.model_name}</span>}
          </p>
        </div>
-        <div className="flex shrink-0 items-center gap-1.5">
+        <span className={cn('inline-flex shrink-0 items-center gap-1 rounded-full px-2.5 py-1 text-xs font-bold', meta.badge)}>
-          {RESULT_META[item.result] && (
+          <span className={cn('size-1.5 rounded-full', meta.dot)} />
-            <span className={cn('inline-flex items-center whitespace-nowrap rounded-full px-2 py-1 text-xs font-bold', RESULT_META[item.result].badge)}>
+          {meta.display}
-              {RESULT_META[item.result].label}
+        </span>
            </span>
          )}
          <span className={cn('inline-flex items-center gap-1 whitespace-nowrap rounded-full px-2.5 py-1 text-xs font-bold', meta.badge)}>
            <span className={cn('size-1.5 rounded-full', meta.dot)} />
            {meta.display}
          </span>
        </div>
      </div>
      <div className="mt-2.5 flex flex-wrap items-center gap-x-3 gap-y-1 text-xs text-neutral-60">
@ -99,52 +78,15 @@ function Card({
        <span>마감 {formatKstDateTime(item.qt_end_time)}</span>
      </div>
-      {renegoLabel &&
+      {(canEnter || canReject || isDone) && (
        (item.renegotiationMemo ? (
          <button
            type="button"
            onClick={() => onMemo(item)}
            className="mt-2.5 flex w-full items-center justify-between rounded-xl bg-neutral-10 px-3 py-2 transition-all hover:bg-neutral-20 active:scale-[0.99]"
          >
            <span className="whitespace-nowrap text-xs font-bold text-neutral-80">{renegoLabel}</span>
            <span className="flex items-center gap-1 whitespace-nowrap text-[11px] text-neutral-60">
              담당자 메모
              <MessageSquareText className="size-3.5 text-neutral-50" />
            </span>
          </button>
        ) : (
          <div className="mt-2.5 rounded-xl bg-neutral-10 px-3 py-2">
            <p className="text-xs font-bold text-neutral-80">{renegoLabel}</p>
          </div>
        ))}
      {(canEnter || canReject || isDone || isRejected || item.renegotiable) && (
        <div className="mt-3 flex gap-2">
          {isRejected && (
            <button
              type="button"
              onClick={() => onRejectDetail(item)}
              className="flex-1 rounded-lg border border-brand-600/40 py-2 text-xs font-bold text-brand-700 transition-all hover:bg-brand-50 active:scale-[0.98]"
            >
              거부 사유 보기
            </button>
          )}
          {item.renegotiable && (
            <button
              type="button"
              onClick={() => onRenegotiate(item)}
              className="flex-1 rounded-lg border border-brand-600/40 py-2 text-xs font-bold text-brand-700 transition-all hover:bg-brand-50 active:scale-[0.98]"
            >
              재협상 요청
            </button>
          )}
          {isDone && (
            <button
              type="button"
              onClick={() => onExtraInfo(item)}
              className="flex-1 rounded-lg border border-brand-600/40 py-2 text-xs font-bold text-brand-700 transition-all hover:bg-brand-50 active:scale-[0.98]"
            >
-              부가정보 보기
+              {hasExtra ? '부가정보 수정' : '부가정보 입력'}
            </button>
          )}
          {canReject && (
@ -153,7 +95,7 @@ function Card({
              onClick={() => onReject(item)}
              className="flex-1 rounded-lg border border-border py-2 text-xs font-bold text-neutral-70 transition-all hover:bg-neutral-10 active:scale-[0.98]"
            >
-              협상 거부
+              거절
            </button>
          )}
          {canEnter && (
--- a/frontend/src/features/list/components/WorkspaceTable.tsx
+++ b/frontend/src/features/list/components/WorkspaceTable.tsx
@ -1,9 +1,8 @@
 import { type ReactNode } from 'react'
-import { Loader2, MessageSquareText } from 'lucide-react'
+import { Loader2 } from 'lucide-react'
 import { cn, formatKstDateTime } from '@/lib'
 import { RENEGO_STATUS_LABEL } from '@/apis/negotiation/negotiation.type'
 import type { ListItem } from '@/features/list/types'
-import { statusMeta, canEnterChat, isEndedStatus, RESULT_META } from '@/features/list/lib/status'
+import { statusMeta } from '@/features/list/lib/status'
 interface WorkspaceTableProps {
  items: ListItem[]
@ -12,27 +11,22 @@ interface WorkspaceTableProps {
  onEnter: (item: ListItem) => void
  onReject: (item: ListItem) => void
  onExtraInfo: (item: ListItem) => void
  onRenegotiate: (item: ListItem) => void
  onMemo: (item: ListItem) => void
  onRejectDetail: (item: ListItem) => void
 }
-// th 기본 정렬은 center — 정렬은 베이스에 넣지 않고 컬럼마다 명시한다(cn 이 tailwind-merge 가 아니라 충돌 시 승자가 불명확).
+const HEAD = 'px-5 py-3.5 text-left text-[11px] font-bold uppercase tracking-wider text-neutral-60 whitespace-nowrap'
 const HEAD = 'px-5 py-3.5 text-[11px] font-bold uppercase tracking-wider text-neutral-60 whitespace-nowrap'
 const CELL = 'px-5 py-4 align-middle text-sm text-neutral-80'
-export function WorkspaceTable({ items, isLoading, busyId, onEnter, onReject, onExtraInfo, onRenegotiate, onMemo, onRejectDetail }: WorkspaceTableProps) {
+export function WorkspaceTable({ items, isLoading, busyId, onEnter, onReject, onExtraInfo }: WorkspaceTableProps) {
  return (
    <div className="w-full overflow-x-auto">
      <table className="w-full min-w-[900px] border-collapse">
        <thead>
          <tr className="border-b border-border bg-table-header">
-            <th className={cn(HEAD, 'text-left')}>견적번호</th>
+            <th className={HEAD}>견적번호</th>
-            <th className={cn(HEAD, 'text-left')}>상품</th>
+            <th className={HEAD}>상품</th>
-            <th className={cn(HEAD, 'text-left')}>제조사</th>
+            <th className={HEAD}>제조사</th>
-            <th className={cn(HEAD, 'text-right')}>상태</th>
+            <th className={cn(HEAD, 'text-center')}>상태</th>
-            <th className={cn(HEAD, 'text-center')}>결과</th>
+            <th className={HEAD}>마감일</th>
            <th className={cn(HEAD, 'text-left')}>마감일</th>
            <th className={cn(HEAD, 'text-right')}>액션</th>
          </tr>
        </thead>
@ -47,7 +41,7 @@ export function WorkspaceTable({ items, isLoading, busyId, onEnter, onReject, on
            </StateRow>
          ) : (
            items.map((item) => (
-              <Row key={item.session_id} item={item} busy={busyId === item.session_id} onEnter={onEnter} onReject={onReject} onExtraInfo={onExtraInfo} onRenegotiate={onRenegotiate} onMemo={onMemo} onRejectDetail={onRejectDetail} />
+              <Row key={item.session_id} item={item} busy={busyId === item.session_id} onEnter={onEnter} onReject={onReject} onExtraInfo={onExtraInfo} />
            ))
          )}
        </tbody>
@ -62,27 +56,19 @@ function Row({
  onEnter,
  onReject,
  onExtraInfo,
  onRenegotiate,
  onMemo,
  onRejectDetail,
 }: {
  item: ListItem
  busy: boolean
  onEnter: (item: ListItem) => void
  onReject: (item: ListItem) => void
  onExtraInfo: (item: ListItem) => void
  onRenegotiate: (item: ListItem) => void
  onMemo: (item: ListItem) => void
  onRejectDetail: (item: ListItem) => void
 }) {
  const meta = statusMeta(item.session_status)
-  const ended = isEndedStatus(item.session_status)
+  const canEnter = !['미참여', '협상거부'].includes(item.session_status)
  const canEnter = canEnterChat(item.session_status, item.hasChat)
  const canReject = ['협상생성', '협상중'].includes(item.session_status)
  // 거부 건은 제출 내역이 대화에 남지 않는다 — 세션에 적힌 사유를 여기서만 다시 볼 수 있다.
  const isRejected = item.session_status === '협상거부'
  const isDone = item.session_status === '협상완료'
-  const enterLabel = ended ? '결과 보기' : '협상 입장'
+  const enterLabel = isDone ? '결과 보기' : '협상 입장'
  const hasExtra = item.custom && Object.keys(item.custom).length > 0
  return (
    <tr className="border-b border-border/60 transition-colors last:border-0 hover:bg-table-hover/70">
@ -97,66 +83,22 @@ function Row({
        </p>
      </td>
      <td className={cn(CELL, 'whitespace-nowrap text-neutral-70')}>{item.maker_name || '-'}</td>
-      <td className={cn(CELL, 'text-right')}>
+      <td className={cn(CELL, 'text-center')}>
-        <span className={cn('inline-flex items-center gap-1 whitespace-nowrap rounded-full px-2.5 py-1 text-xs font-bold', meta.badge)}>
+        <span className={cn('inline-flex items-center gap-1 rounded-full px-2.5 py-1 text-xs font-bold', meta.badge)}>
          <span className={cn('size-1.5 rounded-full', meta.dot)} />
          {meta.display}
        </span>
      </td>
      <td className={cn(CELL, 'text-center')}>
        {RESULT_META[item.result] ? (
          <span className={cn('inline-flex items-center whitespace-nowrap rounded-full px-2 py-1 text-xs font-bold', RESULT_META[item.result].badge)}>
            {RESULT_META[item.result].label}
          </span>
        ) : (
          <span className="text-xs text-neutral-40">–</span>
        )}
      </td>
      <td className={cn(CELL, 'whitespace-nowrap text-neutral-70')}>{formatKstDateTime(item.qt_end_time)}</td>
      <td className={CELL}>
        <div className="flex items-center justify-end gap-2">
          {/* 재협상: 요청 가능하면 버튼, 요청 이력이 있으면 상태 텍스트(담당자 메모 있으면 클릭 시 팝업) */}
          {item.renegotiable ? (
            <button
              type="button"
              onClick={() => onRenegotiate(item)}
              className="rounded-lg border border-brand-600/40 px-3 py-1.5 text-xs font-bold text-brand-700 transition-all hover:bg-brand-50 active:scale-[0.98]"
            >
              재협상 요청
            </button>
          ) : (
            RENEGO_STATUS_LABEL[item.renegotiationStatus] &&
            (item.renegotiationMemo ? (
              <button
                type="button"
                onClick={() => onMemo(item)}
                className="inline-flex items-center gap-1.5 whitespace-nowrap rounded-lg bg-neutral-10 px-2.5 py-1.5 text-xs font-bold text-neutral-70 transition-all hover:bg-neutral-20 active:scale-[0.98]"
              >
                {RENEGO_STATUS_LABEL[item.renegotiationStatus]}
                <MessageSquareText className="size-3.5 text-neutral-50" />
              </button>
            ) : (
              <span className="whitespace-nowrap rounded-lg bg-neutral-10 px-2.5 py-1.5 text-xs font-bold text-neutral-70">
                {RENEGO_STATUS_LABEL[item.renegotiationStatus]}
              </span>
            ))
          )}
          {isDone && (
            <button
              type="button"
              onClick={() => onExtraInfo(item)}
              className="rounded-lg border border-brand-600/40 px-3 py-1.5 text-xs font-bold text-brand-700 transition-all hover:bg-brand-50 active:scale-[0.98]"
            >
-              부가정보 보기
+              {hasExtra ? '부가정보 수정' : '부가정보 입력'}
            </button>
          )}
          {isRejected && (
            <button
              type="button"
              onClick={() => onRejectDetail(item)}
              className="rounded-lg border border-brand-600/40 px-3 py-1.5 text-xs font-bold text-brand-700 transition-all hover:bg-brand-50 active:scale-[0.98]"
            >
              거부 사유 보기
            </button>
          )}
          {canReject && (
@ -165,7 +107,7 @@ function Row({
              onClick={() => onReject(item)}
              className="rounded-lg border border-border px-3 py-1.5 text-xs font-bold text-neutral-70 transition-all hover:bg-neutral-10 active:scale-[0.98]"
            >
-              협상 거부
+              거절
            </button>
          )}
          {canEnter ? (
@ -178,7 +120,9 @@ function Row({
              {busy && <Loader2 className="size-3 animate-spin" />}
              {enterLabel}
            </button>
-          ) : null}
+          ) : (
            !canReject && <span className="text-xs text-neutral-50">–</span>
          )}
        </div>
      </td>
    </tr>
@ -188,7 +132,7 @@ function Row({
 function StateRow({ children }: { children: ReactNode }) {
  return (
    <tr>
-      <td colSpan={7} className="py-20">
+      <td colSpan={6} className="py-20">
        <div className="flex items-center justify-center">{children}</div>
      </td>
    </tr>
--- a/frontend/src/features/list/containers/ListWorkspace.tsx
+++ b/frontend/src/features/list/containers/ListWorkspace.tsx
@ -1,30 +1,18 @@
-import { useEffect, useState } from 'react'
+import { useState } from 'react'
 import { useNavigate } from 'react-router'
 import { useShallow } from 'zustand/react/shallow'
-import { HelpCircle, Search } from 'lucide-react'
+import { Search } from 'lucide-react'
-import {
+import { getApiErrorMessage, useMeQuery, useParticipateMutation, useRejectMutation, useSaveExtraInfoMutation } from '@/apis'
  getApiErrorMessage,
  useMeQuery,
  useParticipateMutation,
  useRejectMutation,
  useRequestRenegotiationMutation,
  useSaveExtraInfoMutation,
 } from '@/apis'
 import { RejectDetailPopup, RejectPopup, type RejectSubmitPayload } from '@/components'
 import { cn, toast } from '@/lib'
 import { useList } from '@/features/list/hooks/useList'
 import { useListStore } from '@/features/list/stores/useListStore'
 import { KpiCards } from '@/features/list/components/KpiCards'
 import { StatusTabs } from '@/features/list/components/StatusTabs'
 import { SortControl } from '@/features/list/components/SortControl'
 import { WorkspaceTable } from '@/features/list/components/WorkspaceTable'
 import { WorkspaceCards } from '@/features/list/components/WorkspaceCards'
 import { Pagination } from '@/features/list/components/Pagination'
 import { RejectPopup } from '@/features/list/components/RejectPopup'
 import { ExtraInfoPopup } from '@/features/list/components/ExtraInfoPopup'
 import { RenegotiationPopup } from '@/features/list/components/RenegotiationPopup'
 import { RenegotiationMemoPopup } from '@/features/list/components/RenegotiationMemoPopup'
 import { GuidePopup } from '@/features/list/components/GuidePopup'
 import { isEndedStatus } from '@/features/list/lib/status'
 import type { ListItem } from '@/features/list/types'
 // 상태별 거부 불가 안내
@ -37,46 +25,25 @@ const REJECT_BLOCKED: Record<string, string> = {
 export function ListWorkspace() {
  const navigate = useNavigate()
  const { data: user } = useMeQuery()
-  // 리스트는 서버 페이징 + 서버 검색(keyword: 견적번호·상품명·상품코드 부분일치).
+  // 리스트는 서버 페이징. (검색은 백엔드 미지원 → 프론트 검색은 비워 둠)
  const { items, isLoading, totalPages, currentPage, setCurrentPage } = useList()
  const participate = useParticipateMutation()
  const reject = useRejectMutation()
  const saveExtra = useSaveExtraInfoMutation()
  const requestRenego = useRequestRenegotiationMutation()
-  const { selectedStatus, selectedResult, selectedDeadline, setStatus, toggleResult, setDeadline, setKeyword } =
+  const { selectedStatus, setStatus } = useListStore(
-    useListStore(
+    useShallow((s) => ({
-      useShallow((s) => ({
+      selectedStatus: s.selectedStatus,
-        selectedStatus: s.selectedStatus,
+      setStatus: s.setStatus,
-        selectedResult: s.selectedResult,
+    })),
-        selectedDeadline: s.selectedDeadline,
+  )
        setStatus: s.setStatus,
        toggleResult: s.toggleResult,
        setDeadline: s.setDeadline,
        setKeyword: s.setKeyword,
      })),
    )
  // 입력은 즉시 반영하되, 서버 요청은 300ms 디바운스(타이핑마다 호출 방지). 변경 시 store 가 페이지를 1로 되돌린다.
  const [search, setSearch] = useState('')
  useEffect(() => {
    const id = setTimeout(() => setKeyword(search), 300)
    return () => clearTimeout(id)
  }, [search, setKeyword])
  const [enteringId, setEnteringId] = useState<string | null>(null)
  const [rejectTarget, setRejectTarget] = useState<ListItem | null>(null)
  const [extraTarget, setExtraTarget] = useState<ListItem | null>(null)
  const [renegoTarget, setRenegoTarget] = useState<ListItem | null>(null)
  const [memoTarget, setMemoTarget] = useState<ListItem | null>(null)
  const [rejectDetailTarget, setRejectDetailTarget] = useState<ListItem | null>(null)
  const [guideOpen, setGuideOpen] = useState(false)
  const handleEnter = (item: ListItem) => {
    // 종료 건(완료·미참여·거부)은 열람 전용 — 참여 API 는 미참여/거부를 막으므로 바로 채팅으로 보낸다.
    if (isEndedStatus(item.session_status)) {
      navigate(`/chat?session_id=${item.session_id}`)
      return
    }
    setEnteringId(item.session_id)
    participate.mutate(item.session_id, {
      onSuccess: () => navigate(`/chat?session_id=${item.session_id}`),
@ -96,16 +63,13 @@ export function ListWorkspace() {
    setRejectTarget(item)
  }
-  const handleRejectSubmit = (request: RejectSubmitPayload) => {
+  const handleRejectSubmit = (reason: string) => {
    if (!rejectTarget) return
    reject.mutate(
-      { sessionId: rejectTarget.session_id, request },
+      { sessionId: rejectTarget.session_id, request: { reject_reason: reason } },
      {
-        onSuccess: () => {
+        onSuccess: () => toast.warning('참여 거절이 완료되었습니다.'),
-          setRejectTarget(null)
+        onError: (error) => toast.error(getApiErrorMessage(error, '거절 처리에 실패했습니다.')),
          toast.warning('협상 거부가 완료되었습니다.')
        },
        onError: (error) => toast.error(getApiErrorMessage(error, '거부 처리에 실패했습니다.')),
      },
    )
  }
@ -121,53 +85,28 @@ export function ListWorkspace() {
    )
  }
  const handleRenegoSubmit = (reason: string, desiredPrice: number | null) => {
    if (!renegoTarget) return
    requestRenego.mutate(
      { sessionId: renegoTarget.session_id, request: { reason, desired_price: desiredPrice } },
      {
        onSuccess: () => toast.success('재협상을 요청했습니다. 담당자 검토 후 결과가 목록에 표시됩니다.'),
        onError: (error) => toast.error(getApiErrorMessage(error, '재협상 요청에 실패했습니다.')),
      },
    )
  }
  return (
    <div className="space-y-5">
-      {/* 헤더 */}
+      {/* 환영 배너 */}
-      <div className="flex flex-wrap items-baseline justify-between gap-2">
+      <div className="flex flex-wrap items-center justify-between gap-2 rounded-2xl border border-border bg-white px-5 py-4 shadow-[0_2px_12px_rgba(0,0,0,0.02)]">
        <div>
-          <h1 className="text-xl font-extrabold tracking-tight text-neutral-90">협상 워크스페이스</h1>
+          <p className="text-[15px] font-bold text-neutral-90">
-          <p className="mt-0.5 text-[13px] text-neutral-60">
+            {user?.supplierName ? `${user.supplierName} 담당자님, 환영합니다.` : '공급 파트너님, 환영합니다.'}
-            {user?.supplierName ? `${user.supplierName} (공급 파트너)` : '공급 파트너'} · 진행/결과를 한눈에
+          </p>
          <p className="mt-0.5 text-xs text-neutral-60">
            진행 중인 협상 건을 확인하고 가격 협상에 참여해 주세요.
          </p>
        </div>
        <div className="flex items-center gap-2.5">
          <button
            type="button"
            onClick={() => setGuideOpen(true)}
            className="inline-flex items-center gap-1.5 rounded-lg border border-border bg-white px-3 py-1.5 text-[13px] font-bold text-neutral-70 transition-colors hover:bg-neutral-10"
          >
            <HelpCircle className="size-4 text-neutral-50" />
            이용안내
          </button>
        </div>
      </div>
-      {/* KPI 콕핏 — 진행/결과 두 묶음 */}
+      {/* KPI 콕핏 */}
-      <KpiCards
+      <KpiCards selectedStatus={selectedStatus} onSelect={(s) => setStatus(selectedStatus === s ? null : s)} />
        selectedStatus={selectedStatus}
        selectedResult={selectedResult}
        onSelectStatus={(s) => setStatus(selectedStatus === s ? null : s)}
        onSelectResult={toggleResult}
      />
      {/* 워크스페이스 카드 */}
      <div className="overflow-hidden rounded-2xl border border-border bg-white shadow-sm">
        <div className="flex flex-col gap-3 border-b border-border p-4 lg:flex-row lg:items-center lg:justify-between">
          <StatusTabs selected={selectedStatus} onSelect={setStatus} />
          <div className="flex w-full items-center gap-2 lg:w-auto">
            <SortControl selected={selectedDeadline} onSelect={setDeadline} />
            <div className="relative flex-1 lg:flex-none">
              <Search className="pointer-events-none absolute left-2.5 top-1/2 size-3.5 -translate-y-1/2 text-neutral-50" />
              <input
@ -192,9 +131,6 @@ export function ListWorkspace() {
            onEnter={handleEnter}
            onReject={handleReject}
            onExtraInfo={setExtraTarget}
            onRenegotiate={setRenegoTarget}
            onMemo={setMemoTarget}
            onRejectDetail={setRejectDetailTarget}
          />
        </div>
        <div className="lg:hidden">
@ -205,9 +141,6 @@ export function ListWorkspace() {
            onEnter={handleEnter}
            onReject={handleReject}
            onExtraInfo={setExtraTarget}
            onRenegotiate={setRenegoTarget}
            onMemo={setMemoTarget}
            onRejectDetail={setRejectDetailTarget}
          />
        </div>
@ -216,41 +149,13 @@ export function ListWorkspace() {
        </div>
      </div>
      {guideOpen && <GuidePopup onClose={() => setGuideOpen(false)} />}
      {rejectTarget && (
-        <RejectPopup
+        <RejectPopup onClose={() => setRejectTarget(null)} onSubmit={handleRejectSubmit} />
          onClose={() => setRejectTarget(null)}
          onSubmit={handleRejectSubmit}
          isPending={reject.isPending}
        />
      )}
      {extraTarget && (
        <ExtraInfoPopup target={extraTarget} onClose={() => setExtraTarget(null)} onSubmit={handleExtraSubmit} />
      )}
      {renegoTarget && (
        <RenegotiationPopup
          target={renegoTarget}
          onClose={() => setRenegoTarget(null)}
          onSubmit={handleRenegoSubmit}
        />
      )}
      {rejectDetailTarget && (
        <RejectDetailPopup
          onClose={() => setRejectDetailTarget(null)}
          subtitle={`${rejectDetailTarget.qt_number} · ${rejectDetailTarget.item_name}`}
          reason={rejectDetailTarget.rejectReason}
          price={rejectDetailTarget.rejectPrice}
          opinion={String(rejectDetailTarget.custom?.opinion ?? '')}
        />
      )}
      {memoTarget && (
        <RenegotiationMemoPopup target={memoTarget} onClose={() => setMemoTarget(null)} />
      )}
    </div>
  )
 }
--- a/frontend/src/features/list/hooks/useList.ts
+++ b/frontend/src/features/list/hooks/useList.ts
@ -7,13 +7,11 @@ const PAGE_SIZE = 20
 // 필터/정렬/페이지는 서버에 위임하고, 응답(정수 코드)을 화면용 라벨로 변환한다.
 export function useList() {
-  const { selectedStatus, selectedDeadline, selectedResult, keyword, currentPage, setCurrentPage } = useListStore()
+  const { selectedStatus, selectedDeadline, currentPage, setCurrentPage } = useListStore()
  const query = useSessionListQuery({
    status: selectedStatus ? statusLabelToCode(selectedStatus) : undefined,
    order: selectedDeadline ? deadlineToOrder(selectedDeadline) : undefined,
    result: selectedResult ?? undefined,
    keyword: keyword.trim() || undefined,
    page: currentPage,
    page_size: PAGE_SIZE,
  })
--- a/Show More
+++ b/Show More