Update app.py

app.py

@@ -1,15 +1,16 @@
 # -*- coding: utf-8 -*-
 """
-Colab & Hugging Face Spaces 공용 app.py (Clean UI + Stable Summarization)
-- Whisper(faster-whisper) STT
-- Token-based chunking + 2-pass summarization
-- Model select & automatic fallback for summarizer
+Naver-style UI · Whisper STT + Structured Minutes
+- Token-based chunking + 2-pass summarization (KoBART → T5 fallback)
+- KST 정규화(Date/Time), Duration, Title 생성
+- Decisions / Action Items / Owner / Due / Next Meeting 추출
+- Colab & Hugging Face Spaces 공용
 """
+import os, sys, subprocess, tempfile, shutil, re, json
+from datetime import datetime, timezone
+from zoneinfo import ZoneInfo
 
-import os, sys, subprocess, tempfile, shutil
-from datetime import datetime
-
-# --------- Environment helpers ---------
+# ---------- Runtime helpers ----------
 def _has_cmd(cmd: str) -> bool:
     return shutil.which(cmd) is not None
 
@@ -17,274 +18,451 @@ def _pip_install(pkgs):
     subprocess.check_call([sys.executable, "-m", "pip", "install", "--quiet"] + pkgs)
 
 def _ensure_runtime():
-    # ffmpeg
-    if not _has_cmd("ffmpeg"):
-        try:
-            subprocess.run(["apt-get", "update", "-y"], check=False)
-            subprocess.run(["apt-get", "install", "-y", "ffmpeg"], check=False)
-        except Exception:
-            pass
-    # python packages (idempotent)
     need = []
     for mod, pkg in [
-        ("torch", "torch"),
-        ("transformers", "transformers==4.*"),
-        ("sentencepiece", "sentencepiece"),
-        ("faster_whisper", "faster-whisper==1.*"),
-        ("pydub", "pydub"),
-        ("gradio", "gradio==4.*"),
+        ("torch","torch"),
+        ("transformers","transformers==4.*"),
+        ("sentencepiece","sentencepiece"),
+        ("faster_whisper","faster-whisper==1.*"),
+        ("pydub","pydub"),
+        ("dateparser","dateparser"),
+        ("pandas","pandas"),
+        ("gradio","gradio==4.*"),
     ]:
-        try:
-            __import__(mod)
-        except Exception:
-            need.append(pkg)
+        try: __import__(mod)
+        except Exception: need.append(pkg)
     if need:
         _pip_install(need)
+    if not _has_cmd("ffmpeg"):
+        try:
+            subprocess.run(["apt-get","update","-y"], check=False)
+            subprocess.run(["apt-get","install","-y","ffmpeg"], check=False)
+        except Exception:
+            pass
 
 _ensure_runtime()
 
-# --------- Imports ---------
+# ---------- Imports ----------
 import gradio as gr
+import pandas as pd
 import torch
 from pydub import AudioSegment
 from faster_whisper import WhisperModel
 from transformers import pipeline, AutoTokenizer
+import dateparser
 
-# --------- STT (Whisper) ---------
+# ---------- STT ----------
 DEFAULT_WHISPER_SIZE = os.getenv("WHISPER_MODEL_SIZE", "small")  # tiny/base/small/medium/large-v3
 device = "cuda" if torch.cuda.is_available() and os.path.exists("/proc/driver/nvidia") else "cpu"
 compute_type = "float16" if device == "cuda" else "int8"
-
 _asr = WhisperModel(DEFAULT_WHISPER_SIZE, device=device, compute_type=compute_type)
 
-# --------- Summarizer (select & fallback) ---------
+# ---------- Summarizer (primary + fallback) ----------
 PRIMARY_SUMM = "gogamza/kobart-summarization"
-FALLBACK_SUMM = "lcw99/t5-base-korean-text-summary"  # 폴백
-
-# lazy holders
-_SUMM_MODEL_NAME = PRIMARY_SUMM
+FALLBACK_SUMM = "lcw99/t5-base-korean-text-summary"
+_SUMM_MODEL_NAME = None
 _tokenizer = None
 _summarizer = None
 
 def load_summarizer(model_name: str):
