feat: 회의 오디오 원본 보관 — 전사가 놓친 발화를 되살릴 수 있게

46분 대면 회의 실측에서 Web Speech 포착률이 7~10%에 그쳤다(489어절 /
분당 10.6어절, 30초 이상 공백 26곳 26분 29초). 빈 텍스트 청크 19개는
Chrome이 `isFinal: true`에 `transcript: ""`를 준 것으로, 소리는 감지했으나
인식에 실패했다는 신호다.

지금까지는 오디오를 어디에도 남기지 않아 놓친 발화를 복구할 수도, 얼마나
놓쳤는지 잴 수도 없었다. 전사와 독립적으로 원음을 파일로 남긴다.

## 유실 방지 설계

메모리에 모았다가 종료 시 한 번에 쓰지 않는다. 그러면 탭이나 서버가 죽는
순간 회의 전체가 사라진다. 15초 조각마다 디스크에 append 하므로 어느
시점에 중단되든 그때까지의 오디오는 남는다.

- 서버 업로드가 실패해도 녹음을 멈추지 않고 브라우저 사본으로 회수한다
- 조각이 3회 재시도 후에도 실패하면 뒤를 이어 붙이지 않고 멈춘다.
  중간이 빈 파일은 짧은 파일보다 나쁘다 — 재생도 전사도 안 된다
- 한 조각도 못 받았으면 "보관됨"이라고 하지 않고 오류를 띄운다
- 서버 사본이 로컬보다 짧으면 경고한다

## 캡처 제약 변경

`noiseSuppression: false, echoCancellation: false, autoGainControl: true`.
브라우저 기본값은 전화 통화용 튜닝이라 멀리 앉은 화자를 노이즈로 지운다.
AGC는 조용한 화자를 끌어올려 주므로 남긴다. 실측으로 검증할 가설이며
회귀 방지 테스트를 걸어 뒀다.

## 검증

- 서버 파이프라인: 184조각 755KB 업로드 → 다운로드 SHA256 바이트 일치
- 클라이언트 전 경로: 합성 스트림으로 48초 녹음 → 로컬·서버 크기 일치,
  서버 파일이 decodeAudioData로 48.12초 실제 오디오로 디코딩됨
- 경로 조작 400 / 없는 세션 404 / 빈 조각 400 / 미허용 mimeType 400
- 테스트 162 → 206 통과, 신규 타입 에러 0, 린트 baseline과 동일

실제 마이크 경로는 테스트하지 못했다. Web Speech와 getUserMedia가 같은
마이크를 두고 경합하는지 실사용 확인이 필요하다.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WzAH7GPWSYTe2AoBV6CZDP

.env.example

@@ -25,13 +25,39 @@ POSTGRES_PASSWORD=
 DATABASE_URL=
 
 # -----------------------------------------------------------------------------
-# 선택 — Gemini API 키
+# 선택 — AI 프로바이더
 # -----------------------------------------------------------------------------
-# Gemini AI 요약 기능을 쓰려면 키가 필요합니다.
+# AI 요약 기능을 쓰려면 프로바이더 설정이 필요합니다. 두 가지 방법 중 선택:
-# 두 가지 방법 중 선택:
+#   (A) 웹 UI 방식 — 앱 기동 후 /settings에서 선택·입력 (브라우저 LocalStorage, 추천)
-#   (A) 웹 UI 방식 — 앱 기동 후 /settings에서 입력 (브라우저 LocalStorage 저장, 추천)
+#   (B) 환경변수 방식 — 아래 값을 채우면 모든 사용자가 공통으로 사용
-#   (B) 환경변수 방식 — 아래 값 채우면 모든 사용자가 공통으로 사용
 #
+# 설정이 없어도 "단순 변환" 모드는 정상 동작합니다.
+
+# --- (기본) Google Gemini 직접 호출 ---
 # 무료 발급: https://aistudio.google.com/apikey
-# 키 없이도 "단순 변환" 모드는 정상 동작합니다.
 GEMINI_API_KEY=
+
+# --- (선택) OpenAI 호환 엔드포인트 ---
+# OrcaRouter · OpenAI · Ollama · LM Studio · vLLM 등 OpenAI Chat Completions
+# 형식을 따르는 엔드포인트라면 무엇이든 연결됩니다.
+#
+# LLM_PROVIDER=openai-compatible 로 두었을 때만 아래 값들이 사용됩니다.
+#   OpenAI     : LLM_BASE_URL=https://api.openai.com/v1      LLM_MODEL=gpt-4o-mini
+#   OrcaRouter : LLM_BASE_URL=https://api.orcarouter.ai/v1   LLM_MODEL=google/gemini-3.5-flash-lite
+#   Ollama     : LLM_BASE_URL=http://localhost:11434/v1      LLM_MODEL=llama3.1  (키 불필요)
+#
+# ⚠️ 중계 서비스를 쓰면 회의 전문이 그 회사 서버를 거칩니다. SECURITY.md 참고.
+# LLM_PROVIDER=
+# LLM_BASE_URL=
+# LLM_MODEL=
+# LLM_API_KEY=
+
+# ─────────────────────────────────────────────────────────────
+# 회의 오디오 녹음 저장 위치 (선택)
+# ─────────────────────────────────────────────────────────────
+# 기본값은 <프로젝트>/uploads/recordings 입니다.
+# Docker Compose에서는 uploads 볼륨에 저장되어 컨테이너를 재시작해도 남습니다.
+#
+# ⚠️ 녹음 파일에는 회의 원음이 그대로 들어 있습니다. 디스크 암호화된 위치에
+#    두고, 필요 없어진 녹음은 직접 삭제하세요. SECURITY.md 참고.
+# RECORDINGS_DIR=

README.md