-    """Load summarizer & tokenizer for the given model (with device mapping)"""
-    global _summarizer, _tokenizer, _SUMM_MODEL_NAME
-    if _summarizer is not None and _SUMM_MODEL_NAME == model_name:
+    global _SUMM_MODEL_NAME, _tokenizer, _summarizer
+    if _SUMM_MODEL_NAME == model_name and _summarizer is not None:
         return
     _SUMM_MODEL_NAME = model_name
     _tokenizer = AutoTokenizer.from_pretrained(model_name, use_fast=True)
-    _summarizer = pipeline(
-        "summarization",
-        model=model_name,
-        device=0 if device == "cuda" else -1
-    )
+    _summarizer = pipeline("summarization", model=model_name,
+                           device=0 if device=="cuda" else -1)
 
-# 초기 로드 (실패 시 폴백)
 try:
     load_summarizer(PRIMARY_SUMM)
 except Exception:
     load_summarizer(FALLBACK_SUMM)
 
-# --------- Utils ---------
+# ---------- Utils: audio ----------
+KST = ZoneInfo("Asia/Seoul")
+
 def convert_to_wav(src_path: str) -> str:
-    if src_path.lower().endswith(".wav"):
-        return src_path
+    if src_path.lower().endswith(".wav"): return src_path
     if not _has_cmd("ffmpeg"):
-        raise RuntimeError("ffmpeg 필요 (Spaces: apt.txt에 'ffmpeg' 추가)")
+        raise RuntimeError("ffmpeg가 필요합니다. (Spaces: apt.txt에 'ffmpeg')")
     sound = AudioSegment.from_file(src_path)
-    fd, tmp_wav = tempfile.mkstemp(suffix=".wav")
-    os.close(fd)
+    fd, tmp_wav = tempfile.mkstemp(suffix=".wav"); os.close(fd)
     sound.export(tmp_wav, format="wav")
     return tmp_wav
 
-def tokenize_chunks(text: str, max_tokens: int = 900, overlap: int = 100):
-    """Token-based sliding window chunks to respect model limits."""
-    if not text.strip():
-        return []
+def get_audio_minutes(src_path: str) -> float:
+    audio = AudioSegment.from_file(src_path)
+    return round(len(audio) / 60000.0, 1)
+
+# ---------- Utils: summarization ----------
+def tokenize_chunks(text: str, max_tokens: int = 900, overlap: int = 120):
+    if not text.strip(): return []
     ids = _tokenizer.encode(text, add_special_tokens=False)
-    chunks = []
-    i = 0
-    n = len(ids)
-    if n == 0:
-        return []
+    if not ids: return []
+    chunks = []; i = 0; n = len(ids)
     while i < n:
         end = min(i + max_tokens, n)
         chunk_ids = ids[i:end]
         chunks.append(_tokenizer.decode(chunk_ids, skip_special_tokens=True))
-        if end == n:
-            break
+        if end == n: break
         i = end - overlap if end - overlap > i else end
     return chunks
 
 def summarize_text(text: str):
-    """2-pass summarization with token-based chunking and safe params."""
-    # 1) chunk by tokens
     chunks = tokenize_chunks(text, max_tokens=900, overlap=120)
-    if not chunks:
-        return ""
-
-    # 2) partial summaries
-    partial_summaries = []
+    if not chunks: return ""
+    partials = []
     for c in chunks:
         try:
-            out = _summarizer(
-                c,
-                max_length=160,
-                min_length=60,
-                do_sample=False
-            )[0]["summary_text"]
+            out = _summarizer(c, max_length=160, min_length=60, do_sample=False)[0]["summary_text"]
         except Exception:
-            # 폴백 모델로 재시도
             if _SUMM_MODEL_NAME != FALLBACK_SUMM:
                 load_summarizer(FALLBACK_SUMM)
                 out = _summarizer(c, max_length=160, min_length=60, do_sample=False)[0]["summary_text"]
             else:
-                out = c  # 그래도 실패하면 원문을 부분 대체
-        partial_summaries.append(out.strip())
-
-    # 3) meta summary
-    combined = "\n".join(partial_summaries)
+                out = c
+        partials.append(out.strip())
+    combined = "\n".join(partials)
     try:
-        final = _summarizer(
-            combined,
-            max_length=180,
-            min_length=70,
-            do_sample=False
-        )[0]["summary_text"]
+        final = _summarizer(combined, max_length=180, min_length=70, do_sample=False)[0]["summary_text"]
     except Exception:
-        # 최종 폴백
         if _SUMM_MODEL_NAME != FALLBACK_SUMM:
             load_summarizer(FALLBACK_SUMM)
             final = _summarizer(combined, max_length=180, min_length=70, do_sample=False)[0]["summary_text"]
         else:
-            final = combined[:1000]  # 아주 긴 경우 잘라서 반환
+            final = combined[:1000]
     return final.strip()
 
-def save_minutes_to_file(minutes_text: str) -> str:
-    fd, path = tempfile.mkstemp(suffix=".txt")
-    with os.fdopen(fd, "w", encoding="utf-8") as f:
-        f.write(minutes_text)
-    return path
-
-# --------- Core ---------
-def transcribe_and_summarize(audio_path, whisper_size, auto_detect_lang, summarizer_choice):
-    status = []
-
-    # set Whisper size (reload if changed)
+# ---------- NLP heuristics ----------
+# 기관/고객사 단서
+ORG_HINTS = ["보험", "은행", "카드", "증권", "캐피탈", "생명", "손보", "주식회사", "㈜"]
+STOPWORDS = set(["그리고","하지만","그래서","그러면","저희","우리","오늘","내일","이번","다음","함","함.", "합니다","합니다."])
+
+name_pattern = re.compile(r"([가-힣]{2,4})(님|[과차부대]장|[이팀본]장)?")
+due_patterns = [
+    r"(오늘|내일|모레|이번\s*주\s*[월화수목금토일]|다음\s*주\s*[월화수목금토일]|[0-9]{1,2}\s*월\s*[0-9]{1,2}\s*일)(\s*[오전오후]?\s*[0-9]{1,2}\s*시(\s*[0-9]{1,2}\s*분)?)?\s*(까지)?",
+    r"(금일까지|주말까지|월말까지|분기말까지)"
+]
+next_meeting_patterns = [
+    r"(다음\s*주\s*[월화수목금토일]\s*[0-9]{1,2}\s*시)",
+    r"(다음\s*미팅|재회의|후속\s*회의|follow[- ]?up)\s*(은|는)?\s*(?:[에|으로])?\s*([^\n\.]+)?"
+]
+decision_keywords = ["하기로 함", "확정", "승인", "결정", "합의"]
+action_markers = ["해주세요", "해 주세요", "부탁", "진행해", "진행하세요", "하겠습니다", "할게요", "해야 합니다", "필요합니다", "조치 바랍니다"]
+
+def normalize_datetime_kst(text: str, base_dt: datetime):
+    """자연어 날짜/시간(한국어)을 KST로 정규화"""
+    if not text: return None
+    dt = dateparser.parse(
+        text,
+        settings={
+            "TIMEZONE": "Asia/Seoul",
+            "RETURN_AS_TIMEZONE_AWARE": True,
+            "PREFER_DATES_FROM": "future",
+            "RELATIVE_BASE": base_dt.astimezone(KST)
+        },
+        languages=["ko", "en"]
+    )
+    return dt.astimezone(KST) if dt else None
+
+def extract_organizations(text: str):
+    orgs = set()
+    tokens = re.findall(r"[가-힣A-Za-z0-9][가-힣A-Za-z0-9\(\)㈜\.]*", text)
+    for t in tokens:
+        if any(h in t for h in ORG_HINTS) and len(t) <= 30:
+            orgs.add(t.strip(" ."))
+    return list(orgs)[:3]
+
+def extract_topic(text: str):
+    # 단순 키워드 후보: 2~8자, 숫자/불용어 제외, 빈도 상위
+    words = re.findall(r"[가-힣A-Za-z0-9]{2,}", text)
+    freq = {}
+    for w in words:
+        if w in STOPWORDS: continue
+        if re.match(r"^\d+$", w): continue
+        freq[w] = freq.get(w, 0) + 1
+    top = sorted(freq.items(), key=lambda x: x[1], reverse=True)[:5]
+    return " / ".join([t[0] for t in top]) if top else "회의"
+
+def build_title(date_dt: datetime, orgs, topic):
+    d = date_dt.astimezone(KST).strftime("%Y-%m-%d")
+    org = orgs[0] if orgs else "고객사"
+    top = topic if topic else "회의"
+    return f"{d} · {org} · {top}"
+
+def split_sentences(text: str):
+    # 간단 문장 분리
+    sents = re.split(r"(?<=[\.!?]|다\.)\s+|\n", text)
+    return [s.strip() for s in sents if s.strip()]
+
+def find_owner_near(sentence: str):
+    # 문장 내 이름/직함 패턴 추출
+    m = name_pattern.findall(sentence)
+    if not m: return ""
+    # 가장 처음 등장한 이름 반환
+    return m[0][0]
+
+def parse_due_in_sentence(sentence: str, base_dt: datetime):
+    for pat in due_patterns:
+        m = re.search(pat, sentence)
+        if m:
+            dt = normalize_datetime_kst(m.group(0), base_dt)
+            if dt:
+                return dt.strftime("%Y-%m-%d %H:%M")
+    return ""
+
+def extract_decisions(text: str):
+    sents = split_sentences(text)
+    results = []
+    for s in sents:
+        if any(k in s for k in decision_keywords):
+            results.append(s)
+    return results
+
+def extract_actions(text: str, base_dt: datetime):
+    sents = split_sentences(text)
+    rows = []
+    for s in sents:
+        if any(k in s for k in action_markers):
+            owner = find_owner_near(s)
+            due = parse_due_in_sentence(s, base_dt)
+            task = s
+            rows.append({"Task": task, "Owner": owner, "Due": due})
+    return rows
+
+def extract_next_meeting(text: str, base_dt: datetime):
+    sents = split_sentences(text)
+    for s in sents:
+        if any(re.search(p, s) for p in next_meeting_patterns):
+            # 날짜/시간 구간만 파싱 시도
+            dt = None
+            for pat in next_meeting_patterns:
+                m = re.search(pat, s)
+                if m:
+                    dt = normalize_datetime_kst(m.group(0), base_dt)
+                    if dt: break
+            return s, (dt.strftime("%Y-%m-%d %H:%M") if dt else "")
+    return "", ""
+
+# ---------- Core ----------
+def transcribe_and_structure(audio_path, whisper_size, auto_detect_lang, summarizer_choice):
+    # Whisper reload
     global _asr
     if whisper_size and whisper_size != DEFAULT_WHISPER_SIZE:
         try:
             _asr = WhisperModel(whisper_size, device=device, compute_type=compute_type)
         except Exception as e:
-            return "", "", "", None, f"⚠️ Whisper 모델 로드 실패: {e}"
+            return "", "", "", "", "", None, pd.DataFrame(), pd.DataFrame(), "", "", f"⚠️ Whisper 로드 실패: {e}"
 
-    # set summarizer
-    target_model = PRIMARY_SUMM if summarizer_choice == "KoBART (gogamza)" else FALLBACK_SUMM
+    # Summarizer select
+    target = PRIMARY_SUMM if summarizer_choice == "KoBART" else FALLBACK_SUMM
     try:
-        load_summarizer(target_model)
+        load_summarizer(target)
     except Exception as e:
-        status.append(f"⚠️ 요약 모델 로드 실패({target_model}): {e} → 폴백 사용")
         try:
             load_summarizer(FALLBACK_SUMM)
         except Exception as e2:
-            return "", "", "", None, f"⚠️ 요약 모델 로드 실패(폴백도 실패): {e2}"
+            return "", "", "", "", "", None, pd.DataFrame(), pd.DataFrame(), "", "", f"⚠️ 요약 모델 로드 실패: {e2}"
 
     if not audio_path:
-        return "⚠️ 오디오가 입력되지 않았습니다.", "", "", None, "⚠️ 오디오를 업로드하거나 녹음해 주세요."
+        return "⚠️ 오디오 없음", "", "", "", "", None, pd.DataFrame(), pd.DataFrame(), "", "", "⚠️ 오디오를 업로드하거나 녹음해 주세요."
+
+    # 파일 메타 시작시간(업로드 파일 수정시각으로 근사) & Duration
+    try:
+        file_epoch = os.path.getmtime(audio_path)
+        file_start = datetime.fromtimestamp(file_epoch, tz=KST)
+    except Exception:
+        file_start = datetime.now(tz=KST)
 
-    # STT
     wav_path = None
     try:
         wav_path = convert_to_wav(audio_path)
-        language = None if auto_detect_lang else "ko"
+        duration_min = get_audio_minutes(wav_path)  # 매우 높음
+        # STT
         segments, info = _asr.transcribe(
             wav_path,
-            language=language,
+            language=None if auto_detect_lang else "ko",
             vad_filter=True,
             beam_size=5
         )
-        text = "".join(seg.text for seg in segments).strip()
-        if not text:
-            return "⚠️ 인식된 텍스트가 없습니다.", "", "", None, "⚠️ 음성 인식 결과가 비어 있습니다."
+        full_text = "".join(seg.text for seg in segments).strip()
+        if not full_text:
+            return "⚠️ 인식된 텍스트 없음", "", "", "", "", duration_min, pd.DataFrame(), pd.DataFrame(), "", "", "⚠️ 음성 인식 결과가 비어 있습니다."
     except Exception as e:
-        return "", "", "", None, f"⚠️ 음성 인식 오류: {e}"
+        return "", "", "", "", "", None, pd.DataFrame(), pd.DataFrame(), "", "", f"⚠️ 음성 인식 오류: {e}"
     finally:
         if wav_path and wav_path != audio_path and os.path.exists(wav_path):
             try: os.remove(wav_path)
             except: pass
 
-    # Summarize
+    # Summary
     try:
-        summary = summarize_text(text)
+        summary = summarize_text(full_text)
     except Exception as e:
-        # 마지막 방어
         try:
             load_summarizer(FALLBACK_SUMM)
-            summary = summarize_text(text)
-            status.append("ℹ️ 요약 모델을 폴백으로 전환하여 처리했습니다.")
+            summary = summarize_text(full_text)
+            status = "✅ 완료 (요약 모델 폴백 사용)"
         except Exception as e2:
-            return text, "", "", None, f"⚠️ 요약 실패: {e2}"
+            summary = ""
+            status = f"⚠️ 요약 실패: {e2}"
+    else:
+        status = "✅ 완료"
+
+    # Date/Time (발화 중 상대/절대 시간 정규화 시도: "오늘/내일/8월 12일 3시" 등)
+    # 가장 강한 시간 표현이 있으면 그걸로, 없으면 파일 시작시간
+    time_candidates = []
+    # 간단히 시간 단서 수집: "오늘|내일|모레|이번 주|다음 주|[0-9]+월 [0-9]+일" 등
+    for pat in due_patterns + [r"[0-9]{1,2}\s*월\s*[0-9]{1,2}\s*일\s*[오전오후]?\s*[0-9]{1,2}\s*시(\s*[0-9]{1,2}\s*분)?"]:
+        for m in re.finditer(pat, full_text):
+            time_candidates.append(m.group(0))
+    dt_main = file_start
+    for cand in time_candidates:
+        dt = normalize_datetime_kst(cand, file_start)
+        if dt:
+            dt_main = dt
+            break
+
+    # Org/Topic → Title
+    orgs = extract_organizations(full_text)
+    topic = extract_topic(full_text)
+    title = build_title(dt_main, orgs, topic)
+
+    # Decisions
+    decisions = extract_decisions(full_text)
+    decisions_df = pd.DataFrame({"Decision": decisions}) if decisions else pd.DataFrame(columns=["Decision"])
+
+    # Actions(+Owner/Due)
+    actions = extract_actions(full_text, dt_main)
+    actions_df = pd.DataFrame(actions) if actions else pd.DataFrame(columns=["Task","Owner","Due"])
+
+    # Next Meeting
+    next_sent, next_dt = extract_next_meeting(full_text, dt_main)
+
+    # 회의록 본문(복사/저장)
+    minutes_md = f"""📋 회의록
+- 🗓 일시: {dt_main.strftime("%Y-%m-%d %H:%M KST")}
+- ⏱ 길이: {duration_min}분
+- 🧾 제목: {title}
+- 🏢 고객사 후보: {", ".join(orgs) if orgs else "N/A"}
 
-    now = datetime.now().strftime("%Y-%m-%d %H:%M")
-    minutes = f"""📋 회의록
-- 🕒 날짜: {now}
-- 🧠 요약:
+## 요약
 {summary}
 