@@ -28,7 +28,7 @@ docker compose up -d
   - [⚡ 실시간 롤링 요약](#-실시간-롤링-요약)
   - [💾 회의록 저장/조회/검색](#-회의록-저장조회검색)
   - [✅ 액션 아이템 자동 추출](#-액션-아이템-자동-추출)
-  - [🔑 웹에서 API 키 설정](#-웹에서-api-키-설정)
+  - [🔑 AI 프로바이더 & API 키 설정](#-ai-프로바이더--api-키-설정)
   - [📋 Google Docs 호환 복사](#-google-docs-호환-복사)
 - [🚀 시작하기](#-시작하기)
   - [Docker Compose (권장)](#docker-compose-권장)
@@ -51,10 +51,29 @@ docker compose up -d
 
 **특징**
 - 즉시 시작 — 별도 STT 서버나 키 없이 작동
+- **오디오 원본 동시 녹음** — 전사와 무관하게 회의 원음을 파일로 보관
 - **자동 재연결** — 네트워크 끊김 시 최대 8회 재시도, 누적 transcript 보존
 - 확정 전 텍스트는 회색 이탤릭 + 깜빡이는 커서로 시각화
 - 녹음 중 `🔴 N단어 · M개 구간` 실시간 카운터
 
+> ⚠️ **Web Speech API는 발화를 상당량 놓칩니다.** 원거리·다인 대면 회의에서
+> 실측 포착률이 10% 안팎이었습니다(46분 회의 / 489어절). 회의 전사용으로
+> 설계된 엔진이 아니라 근접 음성 명령용입니다. 그래서 **오디오 원본을 반드시
+> 함께 남깁니다** — 놓친 발화는 나중에 서버 STT로 다시 살릴 수 있습니다.
+
+### 🎧 오디오 원본 보관
+
+녹음을 시작하면 전사와 **별개로** 마이크 입력을 오디오 파일로 저장합니다.
+
+- 15초마다 조각을 서버에 이어 붙여 **탭이나 서버가 죽어도 그때까지의 오디오는 남습니다**
+- 서버 저장이 실패해도 녹음은 중단되지 않고, 브라우저 사본을 **⬇️ 내려받기**로 회수할 수 있습니다
+- 한 조각도 못 받았으면 "보관됨"이라고 하지 않고 오류를 띄웁니다
+- 저장 위치: `uploads/recordings/` (Docker에서는 `uploads` 볼륨 → 재시작해도 유지)
+
+**캡처 설정** — 브라우저 기본값은 전화 통화용 튜닝이라 멀리 앉은 화자를
+노이즈로 지워버립니다. 그래서 노이즈 억제·에코 제거를 끄고 AGC만 남깁니다
+(`src/lib/recording.ts`의 `RECORDING_AUDIO_CONSTRAINTS`).
+
 **사용**
 1. 홈에서 **🎤 녹음 시작** 클릭
 2. 마이크 권한 허용
@@ -69,14 +88,25 @@ docker compose up -d
 
 | 템플릿 | 생성되는 구조 | 기본 강도 | 라이브 요약 |
 |---|---|---|---|
-| 🗂️ 회의록 | 요약 / 논의 / 액션 / 결정 | 표준 | ✅ |
+| 🗂️ 회의록 | 요약 / **내용 기반 주제 섹션** / 액션 / 결정 | 표준 | ✅ |
 | 🎓 강의·세미나 노트 | 핵심 개념 / 예시 / 인용 / 후속 질문 | 상세 | ✅ |
-| 🤝 1:1 미팅 | 주제 / 고민 / 피드백 / 다음 액션 | 표준 | ✅ |
+| 🤝 1:1 미팅 | 요지 / **내용 기반 주제 섹션** / 고민 / 피드백 / 다음 액션 | 표준 | ✅ |
 | 💡 브레인스토밍 | 카테고리별 아이디어 / 즉시 시도 / 보류 | 상세 | ✅ |
 | 🎤 인터뷰 | Q&A 포맷 / 인상적 발언 / 종합 | 표준 | ❌ |
 | 📝 원문 정리 | 요약 없이 문단화·오탈자 정리만 | 상세 고정 | ❌ |
 | ⚙️ 커스텀 | 자유 프롬프트 입력 | - | ✅ |
 
+**내용 기반 주제 섹션**
+
+회의록·1:1 템플릿은 `## 주요 논의 사항` 같은 고정 제목을 쓰지 않습니다. 그 회의가 실제로 무엇을
+다뤘는지에 따라 AI가 섹션 제목을 직접 짓습니다 — 예를 들어 `## 단계별 개발 계획`,
+`## 수익화 방안`, `## 기술적 고려사항` 처럼. 제목만 훑어도 회의 내용이 파악됩니다.
+
+**액션 아이템 담당자**
+
+발화에서 담당자가 파악되면 `- [ ] (김지훈) 경쟁 사이트 리스트업 — 5/17까지` 형태로 이름과 기한이 붙습니다.
+담당자가 정해지지 않은 항목도 버리지 않고 그대로 수집합니다.
+
 **강도 3단계**
 - **간결** — 각 섹션 3줄 이내
 - **표준** — 맥락이 이해될 정도
@@ -101,7 +131,7 @@ docker compose up -d
 - 429 쿼터 초과 시 60초 자동 쿨다운, UI에 카운트다운 노출
 - 일반 실패 시 지수 백오프 (15s → 30s → 최대 120s)
 
-**비용 가드 (Gemini 2.5 Flash Lite 무료 등급 기준)**
+**비용 가드 (Gemini Flash Lite 무료 등급 기준)**
 - 15 RPM / 1000 RPD / 250K TPM
 - 30초 폴링 + 증분 게이트 → 1시간 회의 ≤ 60회 호출, 발화량 적으면 훨씬 적음
 - 개인 사용 시 일일 한도 도달 거의 불가
@@ -154,9 +184,22 @@ docker compose up -d
 
 ---
 
-### 🔑 웹에서 API 키 설정
+### 🔑 AI 프로바이더 & API 키 설정
 
-`.env`를 만지지 않고 `/settings` 페이지에서 Gemini 키를 입력·저장·검증할 수 있습니다.
+`.env`를 만지지 않고 `/settings` 페이지에서 프로바이더·모델·키를 선택하고 검증할 수 있습니다.
+
+**선택 가능한 프로바이더**
+
+| 프리셋 | 엔드포인트 | 비고 |
+|--------|-----------|------|
+| **Google Gemini** (기본) | Google 직접 호출 | 무료 티어가 있어 가장 간단 |
+| **OpenAI** | `https://api.openai.com/v1` | Chat Completions |
+| **OrcaRouter** | `https://api.orcarouter.ai/v1` | 하나의 키로 여러 제공사 모델 |
+| **로컬 모델** | `http://localhost:11434/v1` | Ollama · LM Studio · vLLM — 회의 내용이 외부로 나가지 않음 |
+| **직접 입력** | 사용자 지정 | OpenAI 호환이면 무엇이든 |
+
+Gemini 외 프리셋은 모두 동일한 **OpenAI Chat Completions** 어댑터를 사용합니다
+(`src/lib/providers/openai-compatible.ts`). base URL과 모델 ID만 바꾸면 새 서비스가 붙습니다.
 
 **저장 위치**
 - 브라우저 LocalStorage (서버 DB에 저장되지 않음)
@@ -164,9 +207,9 @@ docker compose up -d
 
 **우선순위**
 ```
-1. 요청 body의 apiKey  (브라우저 LocalStorage)
+1. 요청 body의 provider/apiKey/baseUrl/model  (브라우저 LocalStorage)
        ↓ 없으면
-2. process.env.GEMINI_API_KEY  (서버 환경변수 fallback)
+2. 서버 환경변수  (GEMINI_API_KEY 또는 LLM_PROVIDER / LLM_BASE_URL / LLM_MODEL / LLM_API_KEY)
        ↓ 없으면
 3. summarize → 단순 변환 폴백 (warning 표시)
    summarize-live → 503 + 안내
@@ -175,12 +218,14 @@ docker compose up -d
 **기능**
 - 마스킹된 현재 키 표시 (`AIza••••XYZ12`)
 - 보이기/숨기기 토글
-- **🧪 테스트 호출** — 가벼운 Gemini 응답으로 즉시 키 검증
+- **🧪 테스트 호출** — 가벼운 응답으로 즉시 설정 검증 (사용된 모델명 표시)
-- 현재 키 소스 배지 (`브라우저` / `환경변수` / `없음`)
+- 현재 소스 배지 (`브라우저` / `환경변수` / `없음`)
+- 기존에 Gemini 키만 저장해둔 사용자는 **재입력 없이 그대로 동작** (자동 승계)
 
 **보안**
 - HTTPS 권장 (LocalStorage는 동일 출처 정책 의존)
 - GET 응답에 절대 풀 키 노출 안 함
+- base URL은 `http`/`https`만 허용 — 자세한 내용은 [SECURITY.md](SECURITY.md)
 
 ---
 
@@ -231,12 +276,13 @@ DATABASE_URL=postgresql://meetinguser:<위와_같은_비번>@localhost:5432/meet
 
 > ⚠️ `POSTGRES_PASSWORD`를 비워두면 docker compose가 명시적 에러로 실패합니다. 보안을 위한 의도된 동작.
 
-> 💡 **Gemini API 키는 두 가지 방법 중 선택**
+> 💡 **AI 프로바이더 설정은 두 가지 방법 중 선택**
 >
-> - **(A) 웹 UI** — 앱 기동 후 `/settings`에서 입력 (브라우저 LocalStorage, 추천)
+> - **(A) 웹 UI** — 앱 기동 후 `/settings`에서 프로바이더 선택 + 키 입력 (브라우저 LocalStorage, 추천)
-> - **(B) `.env` 환경변수** — `GEMINI_API_KEY=AIza...` 작성
+> - **(B) `.env` 환경변수** — `GEMINI_API_KEY=AIza...` 또는 `LLM_PROVIDER` / `LLM_BASE_URL` / `LLM_MODEL` / `LLM_API_KEY`
 >
-> [Google AI Studio](https://aistudio.google.com/apikey)에서 무료로 발급. 키 없이도 "단순 변환" 모드는 동작.
+> 기본값인 Gemini 키는 [Google AI Studio](https://aistudio.google.com/apikey)에서 무료로 발급.
+> 설정이 없어도 "단순 변환" 모드는 동작.
 
 #### 3. DB 마이그레이션 (최초 1회)
 
@@ -304,11 +350,11 @@ npm run test:coverage     # 커버리지 리포트
 |------|------|
 | 프레임워크 | Next.js 16 (App Router) + React 19 + TypeScript |
 | STT (실시간) | Web Speech API — Chrome 내장, 무료 |
-| AI 요약 | Gemini 2.5 Flash Lite (무료 등급 15 RPM / 1000 RPD) |
+| AI 요약 | Gemini 3.5 Flash Lite (기본) · OpenAI 호환 엔드포인트 선택 가능 |
 | DB | PostgreSQL 16 + Prisma 7 (driver adapter `@prisma/adapter-pg`) |
 | Markdown | `marked` + `isomorphic-dompurify` |
 | 스타일 | Tailwind CSS v4 |
-| 테스트 | Vitest 4 (jsdom, 102 tests) |
+| 테스트 | Vitest 4 (jsdom, 141 tests) |
 | 배포 | Docker Compose + standalone Next.js 빌드 |
 
 ---
@@ -339,14 +385,20 @@ src/
 │   ├── page.tsx                                  # 메인 (녹음/요약)
 │   └── layout.tsx
 ├── lib/
+│   ├── providers/                                # AI 프로바이더 어댑터
+│   │   ├── index.ts                              #   complete() 디스패치
+│   │   ├── types.ts                              #   ProviderSettings / CompletionResult
+│   │   ├── presets.ts                            #   설정 UI용 프리셋 목록
+│   │   ├── gemini.ts                             #   Google Generative Language API
+│   │   └── openai-compatible.ts                  #   OpenAI Chat Completions 호환
 │   ├── db.ts                                     # Prisma 싱글톤 (pg adapter)
 │   ├── markdown.ts                               # marked + DOMPurify + Docs용 복사
 │   ├── action-items.ts                           # - [ ] 휴리스틱 파서
-│   ├── api-keys.ts                               # 서버: 요청 키 → env fallback
+│   ├── api-keys.ts                               # 서버: 요청 설정 → env fallback
-│   ├── api-key-storage.ts                        # 클라: LocalStorage + 마스킹
+│   ├── api-key-storage.ts                        # 클라: LocalStorage + 마스킹 + 프로바이더 설정
 │   ├── templates.ts                              # 템플릿 레지스트리 + 프롬프트 빌더
-│   ├── minutes-generator.ts                      # 최종 요약 생성
+│   ├── minutes-generator.ts                      # 최종 요약 생성 (프로바이더 무관)
-│   ├── live-summary.ts                           # 롤링 요약 생성
+│   ├── live-summary.ts                           # 롤링 요약 생성 (프로바이더 무관)
 │   ├── transcript-formatter.ts
 │   ├── audio-validation.ts
 │   ├── upload-handler.ts
@@ -409,7 +461,7 @@ prisma/
 - 같은 머신을 다른 사람과 공유하지 않는 것을 가정
 - 회의 transcript / 회의록은 평문으로 PostgreSQL에 저장됨 (디스크 암호화는 호스트 OS에 위임)
 
-### Gemini API 키
+### API 키
 - LocalStorage 저장 (브라우저 동일 출처 정책으로 보호)
 - 서버 DB에 저장되지 않음
 - 요청 시점에만 body로 전송, 일회성 사용
@@ -417,10 +469,14 @@ prisma/
 
 ### 외부 데이터 송출
 - **Web Speech API** — Chrome이 마이크 오디오를 Google 서버로 전송하여 전사 (Chrome 자체 동작, 우리 서버 경유 X)
-- **Gemini API** — 사용자가 명시적으로 활성화한 경우에만 transcript를 Google 서버로 전송
+- **AI 요약 API** — 사용자가 명시적으로 활성화한 경우에만 transcript를 선택한 프로바이더로 전송
+  - Gemini / OpenAI 직접 호출 → 해당 회사 서버 1곳
+  - OrcaRouter 등 중계 라우터 → **라우터 운영사 + 실제 모델 제공사** 양쪽
+  - 로컬 모델 (Ollama / LM Studio / vLLM) → **외부 전송 없음**
 - **그 외** — 외부 호출 없음 (텔레메트리 / 분석 도구 미설치)
 
-> ⚠️ **회사 회의 등 민감 정보가 외부 클라우드(Google)로 송출되는 점에 유의.** 사내 컴플라이언스 정책 확인 후 사용 권장.
+> ⚠️ **회사 회의 등 민감 정보가 외부 클라우드로 송출되는 점에 유의.** 사내 컴플라이언스 정책 확인 후 사용 권장.
+> 외부 전송이 곤란하다면 `/settings`에서 **로컬 모델**을 선택하세요.
 
 ### 권장 배포 방식
 
@@ -446,8 +502,9 @@ prisma/
 
 | 제약 | 설명 | 대응 |
 |---|---|---|
-| **Chrome 전용** | Web Speech API는 비표준 — Safari / Firefox는 제한적 | Phase 4에서 서버 사이드 전사 검토 |
+| **Chrome 전용** | Web Speech API는 비표준 — Safari / Firefox는 제한적 | 서버 사이드 STT 전환 예정 |
-| **화자 구분 없음** | 의도적 비지원 (Non-goal) | — |
+| **전사 포착률 낮음** | 원거리·다인 대면 회의 실측 10% 안팎 | 오디오 원본 보관 → 서버 STT 재전사 (진행 예정) |
+| **화자 구분 없음** | 미구현 (PR #16 / #17 검토 중) | — |
 | **Gemini 무료 등급 한도** | 15 RPM / 1000 RPD | 한도 초과 시 자동 쿨다운, 단순 변환 폴백 |
 | **단일 사용자** | 인증 없음, 데이터 격리 없음 | 1인 1인스턴스로 운용 |
 | **마크다운 검색** | PostgreSQL `ILIKE` (수천 건 이상에서 느려질 수 있음) | 필요 시 `tsvector` 인덱스 추가 |

SECURITY.md

@@ -48,9 +48,9 @@
 
 | 데이터 | 저장 위치 | 외부 송출 |
 |---|---|---|
-| 회의 transcript / 회의록 | PostgreSQL (`meetings.markdownMinutes`, `rawTranscript`) | Gemini AI 요약 활성화 시 transcript가 Google로 전송 |
+| 회의 transcript / 회의록 | PostgreSQL (`meetings.markdownMinutes`, `rawTranscript`) | AI 요약 활성화 시 transcript가 **선택한 프로바이더**로 전송 |
 | 액션 아이템 | PostgreSQL (`action_items`) | 외부 송출 없음 |
-| Gemini API 키 | 브라우저 LocalStorage 또는 `.env` | 요청 시 Google에만 전송 |
+| API 키 | 브라우저 LocalStorage 또는 `.env` | 요청 시 선택한 프로바이더에만 전송 |
 | 음성 데이터 | 메모리 (실시간), `/app/uploads` (파일 업로드) | **Chrome Web Speech API → Google 서버** ⚠️ |
 
 ### ⚠️ 주의: Web Speech API의 음성 외부 전송
@@ -63,6 +63,30 @@ Chrome의 `SpeechRecognition` API는 **음성 데이터를 Google 서버로 전
 
 이 경우 **파일 업로드 탭**도 같은 한계가 있으므로(현재 업로드 후 전사는 미구현, Phase 4에서 자체 STT 검토 예정), 이 도구의 사용을 보류하는 것을 권장합니다.
 
+### ⚠️ 주의: AI 프로바이더 선택에 따른 전송 경로
+
+`/settings`에서 고른 프로바이더에 따라 **회의 전문이 지나가는 회사가 달라집니다.**
+
+| 선택 | transcript를 보게 되는 주체 |
+|---|---|
+| Google Gemini (기본) | Google |
+| OpenAI | OpenAI |
+| OrcaRouter 등 중계 라우터 | **라우터 운영사 + 라우터가 고른 실제 모델 제공사** (2단계) |
+| 로컬 모델 (Ollama / LM Studio / vLLM) | **없음** — 요청이 내 머신 밖으로 나가지 않음 |
+
+- 중계 라우터는 요청을 대신 전달하는 구조상 **평문 프롬프트를 볼 수 있는 주체가 한 곳 늘어납니다.** 로깅·보관 정책은 각 서비스 약관을 직접 확인하세요.
+- 사내 컴플라이언스가 외부 전송을 제한한다면 **로컬 모델** 프리셋을 사용하세요.
+
+### base URL은 서버가 대신 호출합니다 (SSRF 주의)
+
+OpenAI 호환 프리셋의 base URL은 브라우저가 아니라 **Next.js Route Handler(서버)** 가 fetch 합니다.
+
+- `http` / `https` 스킴만 허용합니다 (`normalizeBaseUrl`).
+- 그 외 호스트 제한은 없습니다. 이 앱은 `127.0.0.1` 단일 사용자 실행을 전제로 하므로 의도된 설계이지만,
+  **앱을 LAN이나 인터넷에 노출하면 요청자가 서버 내부망 주소를 base URL로 넣어 스캔할 수 있습니다.**
+- 노출 배포가 필요하다면 리버스 프록시에서 egress를 제한하거나, `LLM_BASE_URL`을 환경변수로 고정하고
+  요청 body의 `baseUrl`을 무시하도록 수정하세요.
+
 ---
 
 ## ✅ 구현된 보안 조치
@@ -91,9 +115,10 @@ Chrome의 `SpeechRecognition` API는 **음성 데이터를 Google 서버로 전
 
 ### API 키 보호
 - `/api/settings/status`: 키 존재 여부만 응답 (값 노출 X)
-- `/api/settings/test`: 401/403/429 분류, detail 200자로 제한
+- `/api/settings/test`: 401/403/429 분류, 업스트림 응답 본문을 그대로 돌려주지 않음
-- `getStoredApiKey` GET 요청에 절대 포함 안 함 (body 전송만)
+- 키는 GET 요청에 절대 포함 안 함 (body 전송만)
 - `maskApiKey()`: UI에 표시 시 `AIza••••XYZ12` 형태로 마스킹
+- Gemini는 `x-goog-api-key` 헤더, OpenAI 호환은 `Authorization: Bearer` 헤더 — **키를 URL에 넣지 않음** (로그/리퍼러 유출 방지)
 
 ---
 
@@ -107,6 +132,26 @@ Chrome의 `SpeechRecognition` API는 **음성 데이터를 Google 서버로 전
 - 추가 보호가 필요하면 reverse proxy(nginx, Caddy)에 Basic Auth 추가
 - 회사 환경에서는 SSO 통합이 필요하지만 현재 비목표
 
+### MEDIUM — 회의 원음이 디스크에 평문으로 남습니다
+
+**현황**: 실시간 녹음을 시작하면 회의 오디오 원본이 `uploads/recordings/`에 저장됩니다
+(Docker에서는 `uploads` 볼륨). 암호화하지 않은 평문 오디오이며, 회의에서 오간
+말이 그대로 들어 있습니다. **전사 텍스트보다 민감도가 높습니다** — 텍스트는
+Web Speech가 대부분 놓치지만 오디오에는 전부 남습니다.
+
+이 저장은 의도된 설계입니다. Web Speech의 포착률이 낮아(실측 10% 안팎) 원음을
+남기지 않으면 놓친 발화를 복구할 방법이 없습니다.
+
+**완화**:
+- 디스크 암호화(FileVault / BitLocker)가 켜진 머신에서 운용
+- 불필요해진 녹음은 `uploads/recordings/`에서 직접 삭제
+- `RECORDINGS_DIR` 환경변수로 저장 위치를 별도 암호화 볼륨으로 지정 가능
+- 녹음 파일 자동 만료/삭제는 **미구현** — 수동 관리가 필요합니다
+
+**세션 ID 추측**: 녹음 조회·추가 API는 128비트 난수 ID만으로 접근을 가릅니다.
+인증이 없으므로, 같은 머신에서 앱에 접근 가능한 주체는 ID를 알면 오디오를
+내려받을 수 있습니다. 단일 사용자 로컬 실행 전제입니다.
+
 ### MEDIUM — 파일 업로드 매직 바이트 미검증
 **현황**: `audio-validation.ts`는 `file.type`(클라이언트 제공)과 파일명 확장자만 검사. 매직 바이트 검증 없음.
 

docs/ROADMAP.md

@@ -155,6 +155,64 @@
 
 ---
 
+## 🔴 실사용 진단 (2026-09-08 대면 회의)
+
+46분 대면 회의를 실제로 녹음해 본 결과다. 로드맵의 우선순위를 바꾼 근거.
+
+| 지표 | 값 |
+|---|---|
+| 회의 길이 | 46분 6초 |
+| 총 청크 | 122개 |
+| 총 어절 | **489** |
+| 분당 어절 | **10.6** (한국어 대화 통상 100~150) |
+| 추정 포착률 | **7~10%** |
+| 30초 이상 공백 | 26곳 / 합계 26분 29초 (회의의 57%) |
+| 빈 텍스트 청크 | 19개 (16%) |
+
+**빈 청크 19개가 결정적 증거다.** Chrome이 `isFinal: true`에 `transcript: ""`를
+준 경우로, "소리는 감지했으나 인식 실패"를 뜻한다. 마이크 입력 문제가 아니라
+Web Speech가 원거리·다인 한국어를 못 알아듣고 버린 것이다.
+
+**결론: Web Speech API는 회의 전사에 쓸 수 없다.** 재시작 갭을 메우고 interim을
+flush해서 7%를 20~30%로는 올려도 90%로는 못 간다. 구현 결함이 아니라 엔진의 한계다.
+
+---
+
+## 🎯 P0 — 유실을 멈춘다
+
+- [x] **오디오 원본 녹음** — `MediaRecorder`로 회의 원음을 파일로 보관
+  - [x] 15초 조각 단위로 서버에 append → 탭/서버가 죽어도 그때까지는 남음
+  - [x] 서버 실패해도 녹음 계속 + 브라우저 사본 내려받기
+  - [x] 0바이트일 때 "보관됨"이라고 하지 않음
+  - [x] 캡처 제약에서 노이즈 억제·에코 제거 해제 (원거리 화자 보존)
+  - [x] 회의록 저장 시 `audioFileName`/`audioMimeType`/`audioDuration` 연결
+- [ ] **서버 STT 파이프라인** — 녹음 파일 → Whisper / Gemini audio → transcript
+  - [ ] `/api/upload`를 막다른 길에서 본선 경로로 승격
+  - [ ] 프로바이더 레이어에 `/v1/audio/transcriptions` 추가 (#12 구조 확장)
+  - [ ] Web Speech는 "녹음 중 실시간 미리보기"로 강등, 확정본은 종료 후 재전사
+  - [ ] 같은 오디오로 Web Speech vs STT 포착률 실측 비교
+- [ ] **빈 청크 필터링** — 빈 발화 19개가 요약 프롬프트를 오염시키고 있음
+- [ ] **타임스탬프 실측화** — `useSpeechRecognition.ts`의 `startTime: now - 2` 하드코딩 제거
+- [ ] **10만 자 하드 실패 → 분할 요약** — 긴 회의가 마지막에 통째로 실패함
+
+## 🎯 P1 — 입력단 개선
+
+- [ ] 대면 회의용 USB 전방향 마이크 도입 (코드로 못 푸는 물리적 한계)
+- [ ] 원격 회의용 `echoCancellation` 재활성 경로 분리
+
+## 🎯 P2 — 화자 분리 재설계
+
+- [ ] **PR #17은 현재 형태로 머지 보류** — 실사용에서 46분 회의를 화자 1명으로
+      판정했고, 5개 청크는 배정조차 실패했다. `assignSpeakers()`가 쓰는 시간축이
+      가짜(`now - 2`)라 diarization의 실제 타임라인과 맞지 않는다
+- [ ] 서버 STT 도입 후 재설계 — Whisper의 단어 단위 실제 타임스탬프 위에서
+      diarization을 돌리면 그때 비로소 겹침 기반 배정이 의미를 갖는다
+- [ ] #17의 sherpa-onnx 래퍼·모델 셋업 스크립트는 그때 재활용
+- [ ] 참석자 수 힌트는 유지 (#17 실측에서 효과 확인됨)
+- [ ] PR #16(dual-stream)은 원격 회의 전용으로 분리 검증
+
+---
+
 ## 🎯 Phase 3 — 참석자 + 태그 (3~5일)
 
 ### Issues
@@ -199,7 +257,6 @@
 
 다음 기능은 개인 사용 목적에 부합하지 않아 **의도적으로 범위 밖**:
 
-- **화자 구분 (Speaker Diarization)** — 유료 API 비용/복잡도 대비 개인용에 과함
 - **실시간 공동 편집 (CRDT)** — Yjs/Liveblocks 도입 복잡도 대비 이득 없음
 - **권한 관리 / 워크스페이스** — 단일 사용자 가정
 - **모바일 네이티브 앱** — 웹 PWA로 충분

src/__tests__/api-key-storage.test.ts

@@ -4,6 +4,10 @@ import {
   setStoredApiKey,
   clearStoredApiKey,
   maskApiKey,
+  getStoredProviderConfig,
+  setStoredProviderConfig,
+  clearStoredProviderConfig,
+  getProviderRequestPayload,
 } from '@/lib/api-key-storage'
 
 describe('LocalStorage api key helpers', () => {
@@ -48,3 +52,99 @@ describe('maskApiKey', () => {
     expect(maskApiKey('123456789')).toBe('1234••••6789')
   })
 })
+
+describe('프로바이더 설정 저장', () => {
+  beforeEach(() => {
+    window.localStorage.clear()
+  })
+
+  it('저장 후 동일한 설정을 돌려준다', () => {
+    setStoredProviderConfig({
+      presetId: 'orcarouter',
+      apiKey: 'sk-test',
+      baseUrl: 'https://api.orcarouter.ai/v1',
+      model: 'google/gemini-2.5-flash-lite',
+    })
+
+    expect(getStoredProviderConfig()).toEqual({
+      presetId: 'orcarouter',
+      apiKey: 'sk-test',
+      baseUrl: 'https://api.orcarouter.ai/v1',
+      model: 'google/gemini-2.5-flash-lite',
+    })
+  })
+
+  it('미설정이거나 깨진 값이면 null', () => {
+    expect(getStoredProviderConfig()).toBeNull()
+    window.localStorage.setItem('meeting-minutes:llm-provider', '{not json')
+    expect(getStoredProviderConfig()).toBeNull()
+  })
+
+  it('clear 시 삭제된다', () => {
+    setStoredProviderConfig({
+      presetId: 'openai',
+      apiKey: 'sk',
+      baseUrl: 'https://api.openai.com/v1',
+      model: 'gpt-4o-mini',
+    })
+    clearStoredProviderConfig()
+    expect(getStoredProviderConfig()).toBeNull()
+  })
+})
+
+describe('getProviderRequestPayload', () => {
+  beforeEach(() => {
+    window.localStorage.clear()
+  })
+
+  it('프로바이더 설정이 없으면 기존 Gemini 키를 그대로 사용한다', () => {
+    setStoredApiKey('AIza-legacy')
+
+    expect(getProviderRequestPayload()).toEqual({
+      provider: 'gemini',
+      apiKey: 'AIza-legacy',
+      baseUrl: '',
+      model: '',
+    })
+  })
+
+  it('아무것도 없으면 빈 gemini 설정을 돌려준다', () => {
+    expect(getProviderRequestPayload()).toEqual({
+      provider: 'gemini',
+      apiKey: '',
+      baseUrl: '',
+      model: '',
+    })
+  })
+
+  it('프리셋 id로부터 provider를 결정한다', () => {
+    setStoredProviderConfig({
+      presetId: 'local',
+      apiKey: '',
+      baseUrl: 'http://localhost:11434/v1',
+      model: 'llama3.1',
+    })
+
+    expect(getProviderRequestPayload()).toEqual({
+      provider: 'openai-compatible',
+      apiKey: '',
+      baseUrl: 'http://localhost:11434/v1',
+      model: 'llama3.1',
+    })
+  })
+
+  it('gemini 프리셋에서 키를 비워두면 기존 키로 폴백한다', () => {
+    setStoredApiKey('AIza-legacy')
+    setStoredProviderConfig({
+      presetId: 'gemini',
+      apiKey: '',
+      baseUrl: '',
+      model: 'gemini-2.5-pro',
+    })
+
+    const payload = getProviderRequestPayload()
+    expect(payload.provider).toBe('gemini')
+    expect(payload.apiKey).toBe('AIza-legacy')
+    expect(payload.model).toBe('gemini-2.5-pro')
+  })
+})

src/__tests__/api-keys.test.ts

@@ -1,5 +1,10 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-import { resolveGeminiApiKey, isEnvKeyConfigured } from '@/lib/api-keys'
+import {
+  resolveGeminiApiKey,
+  isEnvKeyConfigured,
+  isEnvProviderConfigured,
+  resolveProviderSettings,
+} from '@/lib/api-keys'
 
 describe('resolveGeminiApiKey', () => {
   const originalEnv = process.env.GEMINI_API_KEY
@@ -70,3 +75,139 @@ describe('isEnvKeyConfigured', () => {
     expect(isEnvKeyConfigured()).toBe(false)
   })
 })
+
+describe('resolveProviderSettings', () => {
+  const ENV_KEYS = [
+    'GEMINI_API_KEY',
+    'LLM_PROVIDER',
+    'LLM_BASE_URL',
+    'LLM_API_KEY',
+    'LLM_MODEL',
+  ] as const
+  const saved: Record<string, string | undefined> = {}
+
+  beforeEach(() => {
+    for (const key of ENV_KEYS) {
+      saved[key] = process.env[key]
+      delete process.env[key]
+    }
+  })
+
+  afterEach(() => {
+    for (const key of ENV_KEYS) {
+      if (saved[key] === undefined) delete process.env[key]
+      else process.env[key] = saved[key]
+    }
+  })
+
+  it('provider를 지정하지 않으면 gemini로 간주한다', () => {
+    expect(resolveProviderSettings({ apiKey: 'req-key' })).toEqual({
+      provider: 'gemini',
+      apiKey: 'req-key',
+      model: undefined,
+    })
+  })
+
+  it('gemini인데 키가 아무데도 없으면 null (단순 변환 폴백)', () => {
+    expect(resolveProviderSettings({})).toBeNull()
+    expect(resolveProviderSettings(null)).toBeNull()
+  })
+
+  it('gemini 키는 요청 → GEMINI_API_KEY 순으로 해석한다', () => {
+    process.env.GEMINI_API_KEY = 'env-key'
+    expect(resolveProviderSettings({ apiKey: 'req-key' })?.apiKey).toBe('req-key')
+    expect(resolveProviderSettings({})?.apiKey).toBe('env-key')
+  })
+
+  it('openai-compatible은 baseUrl과 model이 모두 있어야 한다', () => {
+    const base = { provider: 'openai-compatible', apiKey: 'sk-x' }
+    expect(resolveProviderSettings(base)).toBeNull()
+    expect(
+      resolveProviderSettings({ ...base, baseUrl: 'https://a.example/v1' }),
+    ).toBeNull()
+    expect(
+      resolveProviderSettings({ ...base, model: 'gpt-4o-mini' }),
+    ).toBeNull()
+    expect(
+      resolveProviderSettings({
+        ...base,
+        baseUrl: 'https://a.example/v1',
+        model: 'gpt-4o-mini',
+      }),
+    ).toEqual({
+      provider: 'openai-compatible',
+      apiKey: 'sk-x',
+      baseUrl: 'https://a.example/v1',
+      model: 'gpt-4o-mini',
+    })
+  })
+
+  it('openai-compatible은 키가 비어도 허용한다 (로컬 모델 서버)', () => {
+    const settings = resolveProviderSettings({
+      provider: 'openai-compatible',
+      apiKey: '',
+      baseUrl: 'http://localhost:11434/v1',
+      model: 'llama3.1',
+    })
+    expect(settings?.apiKey).toBe('')
+  })
+
+  it('LLM_* 환경변수만으로도 설정된다', () => {
+    process.env.LLM_PROVIDER = 'openai-compatible'
+    process.env.LLM_BASE_URL = 'https://api.orcarouter.ai/v1'
+    process.env.LLM_MODEL = 'google/gemini-2.5-flash-lite'
+    process.env.LLM_API_KEY = 'sk-env'
+
+    expect(resolveProviderSettings({})).toEqual({
+      provider: 'openai-compatible',
+      apiKey: 'sk-env',
+      baseUrl: 'https://api.orcarouter.ai/v1',
+      model: 'google/gemini-2.5-flash-lite',
+    })
+  })
+
+  it('알 수 없는 provider 값은 무시하고 기본값으로 떨어진다', () => {
+    process.env.GEMINI_API_KEY = 'env-key'
+    expect(resolveProviderSettings({ provider: 'anthropic' })?.provider).toBe(
+      'gemini',
+    )
+  })
+})
+
+describe('isEnvProviderConfigured', () => {
+  const ENV_KEYS = ['GEMINI_API_KEY', 'LLM_PROVIDER', 'LLM_BASE_URL', 'LLM_MODEL', 'LLM_API_KEY'] as const
+  const saved: Record<string, string | undefined> = {}
+
+  beforeEach(() => {
+    for (const key of ENV_KEYS) {
+      saved[key] = process.env[key]
+      delete process.env[key]
+    }
+  })
+
+  afterEach(() => {
+    for (const key of ENV_KEYS) {
+      if (saved[key] === undefined) delete process.env[key]
+      else process.env[key] = saved[key]
+    }
+  })
+
+  it('아무 것도 없으면 false', () => {
+    expect(isEnvProviderConfigured()).toBe(false)
+  })
+
+  it('GEMINI_API_KEY만 있어도 true', () => {
+    process.env.GEMINI_API_KEY = 'k'
+    expect(isEnvProviderConfigured()).toBe(true)
+  })
+
+  it('openai-compatible은 base URL과 모델까지 있어야 true', () => {
+    process.env.LLM_PROVIDER = 'openai-compatible'
+    process.env.LLM_API_KEY = 'k'
+    expect(isEnvProviderConfigured()).toBe(false)
+
+    process.env.LLM_BASE_URL = 'https://a.example/v1'
+    process.env.LLM_MODEL = 'm'
+    expect(isEnvProviderConfigured()).toBe(true)
+  })
+})

src/__tests__/live-summary.test.ts

@@ -1,5 +1,8 @@
 import { describe, it, expect, vi } from 'vitest'
-import { generateLiveSummary } from '@/lib/live-summary'
+import {
+  generateLiveSummary,
+  planLiveSummaryRequest,
+} from '@/lib/live-summary'
 
 describe('generateLiveSummary', () => {
   it('Gemini API 응답을 받아 중간 요약 마크다운을 반환한다', async () => {
@@ -128,3 +131,158 @@ describe('generateLiveSummary', () => {
     expect(init.headers['x-goog-api-key']).toBe('secret-key')
   })
 })
+
+describe('generateLiveSummary — openai-compatible', () => {
+  it('OpenAI 호환 엔드포인트로 중간 요약을 만든다', async () => {
+    const mockFetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: () =>
+        Promise.resolve({
+          choices: [{ message: { content: '## 요약\n진행 중' } }],
+        }),
+    })
+
+    const result = await generateLiveSummary('회의 내용', {
+      provider: {
+        provider: 'openai-compatible',
+        apiKey: 'sk-test',
+        baseUrl: 'http://localhost:11434/v1',
+        model: 'llama3.1',
+      },
+      fetchFn: mockFetch,
+    })
+
+    expect(result.success).toBe(true)
+    expect(mockFetch.mock.calls[0][0]).toBe(
+      'http://localhost:11434/v1/chat/completions',
+    )
+  })
+})
+
+describe('planLiveSummaryRequest', () => {
+  const base = {
+    totalChunks: 50,
+    lastSummarizedIndex: 30,
+    incrementsSinceFull: 3,
+    fullRefreshEvery: 20,
+    hasPreviousSummary: true,
+  }
+
+  it('평상시에는 직전 지점부터 증분으로 보낸다', () => {
+    expect(planLiveSummaryRequest(base)).toEqual({
+      mode: 'incremental',
+      startIndex: 30,
+    })
+  })
+
+  it('첫 호출은 전체를 보낸다', () => {
+    expect(
+      planLiveSummaryRequest({ ...base, lastSummarizedIndex: 0 }),
+    ).toEqual({ mode: 'full', startIndex: 0 })
+  })
+
+  it('갱신할 직전 요약이 없으면 전체를 보낸다', () => {
+    expect(
+      planLiveSummaryRequest({ ...base, hasPreviousSummary: false }),
+    ).toEqual({ mode: 'full', startIndex: 0 })
+  })
+
+  it('증분이 누적되면 전체 재요약으로 오차를 끊는다', () => {
+    expect(
+      planLiveSummaryRequest({ ...base, incrementsSinceFull: 20 }),
+    ).toEqual({ mode: 'full', startIndex: 0 })
+  })
+
+  it('fullRefreshEvery=0이면 전체 재요약을 하지 않는다', () => {
+    expect(
+      planLiveSummaryRequest({
+        ...base,
+        fullRefreshEvery: 0,
+        incrementsSinceFull: 999,
+      }).mode,
+    ).toBe('incremental')
+  })
+
+  it('전사가 초기화되어 인덱스가 범위를 벗어나면 전체를 보낸다', () => {
+    expect(
+      planLiveSummaryRequest({ ...base, totalChunks: 5 }),
+    ).toEqual({ mode: 'full', startIndex: 0 })
+  })
+})
+
+describe('generateLiveSummary — 증분 모드', () => {
+  function mockOk(text = '## 요약\n갱신됨') {
+    return vi.fn().mockResolvedValue({
+      ok: true,
+      json: () =>
+        Promise.resolve({
+          candidates: [{ content: { parts: [{ text }] } }],
+        }),
+    })
+  }
+
+  function sentPrompt(mockFetch: ReturnType<typeof vi.fn>): string {
+    const body = JSON.parse(mockFetch.mock.calls[0][1].body)
+    return body.contents[0].parts[0].text
+  }
+
+  it('previousSummary가 있으면 요약과 신규 발화를 나눠 전달한다', async () => {
+    const mockFetch = mockOk()
+
+    await generateLiveSummary('새로 나온 이야기', {
+      apiKey: 'k',
+      previousSummary: '## 요약\n이전까지의 내용',
+      fetchFn: mockFetch,
+    })
+
+    const prompt = sentPrompt(mockFetch)
+    expect(prompt).toContain('[지금까지의 요약]')
+    expect(prompt).toContain('이전까지의 내용')
+    expect(prompt).toContain('[새로 추가된 발화]')
+    expect(prompt).toContain('새로 나온 이야기')
+    expect(prompt).toContain('갱신')
+  })
+
+  it('previousSummary가 없으면 기존 전체 요약 형식을 유지한다', async () => {
+    const mockFetch = mockOk()
+
+    await generateLiveSummary('전체 전사', { apiKey: 'k', fetchFn: mockFetch })
+
+    const prompt = sentPrompt(mockFetch)
+    expect(prompt).toContain('음성 인식 텍스트:')
+    expect(prompt).not.toContain('[지금까지의 요약]')
+  })
+
+  it('빈 문자열 previousSummary는 증분으로 취급하지 않는다', async () => {
+    const mockFetch = mockOk()
+
+    await generateLiveSummary('전체 전사', {
+      apiKey: 'k',
+      previousSummary: '   ',
+      fetchFn: mockFetch,
+    })
+
+    expect(sentPrompt(mockFetch)).not.toContain('[지금까지의 요약]')
+  })
+
+  it('긴 회의에서 증분 프롬프트가 전체 프롬프트보다 짧다', async () => {
+    const longTranscript = '회의 발화 한 줄입니다.\n'.repeat(500)
+
+    const fullFetch = mockOk()
+    await generateLiveSummary(longTranscript, {
+      apiKey: 'k',
+      fetchFn: fullFetch,
+    })
+
+    const incFetch = mockOk()
+    await generateLiveSummary('마지막 30초에 나온 이야기', {
+      apiKey: 'k',
+      previousSummary: '## 요약\n지금까지의 요약 본문',
+      fetchFn: incFetch,
+    })
+
+    expect(sentPrompt(incFetch).length).toBeLessThan(
+      sentPrompt(fullFetch).length / 5,
+    )
+  })
+})

src/__tests__/minutes-generator.test.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect, vi } from 'vitest'
 import {
   generateSimpleMinutes,
+  generateAiMinutes,
   generateGeminiMinutes,
   type MinutesInput,
 } from '@/lib/minutes-generator'
@@ -105,3 +106,49 @@ describe('generateGeminiMinutes', () => {
     }
   })
 })
+
+describe('generateAiMinutes — openai-compatible', () => {
+  const settings = {
+    provider: 'openai-compatible' as const,
+    apiKey: 'sk-test',
+    baseUrl: 'https://api.orcarouter.ai/v1',
+    model: 'google/gemini-2.5-flash-lite',
+  }
+
+  it('OpenAI 호환 엔드포인트 응답으로 회의록을 만든다', async () => {
+    const mockFetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: () =>
+        Promise.resolve({
+          choices: [{ message: { content: '## 요약\n- 리팩토링 완료' } }],
+        }),
+    })
+
+    const result = await generateAiMinutes(sampleInput, {
+      provider: settings,
+      fetchFn: mockFetch,
+    })
+
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.markdown).toContain('# 주간 스프린트 회의')
+      expect(result.markdown).toContain('리팩토링 완료')
+      // 하단 문구는 실제 사용한 모델을 표기한다
+      expect(result.markdown).toContain('google/gemini-2.5-flash-lite')
+    }
+  })
+
+  it('응답이 비어 있으면 실패로 처리해 단순 변환 폴백을 유도한다', async () => {
+    const mockFetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({ choices: [{ message: { content: '  ' } }] }),
+    })
+
+    const result = await generateAiMinutes(sampleInput, {
+      provider: settings,
+      fetchFn: mockFetch,
+    })
+
+    expect(result.success).toBe(false)
+  })
+})

src/__tests__/providers.test.ts

@@ -0,0 +1,222 @@
+import { describe, it, expect, vi } from 'vitest'
+import {
+  complete,
+  describeModel,
+  normalizeBaseUrl,
+  toProviderSettings,
+  DEFAULT_GEMINI_MODEL,
+  findPreset,
+  PROVIDER_PRESETS,
+} from '@/lib/providers'
+
+function okResponse(content: string) {
+  return {
+    ok: true,
+    json: () => Promise.resolve({ choices: [{ message: { content } }] }),
+  }
+}
+
+const OPENAI_SETTINGS = {
+  provider: 'openai-compatible' as const,
+  apiKey: 'sk-test',
+  baseUrl: 'https://api.orcarouter.ai/v1',
+  model: 'google/gemini-2.5-flash-lite',
+}
+
+describe('normalizeBaseUrl', () => {
+  it('끝의 슬래시를 제거한다', () => {
+    expect(normalizeBaseUrl('https://api.example.com/v1/')).toBe(
+      'https://api.example.com/v1',
+    )
+  })
+
+  it('앞뒤 공백을 제거한다', () => {
+    expect(normalizeBaseUrl('  https://api.example.com/v1  ')).toBe(
+      'https://api.example.com/v1',
+    )
+  })
+
+  it('http/https 이외의 스킴은 거부한다', () => {
+    expect(normalizeBaseUrl('file:///etc/passwd')).toBeNull()
+    expect(normalizeBaseUrl('ftp://example.com')).toBeNull()
+  })
+
+  it('URL이 아니거나 비어 있으면 null', () => {
+    expect(normalizeBaseUrl('not-a-url')).toBeNull()
+    expect(normalizeBaseUrl('   ')).toBeNull()
+  })
+})
+
+describe('complete — openai-compatible', () => {
+  it('/chat/completions로 OpenAI 형식 요청을 보낸다', async () => {
+    const mockFetch = vi.fn().mockResolvedValue(okResponse('## 요약'))
+
+    const result = await complete('프롬프트', OPENAI_SETTINGS, {
+      fetchFn: mockFetch,
+    })
+
+    expect(result.success).toBe(true)
+    if (result.success) expect(result.text).toBe('## 요약')
+
+    const [url, init] = mockFetch.mock.calls[0]
+    expect(url).toBe('https://api.orcarouter.ai/v1/chat/completions')
+    expect(init.headers.Authorization).toBe('Bearer sk-test')
+
+    const body = JSON.parse(init.body)
+    expect(body.model).toBe('google/gemini-2.5-flash-lite')
+    expect(body.messages).toEqual([{ role: 'user', content: '프롬프트' }])
+  })
+
+  it('키가 없으면 Authorization 헤더를 붙이지 않는다 (로컬 모델 서버)', async () => {
+    const mockFetch = vi.fn().mockResolvedValue(okResponse('요약'))
+
+    await complete(
+      '프롬프트',
+      { ...OPENAI_SETTINGS, apiKey: '', baseUrl: 'http://localhost:11434/v1' },
+      { fetchFn: mockFetch },
+    )
+
+    const [, init] = mockFetch.mock.calls[0]
+    expect(init.headers.Authorization).toBeUndefined()
+  })
+
+  it('base URL이 없으면 호출하지 않고 에러를 반환한다', async () => {
+    const mockFetch = vi.fn()
+
+    const result = await complete(
+      '프롬프트',
+      { ...OPENAI_SETTINGS, baseUrl: '' },
+      { fetchFn: mockFetch },
+    )
+
+    expect(result.success).toBe(false)
+    expect(mockFetch).not.toHaveBeenCalled()
+  })
+
+  it('모델이 없으면 호출하지 않고 에러를 반환한다', async () => {
+    const mockFetch = vi.fn()
+
+    const result = await complete(
+      '프롬프트',
+      { ...OPENAI_SETTINGS, model: '  ' },
+      { fetchFn: mockFetch },
+    )
+
+    expect(result.success).toBe(false)
+    if (!result.success) expect(result.error).toContain('모델')
+    expect(mockFetch).not.toHaveBeenCalled()
+  })
+
+  it('429는 rateLimited 플래그를 세운다', async () => {
+    const mockFetch = vi.fn().mockResolvedValue({ ok: false, status: 429 })
+
+    const result = await complete('프롬프트', OPENAI_SETTINGS, {
+      fetchFn: mockFetch,
+    })
+
+    expect(result.success).toBe(false)
+    if (!result.success) expect(result.rateLimited).toBe(true)
+  })
+
+  it('401은 인증 실패로 안내한다', async () => {
+    const mockFetch = vi.fn().mockResolvedValue({ ok: false, status: 401 })
+
+    const result = await complete('프롬프트', OPENAI_SETTINGS, {
+      fetchFn: mockFetch,
+    })
+
+    expect(result.success).toBe(false)
+    if (!result.success) expect(result.error).toContain('인증')
+  })
+
+  it('네트워크 예외를 결과 객체로 감싼다', async () => {
+    const mockFetch = vi.fn().mockRejectedValue(new Error('ECONNREFUSED'))
+
+    const result = await complete('프롬프트', OPENAI_SETTINGS, {
+      fetchFn: mockFetch,
+    })
+
+    expect(result.success).toBe(false)
+    if (!result.success) expect(result.error).toContain('ECONNREFUSED')
+  })
+})
+
+describe('complete — gemini 라우팅', () => {
+  it('provider가 gemini면 Google 엔드포인트를 호출한다', async () => {
+    const mockFetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: () =>
+        Promise.resolve({
+          candidates: [{ content: { parts: [{ text: '요약' }] } }],
+        }),
+    })
+
+    await complete(
+      '프롬프트',
+      { provider: 'gemini', apiKey: 'AIza-test' },
+      { fetchFn: mockFetch },
+    )
+
+    const [url, init] = mockFetch.mock.calls[0]
+    expect(url).toContain('generativelanguage.googleapis.com')
+    expect(url).toContain(DEFAULT_GEMINI_MODEL)
+    expect(init.headers['x-goog-api-key']).toBe('AIza-test')
+  })
+
+  it('모델을 지정하면 해당 모델 엔드포인트를 호출한다', async () => {
+    const mockFetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: () =>
+        Promise.resolve({
+          candidates: [{ content: { parts: [{ text: '요약' }] } }],
+        }),
+    })
+
+    await complete(
+      '프롬프트',
+      { provider: 'gemini', apiKey: 'AIza-test', model: 'gemini-2.5-pro' },
+      { fetchFn: mockFetch },
+    )
+
+    expect(mockFetch.mock.calls[0][0]).toContain('gemini-2.5-pro')
+  })
+})
+
+describe('toProviderSettings', () => {
+  it('provider가 없으면 기존 Gemini 호출부와 동일하게 동작한다', () => {
+    expect(toProviderSettings(undefined, 'legacy-key')).toEqual({
+      provider: 'gemini',
+      apiKey: 'legacy-key',
+    })
+  })
+
+  it('provider가 있으면 그대로 사용한다', () => {
+    expect(toProviderSettings(OPENAI_SETTINGS, 'ignored')).toBe(OPENAI_SETTINGS)
+  })
+})
+
+describe('describeModel', () => {
+  it('gemini는 기본 모델명을 돌려준다', () => {
+    expect(describeModel({ provider: 'gemini', apiKey: 'k' })).toBe(
+      DEFAULT_GEMINI_MODEL,
+    )
+  })
+
+  it('openai-compatible은 설정한 모델명을 돌려준다', () => {
+    expect(describeModel(OPENAI_SETTINGS)).toBe('google/gemini-2.5-flash-lite')
+  })
+})
+
+describe('프리셋', () => {
+  it('알 수 없는 id는 기본 프리셋으로 폴백한다', () => {
+    expect(findPreset('없는-프리셋').id).toBe('gemini')
+    expect(findPreset(null).id).toBe('gemini')
+  })
+
+  it('openai-compatible 프리셋은 base URL 또는 직접 입력 안내를 갖는다', () => {
+    for (const preset of PROVIDER_PRESETS) {
+      if (preset.provider !== 'openai-compatible') continue
+      expect(preset.id === 'custom' || preset.baseUrl.length > 0).toBe(true)
+    }
+  })
+})

src/__tests__/recording-store.test.ts

@@ -0,0 +1,164 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import { mkdtemp, rm, readFile } from 'fs/promises'
+import { tmpdir } from 'os'
+import path from 'path'
+
+type Store = typeof import('@/lib/recording-store')
+
+let dir: string
+let store: Store
+
+beforeEach(async () => {
+  dir = await mkdtemp(path.join(tmpdir(), 'recordings-'))
+  process.env.RECORDINGS_DIR = dir
+  vi.resetModules()
+  store = await import('@/lib/recording-store')
+})
+
+afterEach(async () => {
+  delete process.env.RECORDINGS_DIR
+  await rm(dir, { recursive: true, force: true })
+})
+
+describe('createRecording', () => {
+  it('세션 메타를 만들고 확장자를 붙인다', async () => {
+    const meta = await store.createRecording('audio/webm;codecs=opus')
+
+    expect(meta.id).toMatch(/^[0-9a-f]{32}$/)
+    expect(meta.fileName).toBe(`${meta.id}.webm`)
+    expect(meta.finalizedAt).toBeNull()
+    expect(meta.durationMs).toBeNull()
+  })
+
+  it('매번 다른 id를 준다', async () => {
+    const a = await store.createRecording('audio/webm')
+    const b = await store.createRecording('audio/webm')
+    expect(a.id).not.toBe(b.id)
+  })
+})
+
+describe('appendChunk', () => {
+  it('조각을 받은 순서대로 이어 붙인다', async () => {
+    const { id } = await store.createRecording('audio/webm')
+
+    await store.appendChunk(id, Buffer.from('AAA'))
+    await store.appendChunk(id, Buffer.from('BBB'))
+    const last = await store.appendChunk(id, Buffer.from('CC'))
+
+    expect(last).toEqual({ ok: true, bytes: 8 })
+
+    const meta = await store.getRecording(id)
+    const written = await readFile(path.join(dir, meta!.fileName), 'utf-8')
+    expect(written).toBe('AAABBBCC')
+  })
+
+  it('동시에 들어와도 순서가 섞이지 않는다', async () => {
+    const { id } = await store.createRecording('audio/webm')
+
+    // 클라이언트가 직렬로 보내도 서버에서 겹칠 수 있다. 겹쳐도 파일이
+    // 깨지지 않아야 한다 — 순서가 어긋나면 컨테이너를 못 읽는다.
+    await Promise.all([
+      store.appendChunk(id, Buffer.from('1')),
+      store.appendChunk(id, Buffer.from('2')),
+      store.appendChunk(id, Buffer.from('3')),
+      store.appendChunk(id, Buffer.from('4')),
+    ])
+
+    const meta = await store.getRecording(id)
+    const written = await readFile(path.join(dir, meta!.fileName), 'utf-8')
+    expect(written).toHaveLength(4)
+    expect(written.split('').sort().join('')).toBe('1234')
+  })
+
+  it('없는 세션은 404로 거절한다', async () => {
+    const result = await store.appendChunk('f'.repeat(32), Buffer.from('x'))
+    expect(result).toEqual({
+      ok: false,
+      error: '녹음 세션을 찾을 수 없습니다.',
+      status: 404,
+    })
+  })
+
+  it('누적 크기를 정확히 보고한다', async () => {
+    const { id } = await store.createRecording('audio/webm')
+    await store.appendChunk(id, Buffer.from('keep'))
+
+    const result = await store.appendChunk(id, Buffer.alloc(1024))
+    expect(result).toEqual({ ok: true, bytes: 4 + 1024 })
+  })
+})
+
+describe('finalizeRecording', () => {
+  it('길이를 확정하고 최종 크기를 돌려준다', async () => {
+    const { id } = await store.createRecording('audio/webm')
+    await store.appendChunk(id, Buffer.from('0123456789'))
+
+    const status = await store.finalizeRecording(id, 46_000)
+
+    expect(status?.bytes).toBe(10)
+    expect(status?.durationMs).toBe(46_000)
+    expect(status?.finalizedAt).not.toBeNull()
+  })
+
+  it('확정 정보가 디스크에도 남는다', async () => {
+    const { id } = await store.createRecording('audio/webm')
+    await store.finalizeRecording(id, 1_234)
+
+    const reloaded = await store.getRecording(id)
+    expect(reloaded?.durationMs).toBe(1_234)
+  })
+
+  it('길이가 숫자가 아니면 null로 둔다', async () => {
+    const { id } = await store.createRecording('audio/webm')
+    const status = await store.finalizeRecording(id, null)
+    expect(status?.durationMs).toBeNull()
+  })
+
+  it('없는 세션은 null', async () => {
+    expect(await store.finalizeRecording('e'.repeat(32), 1)).toBeNull()
+  })
+})
+
+describe('getRecording', () => {
+  it('잘못된 id는 파일을 찾아보지도 않는다', async () => {
+    expect(await store.getRecording('../../etc/passwd')).toBeNull()
+    expect(await store.getRecording('..')).toBeNull()
+  })
+})
+
+describe('openRecording', () => {
+  it('조각이 하나도 없으면 null', async () => {
+    const { id } = await store.createRecording('audio/webm')
+    expect(await store.openRecording(id)).toBeNull()
+  })
+
+  it('저장된 바이트를 그대로 읽어준다', async () => {
+    const { id } = await store.createRecording('audio/webm')
+    await store.appendChunk(id, Buffer.from('hello'))
+
+    const opened = await store.openRecording(id)
+    expect(opened?.bytes).toBe(5)
+    expect(opened?.meta.mimeType).toBe('audio/webm')
+
+    const chunks: Buffer[] = []
+    for await (const chunk of opened!.stream) {
+      chunks.push(Buffer.from(chunk as Buffer))
+    }
+    expect(Buffer.concat(chunks).toString()).toBe('hello')
+  })
+})
+
+describe('크래시 내성', () => {
+  it('종료 처리 없이 중단돼도 그때까지의 오디오는 남는다', async () => {
+    const { id } = await store.createRecording('audio/webm')
+    await store.appendChunk(id, Buffer.from('part1'))
+    await store.appendChunk(id, Buffer.from('part2'))
+    // finalize 없이 프로세스가 죽었다고 치고 모듈을 새로 읽는다.
+    vi.resetModules()
+    const reloaded: Store = await import('@/lib/recording-store')
+
+    const status = await reloaded.getRecordingStatus(id)
+    expect(status?.bytes).toBe(10)
+    expect(status?.finalizedAt).toBeNull()
+  })
+})

src/__tests__/recording.test.ts

@@ -0,0 +1,149 @@
+import { describe, it, expect } from 'vitest'
+import {
+  PREFERRED_MIME_TYPES,
+  RECORDING_AUDIO_CONSTRAINTS,
+  extensionForMimeType,
+  formatBytes,
+  formatDuration,
+  isValidRecordingId,
+  pickRecorderMimeType,
+  recordingDownloadName,
+} from '@/lib/recording'
+
+describe('pickRecorderMimeType', () => {
+  it('가장 앞선 후보를 고른다', () => {
+    const picked = pickRecorderMimeType(() => true)
+    expect(picked).toBe(PREFERRED_MIME_TYPES[0])
+  })
+
+  it('지원하지 않는 후보는 건너뛴다', () => {
+    const picked = pickRecorderMimeType((type) => type === 'audio/mp4')
+    expect(picked).toBe('audio/mp4')
+  })
+
+  it('아무것도 지원하지 않으면 null', () => {
+    expect(pickRecorderMimeType(() => false)).toBeNull()
+  })
+})
+
+describe('extensionForMimeType', () => {
+  it('코덱 파라미터를 떼고 판단한다', () => {
+    expect(extensionForMimeType('audio/webm;codecs=opus')).toBe('webm')
+    expect(extensionForMimeType('audio/ogg; codecs=opus')).toBe('ogg')
+  })
+
+  it('주요 컨테이너를 매핑한다', () => {
+    expect(extensionForMimeType('audio/webm')).toBe('webm')
+    expect(extensionForMimeType('audio/mp4')).toBe('m4a')
+    expect(extensionForMimeType('audio/mpeg')).toBe('mp3')
+    expect(extensionForMimeType('audio/wav')).toBe('wav')
+  })
+
+  it('대소문자를 가리지 않는다', () => {
+    expect(extensionForMimeType('AUDIO/WEBM')).toBe('webm')
+  })
+
+  it('모르는 형식은 bin으로 떨어진다', () => {
+    expect(extensionForMimeType('application/octet-stream')).toBe('bin')
+  })
+})
+
+describe('isValidRecordingId', () => {
+  const valid = 'a'.repeat(32)
+
+  it('32자 hex만 통과시킨다', () => {
+    expect(isValidRecordingId(valid)).toBe(true)
+    expect(isValidRecordingId('0123456789abcdef0123456789abcdef')).toBe(true)
+  })
+
+  it('경로 조작 시도를 막는다', () => {
+    expect(isValidRecordingId('../../etc/passwd')).toBe(false)
+    expect(isValidRecordingId(`${valid}/../x`)).toBe(false)
+    expect(isValidRecordingId('..')).toBe(false)
+    expect(isValidRecordingId(`../${valid}`)).toBe(false)
+  })
+
+  it('길이나 문자셋이 어긋나면 거부한다', () => {
+    expect(isValidRecordingId('a'.repeat(31))).toBe(false)
+    expect(isValidRecordingId('a'.repeat(33))).toBe(false)
+    expect(isValidRecordingId('A'.repeat(32))).toBe(false)
+    expect(isValidRecordingId('g'.repeat(32))).toBe(false)
+    expect(isValidRecordingId('')).toBe(false)
+  })
+
+  it('문자열이 아니면 거부한다', () => {
+    expect(isValidRecordingId(null)).toBe(false)
+    expect(isValidRecordingId(undefined)).toBe(false)
+    expect(isValidRecordingId(123)).toBe(false)
+  })
+})
+
+describe('recordingDownloadName', () => {
+  const at = new Date(2026, 8, 8, 14, 5)
+
+  it('날짜와 제목을 붙인다', () => {
+    expect(recordingDownloadName('주간 회의', at, 'audio/webm')).toBe(
+      '20260908-1405_주간_회의.webm',
+    )
+  })
+
+  it('제목이 없으면 날짜만 쓴다', () => {
+    expect(recordingDownloadName('   ', at, 'audio/webm')).toBe(
+      '20260908-1405.webm',
+    )
+  })
+
+  it('파일명에 못 쓰는 문자를 지운다', () => {
+    const name = recordingDownloadName('a/b\\c:d*e?f"g<h>i|j', at, 'audio/webm')
+    expect(name).toBe('20260908-1405_abcdefghij.webm')
+    expect(name).not.toMatch(/[\\/:*?"<>|]/)
+  })
+
+  it('아주 긴 제목을 자른다', () => {
+    const name = recordingDownloadName('가'.repeat(200), at, 'audio/webm')
+    expect(name.length).toBeLessThan(90)
+  })
+})
+
+describe('formatBytes', () => {
+  it('단위를 바꿔가며 표기한다', () => {
+    expect(formatBytes(512)).toBe('512B')
+    expect(formatBytes(2048)).toBe('2KB')
+    expect(formatBytes(5 * 1024 * 1024)).toBe('5.0MB')
+  })
+
+  it('비정상 값은 0으로 떨어진다', () => {
+    expect(formatBytes(-1)).toBe('0B')
+    expect(formatBytes(NaN)).toBe('0B')
+  })
+})
+
+describe('formatDuration', () => {
+  it('한 시간 미만은 분:초', () => {
+    expect(formatDuration(0)).toBe('00:00')
+    expect(formatDuration(65_000)).toBe('01:05')
+    expect(formatDuration(46 * 60_000 + 6_000)).toBe('46:06')
+  })
+
+  it('한 시간 이상은 시:분:초', () => {
+    expect(formatDuration(3_600_000)).toBe('1:00:00')
+    expect(formatDuration(3_725_000)).toBe('1:02:05')
+  })
+
+  it('음수는 0으로 본다', () => {
+    expect(formatDuration(-5_000)).toBe('00:00')
+  })
+})
+
+describe('RECORDING_AUDIO_CONSTRAINTS', () => {
+  it('원거리 화자를 지우는 전처리를 끈다', () => {
+    // 46분 대면 회의에서 포착률이 10% 안팎에 그친 원인 중 하나.
+    // 이 값이 다시 true로 돌아가면 회귀다.
+    expect(RECORDING_AUDIO_CONSTRAINTS.noiseSuppression).toBe(false)
+    expect(RECORDING_AUDIO_CONSTRAINTS.echoCancellation).toBe(false)
+  })
+
+  it('조용한 화자를 끌어올리는 AGC는 남긴다', () => {
+    expect(RECORDING_AUDIO_CONSTRAINTS.autoGainControl).toBe(true)
+  })
+})

src/__tests__/templates.test.ts

@@ -164,3 +164,119 @@ describe('liveEnabledFor / depthAdjustableFor', () => {
     expect(depthAdjustableFor('custom')).toBe(false)
   })
 })
+
+describe('내용 기반 섹션 구조', () => {
+  const transcript = '이번에는 가격 비교 사이트를 만들어 봅시다'
+
+  it('meeting은 섹션 제목을 직접 짓도록 지시한다', () => {
+    const prompt = buildPrompt({
+      templateId: 'meeting',
+      depth: 'standard',
+      transcript,
+    })
+    expect(prompt).toContain('섹션 제목을 직접 지어서')
+    // 고정 제목을 쓰지 말라는 지시가 함께 있어야 한다
+    expect(prompt).toContain('일반적인 제목은 쓰지 마세요')
+  })
+
+  it('one_on_one도 주제별 제목을 직접 짓도록 지시한다', () => {
+    const prompt = buildPrompt({
+      templateId: 'one_on_one',
+      depth: 'standard',
+      transcript,
+    })
+    expect(prompt).toContain('제목을 직접 지어')
+  })
+
+  it('raw는 구조적 제목을 덧붙이지 말라는 지시를 유지한다', () => {
+    const prompt = buildPrompt({
+      templateId: 'raw',
+      depth: 'detailed',
+      transcript,
+    })
+    expect(prompt).toContain('구조적 제목(## 섹션)을 덧붙이지 마세요')
+  })
+})
+
+describe('액션 아이템 담당자 표기', () => {
+  const transcript = '다음 주까지 정리해 주세요'
+
+  it('담당자 표기를 요구한다', () => {
+    const prompt = buildPrompt({
+      templateId: 'meeting',
+      depth: 'standard',
+      transcript,
+    })
+    expect(prompt).toContain('(담당자)')
+  })
+
+  it('담당자가 불분명해도 항목을 버리지 않도록 지시한다', () => {
+    const prompt = buildPrompt({
+      templateId: 'meeting',
+      depth: 'standard',
+      transcript,
+    })
+    expect(prompt).toContain('담당자가 불분명해도')
+  })
+
+  it('체크박스 형식을 유지해 액션 아이템 파서와 호환된다', () => {
+    for (const id of ['meeting', 'one_on_one', 'brainstorm'] as const) {
+      const prompt = buildPrompt({ templateId: id, depth: 'standard', transcript })
+      expect(prompt).toContain('- [ ]')
+    }
+  })
+})
+
+describe('공통 규칙', () => {
+  const transcript = '테스트 발화'
+
+  it('프리셋 템플릿 전체에 공통 규칙이 붙는다', () => {
+    for (const id of Object.keys(TEMPLATES) as (keyof typeof TEMPLATES)[]) {
+      const prompt = buildPrompt({ templateId: id, depth: 'standard', transcript })
+      expect(prompt).toContain('지어내지 마세요')
+      expect(prompt).toContain('한국어로 작성하세요')
+    }
+  })
+
+  it('발화자 표기가 있으면 활용하도록 지시한다', () => {
+    const prompt = buildPrompt({
+      templateId: 'meeting',
+      depth: 'standard',
+      transcript,
+    })
+    expect(prompt).toContain('발화자 표기가 있다면')
+  })
+
+  it('영어 기술 용어는 원문 표기를 유지하도록 지시한다', () => {
+    const prompt = buildPrompt({
+      templateId: 'meeting',
+      depth: 'standard',
+      transcript,
+    })
+    expect(prompt).toContain('원문 표기를 유지하세요')
+  })
+
+  it('custom 프롬프트에는 공통 규칙을 덧붙이지 않는다', () => {
+    const prompt = buildPrompt({
+      templateId: 'custom',
+      depth: 'standard',
+      transcript,
+      customPrompt: '한 줄로만 요약해줘',
+    })
+    expect(prompt).toContain('한 줄로만 요약해줘')
+    expect(prompt).not.toContain('지어내지 마세요')
+  })
+
+  it('custom 프롬프트가 비어 있으면 meeting 템플릿 + 공통 규칙으로 대체한다', () => {
+    const prompt = buildPrompt({
+      templateId: 'custom',
+      depth: 'standard',
+      transcript,
+      customPrompt: '   ',
+    })
+    expect(prompt).toContain('회의록 작성 전문가')
+    expect(prompt).toContain('지어내지 마세요')
+    // 기존 동작 유지 — custom 경로에는 강도/라이브 모디파이어를 적용하지 않는다
+    expect(prompt).not.toContain('작성 강도')
+  })
+})

src/__tests__/use-audio-recorder.test.ts

@@ -0,0 +1,239 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import { act, renderHook, waitFor } from '@testing-library/react'
+import { useAudioRecorder } from '@/hooks/useAudioRecorder'
+
+/**
+ * jsdom에는 MediaRecorder도 getUserMedia도 없다. 훅이 다루는 것은
+ * "조각이 언제 오고 어디로 가는가"이므로 그 둘만 흉내 내면 충분하다.
+ */
+
+class FakeMediaRecorder {
+  static isTypeSupported = () => true
+
+  state: 'inactive' | 'recording' = 'inactive'
+  ondataavailable: ((event: { data: Blob }) => void) | null = null
+  onerror: (() => void) | null = null
+  private listeners: Record<string, Array<() => void>> = {}
+
+  constructor(
+    public stream: MediaStream,
+    public options?: MediaRecorderOptions,
+  ) {
+    instances.push(this)
+  }
+
+  start() {
+    this.state = 'recording'
+  }
+
+  stop() {
+    this.state = 'inactive'
+    // 실제 MediaRecorder는 stop() 시 남은 버퍼를 한 번 더 내보낸 뒤 stop을 쏜다.
+    for (const fn of this.listeners.stop ?? []) fn()
+  }
+
+  addEventListener(type: string, fn: () => void) {
+    ;(this.listeners[type] ??= []).push(fn)
+  }
+
+  emit(bytes: number) {
+    this.ondataavailable?.({ data: new Blob([new Uint8Array(bytes)]) })
+  }
+}
+
+let instances: FakeMediaRecorder[] = []
+let stopTracks: ReturnType<typeof vi.fn>
+let fetchMock: ReturnType<typeof vi.fn>
+
+function jsonResponse(body: unknown, ok = true, status = 200) {
+  return { ok, status, json: async () => body }
+}
+
+beforeEach(() => {
+  instances = []
+  stopTracks = vi.fn()
+
+  vi.stubGlobal('MediaRecorder', FakeMediaRecorder)
+  vi.stubGlobal('navigator', {
+    mediaDevices: {
+      getUserMedia: vi.fn(async () => ({
+        getTracks: () => [{ stop: stopTracks }],
+      })),
+    },
+  })
+
+  fetchMock = vi.fn(async (url: string) => {
+    if (url === '/api/recordings') {
+      return jsonResponse({ id: 'a'.repeat(32), mimeType: 'audio/webm' }, true, 201)
+    }
+    if (url.endsWith('/chunk')) return jsonResponse({ bytes: 1024 })
+    return jsonResponse({ bytes: 1024 })
+  })
+  vi.stubGlobal('fetch', fetchMock)
+})
+
+afterEach(() => {
+  vi.unstubAllGlobals()
+})
+
+async function startedHook() {
+  const view = renderHook(() => useAudioRecorder())
+  await waitFor(() => expect(view.result.current.isSupported).toBe(true))
+  await act(async () => {
+    await view.result.current.startRecording()
+  })
+  return view
+}
+
+describe('useAudioRecorder — 캡처 제약', () => {
+  it('원거리 화자를 지우는 전처리를 끄고 마이크를 연다', async () => {
+    await startedHook()
+
+    expect(navigator.mediaDevices.getUserMedia).toHaveBeenCalledWith({
+      audio: expect.objectContaining({
+        noiseSuppression: false,
+        echoCancellation: false,
+        autoGainControl: true,
+      }),
+    })
+  })
+})
+
+describe('useAudioRecorder — 조각 업로드', () => {
+  it('조각이 생길 때마다 서버로 올린다', async () => {
+    const view = await startedHook()
+
+    await act(async () => {
+      instances[0].emit(2048)
+    })
+
+    await waitFor(() => {
+      const chunkCalls = fetchMock.mock.calls.filter((c) =>
+        String(c[0]).endsWith('/chunk'),
+      )
+      expect(chunkCalls).toHaveLength(1)
+    })
+
+    expect(view.result.current.localBytes).toBe(2048)
+  })
+
+  it('빈 조각은 올리지 않는다', async () => {
+    await startedHook()
+
+    await act(async () => {
+      instances[0].emit(0)
+    })
+
+    const chunkCalls = fetchMock.mock.calls.filter((c) =>
+      String(c[0]).endsWith('/chunk'),
+    )
+    expect(chunkCalls).toHaveLength(0)
+  })
+
+  it('업로드가 끝내 실패하면 뒤 조각을 이어 붙이지 않고 경고한다', async () => {
+    // 중간이 빈 파일은 짧은 파일보다 나쁘다 — 재생도 전사도 안 된다.
+    fetchMock.mockImplementation(async (url: string) => {
+      if (url === '/api/recordings') {
+        return jsonResponse({ id: 'a'.repeat(32) }, true, 201)
+      }
+      if (url.endsWith('/chunk')) return jsonResponse({ error: 'nope' }, false, 500)
+      return jsonResponse({})
+    })
+
+    const view = await startedHook()
+
+    await act(async () => {
+      instances[0].emit(1024)
+    })
+
+    // 500은 일시 장애일 수 있으므로 백오프를 두고 3회까지 재시도한다.
+    await waitFor(
+      () => {
+        expect(view.result.current.uploadWarning).toContain('서버 저장이 중단')
+      },
+      { timeout: 5_000 },
+    )
+
+    const callsAfterBreak = fetchMock.mock.calls.filter((c) =>
+      String(c[0]).endsWith('/chunk'),
+    ).length
+
+    await act(async () => {
+      instances[0].emit(1024)
+    })
+
+    expect(
+      fetchMock.mock.calls.filter((c) => String(c[0]).endsWith('/chunk')).length,
+    ).toBe(callsAfterBreak)
+  })
+
+  it('세션 생성이 실패해도 녹음은 계속된다', async () => {
+    fetchMock.mockImplementation(async (url: string) => {
+      if (url === '/api/recordings') {
+        return jsonResponse({ error: 'down' }, false, 500)
+      }
+      return jsonResponse({})
+    })
+
+    const view = await startedHook()
+
+    expect(view.result.current.isRecording).toBe(true)
+    expect(view.result.current.uploadWarning).toContain('내려받아')
+
+    await act(async () => {
+      instances[0].emit(4096)
+    })
+    expect(view.result.current.localBytes).toBe(4096)
+  })
+})
+
+describe('useAudioRecorder — 종료', () => {
+  it('오디오를 한 조각도 못 받았으면 보관됐다고 말하지 않는다', async () => {
+    const view = await startedHook()
+
+    await act(async () => {
+      await view.result.current.stopRecording()
+    })
+
+    expect(view.result.current.recording).toBeNull()
+    expect(view.result.current.error).toContain('한 조각도 캡처되지 않았습니다')
+    expect(view.result.current.isRecording).toBe(false)
+  })
+
+  it('받은 조각이 있으면 결과를 넘기고 마이크를 놓는다', async () => {
+    const view = await startedHook()
+
+    await act(async () => {
+      instances[0].emit(1024)
+    })
+    await act(async () => {
+      await view.result.current.stopRecording()
+    })
+
+    expect(view.result.current.recording?.blob.size).toBe(1024)
+    expect(view.result.current.recording?.recordingId).toBe('a'.repeat(32))
+    expect(stopTracks).toHaveBeenCalled()
+    expect(view.result.current.isRecording).toBe(false)
+  })
+
+  it('서버 사본이 로컬보다 짧으면 경고한다', async () => {
+    fetchMock.mockImplementation(async (url: string) => {
+      if (url === '/api/recordings') {
+        return jsonResponse({ id: 'a'.repeat(32) }, true, 201)
+      }
+      if (url.endsWith('/chunk')) return jsonResponse({ bytes: 10 })
+      return jsonResponse({ bytes: 10 })
+    })
+
+    const view = await startedHook()
+
+    await act(async () => {
+      instances[0].emit(4096)
+    })
+    await act(async () => {
+      await view.result.current.stopRecording()
+    })
+
+    expect(view.result.current.uploadWarning).toContain('서버 사본이 로컬보다 짧습니다')
+  })
+})

src/app/api/meetings/route.ts

@@ -79,6 +79,9 @@ export async function POST(request: NextRequest) {
       customPrompt,
       attendees,
       tags,
+      audioFileName,
+      audioMimeType,
+      audioDuration,
     } = body
 
     if (!title || typeof title !== 'string' || title.trim().length === 0) {
@@ -112,6 +115,14 @@ export async function POST(request: NextRequest) {
         tags: Array.isArray(tags)
           ? tags.filter((t) => typeof t === 'string')
           : [],
+        audioFileName:
+          typeof audioFileName === 'string' ? audioFileName : null,
+        audioMimeType:
+          typeof audioMimeType === 'string' ? audioMimeType : null,
+        audioDuration:
+          typeof audioDuration === 'number' && Number.isFinite(audioDuration)
+            ? Math.max(0, Math.round(audioDuration))
+            : null,
         status: 'COMPLETED',
         actionItems: {
           create: parsed.map((item, index) => ({

src/app/api/recordings/[id]/chunk/route.ts

@@ -0,0 +1,55 @@
+import { NextRequest } from 'next/server'
+import { appendChunk } from '@/lib/recording-store'
+import { MAX_CHUNK_BYTES, isValidRecordingId } from '@/lib/recording'
+
+export const dynamic = 'force-dynamic'
+
+interface RouteContext {
+  params: Promise<{ id: string }>
+}
+
+/**
+ * 녹음 조각 하나를 이어 붙인다.
+ *
+ * 본문은 MediaRecorder가 준 바이트 그대로다. JSON이나 multipart로 감싸면
+ * base64 팽창이나 파싱 비용만 늘어난다.
+ */
+export async function POST(request: NextRequest, context: RouteContext) {
+  try {
+    const { id } = await context.params
+
+    if (!isValidRecordingId(id)) {
+      return Response.json(
+        { error: '잘못된 녹음 세션 ID입니다.' },
+        { status: 400 },
+      )
+    }
+
+    const buffer = Buffer.from(await request.arrayBuffer())
+
+    if (buffer.byteLength === 0) {
+      return Response.json({ error: '빈 조각입니다.' }, { status: 400 })
+    }
+
+    if (buffer.byteLength > MAX_CHUNK_BYTES) {
+      return Response.json(
+        { error: '조각이 너무 큽니다.' },
+        { status: 413 },
+      )
+    }
+
+    const result = await appendChunk(id, buffer)
+
+    if (!result.ok) {
+      return Response.json({ error: result.error }, { status: result.status })
+    }
+
+    return Response.json({ bytes: result.bytes })
+  } catch (err) {
+    const message = err instanceof Error ? err.message : '알 수 없는 오류'
+    return Response.json(
+      { error: `녹음 조각 저장 실패: ${message}` },
+      { status: 500 },
+    )
+  }
+}

src/app/api/recordings/[id]/route.ts

@@ -0,0 +1,86 @@
+import { NextRequest } from 'next/server'
+import { Readable } from 'stream'
+import { finalizeRecording, getRecordingStatus, openRecording } from '@/lib/recording-store'
+import { extensionForMimeType, isValidRecordingId } from '@/lib/recording'
+
+export const dynamic = 'force-dynamic'
+
+interface RouteContext {
+  params: Promise<{ id: string }>
+}
+
+/** 녹음 파일 내려받기. 헤더에는 사용자 입력을 넣지 않는다. */
+export async function GET(_request: NextRequest, context: RouteContext) {
+  const { id } = await context.params
+
+  if (!isValidRecordingId(id)) {
+    return Response.json({ error: '잘못된 녹음 세션 ID입니다.' }, { status: 400 })
+  }
+
+  const opened = await openRecording(id)
+  if (!opened) {
+    return Response.json({ error: '녹음을 찾을 수 없습니다.' }, { status: 404 })
+  }
+
+  const { meta, bytes, stream } = opened
+  const stamp = meta.startedAt.slice(0, 16).replace(/[-:]/g, '').replace('T', '-')
+  const fileName = `meeting-${stamp}.${extensionForMimeType(meta.mimeType)}`
+
+  return new Response(Readable.toWeb(stream as Readable) as ReadableStream, {
+    headers: {
+      'Content-Type': meta.mimeType,
+      'Content-Length': String(bytes),
+      'Content-Disposition': `attachment; filename="${fileName}"`,
+      'Cache-Control': 'no-store',
+    },
+  })
+}
+
+/** 녹음 종료. 길이를 확정하고 최종 상태를 돌려준다. */
+export async function POST(request: NextRequest, context: RouteContext) {
+  try {
+    const { id } = await context.params
+
+    if (!isValidRecordingId(id)) {
+      return Response.json(
+        { error: '잘못된 녹음 세션 ID입니다.' },
+        { status: 400 },
+      )
+    }
+
+    const body = await request.json().catch(() => ({}))
+    const durationMs =
+      typeof body.durationMs === 'number' ? body.durationMs : null
+
+    const status = await finalizeRecording(id, durationMs)
+    if (!status) {
+      return Response.json(
+        { error: '녹음을 찾을 수 없습니다.' },
+        { status: 404 },
+      )
+    }
+
+    return Response.json(status)
+  } catch (err) {
+    const message = err instanceof Error ? err.message : '알 수 없는 오류'
+    return Response.json(
+      { error: `녹음 종료 처리 실패: ${message}` },
+      { status: 500 },
+    )
+  }
+}
+
+/** 현재까지 저장된 크기 확인용. */
+export async function HEAD(_request: NextRequest, context: RouteContext) {
+  const { id } = await context.params
+
+  if (!isValidRecordingId(id)) return new Response(null, { status: 400 })
+
+  const status = await getRecordingStatus(id)
+  if (!status) return new Response(null, { status: 404 })
+
+  return new Response(null, {
+    status: 200,
+    headers: { 'Content-Length': String(status.bytes) },
+  })
+}

src/app/api/recordings/route.ts

@@ -0,0 +1,31 @@
+import { NextRequest } from 'next/server'
+import { createRecording } from '@/lib/recording-store'
+import { PREFERRED_MIME_TYPES } from '@/lib/recording'
+
+export const dynamic = 'force-dynamic'
+
+/** 브라우저가 고른 mimeType만 허용한다. 임의 문자열이 확장자로 새어들면 안 된다. */
+const ALLOWED_MIME_TYPES: readonly string[] = PREFERRED_MIME_TYPES
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json().catch(() => ({}))
+    const { mimeType } = body
+
+    if (typeof mimeType !== 'string' || !ALLOWED_MIME_TYPES.includes(mimeType)) {
+      return Response.json(
+        { error: '지원하지 않는 오디오 형식입니다.' },
+        { status: 400 },
+      )
+    }
+
+    const meta = await createRecording(mimeType)
+    return Response.json(meta, { status: 201 })
+  } catch (err) {
+    const message = err instanceof Error ? err.message : '알 수 없는 오류'
+    return Response.json(
+      { error: `녹음 세션 생성 실패: ${message}` },
+      { status: 500 },
+    )
+  }
+}

src/app/api/settings/status/route.ts

@@ -1,9 +1,10 @@
-import { isEnvKeyConfigured } from '@/lib/api-keys'
+import { isEnvKeyConfigured, isEnvProviderConfigured } from '@/lib/api-keys'
 
 export const dynamic = 'force-dynamic'
 
 export async function GET() {
   return Response.json({
     envConfigured: isEnvKeyConfigured(),
+    envProviderConfigured: isEnvProviderConfigured(),
   })
 }

src/app/api/settings/test/route.ts

@@ -1,5 +1,6 @@
 import { NextRequest } from 'next/server'
-import { resolveGeminiApiKey } from '@/lib/api-keys'
+import { resolveProviderSettings } from '@/lib/api-keys'
+import { complete, describeModel } from '@/lib/providers'
 
 export const dynamic = 'force-dynamic'
 
@@ -8,60 +9,32 @@ const TEST_PROMPT = '"OK"라고만 한 단어로 답하세요.'
 export async function POST(request: NextRequest) {
   try {
     const body = await request.json().catch(() => ({}))
-    const apiKey = resolveGeminiApiKey(body.apiKey)
+    const settings = resolveProviderSettings(body)
 
-    if (!apiKey) {
+    if (!settings) {
       return Response.json(
         {
           ok: false,
-          error: '키가 비어 있습니다.',
+          error: '설정이 비어 있습니다. 키(또는 base URL과 모델)를 확인해주세요.',
         },
         { status: 400 },
       )
     }
 
-    const url =
+    const result = await complete(TEST_PROMPT, settings)
-      'https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-lite:generateContent'
 
-    const response = await fetch(url, {
+    if (!result.success) {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-goog-api-key': apiKey,
-      },
-      body: JSON.stringify({
-        contents: [{ parts: [{ text: TEST_PROMPT }] }],
-      }),
-    })
-
-    if (!response.ok) {
-      const errorText = await response.text().catch(() => '')
-      const message =
-        response.status === 400
-          ? '잘못된 API 키 형식입니다.'
-          : response.status === 403
-            ? '권한이 거부되었습니다. 키를 확인해주세요.'
-            : response.status === 429
-              ? '요청 한도를 초과했지만 키 자체는 유효해 보입니다.'
-              : `Gemini API 오류: ${response.status}`
       return Response.json(
-        {
+        { ok: false, error: result.error },
-          ok: false,
-          error: message,
-          detail: errorText.slice(0, 200),
-        },
         { status: 200 },
       )
     }
 
-    const data = await response.json()
-    const reply: string =
-      data?.candidates?.[0]?.content?.parts?.[0]?.text?.trim() ?? ''
-
     return Response.json({
       ok: true,
-      message: '키가 정상적으로 동작합니다.',
+      message: '설정이 정상적으로 동작합니다.',
-      reply: reply.slice(0, 50),
+      model: describeModel(settings),
+      reply: result.text.trim().slice(0, 50),
     })
   } catch (err) {
     const message = err instanceof Error ? err.message : '알 수 없는 오류'

src/app/api/summarize-live/route.ts

@@ -1,14 +1,15 @@
 import { NextRequest } from 'next/server'
 import { generateLiveSummary } from '@/lib/live-summary'
-import { resolveGeminiApiKey } from '@/lib/api-keys'
+import { resolveProviderSettings } from '@/lib/api-keys'
 import type { SummaryDepth, TemplateId } from '@/lib/templates'
 
 const MAX_TRANSCRIPT_CHARS = 40_000
+const MAX_PREVIOUS_SUMMARY_CHARS = 8_000
 
 export async function POST(request: NextRequest) {
   try {
     const body = await request.json()
-    const { transcript, template, depth, customPrompt, apiKey } = body
+    const { transcript, template, depth, customPrompt, previousSummary } = body
 
     if (!transcript || typeof transcript !== 'string') {
       return Response.json(
@@ -17,12 +18,12 @@ export async function POST(request: NextRequest) {
       )
     }
 
-    const resolvedKey = resolveGeminiApiKey(apiKey)
+    const settings = resolveProviderSettings(body)
-    if (!resolvedKey) {
+    if (!settings) {
       return Response.json(
         {
           error:
-            'Gemini API 키가 설정되지 않았습니다. /settings에서 키를 입력해주세요.',
+            'AI 프로바이더가 설정되지 않았습니다. /settings에서 키를 입력해주세요.',
         },
         { status: 503 },
       )
@@ -33,8 +34,15 @@ export async function POST(request: NextRequest) {
         ? transcript.slice(-MAX_TRANSCRIPT_CHARS)
         : transcript
 
+    // 증분 모드: 직전 요약 + 새 발화만 보내므로 호출당 토큰이 일정하다.
+    const previous =
+      typeof previousSummary === 'string'
+        ? previousSummary.slice(-MAX_PREVIOUS_SUMMARY_CHARS)
+        : undefined
+
     const result = await generateLiveSummary(truncated, {
-      apiKey: resolvedKey,
+      provider: settings,
+      previousSummary: previous,
       template: (template as TemplateId | undefined) ?? 'meeting',
       depth: depth as SummaryDepth | undefined,
       customPrompt:

src/app/api/summarize/route.ts

@@ -1,9 +1,9 @@
 import { NextRequest } from 'next/server'
 import {
-  generateGeminiMinutes,
+  generateAiMinutes,
   generateSimpleMinutes,
 } from '@/lib/minutes-generator'
-import { resolveGeminiApiKey } from '@/lib/api-keys'
+import { resolveProviderSettings } from '@/lib/api-keys'
 import type { SummaryDepth, TemplateId } from '@/lib/templates'
 
 const MAX_TRANSCRIPT_CHARS = 100_000
@@ -11,16 +11,7 @@ const MAX_TRANSCRIPT_CHARS = 100_000
 export async function POST(request: NextRequest) {
   try {
     const body = await request.json()
-    const {
+    const { title, transcript, mode, date, template, depth, customPrompt } = body
-      title,
-      transcript,
-      mode,
-      date,
-      template,
-      depth,
-      customPrompt,
-      apiKey,
-    } = body
 
     if (!transcript || typeof transcript !== 'string') {
       return Response.json(
@@ -48,26 +39,27 @@ export async function POST(request: NextRequest) {
         typeof customPrompt === 'string' ? customPrompt : undefined,
     }
 
-    if (mode === 'gemini') {
+    // 'gemini'는 DB에 저장된 기존 값과의 호환을 위해 유지되는 AI 모드 식별자다.
-      const resolvedKey = resolveGeminiApiKey(apiKey)
+    if (mode === 'gemini' || mode === 'ai') {
-      if (!resolvedKey) {
+      const settings = resolveProviderSettings(body)
+      if (!settings) {
         const fallback = generateSimpleMinutes(input)
         return Response.json({
           markdown: fallback,
           mode: 'simple',
           warning:
-            'Gemini API 키가 설정되지 않아 단순 변환으로 대체되었습니다. /settings에서 키를 설정하세요.',
+            'AI 프로바이더가 설정되지 않아 단순 변환으로 대체되었습니다. /settings에서 설정하세요.',
         })
       }
 
-      const result = await generateGeminiMinutes(input, { apiKey: resolvedKey })
+      const result = await generateAiMinutes(input, { provider: settings })
 
       if (!result.success) {
         const fallback = generateSimpleMinutes(input)
         return Response.json({
           markdown: fallback,
           mode: 'simple',
-          warning: `Gemini 요약에 실패하여 단순 변환으로 대체되었습니다: ${result.error}`,
+          warning: `AI 요약에 실패하여 단순 변환으로 대체되었습니다: ${result.error}`,
         })
       }
 

src/app/page.tsx

@@ -1,11 +1,13 @@
 'use client'
 
-import { useMemo, useState } from 'react'
+import { useCallback, useMemo, useState } from 'react'
 import Link from 'next/link'
 import { AudioUploader } from '@/components/upload/AudioUploader'
 import { LiveRecorder } from '@/components/recorder/LiveRecorder'
+import type { CompletedRecording } from '@/hooks/useAudioRecorder'
+import { extensionForMimeType } from '@/lib/recording'
 import { MinutesViewer } from '@/components/minutes/MinutesViewer'
-import { getStoredApiKey } from '@/lib/api-key-storage'
+import { getProviderRequestPayload } from '@/lib/api-key-storage'
 import {
   TEMPLATES,
   DEFAULT_TEMPLATE_ID,
@@ -43,6 +45,7 @@ export default function HomePage() {
   const [loading, setLoading] = useState(false)
   const [error, setError] = useState<string | null>(null)
   const [uploadedFile, setUploadedFile] = useState<File | null>(null)
+  const [audio, setAudio] = useState<CompletedRecording | null>(null)
 
   const templateList = useMemo(
     () => [
@@ -119,7 +122,7 @@ export default function HomePage() {
           template,
           depth,
           customPrompt: template === 'custom' ? customPrompt : undefined,
-          apiKey: getStoredApiKey(),
+          ...getProviderRequestPayload(),
         }),
       })
       const data = await res.json()
@@ -146,6 +149,19 @@ export default function HomePage() {
     generateMinutes(text, summaryMode)
   }
 
+  const handleRecordingReady = useCallback((recording: CompletedRecording) => {
+    setAudio(recording)
+  }, [])
+
+  // 회의록과 함께 저장할 오디오 정보. 서버 사본이 없으면 붙일 게 없다.
+  const audioMeta = audio?.recordingId
+    ? {
+        audioFileName: `${audio.recordingId}.${extensionForMimeType(audio.mimeType)}`,
+        audioMimeType: audio.mimeType,
+        audioDuration: Math.round(audio.durationMs / 1000),
+      }
+    : undefined
+
   const liveSummaryActive =
     summaryMode === 'gemini' && activeTemplateMeta.live && tab === 'record'
 
@@ -212,7 +228,7 @@ export default function HomePage() {
                     : 'bg-neutral-100 text-neutral-600 hover:bg-neutral-200'
                 }`}
               >
-                Gemini AI 요약
+                AI 요약
               </button>
             </div>
           </div>
@@ -328,6 +344,8 @@ export default function HomePage() {
           {tab === 'record' ? (
             <LiveRecorder
               onTranscriptReady={handleTranscriptReady}
+              onRecordingReady={handleRecordingReady}
+              title={title}
               liveSummaryEnabled={liveSummaryActive}
               template={template}
               depth={depth}
@@ -391,6 +409,7 @@ export default function HomePage() {
             depth={depth}
             customPrompt={template === 'custom' ? customPrompt : undefined}
             summaryMode={summaryMode}
+            audio={audioMeta}
           />
         )}
       </div>

src/app/settings/page.tsx

@@ -4,71 +4,124 @@ import Link from 'next/link'
 import { useEffect, useState } from 'react'
 import {
   clearStoredApiKey,
+  clearStoredProviderConfig,
   getStoredApiKey,
+  getStoredProviderConfig,
   maskApiKey,
-  setStoredApiKey,
+  setStoredProviderConfig,
 } from '@/lib/api-key-storage'
+import {
+  DEFAULT_PRESET_ID,
+  PROVIDER_PRESETS,
+  findPreset,
+} from '@/lib/providers'
 
 type TestState =
   | { status: 'idle' }
   | { status: 'testing' }
-  | { status: 'success'; message: string; reply?: string }
+  | { status: 'success'; message: string; model?: string; reply?: string }
   | { status: 'failed'; message: string }
 
 export default function SettingsPage() {
-  const [storedKey, setStoredKey] = useState<string | null>(null)
+  const [presetId, setPresetId] = useState(DEFAULT_PRESET_ID)
-  const [draftKey, setDraftKey] = useState('')
+  const [apiKey, setApiKey] = useState('')
+  const [baseUrl, setBaseUrl] = useState('')
+  const [model, setModel] = useState('')
   const [showKey, setShowKey] = useState(false)
+  const [savedKey, setSavedKey] = useState<string | null>(null)
   const [envConfigured, setEnvConfigured] = useState<boolean | null>(null)
   const [testState, setTestState] = useState<TestState>({ status: 'idle' })
   const [savedToast, setSavedToast] = useState(false)
 
+  const preset = findPreset(presetId)
+  const isOpenAiCompatible = preset.provider === 'openai-compatible'
+
   useEffect(() => {
-    setStoredKey(getStoredApiKey())
+    const stored = getStoredProviderConfig()
+    if (stored) {
+      const storedPreset = findPreset(stored.presetId)
+      setPresetId(storedPreset.id)
+      setApiKey(stored.apiKey)
+      setBaseUrl(stored.baseUrl)
+      setModel(stored.model)
+      setSavedKey(stored.apiKey || null)
+    } else {
+      // 프로바이더 설정 이전에 저장해둔 Gemini 키를 그대로 이어받는다.
+      const legacyKey = getStoredApiKey()
+      setApiKey(legacyKey ?? '')
+      setModel(findPreset(DEFAULT_PRESET_ID).defaultModel)
+      setSavedKey(legacyKey)
+    }
+
     fetch('/api/settings/status')
       .then((r) => r.json())
-      .then((d) => setEnvConfigured(!!d.envConfigured))
+      .then((d) => setEnvConfigured(!!d.envConfigured || !!d.envProviderConfigured))
       .catch(() => setEnvConfigured(false))
   }, [])
 
+  function handlePresetChange(nextId: string) {
+    const next = findPreset(nextId)
+    if (next.id === presetId) return
+
+    setPresetId(next.id)
+    setBaseUrl(next.baseUrl)
+    setModel(next.defaultModel)
+    // 프로바이더가 바뀌면 이전 키는 무의미할 뿐 아니라, 그대로 두면
+    // 다른 회사 엔드포인트로 전송될 수 있으므로 비운다.
+    setApiKey('')
+    setTestState({ status: 'idle' })
+  }
+
   function handleSave() {
-    const trimmed = draftKey.trim()
+    setStoredProviderConfig({
-    if (!trimmed) return
+      presetId,
-    setStoredApiKey(trimmed)
+      apiKey: apiKey.trim(),
-    setStoredKey(trimmed)
+      baseUrl: baseUrl.trim(),
-    setDraftKey('')
+      model: model.trim(),
+    })
+    setSavedKey(apiKey.trim() || null)
     setSavedToast(true)
     setTimeout(() => setSavedToast(false), 2000)
   }
 
   function handleClear() {
-    if (!confirm('브라우저에 저장된 키를 삭제할까요? 환경변수가 설정되어 있다면 그것을 사용합니다.')) {
+    if (
+      !confirm(
+        '브라우저에 저장된 프로바이더 설정과 키를 삭제할까요? 환경변수가 설정되어 있다면 그것을 사용합니다.',
+      )
+    ) {
       return
     }
+    clearStoredProviderConfig()
     clearStoredApiKey()
-    setStoredKey(null)
+    const fallback = findPreset(DEFAULT_PRESET_ID)
+    setPresetId(fallback.id)
+    setApiKey('')
+    setBaseUrl(fallback.baseUrl)
+    setModel(fallback.defaultModel)
+    setSavedKey(null)
     setTestState({ status: 'idle' })
   }
 
   async function handleTest() {
-    const keyToTest = draftKey.trim() || storedKey
-    if (!keyToTest) {
-      setTestState({ status: 'failed', message: '테스트할 키가 없습니다.' })
-      return
-    }
-
     setTestState({ status: 'testing' })
     try {
       const res = await fetch('/api/settings/test', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ apiKey: keyToTest }),
+        body: JSON.stringify({
+          provider: preset.provider,
+          apiKey: apiKey.trim(),
+          baseUrl: baseUrl.trim(),
+          model: model.trim(),
+        }),
       })
       const data = await res.json()
       if (data.ok) {
         setTestState({
           status: 'success',
           message: data.message,
+          model: data.model,
           reply: data.reply,
         })
       } else {
@@ -82,13 +135,18 @@ export default function SettingsPage() {
     }
   }
 
-  const activeSource = storedKey
+  const canTest =
+    testState.status !== 'testing' &&
+    (preset.apiKeyOptional || apiKey.trim().length > 0) &&
+    (!isOpenAiCompatible || (baseUrl.trim().length > 0 && model.trim().length > 0))
+
+  const activeSource = savedKey
     ? '브라우저 (LocalStorage)'
     : envConfigured
       ? '환경변수 (서버)'
       : '없음'
 
-  const activeBadgeStyle = storedKey
+  const activeBadgeStyle = savedKey
     ? 'bg-purple-100 text-purple-700'
     : envConfigured
       ? 'bg-green-100 text-green-700'
@@ -117,15 +175,15 @@ export default function SettingsPage() {
             ⚙️ 설정
           </h1>
           <p className="mt-2 text-sm text-neutral-500">
-            Gemini API 키를 브라우저에 저장합니다. 키는 서버에 저장되지 않으며,
+            AI 요약에 사용할 프로바이더와 키를 브라우저에 저장합니다. 키는 서버 DB에
-            요청 시점에만 전송되어 사용됩니다.
+            저장되지 않으며, 요청 시점에만 전송되어 사용됩니다.
           </p>
         </header>
 
         <section className="mb-6 rounded-2xl border border-neutral-200 bg-white p-6">
           <div className="mb-4 flex items-center justify-between">
             <h2 className="text-base font-semibold text-neutral-800">
-              현재 키 소스
+              현재 설정
             </h2>
             <span
               className={`text-xs px-2.5 py-1 rounded-full font-medium ${activeBadgeStyle}`}
@@ -135,16 +193,28 @@ export default function SettingsPage() {
           </div>
 
           <div className="space-y-1 text-sm text-neutral-600">
+            <p>
+              <span className="inline-block w-32 text-neutral-500">프로바이더:</span>{' '}
+              <span className="font-medium text-neutral-800">{preset.label}</span>
+            </p>
+            <p>
+              <span className="inline-block w-32 text-neutral-500">모델:</span>{' '}
+              {model.trim() ? (
+                <span className="font-mono text-xs">{model.trim()}</span>
+              ) : (
+                <span className="text-neutral-400">기본값</span>
+              )}
+            </p>
             <p>
               <span className="inline-block w-32 text-neutral-500">브라우저 키:</span>{' '}
-              {storedKey ? (
+              {savedKey ? (
-                <span className="font-mono">{maskApiKey(storedKey)}</span>
+                <span className="font-mono">{maskApiKey(savedKey)}</span>
               ) : (
                 <span className="text-neutral-400">미설정</span>
               )}
             </p>
             <p>
-              <span className="inline-block w-32 text-neutral-500">환경변수 키:</span>{' '}
+              <span className="inline-block w-32 text-neutral-500">환경변수:</span>{' '}
               {envConfigured === null ? (
                 <span className="text-neutral-400">확인 중...</span>
               ) : envConfigured ? (
@@ -156,73 +226,121 @@ export default function SettingsPage() {
           </div>
 
           <p className="mt-3 text-xs text-neutral-500">
-            💡 우선순위: 브라우저 키 → 환경변수 → 단순 변환 폴백
+            💡 우선순위: 브라우저 설정 → 환경변수 → 단순 변환 폴백
           </p>
         </section>
 
         <section className="mb-6 rounded-2xl border border-neutral-200 bg-white p-6">
           <h2 className="mb-4 text-base font-semibold text-neutral-800">
-            Gemini API 키
+            프로바이더
           </h2>
 
-          <label className="block mb-2 text-sm text-neutral-600">
+          <div className="flex flex-wrap gap-2">
-            새 키 입력
+            {PROVIDER_PRESETS.map((item) => (
-          </label>
+              <button
-          <div className="flex gap-2">
+                key={item.id}
-            <input
+                onClick={() => handlePresetChange(item.id)}
-              type={showKey ? 'text' : 'password'}
+                className={`rounded-lg border px-3 py-2 text-sm font-medium transition-all ${
-              value={draftKey}
+                  presetId === item.id
-              onChange={(e) => setDraftKey(e.target.value)}
+                    ? 'border-purple-400 bg-purple-50 text-purple-700'
-              placeholder="AIzaSy..."
+                    : 'border-neutral-200 bg-white text-neutral-600 hover:border-neutral-300 hover:bg-neutral-50'
-              className="flex-1 rounded-xl border border-neutral-300 px-4 py-3 font-mono text-sm focus:border-purple-400 focus:outline-none focus:ring-2 focus:ring-purple-100 transition-all"
+                }`}
-            />
+              >
-            <button
+                {item.label}
-              onClick={() => setShowKey((v) => !v)}
+              </button>
-              className="rounded-xl border border-neutral-300 px-3 text-sm hover:bg-neutral-50 transition-colors"
+            ))}
-              title={showKey ? '숨기기' : '보이기'}
-            >
-              {showKey ? '🙈' : '👁️'}
-            </button>
           </div>
 
-          <p className="mt-2 text-xs text-neutral-500">
+          <p className="mt-3 text-xs text-neutral-500">{preset.description}</p>
-            <a
-              href="https://aistudio.google.com/apikey"
-              target="_blank"
-              rel="noopener noreferrer"
-              className="underline hover:text-purple-600"
-            >
-              Google AI Studio
-            </a>
-            에서 무료로 발급할 수 있습니다.
-          </p>
 
-          <div className="mt-4 flex flex-wrap gap-2">
+          {isOpenAiCompatible && (
+            <div className="mt-5">
+              <label className="mb-2 block text-sm text-neutral-600">
+                API 주소 (base URL)
+              </label>
+              <input
+                type="text"
+                value={baseUrl}
+                onChange={(e) => setBaseUrl(e.target.value)}
+                placeholder="https://api.example.com/v1"
+                className="w-full rounded-xl border border-neutral-300 px-4 py-3 font-mono text-sm focus:border-purple-400 focus:outline-none focus:ring-2 focus:ring-purple-100 transition-all"
+              />
+              <p className="mt-1 text-xs text-neutral-500">
+                OpenAI 호환 엔드포인트의 <code>/chat/completions</code> 앞부분까지
+                입력하세요.
+              </p>
+            </div>
+          )}
+
+          <div className="mt-5">
+            <label className="mb-2 block text-sm text-neutral-600">모델</label>
+            <input
+              type="text"
+              value={model}
+              onChange={(e) => setModel(e.target.value)}
+              placeholder={preset.defaultModel || 'model-id'}
+              className="w-full rounded-xl border border-neutral-300 px-4 py-3 font-mono text-sm focus:border-purple-400 focus:outline-none focus:ring-2 focus:ring-purple-100 transition-all"
+            />
+            {preset.modelHint && (
+              <p className="mt-1 text-xs text-neutral-500">{preset.modelHint}</p>
+            )}
+          </div>
+
+          <div className="mt-5">
+            <label className="mb-2 block text-sm text-neutral-600">
+              {preset.apiKeyLabel}
+            </label>
+            <div className="flex gap-2">
+              <input
+                type={showKey ? 'text' : 'password'}
+                value={apiKey}
+                onChange={(e) => setApiKey(e.target.value)}
+                placeholder={preset.apiKeyPlaceholder}
+                className="flex-1 rounded-xl border border-neutral-300 px-4 py-3 font-mono text-sm focus:border-purple-400 focus:outline-none focus:ring-2 focus:ring-purple-100 transition-all"
+              />
+              <button
+                onClick={() => setShowKey((v) => !v)}
+                className="rounded-xl border border-neutral-300 px-3 text-sm hover:bg-neutral-50 transition-colors"
+                title={showKey ? '숨기기' : '보이기'}
+              >
+                {showKey ? '🙈' : '👁️'}
+              </button>
+            </div>
+            {preset.docsUrl && (
+              <p className="mt-2 text-xs text-neutral-500">
+                <a
+                  href={preset.docsUrl}
+                  target="_blank"
+                  rel="noopener noreferrer"
+                  className="underline hover:text-purple-600"
+                >
+                  {preset.docsLabel ?? preset.docsUrl}
+                </a>
+                에서 발급할 수 있습니다.
+              </p>
+            )}
+          </div>
+
+          <div className="mt-5 flex flex-wrap gap-2">
             <button
               onClick={handleSave}
-              disabled={!draftKey.trim()}
               className="rounded-lg bg-purple-600 px-4 py-2 text-sm font-medium text-white hover:bg-purple-700 disabled:opacity-50 transition-colors"
             >
               💾 저장
             </button>
             <button
               onClick={handleTest}
-              disabled={
+              disabled={!canTest}
-                testState.status === 'testing' ||
-                (!draftKey.trim() && !storedKey)
-              }
               className="rounded-lg border border-purple-300 bg-purple-50 px-4 py-2 text-sm font-medium text-purple-700 hover:bg-purple-100 disabled:opacity-50 transition-colors"
             >
               {testState.status === 'testing' ? '테스트 중...' : '🧪 테스트 호출'}
             </button>
-            {storedKey && (
+            <button
-              <button
+              onClick={handleClear}
-                onClick={handleClear}
+              className="rounded-lg border border-red-200 bg-red-50 px-4 py-2 text-sm font-medium text-red-700 hover:bg-red-100 transition-colors"
-                className="rounded-lg border border-red-200 bg-red-50 px-4 py-2 text-sm font-medium text-red-700 hover:bg-red-100 transition-colors"
+            >
-              >
+              🗑️ 삭제
-                🗑️ 삭제
+            </button>
-              </button>
-            )}
           </div>
 
           {savedToast && (
@@ -234,11 +352,10 @@ export default function SettingsPage() {
           {testState.status === 'success' && (
             <div className="mt-4 rounded-lg border border-green-200 bg-green-50 px-3 py-2 text-sm text-green-700">
               <strong>✓ {testState.message}</strong>
-              {testState.reply && (
+              <p className="mt-1 font-mono text-xs text-green-600">
-                <p className="mt-1 font-mono text-xs text-green-600">
+                {testState.model ? `${testState.model} → ` : ''}
-                  Gemini 응답: {testState.reply}
+                {testState.reply}
-                </p>
+              </p>
-              )}
             </div>
           )}
 
@@ -265,6 +382,9 @@ export default function SettingsPage() {
             <li className="text-amber-700">
               ⚠️ <strong>회의 내용에 민감 정보가 포함된 경우</strong>, 실시간 녹음 기능은 음성을 Google 서버로 전송합니다 (Chrome Web Speech API 동작). 사내 컴플라이언스 정책 확인 후 사용해주세요.
             </li>
+            <li className="text-amber-700">
+              ⚠️ <strong>중계 서비스를 고르면 회의 전문이 그 회사 서버를 거칩니다.</strong> OpenAI·Gemini 직접 호출은 해당 회사만, OrcaRouter 같은 라우터는 라우터 운영사 + 실제 모델 제공사 양쪽을 거칩니다. 외부 전송이 곤란하면 <strong>로컬 모델</strong>을 선택하세요.
+            </li>
           </ul>
         </section>
       </div>

src/components/minutes/MinutesViewer.tsx

@@ -22,6 +22,12 @@ interface MinutesViewerProps {
   depth?: SummaryDepth
   customPrompt?: string
   summaryMode?: 'simple' | 'gemini'
+  /** 이 회의록의 원본 오디오. 서버에 보관된 녹음이 있을 때만 붙는다. */
+  audio?: {
+    audioFileName: string
+    audioMimeType: string
+    audioDuration: number
+  }
 }
 
 type SaveState =
@@ -38,6 +44,7 @@ export function MinutesViewer({
   template,
   depth,
   customPrompt,
+  audio,
   summaryMode,
 }: MinutesViewerProps) {
   const [renderedView, setRenderedView] = useState<'rendered' | 'raw'>(
@@ -110,6 +117,7 @@ export function MinutesViewer({
           template,
           depth,
           customPrompt,
+          ...audio,
         }),
       })
       const data = await res.json()
@@ -126,7 +134,7 @@ export function MinutesViewer({
     }
   }
 
-  const modeLabel = mode === 'gemini' ? 'Gemini AI 요약' : '단순 변환'
+  const modeLabel = mode === 'gemini' ? 'AI 요약' : '단순 변환'
 
   return (
     <div className="space-y-4">

src/components/recorder/LiveRecorder.tsx

@@ -3,11 +3,15 @@
 import { useEffect, useRef } from 'react'
 import { useSpeechRecognition } from '@/hooks/useSpeechRecognition'
 import { useLiveSummary } from '@/hooks/useLiveSummary'
+import { useAudioRecorder, type CompletedRecording } from '@/hooks/useAudioRecorder'
 import { formatTranscriptChunks } from '@/lib/transcript-formatter'
+import { formatBytes, formatDuration } from '@/lib/recording'
 import type { SummaryDepth, TemplateId } from '@/lib/templates'
 
 interface LiveRecorderProps {
   onTranscriptReady: (transcript: string) => void
+  onRecordingReady?: (recording: CompletedRecording) => void
+  title: string
   liveSummaryEnabled: boolean
   template: TemplateId
   depth: SummaryDepth
@@ -16,6 +20,8 @@ interface LiveRecorderProps {
 
 export function LiveRecorder({
   onTranscriptReady,
+  onRecordingReady,
+  title,
   liveSummaryEnabled,
   template,
   depth,
@@ -32,6 +38,21 @@ export function LiveRecorder({
     resetChunks,
   } = useSpeechRecognition()
 
+  const {
+    isRecording,
+    isSupported: isRecordingSupported,
+    error: recordingError,
+    uploadWarning,
+    elapsedMs,
+    localBytes,
+    uploadedBytes,
+    recording,
+    startRecording,
+    stopRecording,
+    downloadRecording,
+    reset: resetRecording,
+  } = useAudioRecorder()
+
   const {
     summary,
     isSummarizing,
@@ -59,6 +80,11 @@ export function LiveRecorder({
     summaryEndRef.current?.scrollIntoView({ behavior: 'smooth', block: 'end' })
   }, [summary])
 
+  // 녹음이 끝나 파일이 확정되면 상위로 올려 회의록과 함께 저장되게 한다.
+  useEffect(() => {
+    if (recording) onRecordingReady?.(recording)
+  }, [recording, onRecordingReady])
+
   if (isSupported === null) {
     return (
       <div className="rounded-2xl border border-neutral-200 bg-neutral-50 p-6 text-center text-sm text-neutral-400">
@@ -78,12 +104,22 @@ export function LiveRecorder({
     )
   }
 
-  function handleStop() {
+  async function handleStart() {
+    resetRecording()
+    // 오디오 녹음을 먼저 건다. 전사가 실패하더라도 원본은 남아야 한다.
+    await startRecording()
+    startListening()
+  }
+
+  async function handleStop() {
     stopListening()
+
     const transcript = formatTranscriptChunks(chunks)
     if (transcript.length > 0) {
       onTranscriptReady(transcript)
     }
+
+    await stopRecording()
   }
 
   const lastUpdatedLabel = lastUpdatedAt
@@ -136,7 +172,7 @@ export function LiveRecorder({
           </button>
         ) : (
           <button
-            onClick={startListening}
+            onClick={handleStart}
             className="flex items-center gap-2 rounded-full bg-blue-600 px-6 py-3 text-white font-medium shadow-lg shadow-blue-600/25 hover:bg-blue-700 transition-colors"
           >
             <span className="text-lg">🎤</span>
@@ -144,9 +180,21 @@ export function LiveRecorder({
           </button>
         )}
 
+        {recording && !isListening && (
+          <button
+            onClick={() => downloadRecording(title)}
+            className="flex items-center gap-2 rounded-full border border-emerald-300 bg-emerald-50 px-4 py-2 text-sm font-medium text-emerald-700 hover:bg-emerald-100 transition-colors"
+          >
+            ⬇️ 오디오 내려받기 ({formatBytes(recording.blob.size)})
+          </button>
+        )}
+
         {chunks.length > 0 && !isListening && (
           <button
-            onClick={resetChunks}
+            onClick={() => {
+              resetChunks()
+              resetRecording()
+            }}
             className="rounded-full border border-neutral-300 px-4 py-2 text-sm text-neutral-600 hover:bg-neutral-50 transition-colors"
           >
             초기화
@@ -159,14 +207,62 @@ export function LiveRecorder({
             녹음 중 · {wordCount}단어 · {chunks.length}개 구간
           </div>
         )}
+
+        {isRecording && (
+          <div className="flex items-center gap-2 rounded-full bg-neutral-100 px-4 py-1.5 text-xs text-neutral-600">
+            <span className="text-sm">🎧</span>
+            오디오 {formatDuration(elapsedMs)} · 저장 {formatBytes(uploadedBytes)}
+            {localBytes > 0 && uploadedBytes < localBytes && (
+              <span className="text-amber-600">
+                (전송 대기 {formatBytes(localBytes - uploadedBytes)})
+              </span>
+            )}
+          </div>
+        )}
       </div>
 
+      {isRecordingSupported === false && (
+        <div className="rounded-xl border border-amber-200 bg-amber-50 p-4 text-sm text-amber-800">
+          이 브라우저는 오디오 녹음을 지원하지 않습니다. 전사만 진행되며,
+          <strong> 놓친 발화를 나중에 복구할 수 없습니다.</strong> Chrome을 사용해주세요.
+        </div>
+      )}
+
+      {recordingError && (
+        <div className="rounded-xl border border-red-200 bg-red-50 p-4 text-sm text-red-700">
+          <strong>오디오 녹음 오류:</strong> {recordingError}
+        </div>
+      )}
+
+      {uploadWarning && (
+        <div className="rounded-xl border border-amber-200 bg-amber-50 p-4 text-sm text-amber-800">
+          <strong>⚠️ 서버 저장 문제:</strong> {uploadWarning}
+        </div>
+      )}
+
       {recognitionError && (
         <div className="rounded-xl border border-red-200 bg-red-50 p-4 text-sm text-red-700">
           <strong>음성 인식 오류:</strong> {recognitionError}
         </div>
       )}
 
+      {recording && !isListening && (
+        <div className="rounded-xl border border-emerald-200 bg-emerald-50 p-4 text-sm text-emerald-800">
+          <strong>
+            🎧 오디오 {formatDuration(recording.durationMs)} ·{' '}
+            {formatBytes(recording.blob.size)} 확보
+          </strong>
+          {' — '}
+          {recording.recordingId
+            ? `서버에 ${formatBytes(recording.uploadedBytes)} 저장됨.`
+            : '서버 저장 실패 — 브라우저 사본만 있습니다.'}{' '}
+          전사가 놓친 발화는 이 오디오로 다시 살릴 수 있습니다.
+          {!recording.recordingId && (
+            <strong> 지금 내려받아 보관해주세요.</strong>
+          )}
+        </div>
+      )}
+
       {isListening && !hasTranscript && (
         <div className="rounded-2xl border border-dashed border-blue-300 bg-blue-50/50 p-6 text-center">
           <p className="text-sm text-blue-700">

src/hooks/useAudioRecorder.ts

@@ -0,0 +1,390 @@
+'use client'
+
+import { useCallback, useEffect, useRef, useState } from 'react'
+import {
+  AUDIO_BITS_PER_SECOND,
+  CHUNK_INTERVAL_MS,
+  RECORDING_AUDIO_CONSTRAINTS,
+  pickRecorderMimeType,
+  recordingDownloadName,
+} from '@/lib/recording'
+
+export interface CompletedRecording {
+  /** 서버 세션 id. 세션 생성에 실패했으면 null이고 로컬 사본만 있다. */
+  recordingId: string | null
+  mimeType: string
+  blob: Blob
+  durationMs: number
+  startedAt: Date
+  /** 서버에 실제로 저장된 바이트. 0이거나 blob보다 작으면 일부가 못 올라갔다. */
+  uploadedBytes: number
+}
+
+export interface AudioRecorderHook {
+  isRecording: boolean
+  isSupported: boolean | null
+  /** 녹음을 시작조차 못하게 만든 오류. */
+  error: string | null
+  /** 녹음은 되고 있으나 서버 사본에 문제가 있을 때의 경고. */
+  uploadWarning: string | null
+  elapsedMs: number
+  localBytes: number
+  uploadedBytes: number
+  recording: CompletedRecording | null
+  startRecording: () => Promise<void>
+  stopRecording: () => Promise<void>
+  downloadRecording: (title: string) => void
+  reset: () => void
+}
+
+const MAX_CHUNK_RETRIES = 3
+
+function describeCaptureError(err: unknown): string {
+  const name = err instanceof Error ? err.name : ''
+
+  switch (name) {
+    case 'NotAllowedError':
+    case 'SecurityError':
+      return '마이크 권한이 거부되어 녹음할 수 없습니다. 주소창 왼쪽 자물쇠 아이콘에서 마이크를 허용해주세요.'
+    case 'NotFoundError':
+      return '마이크를 찾을 수 없습니다. 장치가 연결되어 있는지 확인해주세요.'
+    case 'NotReadableError':
+      return '다른 프로그램이 마이크를 사용 중입니다. 해당 프로그램을 종료하고 다시 시도해주세요.'
+    default:
+      return err instanceof Error
+        ? `마이크를 열 수 없습니다: ${err.message}`
+        : '마이크를 열 수 없습니다.'
+  }
+}
+
+/**
+ * 회의 오디오를 파일로 남긴다.
+ *
+ * 전사와 독립적으로 동작한다. Web Speech가 발화를 놓치든 네트워크가 끊기든
+ * 오디오만은 남아야 나중에 서버 STT로 다시 살릴 수 있다. 그래서 서버 업로드가
+ * 실패해도 녹음을 중단하지 않고, 브라우저 안의 사본을 끝까지 들고 간다.
+ */
+export function useAudioRecorder(): AudioRecorderHook {
+  const [isSupported, setIsSupported] = useState<boolean | null>(null)
+  const [isRecording, setIsRecording] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  const [uploadWarning, setUploadWarning] = useState<string | null>(null)
+  const [elapsedMs, setElapsedMs] = useState(0)
+  const [localBytes, setLocalBytes] = useState(0)
+  const [uploadedBytes, setUploadedBytes] = useState(0)
+  const [recording, setRecording] = useState<CompletedRecording | null>(null)
+
+  const recorderRef = useRef<MediaRecorder | null>(null)
+  const streamRef = useRef<MediaStream | null>(null)
+  const partsRef = useRef<Blob[]>([])
+  const sessionIdRef = useRef<string | null>(null)
+  const mimeTypeRef = useRef<string | null>(null)
+  const startedAtRef = useRef<Date | null>(null)
+  const uploadChainRef = useRef<Promise<void>>(Promise.resolve())
+  const uploadBrokenRef = useRef(false)
+
+  useEffect(() => {
+    setIsSupported(
+      typeof window !== 'undefined' &&
+        typeof window.MediaRecorder !== 'undefined' &&
+        typeof navigator !== 'undefined' &&
+        !!navigator.mediaDevices?.getUserMedia,
+    )
+  }, [])
+
+  // 녹음 중에는 1초마다 경과 시간을 갱신한다. 이 시각이 나중에 전사 청크를
+  // 오디오 타임라인에 맞추는 기준이 된다.
+  useEffect(() => {
+    if (!isRecording) return
+
+    const timer = setInterval(() => {
+      if (startedAtRef.current) {
+        setElapsedMs(Date.now() - startedAtRef.current.getTime())
+      }
+    }, 1000)
+
+    return () => clearInterval(timer)
+  }, [isRecording])
+
+  // 녹음 중 탭을 닫으면 아직 못 올린 조각이 사라진다. 확인을 한 번 받는다.
+  useEffect(() => {
+    if (!isRecording) return
+
+    function warn(event: BeforeUnloadEvent) {
+      event.preventDefault()
+    }
+
+    window.addEventListener('beforeunload', warn)
+    return () => window.removeEventListener('beforeunload', warn)
+  }, [isRecording])
+
+  /**
+   * 조각을 순서대로 올린다.
+   *
+   * 순서가 곧 파일의 순서이므로 병렬로 보내지 않는다. 한 조각이 끝내 실패하면
+   * 그 뒤를 이어 붙여봐야 중간이 비어 재생도 전사도 안 되는 파일이 되므로,
+   * 그 시점에 업로드를 멈추고 로컬 사본을 쓰라고 알린다.
+   */
+  const queueUpload = useCallback((chunk: Blob) => {
+    const id = sessionIdRef.current
+    if (!id || uploadBrokenRef.current) return
+
+    uploadChainRef.current = uploadChainRef.current.then(async () => {
+      if (uploadBrokenRef.current) return
+
+      for (let attempt = 1; attempt <= MAX_CHUNK_RETRIES; attempt++) {
+        try {
+          const res = await fetch(`/api/recordings/${id}/chunk`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/octet-stream' },
+            body: chunk,
+          })
+
+          if (res.ok) {
+            const data = await res.json()
+            setUploadedBytes(data.bytes)
+            return
+          }
+
+          // 4xx는 재시도해도 같은 답이 온다.
+          if (res.status >= 400 && res.status < 500) break
+        } catch {
+          // 네트워크 오류 — 아래에서 재시도한다.
+        }
+
+        if (attempt < MAX_CHUNK_RETRIES) {
+          await new Promise((resolve) => setTimeout(resolve, 500 * attempt))
+        }
+      }
+
+      uploadBrokenRef.current = true
+      setUploadWarning(
+        '서버 저장이 중단되었습니다. 녹음은 계속되고 있으니 종료 후 반드시 오디오를 내려받아 주세요.',
+      )
+    })
+  }, [])
+
+  const startRecording = useCallback(async () => {
+    if (recorderRef.current) return
+
+    setError(null)
+    setUploadWarning(null)
+    setRecording(null)
+    setElapsedMs(0)
+    setLocalBytes(0)
+    setUploadedBytes(0)
+    partsRef.current = []
+    sessionIdRef.current = null
+    uploadBrokenRef.current = false
+    uploadChainRef.current = Promise.resolve()
+
+    if (isSupported !== true) {
+      setError('이 브라우저는 오디오 녹음을 지원하지 않습니다. Chrome을 사용해주세요.')
+      return
+    }
+
+    const mimeType = pickRecorderMimeType((type) =>
+      MediaRecorder.isTypeSupported(type),
+    )
+    if (!mimeType) {
+      setError('브라우저가 지원하는 녹음 형식을 찾지 못했습니다.')
+      return
+    }
+
+    let stream: MediaStream
+    try {
+      stream = await navigator.mediaDevices.getUserMedia({
+        audio: RECORDING_AUDIO_CONSTRAINTS,
+      })
+    } catch (err) {
+      setError(describeCaptureError(err))
+      return
+    }
+
+    // 서버 세션은 있으면 좋고 없어도 녹음은 간다. 여기서 포기하면
+    // 오디오를 남기려던 목적 자체를 잃는다.
+    try {
+      const res = await fetch('/api/recordings', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ mimeType }),
+      })
+
+      if (res.ok) {
+        const meta = await res.json()
+        sessionIdRef.current = meta.id
+      } else {
+        uploadBrokenRef.current = true
+        setUploadWarning(
+          '서버에 녹음 세션을 만들지 못했습니다. 브라우저에만 저장되니 종료 후 반드시 내려받아 주세요.',
+        )
+      }
+    } catch {
+      uploadBrokenRef.current = true
+      setUploadWarning(
+        '서버에 연결하지 못했습니다. 브라우저에만 저장되니 종료 후 반드시 내려받아 주세요.',
+      )
+    }
+
+    const recorder = new MediaRecorder(stream, {
+      mimeType,
+      audioBitsPerSecond: AUDIO_BITS_PER_SECOND,
+    })
+
+    recorder.ondataavailable = (event) => {
+      if (event.data.size === 0) return
+      partsRef.current.push(event.data)
+      setLocalBytes((prev) => prev + event.data.size)
+      queueUpload(event.data)
+    }
+
+    recorder.onerror = () => {
+      setError('녹음 중 오류가 발생했습니다. 지금까지의 오디오는 보존되어 있습니다.')
+    }
+
+    streamRef.current = stream
+    recorderRef.current = recorder
+    mimeTypeRef.current = mimeType
+    startedAtRef.current = new Date()
+
+    recorder.start(CHUNK_INTERVAL_MS)
+    setIsRecording(true)
+  }, [isSupported, queueUpload])
+
+  const stopRecording = useCallback(async () => {
+    const recorder = recorderRef.current
+    if (!recorder) return
+    recorderRef.current = null
+
+    // stop()은 남은 버퍼를 dataavailable로 한 번 더 내보낸 뒤 stop을 쏜다.
+    // 그 마지막 조각까지 받아야 회의 끝부분이 잘리지 않는다.
+    if (recorder.state !== 'inactive') {
+      await new Promise<void>((resolve) => {
+        recorder.addEventListener('stop', () => resolve(), { once: true })
+        recorder.stop()
+      })
+    }
+
+    streamRef.current?.getTracks().forEach((track) => track.stop())
+    streamRef.current = null
+
+    await uploadChainRef.current
+
+    const startedAt = startedAtRef.current ?? new Date()
+    const durationMs = Date.now() - startedAt.getTime()
+    const mimeType = mimeTypeRef.current ?? 'audio/webm'
+    const id = sessionIdRef.current
+
+    const blob = new Blob(partsRef.current, { type: mimeType })
+
+    // 한 바이트도 못 받았으면 보관됐다고 말하면 안 된다. 이 기능의 요점은
+    // 오디오가 남는 것인데, 남지 않았는데 남았다고 알리면 사용자는 회의가
+    // 끝난 뒤에야 아무것도 없다는 걸 알게 된다.
+    if (blob.size === 0) {
+      setError(
+        '오디오가 한 조각도 캡처되지 않았습니다. 마이크 입력 장치를 확인하고 다시 녹음해주세요.',
+      )
+      setElapsedMs(durationMs)
+      setIsRecording(false)
+      return
+    }
+
+    let serverBytes = 0
+    if (id && !uploadBrokenRef.current) {
+      try {
+        const res = await fetch(`/api/recordings/${id}`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ durationMs }),
+        })
+        if (res.ok) {
+          serverBytes = (await res.json()).bytes ?? 0
+        }
+      } catch {
+        setUploadWarning(
+          '녹음 종료 처리에 실패했습니다. 저장된 조각은 남아 있지만, 로컬 사본도 내려받아 두시길 권합니다.',
+        )
+      }
+    }
+
+    // 서버 사본이 로컬보다 짧으면 조각이 새어나간 것이다. 조용히 넘기지 않는다.
+    if (id && !uploadBrokenRef.current && serverBytes < blob.size) {
+      setUploadWarning(
+        `서버 사본이 로컬보다 짧습니다 (${serverBytes} / ${blob.size} bytes). 오디오를 내려받아 보관해주세요.`,
+      )
+    }
+
+    setElapsedMs(durationMs)
+    setUploadedBytes(serverBytes)
+    setRecording({
+      recordingId: uploadBrokenRef.current ? null : id,
+      mimeType,
+      blob,
+      durationMs,
+      startedAt,
+      uploadedBytes: serverBytes,
+    })
+    setIsRecording(false)
+  }, [])
+
+  const downloadRecording = useCallback((title: string) => {
+    const parts = partsRef.current
+    if (parts.length === 0) return
+
+    const mimeType = mimeTypeRef.current ?? 'audio/webm'
+    const blob = new Blob(parts, { type: mimeType })
+    const url = URL.createObjectURL(blob)
+
+    const anchor = document.createElement('a')
+    anchor.href = url
+    anchor.download = recordingDownloadName(
+      title,
+      startedAtRef.current ?? new Date(),
+      mimeType,
+    )
+    document.body.appendChild(anchor)
+    anchor.click()
+    anchor.remove()
+
+    setTimeout(() => URL.revokeObjectURL(url), 1_000)
+  }, [])
+
+  const reset = useCallback(() => {
+    partsRef.current = []
+    sessionIdRef.current = null
+    startedAtRef.current = null
+    uploadBrokenRef.current = false
+    setRecording(null)
+    setElapsedMs(0)
+    setLocalBytes(0)
+    setUploadedBytes(0)
+    setError(null)
+    setUploadWarning(null)
+  }, [])
+
+  // 언마운트 시 마이크를 놓아준다. 탭 표시등이 켜진 채 남지 않도록.
+  useEffect(() => {
+    return () => {
+      const recorder = recorderRef.current
+      if (recorder && recorder.state !== 'inactive') {
+        recorder.stop()
+      }
+      streamRef.current?.getTracks().forEach((track) => track.stop())
+    }
+  }, [])
+
+  return {
+    isRecording,
+    isSupported,
+    error,
+    uploadWarning,
+    elapsedMs,
+    localBytes,
+    uploadedBytes,
+    recording,
+    startRecording,
+    stopRecording,
+    downloadRecording,
+    reset,
+  }
+}

src/hooks/useLiveSummary.ts

@@ -4,13 +4,16 @@ import { useEffect, useMemo, useRef, useState } from 'react'
 import type { TranscriptChunk } from '@/lib/transcript-formatter'
 import { formatTranscriptChunks } from '@/lib/transcript-formatter'
 import type { SummaryDepth, TemplateId } from '@/lib/templates'
-import { getStoredApiKey } from '@/lib/api-key-storage'
+import { getProviderRequestPayload } from '@/lib/api-key-storage'
+import { planLiveSummaryRequest } from '@/lib/live-summary'
 
 interface UseLiveSummaryOptions {
   enabled: boolean
   pollIntervalMs?: number
   minWords?: number
   incrementWords?: number
+  /** 증분 요약을 이 횟수만큼 반복하면 전사 전체로 한 번 다시 요약한다. 0이면 끈다. */
+  fullRefreshEvery?: number
   template?: TemplateId
   depth?: SummaryDepth
   customPrompt?: string
@@ -41,6 +44,7 @@ export function useLiveSummary(
     pollIntervalMs = 30_000,
     minWords = 25,
     incrementWords = 40,
+    fullRefreshEvery = 20,
     template = 'meeting',
     depth,
     customPrompt,
@@ -64,6 +68,11 @@ export function useLiveSummary(
   const cooldownUntilRef = useRef<number | null>(null)
   const consecutiveFailuresRef = useRef(0)
 
+  // 증분 요약 상태 — 성공했을 때만 전진시켜서 실패해도 발화를 잃지 않는다.
+  const summaryRef = useRef('')
+  const lastSummarizedIndexRef = useRef(0)
+  const incrementsSinceFullRef = useRef(0)
+
   useEffect(() => {
     chunksRef.current = chunks
   }, [chunks])
@@ -98,12 +107,31 @@ export function useLiveSummary(
         return
       }
 
-      const transcript = formatTranscriptChunks(chunksRef.current)
+      const allChunks = chunksRef.current
+      const transcript = formatTranscriptChunks(allChunks)
       const currentWordCount = countWords(transcript)
 
       if (currentWordCount < minWords) return
       if (currentWordCount - lastWordCountRef.current < incrementWords) return
 
+      const plan = planLiveSummaryRequest({
+        totalChunks: allChunks.length,
+        lastSummarizedIndex: lastSummarizedIndexRef.current,
+        incrementsSinceFull: incrementsSinceFullRef.current,
+        fullRefreshEvery,
+        hasPreviousSummary: summaryRef.current.trim().length > 0,
+      })
+
+      // 요청을 보내는 시점의 길이를 고정해 둔다. 응답을 기다리는 동안
+      // 새 청크가 쌓여도 그 부분은 다음 회차로 넘어간다.
+      const chunkCountAtSend = allChunks.length
+      const payloadTranscript =
+        plan.mode === 'full'
+          ? transcript
+          : formatTranscriptChunks(allChunks.slice(plan.startIndex))
+
+      if (payloadTranscript.trim().length === 0) return
+
       const controller = new AbortController()
       abortRef.current = controller
       inFlightRef.current = true
@@ -115,11 +143,13 @@ export function useLiveSummary(
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
           body: JSON.stringify({
-            transcript,
+            transcript: payloadTranscript,
+            previousSummary:
+              plan.mode === 'incremental' ? summaryRef.current : undefined,
             template: configRef.current.template,
             depth: configRef.current.depth,
             customPrompt: configRef.current.customPrompt,
-            apiKey: getStoredApiKey(),
+            ...getProviderRequestPayload(),
           }),
           signal: controller.signal,
         })
@@ -142,8 +172,12 @@ export function useLiveSummary(
 
         const data = await res.json()
         setSummary(data.markdown)
+        summaryRef.current = data.markdown
         setLastUpdatedAt(Date.now())
         lastWordCountRef.current = currentWordCount
+        lastSummarizedIndexRef.current = chunkCountAtSend
+        incrementsSinceFullRef.current =
+          plan.mode === 'full' ? 0 : incrementsSinceFullRef.current + 1
         consecutiveFailuresRef.current = 0
         cooldownUntilRef.current = null
         setCooldownUntil(null)
@@ -164,7 +198,7 @@ export function useLiveSummary(
     return () => {
       clearInterval(interval)
     }
-  }, [enabled, pollIntervalMs, minWords, incrementWords])
+  }, [enabled, pollIntervalMs, minWords, incrementWords, fullRefreshEvery])
 
   useEffect(() => {
     return () => {

src/lib/api-key-storage.ts

@@ -1,5 +1,7 @@
 'use client'
 
+import { findPreset, type ProviderId } from './providers'
+
 const STORAGE_KEY = 'meeting-minutes:gemini-api-key'
 
 export function getStoredApiKey(): string | null {
@@ -34,3 +36,86 @@ export function maskApiKey(key: string): string {
   if (key.length <= 8) return '••••'
   return `${key.slice(0, 4)}••••${key.slice(-4)}`
 }
+
+/* ------------------------------------------------------------------------- *
+ * 프로바이더 설정 (Gemini / OpenAI 호환 엔드포인트)
+ * ------------------------------------------------------------------------- */
+
+const PROVIDER_STORAGE_KEY = 'meeting-minutes:llm-provider'
+
+export interface StoredProviderConfig {
+  presetId: string
+  apiKey: string
+  baseUrl: string
+  model: string
+}
+
+export interface ProviderRequestPayload {
+  provider: ProviderId
+  apiKey: string
+  baseUrl: string
+  model: string
+}
+
+export function getStoredProviderConfig(): StoredProviderConfig | null {
+  if (typeof window === 'undefined') return null
+  try {
+    const raw = window.localStorage.getItem(PROVIDER_STORAGE_KEY)
+    if (!raw) return null
+    const parsed = JSON.parse(raw) as Partial<StoredProviderConfig>
+    if (typeof parsed?.presetId !== 'string') return null
+    return {
+      presetId: parsed.presetId,
+      apiKey: typeof parsed.apiKey === 'string' ? parsed.apiKey : '',
+      baseUrl: typeof parsed.baseUrl === 'string' ? parsed.baseUrl : '',
+      model: typeof parsed.model === 'string' ? parsed.model : '',
+    }
+  } catch {
+    return null
+  }
+}
+
+export function setStoredProviderConfig(config: StoredProviderConfig): void {
+  if (typeof window === 'undefined') return
+  try {
+    window.localStorage.setItem(PROVIDER_STORAGE_KEY, JSON.stringify(config))
+  } catch {
+    // ignore storage errors (private mode, quota)
+  }
+}
+
+export function clearStoredProviderConfig(): void {
+  if (typeof window === 'undefined') return
+  try {
+    window.localStorage.removeItem(PROVIDER_STORAGE_KEY)
+  } catch {
+    // ignore
+  }
+}
+
+/**
+ * 요약 요청 body에 실을 프로바이더 정보.
+ *
+ * 프로바이더 설정이 없으면 기존 Gemini 키만 쓰던 사용자를 그대로 이어받는다
+ * (별도 마이그레이션 없이 동작).
+ */
+export function getProviderRequestPayload(): ProviderRequestPayload {
+  const stored = getStoredProviderConfig()
+
+  if (!stored) {
+    return {
+      provider: 'gemini',
+      apiKey: getStoredApiKey() ?? '',
+      baseUrl: '',
+      model: '',
+    }
+  }
+
+  const preset = findPreset(stored.presetId)
+  return {
+    provider: preset.provider,
+    apiKey: stored.apiKey || (preset.provider === 'gemini' ? getStoredApiKey() ?? '' : ''),
+    baseUrl: stored.baseUrl,
+    model: stored.model,
+  }
+}

src/lib/api-keys.ts

@@ -1,3 +1,5 @@
+import { isProviderId, type ProviderId, type ProviderSettings } from './providers'
+
 /**
  * Gemini API 키 해석 우선순위:
  * 1) 요청 body로 전달된 키 (브라우저 LocalStorage에서 옴)
@@ -19,3 +21,70 @@ export function resolveGeminiApiKey(
 export function isEnvKeyConfigured(): boolean {
   return (process.env.GEMINI_API_KEY ?? '').trim().length > 0
 }
+
+/** LLM_* 환경변수로 프로바이더가 지정되어 있는지 */
+export function isEnvProviderConfigured(): boolean {
+  const provider = env('LLM_PROVIDER')
+  if (provider === 'openai-compatible') {
+    return env('LLM_BASE_URL').length > 0 && env('LLM_MODEL').length > 0
+  }
+  return isEnvKeyConfigured() || env('LLM_API_KEY').length > 0
+}
+
+export interface ProviderRequestBody {
+  provider?: unknown
+  apiKey?: unknown
+  baseUrl?: unknown
+  model?: unknown
+}
+
+/**
+ * 요청 body + 환경변수로부터 프로바이더 설정을 만든다.
+ * 필드별 우선순위는 기존 키 해석과 동일하게 "요청 → 환경변수" 순이다.
+ *
+ * 사용 가능한 설정이 없으면 null을 돌려주고, 호출부는 단순 변환으로 폴백한다.
+ */
+export function resolveProviderSettings(
+  body: ProviderRequestBody | null | undefined,
+): ProviderSettings | null {
+  const provider = resolveProvider(body?.provider)
+
+  if (provider === 'gemini') {
+    const apiKey = resolveGeminiApiKey(str(body?.apiKey) || env('LLM_API_KEY'))
+    if (!apiKey) return null
+    return {
+      provider,
+      apiKey,
+      model: str(body?.model) || env('LLM_MODEL') || undefined,
+    }
+  }
+
+  const baseUrl = str(body?.baseUrl) || env('LLM_BASE_URL')
+  const model = str(body?.model) || env('LLM_MODEL')
+  if (baseUrl.length === 0 || model.length === 0) return null
+
+  // 로컬 모델 서버는 키가 없어도 되므로 빈 문자열을 허용한다.
+  return {
+    provider,
+    apiKey: str(body?.apiKey) || env('LLM_API_KEY'),
+    baseUrl,
+    model,
+  }
+}
+
+function resolveProvider(requested: unknown): ProviderId {
+  if (isProviderId(requested)) return requested
+
+  const fromEnv = env('LLM_PROVIDER')
+  if (isProviderId(fromEnv)) return fromEnv
+
+  return 'gemini'
+}
+
+function str(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : ''
+}
+
+function env(name: string): string {
+  return (process.env[name] ?? '').trim()
+}

src/lib/live-summary.ts

@@ -1,3 +1,4 @@
+import { complete, toProviderSettings, type ProviderSettings } from './providers'
 import {
   buildPrompt,
   resolveDepth,
@@ -10,7 +11,17 @@ type LiveSummaryResult =
   | { success: false; error: string; rateLimited?: boolean }
 
 interface LiveSummaryOptions {
-  apiKey: string
+  /** 프로바이더 설정. 생략하면 apiKey로 Gemini를 호출한다. */
+  provider?: ProviderSettings
+  apiKey?: string
+  /**
+   * 직전 롤링 요약.
+   *
+   * 값이 있으면 증분 모드로 동작하며, 이때 `transcript` 인자는 전사 전체가 아니라
+   * **직전 요약 이후 새로 추가된 발화**만 담아야 한다. 호출당 토큰이 회의 길이와
+   * 무관하게 일정해진다.
+   */
+  previousSummary?: string
   template?: TemplateId
   depth?: SummaryDepth
   customPrompt?: string
@@ -21,67 +32,94 @@ export async function generateLiveSummary(
   transcript: string,
   options: LiveSummaryOptions,
 ): Promise<LiveSummaryResult> {
-  const { apiKey, fetchFn = fetch } = options
+  const { fetchFn } = options
-
+  const settings = toProviderSettings(options.provider, options.apiKey)
-  if (!apiKey || apiKey.trim().length === 0) {
-    return { success: false, error: 'Gemini API 키가 필요합니다.' }
-  }
 
   const trimmed = transcript.trim()
   if (trimmed.length === 0) {
     return { success: false, error: '요약할 텍스트가 비어 있습니다.' }
   }
 
+  const previous = options.previousSummary?.trim() ?? ''
+  const incremental = previous.length > 0
+
   const templateId = options.template ?? 'meeting'
   const depth = resolveDepth(templateId, options.depth)
   const prompt = buildPrompt({
     templateId,
     depth,
-    transcript: trimmed,
+    transcript: incremental
+      ? `[지금까지의 요약]\n${previous}\n\n[새로 추가된 발화]\n${trimmed}`
+      : trimmed,
     live: true,
+    incremental,
     customPrompt: options.customPrompt,
   })
 
-  const url =
+  const result = await complete(prompt, settings, { fetchFn })
-    'https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-lite:generateContent'
 
-  try {
+  if (!result.success) {
-    const response = await fetchFn(url, {
+    return {
-      method: 'POST',
+      success: false,
-      headers: {
+      error: result.error,
-        'Content-Type': 'application/json',
+      ...(result.rateLimited ? { rateLimited: true } : {}),
-        'x-goog-api-key': apiKey,
-      },
-      body: JSON.stringify({
-        contents: [{ parts: [{ text: prompt }] }],
-      }),
-    })
-
-    if (!response.ok) {
-      if (response.status === 429) {
-        return {
-          success: false,
-          error: 'Gemini 요청 한도 초과. 잠시 후 자동 재시도됩니다.',
-          rateLimited: true,
-        }
-      }
-      return {
-        success: false,
-        error: `Gemini API 호출 실패: ${response.status}`,
-      }
     }
-
-    const data = await response.json()
-    const markdown: string =
-      data?.candidates?.[0]?.content?.parts?.[0]?.text ?? ''
-
-    if (markdown.trim().length === 0) {
-      return { success: false, error: '요약 결과가 비어 있습니다.' }
-    }
-
-    return { success: true, markdown }
-  } catch (err) {
-    const message = err instanceof Error ? err.message : '알 수 없는 오류'
-    return { success: false, error: `실시간 요약 중 오류: ${message}` }
   }
+
+  if (result.text.trim().length === 0) {
+    return { success: false, error: '요약 결과가 비어 있습니다.' }
+  }
+
+  return { success: true, markdown: result.text }
+}
+
+export interface LiveSummaryPlan {
+  /** 'full'이면 전사 전체를 보내고 previousSummary를 쓰지 않는다. */
+  mode: 'full' | 'incremental'
+  /** 이번에 보낼 청크의 시작 인덱스. full이면 0. */
+  startIndex: number
+}
+
+export interface LiveSummaryPlanArgs {
+  totalChunks: number
+  lastSummarizedIndex: number
+  incrementsSinceFull: number
+  /** 0이면 주기적 전체 재요약을 하지 않는다. */
+  fullRefreshEvery: number
+  hasPreviousSummary: boolean
+}
+
+/**
+ * 이번 롤링 요약 호출을 증분으로 보낼지 전체로 보낼지 결정한다.
+ *
+ * 증분 모드는 호출당 토큰을 회의 길이와 무관하게 유지하지만, 요약을 요약하는
+ * 구조라 반복될수록 오차가 쌓인다. 그래서 일정 횟수마다 전사 전체로 한 번씩
+ * 다시 요약해 오차를 끊는다.
+ */
+export function planLiveSummaryRequest(
+  args: LiveSummaryPlanArgs,
+): LiveSummaryPlan {
+  const {
+    totalChunks,
+    lastSummarizedIndex,
+    incrementsSinceFull,
+    fullRefreshEvery,
+    hasPreviousSummary,
+  } = args
+
+  // 전사가 초기화되어 인덱스가 범위를 벗어난 경우
+  if (lastSummarizedIndex > totalChunks) {
+    return { mode: 'full', startIndex: 0 }
+  }
+
+  // 첫 호출이거나 갱신할 요약이 아직 없는 경우
+  if (lastSummarizedIndex === 0 || !hasPreviousSummary) {
+    return { mode: 'full', startIndex: 0 }
+  }
+
+  if (fullRefreshEvery > 0 && incrementsSinceFull >= fullRefreshEvery) {
+    return { mode: 'full', startIndex: 0 }
+  }
+
+  return { mode: 'incremental', startIndex: lastSummarizedIndex }
 }

src/lib/minutes-generator.ts

@@ -1,3 +1,9 @@
+import {
+  complete,
+  describeModel,
+  toProviderSettings,
+  type ProviderSettings,
+} from './providers'
 import {
   buildPrompt,
   resolveDepth,
@@ -14,12 +20,14 @@ export interface MinutesInput {
   customPrompt?: string
 }
 
-type GeminiResult =
+type AiMinutesResult =
   | { success: true; markdown: string }
-  | { success: false; error: string }
+  | { success: false; error: string; rateLimited?: boolean }
 
-interface GeminiOptions {
+interface AiMinutesOptions {
-  apiKey: string
+  /** 프로바이더 설정. 생략하면 apiKey로 Gemini를 호출한다. */
+  provider?: ProviderSettings
+  apiKey?: string
   fetchFn?: typeof fetch
 }
 
@@ -49,15 +57,12 @@ ${content}
 `
 }
 
-export async function generateGeminiMinutes(
+export async function generateAiMinutes(
   input: MinutesInput,
-  options: GeminiOptions,
+  options: AiMinutesOptions,
-): Promise<GeminiResult> {
+): Promise<AiMinutesResult> {
-  const { apiKey, fetchFn = fetch } = options
+  const { fetchFn } = options
-
+  const settings = toProviderSettings(options.provider, options.apiKey)
-  if (!apiKey || apiKey.trim().length === 0) {
-    return { success: false, error: 'Gemini API 키가 필요합니다.' }
-  }
 
   const templateId = input.template ?? 'meeting'
   const depth = resolveDepth(templateId, input.depth)
@@ -69,34 +74,23 @@ export async function generateGeminiMinutes(
     customPrompt: input.customPrompt,
   })
 
-  const url =
+  const result = await complete(prompt, settings, { fetchFn })
-    'https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-lite:generateContent'
 
-  try {
+  if (!result.success) {
-    const response = await fetchFn(url, {
+    return {
-      method: 'POST',
+      success: false,
-      headers: {
+      error: result.error,
-        'Content-Type': 'application/json',
+      ...(result.rateLimited ? { rateLimited: true } : {}),
-        'x-goog-api-key': apiKey,
-      },
-      body: JSON.stringify({
-        contents: [{ parts: [{ text: prompt }] }],
-      }),
-    })
-
-    if (!response.ok) {
-      return {
-        success: false,
-        error: `Gemini API 호출 실패: ${response.status} ${response.statusText}`,
-      }
     }
+  }
 
-    const data = await response.json()
+  const generatedText = result.text.trim()
-    const generatedText =
+  if (generatedText.length === 0) {
-      data?.candidates?.[0]?.content?.parts?.[0]?.text ?? ''
+    return { success: false, error: '요약 결과가 비어 있습니다.' }
+  }
 
-    const dateStr = formatDate(input.date)
+  const dateStr = formatDate(input.date)
-    const markdown = `# ${input.title}
+  const markdown = `# ${input.title}
 
 **날짜**: ${dateStr}
 
@@ -106,15 +100,13 @@ ${generatedText}
 
 ---
 
-*이 회의록은 Gemini AI를 활용하여 자동 생성되었습니다.*
+*이 회의록은 AI(${describeModel(settings)})를 활용하여 자동 생성되었습니다.*
 `
 
-    return { success: true, markdown }
+  return { success: true, markdown }
-  } catch (err) {
-    const message = err instanceof Error ? err.message : '알 수 없는 오류'
-    return {
-      success: false,
-      error: `Gemini API 호출 중 오류 발생: ${message}`,
-    }
-  }
 }
+
+/**
+ * @deprecated `generateAiMinutes`를 사용하세요. Gemini 전용 호출부 하위 호환용입니다.
+ */
+export const generateGeminiMinutes = generateAiMinutes

src/lib/providers/gemini.ts

@@ -0,0 +1,76 @@
+import type {
+  CompletionOptions,
+  CompletionResult,
+  ProviderSettings,
+} from './types'
+
+export const DEFAULT_GEMINI_MODEL = 'gemini-3.5-flash-lite'
+
+const API_ROOT = 'https://generativelanguage.googleapis.com/v1beta/models'
+
+export function resolveGeminiModel(model?: string): string {
+  const trimmed = model?.trim() ?? ''
+  return trimmed.length > 0 ? trimmed : DEFAULT_GEMINI_MODEL
+}
+
+/**
+ * Google Generative Language API 직접 호출.
+ * 키는 URL이 아닌 `x-goog-api-key` 헤더로 보낸다 (로그/리퍼러 유출 방지).
+ */
+export async function completeWithGemini(
+  prompt: string,
+  settings: ProviderSettings,
+  options: CompletionOptions = {},
+): Promise<CompletionResult> {
+  const { fetchFn = fetch } = options
+  const apiKey = settings.apiKey.trim()
+
+  if (apiKey.length === 0) {
+    return { success: false, error: 'Gemini API 키가 필요합니다.' }
+  }
+
+  const model = resolveGeminiModel(settings.model)
+  const url = `${API_ROOT}/${encodeURIComponent(model)}:generateContent`
+
+  try {
+    const response = await fetchFn(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-goog-api-key': apiKey,
+      },
+      body: JSON.stringify({
+        contents: [{ parts: [{ text: prompt }] }],
+      }),
+    })
+
+    if (!response.ok) {
+      if (response.status === 429) {
+        return {
+          success: false,
+          error: 'Gemini API 요청 한도 초과. 잠시 후 자동 재시도됩니다.',
+          rateLimited: true,
+        }
+      }
+      return { success: false, error: describeHttpError(response.status) }
+    }
+
+    const data = await response.json()
+    const text: string = data?.candidates?.[0]?.content?.parts?.[0]?.text ?? ''
+
+    return { success: true, text }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : '알 수 없는 오류'
+    return { success: false, error: `Gemini API 호출 중 오류: ${message}` }
+  }
+}
+
+function describeHttpError(status: number): string {
+  if (status === 400) {
+    return 'Gemini API 오류: 잘못된 요청 또는 키 형식입니다 (400).'
+  }
+  if (status === 401 || status === 403) {
+    return `Gemini API 인증 실패 (${status}). 키를 확인해주세요.`
+  }
+  return `Gemini API 호출 실패: ${status}`
+}

src/lib/providers/index.ts

@@ -0,0 +1,43 @@
+import { completeWithGemini, resolveGeminiModel } from './gemini'
+import { completeWithOpenAICompatible } from './openai-compatible'
+import type {
+  CompletionOptions,
+  CompletionResult,
+  ProviderSettings,
+} from './types'
+
+export * from './types'
+export * from './presets'
+export { DEFAULT_GEMINI_MODEL, resolveGeminiModel } from './gemini'
+export { normalizeBaseUrl } from './openai-compatible'
+
+/**
+ * 설정된 프로바이더로 프롬프트 1회 호출.
+ * 실패는 예외 대신 `{ success: false }`로 돌려주므로 호출부에서 폴백하기 쉽다.
+ */
+export async function complete(
+  prompt: string,
+  settings: ProviderSettings,
+  options: CompletionOptions = {},
+): Promise<CompletionResult> {
+  if (settings.provider === 'openai-compatible') {
+    return completeWithOpenAICompatible(prompt, settings, options)
+  }
+  return completeWithGemini(prompt, settings, options)
+}
+
+/** 회의록 하단 문구 등에 쓸 모델 표기. */
+export function describeModel(settings: ProviderSettings): string {
+  if (settings.provider === 'openai-compatible') {
+    return settings.model?.trim() || '알 수 없는 모델'
+  }
+  return resolveGeminiModel(settings.model)
+}
+
+/** provider 설정이 없으면 기존 Gemini 전용 호출부와 동일하게 동작시킨다. */
+export function toProviderSettings(
+  settings: ProviderSettings | undefined,
+  apiKey: string | undefined,
+): ProviderSettings {
+  return settings ?? { provider: 'gemini', apiKey: apiKey ?? '' }
+}

src/lib/providers/openai-compatible.ts

@@ -0,0 +1,112 @@
+import type {
+  CompletionOptions,
+  CompletionResult,
+  ProviderSettings,
+} from './types'
+
+/**
+ * base URL 검증.
+ *
+ * 이 값은 사용자가 설정 화면에서 입력하고 서버(Route Handler)가 그대로 fetch 하므로,
+ * http/https 이외의 스킴은 거부한다. 앱을 localhost 밖으로 노출한다면
+ * SECURITY.md의 "외부 엔드포인트" 항목을 먼저 확인할 것.
+ */
+export function normalizeBaseUrl(baseUrl: string): string | null {
+  const trimmed = baseUrl.trim().replace(/\/+$/, '')
+  if (trimmed.length === 0) return null
+
+  let parsed: URL
+  try {
+    parsed = new URL(trimmed)
+  } catch {
+    return null
+  }
+
+  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') return null
+
+  return trimmed
+}
+
+/**
+ * OpenAI Chat Completions 호환 엔드포인트 호출.
+ * OrcaRouter · OpenAI · Ollama · LM Studio · vLLM 등이 모두 이 형식을 따른다.
+ */
+export async function completeWithOpenAICompatible(
+  prompt: string,
+  settings: ProviderSettings,
+  options: CompletionOptions = {},
+): Promise<CompletionResult> {
+  const { fetchFn = fetch } = options
+
+  const baseUrl = normalizeBaseUrl(settings.baseUrl ?? '')
+  if (!baseUrl) {
+    return {
+      success: false,
+      error: 'API 주소(base URL)가 올바르지 않습니다. http:// 또는 https:// 로 시작해야 합니다.',
+    }
+  }
+
+  const model = settings.model?.trim() ?? ''
+  if (model.length === 0) {
+    return { success: false, error: '모델 이름이 필요합니다.' }
+  }
+
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+  }
+
+  // 로컬 모델 서버(Ollama/LM Studio)는 키 없이 동작하므로 키가 없어도 호출한다.
+  //
+  // NOTE: 일부 라우터는 "이 요청이 어느 앱에서 왔는지" 식별하는 헤더를 받는다
+  // (OpenRouter의 HTTP-Referer / X-Title 등). 특정 서비스와 제휴해 트래픽을
+  // 귀속시키려면 그 서비스가 공식 문서로 밝힌 헤더를 여기에 추가하면 된다.
+  // 문서화되지 않은 헤더를 추측해서 보내지는 않는다.
+  const apiKey = settings.apiKey.trim()
+  if (apiKey.length > 0) {
+    headers.Authorization = `Bearer ${apiKey}`
+  }
+
+  try {
+    const response = await fetchFn(`${baseUrl}/chat/completions`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({
+        model,
+        messages: [{ role: 'user', content: prompt }],
+        stream: false,
+      }),
+    })
+
+    if (!response.ok) {
+      if (response.status === 429) {
+        return {
+          success: false,
+          error: 'API 요청 한도 초과. 잠시 후 자동 재시도됩니다.',
+          rateLimited: true,
+        }
+      }
+      return { success: false, error: describeHttpError(response.status) }
+    }
+
+    const data = await response.json()
+    const text: string = data?.choices?.[0]?.message?.content ?? ''
+
+    return { success: true, text }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : '알 수 없는 오류'
+    return { success: false, error: `API 호출 중 오류: ${message}` }
+  }
+}
+
+function describeHttpError(status: number): string {
+  if (status === 401 || status === 403) {
+    return `인증에 실패했습니다 (${status}). API 키를 확인해주세요.`
+  }
+  if (status === 404) {
+    return `엔드포인트를 찾을 수 없습니다 (404). base URL과 모델 이름을 확인해주세요.`
+  }
+  if (status === 402) {
+    return '크레딧이 부족합니다 (402). 프로바이더 잔액을 확인해주세요.'
+  }
+  return `API 호출 실패: ${status}`
+}

src/lib/providers/presets.ts

@@ -0,0 +1,98 @@
+import { DEFAULT_GEMINI_MODEL } from './gemini'
+import type { ProviderId } from './types'
+
+export interface ProviderPreset {
+  id: string
+  label: string
+  provider: ProviderId
+  /** openai-compatible 프리셋의 기본 base URL. 사용자가 수정할 수 있다. */
+  baseUrl: string
+  defaultModel: string
+  description: string
+  apiKeyLabel: string
+  apiKeyPlaceholder: string
+  /** 키 없이도 동작하는 엔드포인트(로컬 모델 서버)인지 여부 */
+  apiKeyOptional?: boolean
+  docsUrl?: string
+  docsLabel?: string
+  modelHint?: string
+}
+
+export const PROVIDER_PRESETS: ProviderPreset[] = [
+  {
+    id: 'gemini',
+    label: 'Google Gemini',
+    provider: 'gemini',
+    baseUrl: '',
+    defaultModel: DEFAULT_GEMINI_MODEL,
+    description: 'Google에 직접 호출합니다. 무료 티어가 있어 가장 간단합니다.',
+    apiKeyLabel: 'Gemini API 키',
+    apiKeyPlaceholder: 'AIzaSy...',
+    docsUrl: 'https://aistudio.google.com/apikey',
+    docsLabel: 'Google AI Studio',
+    modelHint:
+      '예: gemini-3.5-flash-lite(저렴·빠름), gemini-3.6-flash, gemini-2.5-pro',
+  },
+  {
+    id: 'openai',
+    label: 'OpenAI',
+    provider: 'openai-compatible',
+    baseUrl: 'https://api.openai.com/v1',
+    defaultModel: 'gpt-4o-mini',
+    description: 'OpenAI Chat Completions API를 사용합니다.',
+    apiKeyLabel: 'OpenAI API 키',
+    apiKeyPlaceholder: 'sk-...',
+    docsUrl: 'https://platform.openai.com/api-keys',
+    docsLabel: 'OpenAI 대시보드',
+    modelHint: '예: gpt-4o-mini, gpt-4o',
+  },
+  {
+    id: 'orcarouter',
+    label: 'OrcaRouter',
+    provider: 'openai-compatible',
+    baseUrl: 'https://api.orcarouter.ai/v1',
+    defaultModel: 'google/gemini-3.5-flash-lite',
+    description:
+      '하나의 키로 여러 제공사 모델을 사용합니다. 별도 가입과 크레딧 충전(또는 BYOK 등록)이 필요합니다.',
+    apiKeyLabel: 'OrcaRouter API 키',
+    apiKeyPlaceholder: 'sk-...',
+    docsUrl: 'https://www.orcarouter.ai/',
+    docsLabel: 'OrcaRouter',
+    modelHint:
+      '예: google/gemini-3.5-flash-lite, openai/gpt-4o-mini, orcarouter/auto',
+  },
+  {
+    id: 'local',
+    label: '로컬 모델',
+    provider: 'openai-compatible',
+    baseUrl: 'http://localhost:11434/v1',
+    defaultModel: 'llama3.1',
+    description:
+      'Ollama · LM Studio · vLLM 등 내 PC에서 도는 모델. 회의 내용이 외부로 나가지 않습니다.',
+    apiKeyLabel: 'API 키 (보통 불필요)',
+    apiKeyPlaceholder: '비워두세요',
+    apiKeyOptional: true,
+    modelHint: 'Ollama 기본 포트는 11434, LM Studio는 1234입니다.',
+  },
+  {
+    id: 'custom',
+    label: '직접 입력',
+    provider: 'openai-compatible',
+    baseUrl: '',
+    defaultModel: '',
+    description: 'OpenAI 호환 엔드포인트라면 무엇이든 연결할 수 있습니다.',
+    apiKeyLabel: 'API 키',
+    apiKeyPlaceholder: 'sk-...',
+    apiKeyOptional: true,
+    modelHint: '엔드포인트가 제공하는 모델 ID를 그대로 입력하세요.',
+  },
+]
+
+export const DEFAULT_PRESET_ID = 'gemini'
+
+export function findPreset(presetId: string | null | undefined): ProviderPreset {
+  return (
+    PROVIDER_PRESETS.find((preset) => preset.id === presetId) ??
+    PROVIDER_PRESETS[0]
+  )
+}

src/lib/providers/types.ts

@@ -0,0 +1,32 @@
+/**
+ * LLM 프로바이더 공통 타입.
+ *
+ * - `gemini`: Google Generative Language API를 직접 호출 (기본값, 기존 동작)
+ * - `openai-compatible`: OpenAI Chat Completions 형식을 따르는 모든 엔드포인트
+ *   (OrcaRouter, OpenAI, Ollama, LM Studio, vLLM 등)
+ */
+export type ProviderId = 'gemini' | 'openai-compatible'
+
+export const PROVIDER_IDS: readonly ProviderId[] = ['gemini', 'openai-compatible']
+
+export function isProviderId(value: unknown): value is ProviderId {
+  return typeof value === 'string' && (PROVIDER_IDS as readonly string[]).includes(value)
+}
+
+export interface ProviderSettings {
+  provider: ProviderId
+  /** 로컬 모델 서버처럼 인증이 필요 없는 엔드포인트에서는 빈 문자열일 수 있다. */
+  apiKey: string
+  /** openai-compatible 전용. 예: https://api.orcarouter.ai/v1 */
+  baseUrl?: string
+  /** 비워두면 프로바이더별 기본 모델을 사용한다. */
+  model?: string
+}
+
+export type CompletionResult =
+  | { success: true; text: string }
+  | { success: false; error: string; rateLimited?: boolean }
+
+export interface CompletionOptions {
+  fetchFn?: typeof fetch
+}

src/lib/recording-store.ts

@@ -0,0 +1,195 @@
+/**
+ * 녹음 조각을 디스크에 이어 붙이는 서버 저장소.
+ *
+ * 메모리에 모아 뒀다가 종료 시 한 번에 쓰지 않는다. 그러면 탭이나 서버가
+ * 죽는 순간 회의 전체가 사라진다. 조각이 도착할 때마다 곧바로 append 하므로
+ * 어느 시점에 중단되든 그때까지의 오디오는 파일로 남아 있다.
+ *
+ * MediaRecorder가 timeslice 모드에서 내보내는 조각은 첫 조각에 컨테이너
+ * 헤더가 들어 있고 이후에는 클러스터만 이어진다. 받은 순서대로 이어 붙이면
+ * 그대로 재생·전사 가능한 파일이 된다. 단 헤더의 duration 필드는 비어 있어
+ * 플레이어에 따라 탐색(seek)이 부정확할 수 있다 — 재전사에는 영향이 없다.
+ */
+
+import { randomBytes } from 'crypto'
+import { createReadStream } from 'fs'
+import type { Readable } from 'stream'
+import { appendFile, mkdir, readFile, stat, writeFile } from 'fs/promises'
+import path from 'path'
+import {
+  MAX_RECORDING_BYTES,
+  extensionForMimeType,
+  isValidRecordingId,
+} from './recording'
+
+/** 별도 볼륨에 두고 싶으면 `RECORDINGS_DIR`로 덮어쓴다. */
+export const RECORDINGS_DIR =
+  process.env.RECORDINGS_DIR ?? path.join(process.cwd(), 'uploads', 'recordings')
+
+export interface RecordingMeta {
+  id: string
+  mimeType: string
+  /** `uploads/recordings/` 기준 상대 파일명. */
+  fileName: string
+  startedAt: string
+  finalizedAt: string | null
+  durationMs: number | null
+}
+
+export interface RecordingStatus extends RecordingMeta {
+  bytes: number
+}
+
+/**
+ * id별 직렬화 큐.
+ *
+ * 조각의 순서가 곧 파일의 순서다. 두 요청이 겹쳐 들어오면 컨테이너가
+ * 깨지므로 같은 녹음에 대한 쓰기는 한 줄로 세운다.
+ */
+const queues = new Map<string, Promise<unknown>>()
+
+function enqueue<T>(id: string, task: () => Promise<T>): Promise<T> {
+  const previous = queues.get(id) ?? Promise.resolve()
+  const next = previous.then(task, task)
+
+  // 앞 작업이 실패해도 뒤 작업은 돌아야 하므로, 큐에는 절대 거부되지 않는
+  // 프로미스를 넣는다. 실패는 호출자가 받는 `next`로만 전달된다.
+  const settled = next.then(
+    () => undefined,
+    () => undefined,
+  )
+
+  // 큐가 무한정 자라지 않도록, 마지막 작업이 끝나면 항목을 지운다.
+  queues.set(id, settled)
+  settled.then(() => {
+    if (queues.get(id) === settled) queues.delete(id)
+  })
+
+  return next
+}
+
+function metaPath(id: string): string {
+  return path.join(RECORDINGS_DIR, `${id}.json`)
+}
+
+function audioPath(meta: RecordingMeta): string {
+  return path.join(RECORDINGS_DIR, meta.fileName)
+}
+
+async function fileSize(filePath: string): Promise<number> {
+  try {
+    return (await stat(filePath)).size
+  } catch {
+    return 0
+  }
+}
+
+/** 새 녹음 세션을 만든다. 오디오 파일은 첫 조각이 도착할 때 생긴다. */
+export async function createRecording(
+  mimeType: string,
+): Promise<RecordingMeta> {
+  const id = randomBytes(16).toString('hex')
+  const meta: RecordingMeta = {
+    id,
+    mimeType,
+    fileName: `${id}.${extensionForMimeType(mimeType)}`,
+    startedAt: new Date().toISOString(),
+    finalizedAt: null,
+    durationMs: null,
+  }
+
+  await mkdir(RECORDINGS_DIR, { recursive: true })
+  await writeFile(metaPath(id), JSON.stringify(meta, null, 2), 'utf-8')
+
+  return meta
+}
+
+export async function getRecording(id: string): Promise<RecordingMeta | null> {
+  if (!isValidRecordingId(id)) return null
+
+  try {
+    const raw = await readFile(metaPath(id), 'utf-8')
+    return JSON.parse(raw) as RecordingMeta
+  } catch {
+    return null
+  }
+}
+
+export async function getRecordingStatus(
+  id: string,
+): Promise<RecordingStatus | null> {
+  const meta = await getRecording(id)
+  if (!meta) return null
+
+  return { ...meta, bytes: await fileSize(audioPath(meta)) }
+}
+
+export type AppendResult =
+  | { ok: true; bytes: number }
+  | { ok: false; error: string; status: number }
+
+/** 조각 하나를 파일 끝에 이어 붙이고 누적 크기를 돌려준다. */
+export async function appendChunk(
+  id: string,
+  chunk: Buffer,
+): Promise<AppendResult> {
+  const meta = await getRecording(id)
+  if (!meta) {
+    return { ok: false, error: '녹음 세션을 찾을 수 없습니다.', status: 404 }
+  }
+
+  return enqueue(id, async () => {
+    const filePath = audioPath(meta)
+    const current = await fileSize(filePath)
+
+    if (current + chunk.byteLength > MAX_RECORDING_BYTES) {
+      return {
+        ok: false as const,
+        error: `녹음이 상한(${Math.round(
+          MAX_RECORDING_BYTES / 1024 / 1024,
+        )}MB)을 넘었습니다.`,
+        status: 413,
+      }
+    }
+
+    await appendFile(filePath, chunk)
+    return { ok: true as const, bytes: current + chunk.byteLength }
+  })
+}
+
+/** 녹음을 닫는다. 이후 조각은 더 오지 않는다고 보고 길이를 확정한다. */
+export async function finalizeRecording(
+  id: string,
+  durationMs: number | null,
+): Promise<RecordingStatus | null> {
+  const meta = await getRecording(id)
+  if (!meta) return null
+
+  return enqueue(id, async () => {
+    const updated: RecordingMeta = {
+      ...meta,
+      finalizedAt: new Date().toISOString(),
+      durationMs:
+        typeof durationMs === 'number' && Number.isFinite(durationMs)
+          ? Math.max(0, Math.round(durationMs))
+          : null,
+    }
+
+    await writeFile(metaPath(id), JSON.stringify(updated, null, 2), 'utf-8')
+    return { ...updated, bytes: await fileSize(audioPath(updated)) }
+  })
+}
+
+/** 다운로드용 읽기 스트림. 파일이 없으면 null. */
+export async function openRecording(
+  id: string,
+): Promise<{ meta: RecordingMeta; bytes: number; stream: Readable } | null> {
+  const meta = await getRecording(id)
+  if (!meta) return null
+
+  const filePath = audioPath(meta)
+  const bytes = await fileSize(filePath)
+  if (bytes === 0) return null
+
+  return { meta, bytes, stream: createReadStream(filePath) }
+}

src/lib/recording.ts

@@ -0,0 +1,139 @@
+/**
+ * 회의 오디오 녹음 — 브라우저·서버가 공유하는 상수와 순수 함수.
+ *
+ * 녹음의 목적은 재생이 아니라 **재전사**다. Web Speech가 놓친 발화를 나중에
+ * 서버 STT로 되살리려면 원본 오디오가 남아 있어야 한다. 그래서 전사와
+ * 무관하게, 전사가 실패하더라도 오디오만은 반드시 파일로 남긴다.
+ */
+
+/** MediaRecorder에 우선순위대로 시도할 컨테이너/코덱. */
+export const PREFERRED_MIME_TYPES = [
+  'audio/webm;codecs=opus',
+  'audio/webm',
+  'audio/ogg;codecs=opus',
+  'audio/mp4',
+] as const
+
+/**
+ * 대면 회의 기준 캡처 제약.
+ *
+ * 브라우저 기본값은 세 가지가 모두 켜져 있고 전화 통화용으로 튜닝돼 있다.
+ * 노이즈 억제는 멀리 앉은 화자의 목소리를 노이즈로 오판해 지워버릴 수 있고,
+ * 에코 제거는 스피커 출력이 없는 대면 회의에서는 얻을 게 없다. 둘 다 끈다.
+ * 반면 AGC는 조용한 화자의 레벨을 끌어올려 주므로 남긴다.
+ *
+ * 원격 회의(스피커 출력이 마이크로 되먹임되는 경우)에는 echoCancellation을
+ * 다시 켜야 한다. 그 경로는 dual-stream 캡처와 함께 다룬다.
+ */
+export const RECORDING_AUDIO_CONSTRAINTS: MediaTrackConstraints = {
+  channelCount: 1,
+  echoCancellation: false,
+  noiseSuppression: false,
+  autoGainControl: true,
+}
+
+/**
+ * 서버로 조각을 올리는 간격.
+ *
+ * 짧을수록 탭이 죽었을 때 잃는 양이 적고, 길수록 요청 수가 준다. 15초면
+ * 최악의 경우에도 15초치만 잃는다.
+ */
+export const CHUNK_INTERVAL_MS = 15_000
+
+/** 음성 전용이므로 128kbps면 STT에 충분하고도 남는다. */
+export const AUDIO_BITS_PER_SECOND = 128_000
+
+/** 회의 하나의 상한. 128kbps 기준 약 8.6시간. */
+export const MAX_RECORDING_BYTES = 500 * 1024 * 1024
+
+/** 조각 하나의 상한. 15초 × 128kbps면 240KB 남짓이라 넉넉하다. */
+export const MAX_CHUNK_BYTES = 8 * 1024 * 1024
+
+/** 브라우저가 지원하는 첫 번째 후보를 고른다. 없으면 null. */
+export function pickRecorderMimeType(
+  isTypeSupported: (type: string) => boolean,
+): string | null {
+  for (const type of PREFERRED_MIME_TYPES) {
+    if (isTypeSupported(type)) return type
+  }
+  return null
+}
+
+/** `audio/webm;codecs=opus` → `webm` */
+export function extensionForMimeType(mimeType: string): string {
+  const base = mimeType.split(';')[0].trim().toLowerCase()
+
+  switch (base) {
+    case 'audio/webm':
+      return 'webm'
+    case 'audio/ogg':
+      return 'ogg'
+    case 'audio/mp4':
+    case 'audio/x-m4a':
+      return 'm4a'
+    case 'audio/mpeg':
+      return 'mp3'
+    case 'audio/wav':
+    case 'audio/x-wav':
+      return 'wav'
+    case 'audio/flac':
+      return 'flac'
+    default:
+      return 'bin'
+  }
+}
+
+/**
+ * 녹음 세션 식별자 검증.
+ *
+ * 이 값이 그대로 파일 경로가 되므로 `..`이나 구분자가 섞이면 안 된다.
+ * 경로 조립 전에 반드시 통과시킨다.
+ */
+const RECORDING_ID_PATTERN = /^[0-9a-f]{32}$/
+
+export function isValidRecordingId(id: unknown): id is string {
+  return typeof id === 'string' && RECORDING_ID_PATTERN.test(id)
+}
+
+/** 사용자가 내려받을 때 보게 될 파일 이름. */
+export function recordingDownloadName(
+  title: string,
+  startedAt: Date,
+  mimeType: string,
+): string {
+  const stamp = [
+    startedAt.getFullYear(),
+    String(startedAt.getMonth() + 1).padStart(2, '0'),
+    String(startedAt.getDate()).padStart(2, '0'),
+    '-',
+    String(startedAt.getHours()).padStart(2, '0'),
+    String(startedAt.getMinutes()).padStart(2, '0'),
+  ].join('')
+
+  const safeTitle = title
+    .trim()
+    .replace(/[\\/:*?"<>|]/g, '')
+    .replace(/\s+/g, '_')
+    .slice(0, 60)
+
+  const stem = safeTitle.length > 0 ? `${stamp}_${safeTitle}` : stamp
+  return `${stem}.${extensionForMimeType(mimeType)}`
+}
+
+export function formatBytes(bytes: number): string {
+  if (!Number.isFinite(bytes) || bytes < 0) return '0B'
+  if (bytes < 1024) return `${bytes}B`
+  if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)}KB`
+  return `${(bytes / 1024 / 1024).toFixed(1)}MB`
+}
+
+export function formatDuration(ms: number): string {
+  const total = Math.max(0, Math.floor(ms / 1000))
+  const h = Math.floor(total / 3600)
+  const m = Math.floor((total % 3600) / 60)
+  const s = total % 60
+  const mm = String(m).padStart(2, '0')
+  const ss = String(s).padStart(2, '0')
+
+  return h > 0 ? `${h}:${mm}:${ss}` : `${mm}:${ss}`
+}

src/lib/templates.ts

@@ -34,20 +34,24 @@ export const TEMPLATES: Record<Exclude<TemplateId, 'custom'>, Template> = {
     depthAdjustable: true,
     basePrompt: `당신은 회의록 작성 전문가입니다. 아래 발화 내용을 분석하여 마크다운 회의록을 작성하세요.
 
-포함할 섹션:
 ## 요약
-(3~5줄 핵심 내용)
+회의 전체를 3~5줄로. 무엇을 논의했고 무엇이 정해졌는지.
 
-## 주요 논의 사항
+이어지는 본문은 **섹션 제목을 직접 지어서** 구성하세요:
-1. 순번 매기기
+- 실제로 논의된 주제를 스스로 파악해 \`##\` 제목을 붙여 나눕니다.
+- "주요 논의 사항", "논의 내용" 같은 일반적인 제목은 쓰지 마세요.
+  이 회의가 무엇을 다뤘는지 제목만 봐도 알 수 있어야 합니다.
+  (예: "단계별 개발 계획", "수익화 방안", "기술적 고려사항")
+- 주제 수는 내용에 따라 정하되 보통 3~6개입니다.
 
 ## 액션 아이템
-- [ ] 담당자와 기한이 명확한 항목만
+반드시 \`- [ ]\` 체크박스 형식으로 작성하세요.
+담당자가 파악되면 \`(담당자)\`를 앞에, 기한이 언급됐으면 뒤에 덧붙입니다.
+예: \`- [ ] (김지훈) 경쟁 사이트 리스트업 — 5/17까지\`
+담당자가 불분명해도 해야 할 일이 명확하면 포함하세요.
 
 ## 결정 사항
-- 합의 또는 확정된 것만
+- 합의되었거나 확정된 것만. 없으면 이 섹션을 생략하세요.`,
-
-한국어로 작성하세요.`,
   },
 
   lecture: {
@@ -60,20 +64,18 @@ export const TEMPLATES: Record<Exclude<TemplateId, 'custom'>, Template> = {
     depthAdjustable: true,
     basePrompt: `당신은 학습용 노트를 작성하는 전문가입니다. 강의/세미나 녹취를 구조화된 학습 자료로 정리하세요.
 
-포함할 섹션:
 ## 주요 주제
 (한 줄 요약)
 
 ## 핵심 개념
 각 개념마다 ### 소제목 + 설명 + 구체 예시
+소제목은 강의에서 실제로 다룬 개념 이름을 그대로 쓰세요.
 
 ## 기억할 인용·예시
 > 중요한 문장 인용 형식으로
 
 ## 후속 질문
-- 스스로 탐구해볼 만한 질문
+- 스스로 탐구해볼 만한 질문`,
-
-한국어로 작성하세요.`,
   },
 
   one_on_one: {
@@ -86,12 +88,11 @@ export const TEMPLATES: Record<Exclude<TemplateId, 'custom'>, Template> = {
     depthAdjustable: true,
     basePrompt: `당신은 1:1 미팅 정리 전문가입니다. 개인적이고 신뢰 기반의 대화임을 존중하며 정리하세요.
 
-포함할 섹션:
 ## 이번 세션 요지
 (2~3줄)
 
-## 논의한 주제
+이어서 대화에서 실제로 다룬 주제마다 **\`##\` 제목을 직접 지어** 나누세요.
-- 주요 대화 흐름
+"논의한 주제" 같은 일반적인 제목 대신, 무엇에 대한 이야기였는지 드러내는 제목을 쓰세요.
 
 ## 고민·블로커
 - 공유된 어려움
@@ -100,9 +101,7 @@ export const TEMPLATES: Record<Exclude<TemplateId, 'custom'>, Template> = {
 - 건설적 피드백 위주
 
 ## 다음 미팅까지 할 일
-- [ ] 합의된 후속 조치
+- [ ] 합의된 후속 조치. 담당자가 있으면 \`(담당자)\` 표기`,
-
-한국어로 작성하세요.`,
   },
 
   brainstorm: {
@@ -115,12 +114,12 @@ export const TEMPLATES: Record<Exclude<TemplateId, 'custom'>, Template> = {
     depthAdjustable: true,
     basePrompt: `당신은 브레인스토밍 세션을 정리하는 전문가입니다. 나온 아이디어를 분류하고 실행 가능성 관점에서 정리하세요.
 
-포함할 섹션:
 ## 세션 개요
 (1~2줄 — 주제/목표)
 
 ## 아이디어 (카테고리별)
 ### [카테고리 이름]
+카테고리는 미리 정해진 목록이 아니라, 나온 아이디어를 보고 직접 묶어서 이름 붙이세요.
 - 아이디어 요약
 
 ## 즉시 시도 가능
@@ -130,9 +129,7 @@ export const TEMPLATES: Record<Exclude<TemplateId, 'custom'>, Template> = {
 - 사유 간단히
 
 ## 다음 스텝
-- 구체적인 후속 행동
+- [ ] 구체적인 후속 행동. 담당자가 있으면 \`(담당자)\` 표기`,
-
-한국어로 작성하세요.`,
   },
 
   interview: {
@@ -145,7 +142,6 @@ export const TEMPLATES: Record<Exclude<TemplateId, 'custom'>, Template> = {
     depthAdjustable: true,
     basePrompt: `당신은 인터뷰 녹취를 Q&A 형식으로 정리하는 전문가입니다.
 
-포함할 섹션:
 ## 개요
 (인터뷰 대상/주제 1~2줄)
 
@@ -159,9 +155,7 @@ A: [답변 요약]
 > 직접 인용
 
 ## 종합 인상
-- 전반적 테마 / 놓치지 말 것
+- 전반적 테마 / 놓치지 말 것`,
-
-한국어로 작성하세요.`,
   },
 
   raw: {
@@ -181,8 +175,7 @@ A: [답변 요약]
 엄격한 규칙:
 - 내용을 삭제하거나 축약하지 마세요
 - 구조적 제목(## 섹션)을 덧붙이지 마세요
-- 타임스탬프가 있으면 그대로 유지하세요
+- 타임스탬프가 있으면 그대로 유지하세요`,
-- 한국어로 작성하세요.`,
   },
 }
 
@@ -195,13 +188,41 @@ const DEPTH_MODIFIERS: Record<SummaryDepth, string> = {
     '작성 강도: **상세**. 원문의 주요 세부사항·수치·고유명사를 누락 없이 포함하세요. 구조만 바꾸고 내용은 최대한 보존합니다.',
 }
 
-const LIVE_MODIFIER = `회의가 아직 진행 중입니다. 지금까지의 내용을 기반으로 **중간 정리**를 작성하세요. 확정되지 않은 결정은 "(논의 중)"으로 표시하세요.`
+const LIVE_MODIFIER = `회의가 아직 진행 중입니다. 지금까지의 내용을 기반으로 **중간 정리**를 작성하세요. 확정되지 않은 결정은 "(논의 중)"으로 표시하세요.
+섹션 제목은 지금까지 나온 주제를 기준으로 붙이되, 이후 갱신될 수 있으므로 간결하게 유지하세요.`
+
+/**
+ * 프리셋 템플릿 전체에 공통으로 덧붙는 규칙.
+ *
+ * custom 프롬프트에는 적용하지 않는다 — 사용자가 전적으로 제어하는 영역이기 때문.
+ */
+const COMMON_RULES = `공통 규칙:
+- 발화에 없는 내용을 지어내지 마세요. 불확실하면 쓰지 마세요.
+- 발화자 표기가 있다면 누가 무엇을 주장하고 약속했는지 반영하세요.
+- 영어 기술 용어·제품명은 번역하거나 음차하지 말고 원문 표기를 유지하세요 (예: latency, deployment).
+- 한국어로 작성하세요.`
+
+/**
+ * 증분 갱신 모드.
+ *
+ * 전사 전체를 매번 다시 보내는 대신 [지금까지의 요약] + [새로 추가된 발화]만 보낸다.
+ * 호출당 토큰이 회의 길이와 무관하게 일정해져, 비용이 제곱이 아닌 선형으로 늘어난다.
+ */
+const INCREMENTAL_MODIFIER = `아래에는 [지금까지의 요약]과 [새로 추가된 발화]가 주어집니다.
+기존 요약을 처음부터 다시 쓰지 말고 **갱신**하세요:
+- 기존 요약의 내용과 구조를 유지한 채 새 발화를 반영합니다.
+- 기존 항목이 새 발화로 확정되거나 번복되었다면 그 항목을 고치세요.
+- 새 발화에 언급되지 않았다는 이유로 기존 내용을 삭제하지 마세요.
+- 출력은 항상 갱신된 회의록 **전체**입니다. 변경분만 출력하지 마세요.`
 
 export interface BuildPromptArgs {
   templateId: TemplateId
   depth: SummaryDepth
+  /** 증분 모드에서는 [지금까지의 요약] + [새로 추가된 발화]를 담은 블록이 들어온다. */
   transcript: string
   live?: boolean
+  /** 직전 요약을 갱신하는 모드. live와 함께 쓴다. */
+  incremental?: boolean
   customPrompt?: string
 }
 
@@ -222,14 +243,21 @@ export function resolveDepth(
 }
 
 export function buildPrompt(args: BuildPromptArgs): string {
-  const { templateId, depth, transcript, live = false, customPrompt } = args
+  const {
+    templateId,
+    depth,
+    transcript,
+    live = false,
+    incremental = false,
+    customPrompt,
+  } = args
 
   let instruction: string
 
   if (templateId === 'custom') {
     const custom = customPrompt?.trim()
     if (!custom) {
-      instruction = TEMPLATES.meeting.basePrompt
+      instruction = `${TEMPLATES.meeting.basePrompt}\n\n${COMMON_RULES}`
     } else {
       instruction = custom
     }
@@ -243,12 +271,21 @@ export function buildPrompt(args: BuildPromptArgs): string {
 
     if (live && template.liveSupported) {
       parts.push(LIVE_MODIFIER)
+
+      if (incremental) {
+        parts.push(INCREMENTAL_MODIFIER)
+      }
     }
 
+    parts.push(COMMON_RULES)
+
     instruction = parts.join('\n\n')
   }
 
-  return `${instruction}\n\n---\n음성 인식 텍스트:\n${transcript}`
+  // 증분 모드의 transcript는 자체 라벨([지금까지의 요약] 등)을 이미 포함한다.
+  const body = incremental ? transcript : `음성 인식 텍스트:\n${transcript}`
+
+  return `${instruction}\n\n---\n${body}`
 }
 
 export function liveEnabledFor(templateId: TemplateId): boolean {