-- 🗣 전체 내용:
-{text}
+## 핵심 의사결정
+{os.linesep.join(["- " + d for d in decisions]) if decisions else "- (없음)"}
+
+## 액션 아이템
+{os.linesep.join(["- " + a["Task"] + (f" · 담당: {a['Owner']}" if a.get('Owner') else "") + (f" · 마감: {a['Due']}" if a.get('Due') else "") for a in actions]) if actions else "- (없음)"}
+
+## 다음 일정
+- {next_sent if next_sent else "(미정)"}{(" · " + next_dt) if next_dt else ""}
 """
-    file_path = save_minutes_to_file(minutes)
-    ok = "✅ 완료! 결과를 확인하세요."
-    if status:
-        ok += " (" + " / ".join(status) + ")"
-    return text, summary, minutes, file_path, ok
+
+    # 다운로드 파일
+    fd, path = tempfile.mkstemp(suffix=".txt")
+    with os.fdopen(fd, "w", encoding="utf-8") as f:
+        f.write(minutes_md)
+
+    return (
+        full_text,                # 전체 텍스트
+        summary,                  # 요약
+        title,                    # 제목
+        dt_main.strftime("%Y-%m-%d %H:%M KST"),  # 일시
+        f"{duration_min}",        # 길이(분)
+        path,                     # 다운로드 파일
+        decisions_df,             # Decisions DF
+        actions_df,               # Actions DF
+        next_sent,                # 다음 일정 문장
+        next_dt,                  # 다음 일정 일시
+        status                    # 상태
+    )
 
 def clear_all():
-    return None, "", "", "", None, ""
+    return None, "", "", "", "", None, pd.DataFrame(), pd.DataFrame(), "", "", ""
+
+# ---------- Naver-like Clean UI ----------
+NAVER_GREEN = "#03C75A"
+CUSTOM_CSS = f"""
+:root {{
+  --nv-green: {NAVER_GREEN};
+  --nv-bg: #f7f8fa;
+  --nv-card: #ffffff;
+  --nv-text: #111827;
+  --nv-subtext: #6b7280;
+  --nv-border: #e5e7eb;
+}}
+body {{ background: var(--nv-bg); }}
+#nv-header {{
+  background: var(--nv-green);
+  color: #fff; padding: 14px 18px; border-bottom: 1px solid rgba(0,0,0,.06);
+}}
+#nv-wrap {{ max-width: 1100px; margin: 22px auto; padding: 0 12px; }}
+.nv-card {{
+  background: var(--nv-card); border: 1px solid var(--nv-border); border-radius: 12px;
+  box-shadow: 0 2px 10px rgba(0,0,0,0.03); padding: 16px;
+}}
+.nv-actions {{ display:flex; gap:10px; align-items:center; margin-top: 8px; }}
+.nv-btn-primary button {{
+  background: var(--nv-green) !important; border-color: var(--nv-green) !important; color: #fff !important;
+}}
+"""
 
-# --------- Clean UI ---------
-with gr.Blocks(title="회의록 자동 생성기 (Whisper)") as demo:
-    gr.Markdown("## 🎙️ 회의 음성 → 텍스트 & 요약")
-    gr.Markdown("간단하게 업로드/녹음하면 텍스트 변환과 요약을 수행합니다.")
+with gr.Blocks(title="회의록 생성기 · Naver Style", css=CUSTOM_CSS) as demo:
+    gr.HTML(f"""
+    <div id="nv-header">
+      <div style="max-width:1100px;margin:0 auto;display:flex;align-items:center;gap:10px;">
+        <div style="font-weight:800;font-size:20px;letter-spacing:-0.2px;">N</div>
+        <div style="font-weight:700;">회의록 생성기</div>
+      </div>
+    </div>
+    <div id="nv-wrap">
+    """)
 
     with gr.Row():
-        with gr.Column(scale=1, min_width=320):
-            audio_input = gr.Audio(sources=["microphone","upload"], type="filepath", label="음성 입력")
-            with gr.Row():
-                whisper_size = gr.Dropdown(
-                    ["tiny","base","small","medium","large-v3"],
-                    value=DEFAULT_WHISPER_SIZE, label="Whisper 모델"
-                )
-                auto_detect = gr.Checkbox(value=False, label="언어 자동감지(다국어)")
-            summarizer_choice = gr.Radio(
-                choices=["KoBART (gogamza)", "Korean T5 (fallback)"],
-                value="KoBART (gogamza)", label="요약 모델"
-            )
-            with gr.Row():
-                run_btn = gr.Button("생성", variant="primary")
+        with gr.Column(scale=1, min_width=380):
+            gr.HTML('<div class="nv-card"><h3 style="margin:6px 0">입력</h3>')
+            audio_input = gr.Audio(sources=["microphone","upload"], type="filepath", label="음성 업로드 · 녹음")
+            with gr.Row(elem_classes=["nv-actions"]):
+                whisper_size = gr.Dropdown(["tiny","base","small","medium","large-v3"],
+                                           value=DEFAULT_WHISPER_SIZE, label="Whisper 모델")
+                summarizer_choice = gr.Radio(choices=["KoBART","Korean T5 (fallback)"],
+                                             value="KoBART", label="요약 모델")
+            auto_detect = gr.Checkbox(value=False, label="언어 자동 감지(다국어)")
+            with gr.Row(elem_classes=["nv-actions"]):
+                run_btn = gr.Button("생성", elem_classes=["nv-btn-primary"])
                 clear_btn = gr.Button("초기화")
-
             status_md = gr.Markdown()
-
-        with gr.Column(scale=2, min_width=420):
-            with gr.Tab("전체 텍스트"):
-                text_out = gr.Textbox(lines=10, show_label=False)
-            with gr.Tab("요약"):
-                sum_out = gr.Textbox(lines=10, show_label=False)
-            with gr.Tab("회의록(.txt 다운로드)"):
-                minutes_out = gr.Textbox(lines=16, show_label=False)
-                dl_file = gr.File(label="다운로드", interactive=False)
+            gr.HTML("</div>")
+
+        with gr.Column(scale=2, min_width=520):
+            gr.HTML('<div class="nv-card"><h3 style="margin:6px 0">결과</h3>')
+            with gr.Tabs():
+                with gr.Tab("요약/본론"):
+                    sum_out = gr.Textbox(lines=10, label="요약")
+                    text_out = gr.Textbox(lines=12, label="전체 텍스트")
+                with gr.Tab("결정 · 액션"):
+                    decisions_df = gr.Dataframe(headers=["Decision"], datatype=["str"], label="핵심 의사결정", wrap=True)
+                    actions_df = gr.Dataframe(headers=["Task","Owner","Due"], datatype=["str","str","str"], label="액션 아이템", wrap=True)
+                with gr.Tab("메타 · 다운로드"):
+                    title_out = gr.Textbox(label="제목 (YYYY-MM-DD · 고객사 · 주제)", interactive=False)
+                    dt_out = gr.Textbox(label="회의 일시(KST)", interactive=False)
+                    dur_out = gr.Textbox(label="길이(분)", interactive=False)
+                    next_sent_out = gr.Textbox(label="다음 일정 문장", interactive=False)
+                    next_dt_out = gr.Textbox(label="다음 일정 일시", interactive=False)
+                    dl_file = gr.File(label="회의록 다운로드(.txt)", interactive=False)
+            gr.HTML("</div>")
+
+    gr.HTML("</div>")  # close wrap
 
     run_btn.click(
-        fn=transcribe_and_summarize,
+        fn=transcribe_and_structure,
         inputs=[audio_input, whisper_size, auto_detect, summarizer_choice],
-        outputs=[text_out, sum_out, minutes_out, dl_file, status_md]
+        outputs=[text_out, sum_out, title_out, dt_out, dur_out, dl_file, decisions_df, actions_df, next_sent_out, next_dt_out, status_md]
     )
     clear_btn.click(
-        fn=clear_all,
-        inputs=None,
-        outputs=[audio_input, text_out, sum_out, minutes_out, dl_file, status_md]
+        fn=clear_all, inputs=None,
+        outputs=[audio_input, text_out, sum_out, title_out, dt_out, dur_out, dl_file, decisions_df, actions_df, next_sent_out, next_dt_out, status_md]
     )
 
 demo.launch()
@@ -292,3 +470,4 @@ demo.launch()
 
 
 
+