msg_lower = message.lower()
    files_needed = set()
    for rule in MEMORY_RULES.values():
        if any(kw in msg_lower for kw in rule["keywords"]):
            files_needed.update(rule["files"])
    return list(files_needed)

def build_system_prompt(memory_files: list[str]) -> str:
    """필요한 파일만 시스템 프롬프트에 포함"""
    parts = []
    if CLAUDE_MD.exists():
        parts.append(CLAUDE_MD.read_text().strip())
    # 자동 메모라이징 로그 항상 포함 (최근 3,000자 제한)
    conv_log = MEMORY_DIR / "conversation_log.md"
    if conv_log.exists():
        content = conv_log.read_text().strip()
        if content:
            parts.append("[대화 요약 기록]\n" + content[-3000:])
    for fname in memory_files:
        fpath = MEMORY_DIR / fname
        if fpath.exists():
            parts.append(fpath.read_text().strip())
    return "\n\n---\n\n".join(parts) if parts else ""

# ── 히스토리 관리 ──────────────────────────────────────
def load_history() -> list:
    if HISTORY_FILE.exists():
        return json.loads(HISTORY_FILE.read_text())
    return []

def auto_memorize(dropped: list):
    """히스토리 초과 대화를 Haiku로 요약 → memory/conversation_log.md에 저장.
    memory_updater.call_haiku_summarizer 를 재사용해 Haiku 호출 중복 제거.
    """
    if not dropped:
        return
    conv_text = "\n".join([
        f"{'나' if t['role']=='user' else '비서'}: {t['content'][:300]}"
        for t in dropped
    ])
    prompt = (
        f"아래 대화에서 향후 대화에 유용한 핵심 사실, 결정, 선호도만 추출해서 "
        f"bullet 5줄 이내 한국어로만 답해. 불필요한 설명 없이.\n\n{conv_text}"
    )
    try:
        from memory_updater import call_haiku_summarizer
        summary, reason = call_haiku_summarizer(
            prompt, script="bot_auto_memorize", timeout=60,
        )
    except Exception as e:
        log.warning(f"auto_memorize 호출 오류: {e}")
        return
    if not summary:
        log.warning(f"auto_memorize 요약 비어있음 (reason={reason})")
        return

    mem_file = MEMORY_DIR / "conversation_log.md"
    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M")
    if not mem_file.exists():
        mem_file.write_text(
            "---\nname: 대화 자동 메모\n"

        "files": PROJECT_CODES["notion"],
    },
    "tasks": {
        # fast-path 미매칭 자유형 요청("완료된 것만 지워" 등)이 LLM으로 갈 때
        # 할일=Notion 태스크임을 알리는 라우팅 (2026-08-07 '할일 없음' 오답 재발 방지)
        "keywords": ["할일", "할 일", "태스크", "task", "투두", "todo", "지연", "리마인더", "마감"],
        "files": ["reference_notion_tasks.md"],
    },
    "calendar": {
        "keywords": ["캘린더", "calendar", "일정", "구글캘린더", "schedule", "미팅", "약속", "회의",
                     "점심", "저녁", "식사"],
        "files": PROJECT_CODES["calendar"],
    },
    "github": {
        "keywords": ["github", "깃허브", "git", "레포", "repo", "commit", "push"],
        "files": PROJECT_CODES["github"],
    },
    "news": {
        "keywords": ["뉴스", "news", "속보", "breaking", "rss", "briefing", "브리핑", "경제뉴스"],
        "files": PROJECT_CODES["news"],
    },
    "gmail": {
        "keywords": ["메일", "mail", "이메일", "email", "gmail", "분류", "수신함"],
        "files": PROJECT_CODES["gmail"],
    },

        tasks_url = f"https://notion.so/{TASKS_DB.replace('-','')}" if TASK_ENABLED else ""
        await update.message.reply_text(
            f"📊 <b>태스크 대시보드</b>\n\n<a href='{tasks_url}'>Notion에서 열기</a>",
            parse_mode="HTML")

    else:  # list (기본)
        tasks = ntask.list_tasks()
        await update.message.reply_text(
            ntask.format_task_list(tasks),
            parse_mode="HTML")


@auth_required
async def handle_task_callback(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
    """태스크 등록 확인/취소 콜백."""
    query = update.callback_query
    await query.answer()
    action = query.data

    if action == "task_confirm":
        pending = ctx.user_data.pop("pending_task", None)
        if not pending:
            await query.message.edit_text("⚠️ 등록 데이터 없음 (만료)")
            return
        tid = ntask.add_task(
            pending["title"],
            due=pending.get("due"),
            priority=pending.get("priority", "🟡보통"),
            assignee=pending.get("assignee", ""),
            tags=pending.get("tags"),
            project_id=pending.get("project_id"),
            remind_at=pending.get("remind_at"),
            recurrence=pending.get("recurrence"),
        )
        if tid:
            # 즉시 알림 (remind_offset 있는 경우 JobQueue 등록)
            if pending.get("remind_at"):
                try:
                    remind_dt = datetime.fromisoformat(pending["remind_at"])
                    delay = (remind_dt - datetime.now(ZoneInfo("Asia/Seoul"))).total_seconds()
                    if delay > 0:
                        async def _remind_job(context):
                            await context.bot.send_message(
                                chat_id=ALLOWED_CHAT_ID,
                                text=f"🔔 <b>리마인더:</b> {pending['title']}",
                                parse_mode="HTML")
                        ctx.application.job_queue.run_once(_remind_job, when=delay)
                except (ValueError, TypeError):
                    pass
            await query.message.edit_text(f"✅ 등록 완료: {pending['title']}")
        else:
            await query.message.edit_text("❌ 등록 실패 (Notion API 오류)")

    elif action == "task_cancel":
        ctx.user_data.pop("pending_task", None)
        await query.message.edit_text("❌ 취소됨")

"""RC Secretary 공통 알림 모듈

ntfy.sh 및 텔레그램을 통한 알림 발송 유틸리티.
모든 스크립트에서 공유하여 사용.

사용 예시:
    from secretary.notifier import send_ntfy, send_telegram

    send_ntfy("작업 완료", tags="white_check_mark")
    send_telegram("보고 내용", parse_mode="HTML")
"""
import os
import requests

NTFY_CHANNEL = "RCMySecretary-raccoon-work-done"
NTFY_URL = f"https://ntfy.sh/{NTFY_CHANNEL}"


def _header_safe(title: str) -> str:
    """HTTP 헤더는 latin-1 한정 — 한글 등 비ASCII 제목은 RFC 2047 인코딩 (ntfy 지원).
    2026-08-07: 한글 Title로 발송 자체가 UnicodeEncodeError로 실패하던 결함 수정."""
    try:
        title.encode("latin-1")
        return title
    except UnicodeEncodeError:
        import base64
        return "=?UTF-8?B?" + base64.b64encode(title.encode()).decode() + "?="


def send_ntfy(message, *, priority=None, tags=None, title=None, click=None):
    """ntfy.sh로 알림 발송.

    Args:
        message: 알림 본문 텍스트.
        priority: ntfy 우선순위 ("urgent", "high", "default", "low", "min").
        tags: ntfy 태그/이모지 (예: "white_check_mark", "warning").
        title: 알림 제목 헤더.
        click: 알림 클릭 시 열릴 URL.

    Returns:
        bool: 발송 성공 여부.
    """
    headers = {}
    if priority:
        headers["Priority"] = priority
    if tags:
        headers["Tags"] = tags
    if title:
        headers["Title"] = _header_safe(title)
    if click:
        headers["Click"] = click
    try:
        r = requests.post(NTFY_URL, data=message.encode("utf-8"), headers=headers, timeout=10)
        return r.ok
    except Exception as e:
        print(f"[notifier] ntfy 발송 실패: {e}")
        return False


def send_ntfy_document(file_path, *, title=None, tags=None, priority=None,
                       filename=None, timeout=120):
    """ntfy.sh로 파일 첨부 발송 (PUT).

    Args:
        file_path: 첨부할 파일 경로.
        title: 알림 제목 헤더.
        tags: ntfy 태그/이모지 (예: "white_check_mark").
        priority: ntfy 우선순위.
        filename: 첨부 파일명. 미지정 시 경로의 파일명 사용.
        timeout: 업로드 타임아웃(초). 대용량 대비 기본 120.

    Returns:
        bool: 발송 성공 여부.
    """
    from pathlib import Path
    p = Path(file_path)
    headers = {"Filename": filename or p.name}
    if title:
        headers["Title"] = _header_safe(title)
    if tags:
        headers["Tags"] = tags
    if priority:
        headers["Priority"] = priority
    try:
        with open(p, "rb") as fh:
            r = requests.put(NTFY_URL, data=fh, headers=headers, timeout=timeout)
        return r.ok
    except Exception as e:
        print(f"[notifier] ntfy 첨부 발송 실패: {e}")
        return False


def send_telegram(message, *, bot_token=None, chat_id=None, parse_mode="HTML",
                  chunk=False, html_fallback=False, disable_web_page_preview=False,
                  reply_markup=None):
    """텔레그램 메시지 발송. 기본값은 비서봇.

    Args:
        message: 발송할 텍스트 메시지.
        bot_token: 봇 토큰. 미지정 시 TELEGRAM_BOT_TOKEN 환경변수 사용.
        chat_id: 채팅 ID. 미지정 시 TELEGRAM_ALLOWED_CHAT_ID 환경변수 사용.
        parse_mode: 메시지 파싱 모드 ("HTML" 또는 "Markdown").
        chunk: True일 때 4000자 한도로 줄 단위 분할 발송 (HTML 태그 잘림 방지).
        html_fallback: HTML 파싱 오류 시 태그 제거 후 plain text 재시도.
        disable_web_page_preview: True일 때 링크 미리보기 비활성화.

    Returns:
        bool: 모든 청크 발송 성공 시 True.
    """
    token = bot_token or os.environ.get("TELEGRAM_BOT_TOKEN", "")
    cid = chat_id or os.environ.get("TELEGRAM_ALLOWED_CHAT_ID", "")
    if not token or not cid:
        print("[notifier] 텔레그램 토큰/채팅ID 없음")
        return False

    if chunk and len(message) > 4000:
        chunks, buf = [], ""
        for line in message.split("\n"):
            if len(buf) + len(line) + 1 > 4000:
                chunks.append(buf.rstrip())
                buf = line + "\n"
            else:
                buf += line + "\n"
        if buf.strip():
            chunks.append(buf.rstrip())
    else:
        chunks = [message]

    ok_all = True
    for piece in chunks:
        if not _send_one(token, cid, piece, parse_mode, html_fallback,
                         disable_web_page_preview, reply_markup):
            ok_all = False
    return ok_all


def _send_one(token, cid, text, parse_mode, html_fallback,
              disable_web_page_preview, reply_markup):
    payload = {"chat_id": cid, "text": text}
    if parse_mode:
        payload["parse_mode"] = parse_mode
    if disable_web_page_preview:
        payload["disable_web_page_preview"] = True
    if reply_markup is not None:
        payload["reply_markup"] = reply_markup
    try:
        r = requests.post(
            f"https://api.telegram.org/bot{token}/sendMessage",
            json=payload, timeout=15,
        )
        data = r.json()
        if data.get("ok"):
            return True
        print(f"[notifier] 텔레그램 발송 실패: {data.get('description', r.text[:100])}")
        if html_fallback and parse_mode:
            import re as _re
            r2 = requests.post(
                f"https://api.telegram.org/bot{token}/sendMessage",
                json={"chat_id": cid, "text": _re.sub(r"<[^>]+>", "", text)},
                timeout=15,
            )
            return r2.json().get("ok", False)
        return False
    except Exception as e:
        print(f"[notifier] 텔레그램 발송 실패: {e}")
        return False


def send_telegram_document(file_path, *, bot_token=None, chat_id=None, caption=None):
    """텔레그램 파일 발송.

    Args:
        file_path: 발송할 파일 경로.
        bot_token: 봇 토큰. 미지정 시 TELEGRAM_BOT_TOKEN 환경변수 사용.
        chat_id: 채팅 ID. 미지정 시 TELEGRAM_ALLOWED_CHAT_ID 환경변수 사용.
        caption: 파일에 첨부할 캡션 텍스트.

    Returns:
        bool: 발송 성공 여부.
    """
    token = bot_token or os.environ.get("TELEGRAM_BOT_TOKEN", "")
    cid = chat_id or os.environ.get("TELEGRAM_ALLOWED_CHAT_ID", "")
    if not token or not cid:
        return False
    try:
        with open(file_path, "rb") as f:
            data = {"chat_id": cid}
            if caption:
                data["caption"] = caption
            r = requests.post(
                f"https://api.telegram.org/bot{token}/sendDocument",
                data=data, files={"document": f}, timeout=30,
            )
        return r.json().get("ok", False)
    except Exception as e:
        print(f"[notifier] 텔레그램 파일 발송 실패: {e}")
        return False

"""RC Secretary 공통 Google OAuth 모듈

Google API(Gmail, Calendar 등) 호출에 필요한 access token 발급 유틸리티.
refresh_token을 이용해 access_token을 갱신하며, 실패 시 1회 재시도.

사용 예시:
    from secretary.google_auth import get_access_token

    token = get_access_token(os.environ["GOOGLE_REFRESH_TOKEN"])
    headers = {"Authorization": f"Bearer {token}"}

환경변수:
    GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET 필수.
    refresh_token은 호출 시 명시적으로 전달.
"""
import os
import time
import requests


def get_access_token(refresh_token=None):
    """Google OAuth2 access token 발급. 실패 시 1회 재시도.

    Args:
        refresh_token: Google refresh token. 명시적 전달 권장.
                       미지정 시 GOOGLE_REFRESH_TOKEN 환경변수 폴백.

    Returns:
        str: 유효한 access token.

    Raises:
        RuntimeError: 환경변수 누락, 토큰 갱신 실패, 네트워크 오류 시.
    """
    token = refresh_token or os.environ.get("GOOGLE_REFRESH_TOKEN", "")
    client_id = os.environ.get("GOOGLE_CLIENT_ID", "")
    client_secret = os.environ.get("GOOGLE_CLIENT_SECRET", "")

    if not all([token, client_id, client_secret]):
        raise RuntimeError("Google OAuth 환경변수 누락 (CLIENT_ID, CLIENT_SECRET, REFRESH_TOKEN)")

    for attempt in range(2):
        try:
            r = requests.post(
                "https://oauth2.googleapis.com/token",
                data={
                    "client_id": client_id,
                    "client_secret": client_secret,
                    "refresh_token": token,
                    "grant_type": "refresh_token",
                },
                timeout=15,
            )
            data = r.json()

            if "error" in data:
                error_msg = f"{data['error']}: {data.get('error_description', '')}"
                # invalid_grant는 재시도해도 무의미 — 즉시 실패
                if data.get("error") == "invalid_grant":
                    raise RuntimeError(f"Google 토큰 갱신 실패: {error_msg}")
                if attempt == 0:
                    print(f"[google_auth] 토큰 갱신 실패 (재시도): {error_msg}")
                    time.sleep(5)
                    continue
                raise RuntimeError(f"Google 토큰 갱신 실패: {error_msg}")

            if "access_token" not in data:
                if attempt == 0:
                    time.sleep(5)
                    continue
                raise RuntimeError(f"Google 응답에 access_token 없음: {data}")

            return data["access_token"]
        except requests.RequestException as e:
            if attempt == 0:
                print(f"[google_auth] 네트워크 오류 (재시도): {e}")
                time.sleep(5)
                continue
            raise RuntimeError(f"Google 토큰 요청 실패: {e}")

    raise RuntimeError("Google 토큰 갱신: 최대 재시도 초과")

"""중앙 JSON 상태 관리 모듈.

모든 JSON state 파일의 읽기/쓰기를 표준화.
- 원자적 쓰기 (임시 파일 + rename)로 crash-safe
- 일관된 에러 핸들링 + 기본값 폴백
"""
import json
from pathlib import Path


def load_json(path, default=None):
    """JSON 파일 로드. 파일 없음/파싱 실패 시 default 반환."""
    p = Path(path)
    if not p.exists():
        return default if default is not None else {}
    try:
        return json.loads(p.read_text())
    except (json.JSONDecodeError, OSError):
        return default if default is not None else {}


def save_json(path, data, *, indent=2, compact=False):
    """JSON 파일 원자적 저장. 디렉토리 자동 생성.

    원자적 쓰기: 같은 디렉토리의 .tmp 파일에 쓴 후 os.replace (POSIX atomic).
    """
    p = Path(path)
    p.parent.mkdir(parents=True, exist_ok=True)
    kw = {"ensure_ascii": False}
    if not compact:
        kw["indent"] = indent
    content = json.dumps(data, **kw)
    tmp = p.with_suffix(".tmp")
    try:
        tmp.write_text(content)
        tmp.replace(p)
    except BaseException:
        tmp.unlink(missing_ok=True)
        raise

"""중앙 RSS 유틸리티 모듈.

RSS 피드 가져오기, HTML 정제, 날짜 파싱 공통 기능.
"""
import re
from datetime import datetime, timezone
from html import unescape
from email.utils import parsedate_to_datetime

import requests

# 매일경제(mk.co.kr)는 Cloudflare가 축약형 UA를 봇으로 판정해 403 challenge HTML을 반환한다.
BROWSER_UA = ("Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 "
              "(KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36")

# 한국경제(hankyung.com)는 브라우저 UA로도 Cloudflare JS challenge(403) — TLS 지문 차단.
# 피드리더 계열 UA는 verified-bot 허용목록으로 통과 (2026-08-07 확인).
# 피드 수집기가 피드리더로 자기소개하는 것이므로 용도에 부합 (검색엔진 봇 위장은 배제).
FEEDREADER_UA = "Feedly/1.0 (+http://www.feedly.com/fetcher.html; like FeedFetcher-Google)"

_UA_OVERRIDES = {"hankyung.com": FEEDREADER_UA}


def ua_for(url: str) -> str:
    """도메인별 UA 선택 — 기본 BROWSER_UA, 차단 우회가 확인된 도메인만 오버라이드."""
    for dom, ua in _UA_OVERRIDES.items():
        if dom in url:
            return ua
    return BROWSER_UA


def strip_html(text: str) -> str:
    """HTML 태그 제거 + 엔티티 디코딩."""
    return unescape(re.sub(r"<[^>]+>", "", text or "")).strip()


def parse_pubdate(s: str):
    """RFC-2822 또는 ISO-8601 날짜 문자열 파싱. 실패 시 None."""
    if not s:
        return None
    s = s.strip()
    try:
        dt = parsedate_to_datetime(s)
        return dt.replace(tzinfo=timezone.utc) if dt.tzinfo is None else dt
    except Exception:
        pass
    try:
        dt = datetime.fromisoformat(s.replace("Z", "+00:00"))
        return dt.replace(tzinfo=timezone.utc) if dt.tzinfo is None else dt
    except Exception:
        return None


def fetch_rss(url: str, *, timeout: int = 10, recover: bool = False):
    """RSS 피드 가져와서 XML root 반환. 실패 시 None.

    recover=True: lxml recovery parser 사용 (malformed XML 허용).
    recover=False: 표준 ElementTree 사용.
    """
    try:
        r = requests.get(url, headers={"User-Agent": ua_for(url)}, timeout=timeout)
        r.raise_for_status()
        if recover:
            from lxml import etree
            parser = etree.XMLParser(recover=True)
            return etree.fromstring(r.content, parser)
        else:
            import xml.etree.ElementTree as ET
            return ET.fromstring(r.content)
    except Exception:
        return None

def classify_message(text: str) -> str:
    """
    메시지를 분류:
    - "destructive": 원격 실행 불가 (차단)
    - "needs_approval": ntfy 승인 후 실행
    - "safe": 바로 실행
    """
    for pat in _destructive_re:
        if pat.search(text):
            return "destructive"
    for pat in _approval_re:
        if pat.search(text):
            return "needs_approval"
    return "safe"


async def request_ntfy_approval(action: str, timeout: int = 300) -> bool:
    """
    ntfy 1회용 UUID 채널로 승인 요청.
    승인 시 True, 거부/타임아웃 시 False.
    replay 방지: UUID 채널 + nonce.
    blocking I/O는 run_in_executor로 이벤트 루프 보호.
    """
    channel = f"rc-approve-{uuid4().hex[:12]}"
    nonce = uuid4().hex[:8]
    loop = asyncio.get_running_loop()

    # 승인 요청 발송 (non-blocking)
    def _send():
        requests.post(f"https://ntfy.sh/{NTFY_CHANNEL}", headers={
            "Title": "Work Approval Request",
            "Tags": "lock",
            "Actions": (
                f"http, Approve, https://ntfy.sh/{channel}, body=allow-{nonce}; "
                f"http, Deny, https://ntfy.sh/{channel}, body=deny-{nonce}"
            ),
        }, data=action.encode("utf-8"), timeout=10)
    try:
        await loop.run_in_executor(None, _send)
    except Exception as e:
        log.error(f"ntfy 승인 요청 발송 실패: {e}")
        return False

    # 응답 폴링 (non-blocking)
    def _poll_once():
        r = requests.get(
            f"https://ntfy.sh/{channel}/json?since=10s&poll=1",
            timeout=15
        )
        for line in r.text.strip().split("\n"):
            if not line:
                continue
            try:
                msg = json.loads(line)
            except json.JSONDecodeError:
                continue
            body = msg.get("message", "")
            if f"allow-{nonce}" in body:
                return "approved"
            if f"deny-{nonce}" in body:
                return "denied"
        return None

    deadline = time.time() + timeout
    while time.time() < deadline:
        try:
            result = await loop.run_in_executor(None, _poll_once)
            if result == "approved":
                return True
            if result == "denied":
                return False
        except Exception as e:
            log.warning(f"ntfy 폴링 오류: {e}")
        await asyncio.sleep(3)

    return False  # 타임아웃 = 거부

    print(f"[ntfy watcher] 카드 응답 기록: {month_key} → {decision}", flush=True)
    send_to_secretary(f"🪪 카드 응답 접수: {decision}\n다음 cron(09:00)에서 처리됩니다.")


def handle_design_feedback(msg: str):
    """편집자 모드 피드백 → design_feedback/<ts>.json 저장 + apply_feedback 자동 트리거."""
    import subprocess
    DESIGN_FB_DIR.mkdir(parents=True, exist_ok=True)
    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
    try:
        payload = json.loads(msg)
    except Exception:
        payload = {"raw": msg}
    fpath = DESIGN_FB_DIR / f"{ts}.json"
    fpath.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
    n = len(payload.get("items", []))
    print(f"[ntfy watcher] 디자인 피드백 {n}건 저장: {fpath.name}", flush=True)
    send_to_secretary(f"🎨 디자인 피드백 {n}건 수신 ({payload.get('page', '')}) → 자동 반영 시도")
    try:
        subprocess.Popen(
            ["/opt/homebrew/bin/python3",
             str(Path(__file__).parent.parent / "archive_site" / "apply_feedback.py"), str(fpath)],
            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
    except Exception as e:
        print(f"[ntfy watcher] apply 트리거 실패: {e}", flush=True)


def watch() -> bool:
    topics = NTFY_CHANNEL + (("," + DESIGN_TOPIC) if DESIGN_TOPIC else "")
    url = f"https://ntfy.sh/{topics}/json"
    try:
        with requests.get(url, stream=True, timeout=(10, 70)) as r:
            for line in r.iter_lines():
                if not line:
                    continue
                try:
                    data = json.loads(line)
                    if data.get("event") != "message":
                        continue

                    msg        = data.get("message", "").strip()
                    title      = data.get("title", "").strip()
                    attachment = data.get("attachment", {})

                    if not msg and not attachment:
                        continue

                    # ── 편집자 모드 디자인 피드백 (해당 토픽만, 봇 포워딩 X) ──
                    if DESIGN_TOPIC and data.get("topic") == DESIGN_TOPIC:
                        if msg:
                            handle_design_feedback(msg)

def route_card_file(src: Path) -> bool:
    """카드 파일 라우팅: archive에 보관 + staging에 사본 + 4사 완비 시 dispatcher 트리거.
    반환: 카드 파일로 처리되었는지 여부."""
    card = detect_card(src.name)
    if not card or not src.suffix.lower().startswith(".xls"):
        return False

    yyyymm = extract_yyyymm(src.name)
    try:
        # 1. archive 보관 (원본 무결성)
        arch_dir = CARD_ARCHIVE / card
        arch_dir.mkdir(parents=True, exist_ok=True)
        arch_path = arch_dir / f"{yyyymm}{src.suffix}"
        # 같은 이름이 있으면 덮어쓰기 (가장 최근 본 = 최신)
        src.replace(arch_path)

        # 2. staging에 사본 (분석용)
        CARD_STAGING.mkdir(parents=True, exist_ok=True)
        staging_path = CARD_STAGING / f"{card}_{yyyymm}{src.suffix}"
        staging_path.write_bytes(arch_path.read_bytes())
    except Exception as e:
        print(f"[card_route] 라우팅 실패 {src.name}: {e}", file=sys.stderr)
        send_ntfy(f"❌ 카드 파일 라우팅 실패: {src.name} — {e}",
                  tags="warning", priority="high")
        return True  # 카드로 인식했으나 실패 — 일반 처리 스킵

    # 3. 현재 staging 상태 → 4사 완비 체크
    present = set()
    for f in CARD_STAGING.iterdir():
        if f.is_file():
            c = detect_card(f.name)
            if c:
                present.add(c)

    n = len(present)
    send_ntfy(f"🪪 {card} {yyyymm} 수령 ({n}/4)", tags="credit_card")

    # 4. 4사 완비 → run_pipeline 즉시 트리거 (백그라운드)
    if n >= len(REQUIRED_CARDS):
        subprocess.Popen(
            ["/opt/homebrew/bin/python3.13", str(CARD_RUNNER)],
            cwd=str(CARD_OPT_DIR.parent),
            stdout=subprocess.DEVNULL,
            stderr=subprocess.DEVNULL,
        )
        send_ntfy("⚡ 4사 완비 — 카드 분석 즉시 트리거", tags="zap")

    return True

        return f"🌤 <b>서울 날씨</b>  데이터 없음 ({e})"


def collect_market_data(is_monday: bool) -> dict:
    range_ = "15d" if is_monday else "10d"
    # 국내 지수: 네이버 금융 (Yahoo Finance는 하루 지연)
    data = {}
    for name, code in [("KOSPI", "KOSPI"), ("KOSDAQ", "KOSDAQ")]:
        try:
            data[name] = get_naver_index(code, is_monday)
        except Exception as e:
            print(f"[morning_briefing] 네이버 지수 실패 {name}: {e}", file=sys.stderr)
            data[name] = None

    # 해외 지수 / 원자재 / 환율: Yahoo Finance
    yahoo_specs = {
        "나스닥":   ("^IXIC",    "pt"),
        "S&P500":   ("^GSPC",    "pt"),
        "다우존스": ("^DJI",     "pt"),
        "금":       ("GC=F",     "$/oz"),
        "구리":     ("HG=F",     "$/lb"),
        "WTI":      ("CL=F",     "$/bbl"),
        "USD/KRW":  ("USDKRW=X", "원"),
        "JPY/KRW":  ("JPYKRW=X", "원/100엔"),
        "CNY/KRW":  ("CNYKRW=X", "원"),
    }
    for name, (sym, unit) in yahoo_specs.items():
        try:
            pairs = get_yahoo(sym, range_)
            if not pairs:
                data[name] = None
                continue
            val, pct, date = pct_change(pairs, is_monday)
            data[name] = {"val": val, "pct": pct, "unit": unit, "date": date}
        except Exception as e:
            print(f"[morning_briefing] Yahoo 실패 {name}: {e}", file=sys.stderr)
            data[name] = None
    return data


def fmt_row(name: str, info: dict) -> str:
    if info is None:
        return f"  {name}: 데이터 없음"
    val, pct, unit = info["val"], info["pct"], info["unit"]
    if unit == "pt":
        return f"  {name}: {val:,.2f}  {arrow(pct)}"
    elif unit in ("원", "원/100엔"):
        return f"  {name}: {val:,.2f}{unit}  {arrow(pct)}"
    else:
        return f"  {name}: ${val:.2f} {unit}  {arrow(pct)}"


def market_sections(data: dict, is_monday: bool) -> tuple:
    label = "주간 변동" if is_monday else "전일 대비"
    idx = [f"📈 <b>지수</b> ({label})", "  <i>국내</i>",
           fmt_row("KOSPI", data.get("KOSPI")), fmt_row("KOSDAQ", data.get("KOSDAQ")),
           "  <i>미국</i>",
           fmt_row("나스닥", data.get("나스닥")), fmt_row("S&P500", data.get("S&P500")),
           fmt_row("다우존스", data.get("다우존스"))]
    comm = [f"🛢 <b>원자재</b> ({label})",
            fmt_row("금", data.get("금")), fmt_row("구리", data.get("구리")),
            fmt_row("WTI", data.get("WTI"))]
    fx   = [f"💱 <b>환율</b> ({label})",
            fmt_row("USD/KRW", data.get("USD/KRW")), fmt_row("JPY/KRW", data.get("JPY/KRW")),
            fmt_row("CNY/KRW", data.get("CNY/KRW"))]
    return "\n".join(idx), "\n".join(comm), "\n".join(fx)


def market_analysis(data: dict, is_monday: bool) -> str:
    """Haiku 호출: 지수/원자재/환율 변동 원인 분석"""
    mode = "주간" if is_monday else "전일 대비"
    # LLM 입력은 표시 포맷과 분리해 부호를 직접 명시 — arrow() 표기가 바뀌어도
    # 방향 오인이 재발하지 않도록 원시 수치 기반 (2026-08-07)
    rows = "\n".join(
        f"{n}: {i['val']:.2f} {i['unit']}  {i['pct']:+.2f}%"
        for n, i in data.items() if i
    )
    prompt = f"""당신은 Special Situation Fund 매니저의 비서입니다.
아래 {mode} 시장 데이터를 보고 각 섹션별 변동 원인과 시사점을 bullet 2줄로 작성하세요.
이모지 없이, 한국어로. 반드시 아래 태그 형식 엄수.

{rows}

[지수분석]
미국/국내 지수 등락 주요 요인, 주목 섹터/이벤트.

[원자재분석]
원자재 가격 변동 요인 및 시사점.

[환율분석]
환율 흐름 및 국내 투자 영향 (USD/KRW 중심)."""

    try:
        # LLM 호출 단일 경계 (token_ledger·haiku_monitor·MCP차단·cwd=/tmp·모델별칭 자동)
        text = call_haiku_tracked(
            prompt,
            system="You are a financial market analyst. Respond only in Korean, no explanations outside the requested format.",
            label="morning_briefing_market", timeout=90)
        if text.startswith("[ERROR]"):
            print(f"[market_analysis] {text[:200]}", file=sys.stderr)

        return strip_html(m.group(1)) if m else ""
    except Exception as e:
        print(f"[morning_news] OG 설명 실패 {url[:60]}: {e}", file=sys.stderr)
        return ""


def get_rss(url: str, max_items: int = 4, fetch_og: bool = False):
    """(title, desc, link) 튜플 리스트 반환. 수집 실패 시 None ('기사 없음' []와 구분).
    후보 기사(최대 max_items×4개)를 수집한 뒤 거시경제·금융 관련성 점수 상위 max_items개 반환.
    동점 시 RSS 원래 순서 유지.
    """
    cutoff = datetime.now(timezone.utc) - timedelta(hours=24)
    try:
        r = requests.get(url, headers={"User-Agent": ua_for(url)}, timeout=10)
        r.raise_for_status()
        root = ET.fromstring(r.content)
        candidates = []  # (score, original_order, title, desc, link)
        seen_titles = set()
        for item in root.iter("item"):
            title = strip_html(item.findtext("title", ""))
            if not title or is_blacklisted(title):
                continue
            # 제목 중복 제거
            if title in seen_titles:
                continue
            seen_titles.add(title)

            # 일본어 기사 제외
            if has_japanese(title):
                continue
            # 연예·엔터테인먼트 기사 제외
            if ENTERTAINMENT_RE.search(title):
                continue

            link = item.findtext("link", "").strip()
            # 비경제 섹션 URL 제외 (스포츠·연예·문화·일본판)
            if EXCLUDE_URL_RE.search(link):
                continue

            # 날짜 필터: 24시간 이내 기사만 (pubDate 없는 기사는 통과)
            pub_s = item.findtext("pubDate", "").strip()
            pub = parse_pubdate(pub_s) if pub_s else None
            if pub and pub < cutoff:
                continue

            raw_desc = strip_html(item.findtext("description", ""))
            if fetch_og and len(raw_desc) < 30 and link:
                raw_desc = get_og_description(link)
            # 조선비즈 방송 리뷰 기사 disclaimer 감지 (정제 전 원문 기준)
            if BROADCAST_REVIEW_RE.search(raw_desc):
                continue
            desc = clean_desc(raw_desc, title)

            score = macro_score(title, desc)
            candidates.append((score, len(candidates), title, desc[:300], link))

            # 충분한 후보 확보 시 중단
            if len(candidates) >= max_items * 4:
                break

        for line in out.strip().splitlines():
            m = re.match(r'(\d+)\.\s*(.+)', line.strip())
            if m:
                idx = int(m.group(1)) - 1
                if 0 <= idx < len(missing_titles):
                    result_map[missing_titles[idx]] = m.group(2).strip()
        return result_map
    except Exception as e:
        print(f"[morning_news] 번역 재시도 실패: {e}", file=sys.stderr)
        return {}


def generate_analysis(all_news: dict) -> tuple:
    """Haiku 호출 → (ss_text, title_ko_map, summary_map)"""
    ko_lines, intl_lines, intl_titles = [], [], []
    for src, items in all_news.items():
        for title, desc, _link in items:
            line = f'[{src}] "{title}"\n  {desc[:200]}' if desc else f'[{src}] "{title}"'
            if src.startswith("🌐"):
                intl_lines.append(line)
                intl_titles.append(title)
            else:
                ko_lines.append(line.replace('"', ''))

    ko_block   = "\n".join(ko_lines[:10])  or "없음"
    intl_block = "\n".join(intl_lines[:6]) or "없음"
    titles_str = "\n".join(f"{i+1}. {t}" for i, t in enumerate(intl_titles)) or "없음"

    prompt = f"""당신은 Special Situation Fund 매니저의 비서입니다. 아래 뉴스를 처리하세요.
출력은 반드시 순수 한국어(한글)로만 작성하세요.

[국내 뉴스]
{ko_block}

[해외 뉴스]
{intl_block}

다음 3개 섹션을 정확히 아래 태그로 구분해 출력하세요. 이모지 없이.

[Special Situation]
뉴스 기반 한국 특수상황 투자 기회 (M&A·구조조정·부실자산·자금난/유동성). 없으면 "해당 없음". bullet 2~3줄.

[뉴스요약]
각 기사 1줄 요약(30자 이내). 형식: 기사제목 ||| 한 줄 요약

[영문번역]
아래 번호가 매겨진 영문 제목을 한국어로 번역. 형식: `번호. 한글번역` (영문 원제는 출력하지 말 것, 번호만 유지).
반드시 모든 번호(1~{len(intl_titles)})를 빠짐없이 번역하세요.
{titles_str}"""

    # 1) Haiku 호출 — 네트워크/CLI 예외만 여기서 격리
    parsed = None
    try:
        # LLM 호출 단일 경계 — 출력을 기존 parsed 형태로 재구성해 다운스트림 무변경 보존
        text = call_haiku_tracked(
            prompt,
            system="You are a financial news analyst. Respond only in Korean with the exact format requested. No extra commentary.",
            label="morning_news", timeout=120)
        if text.startswith("[ERROR]"):
            print(f"[morning_news] Haiku 호출 실패: {text[:200]}", file=sys.stderr)
        else:
            parsed = {"result": text, "is_error": False}
    except Exception as e:
        print(f"[morning_news] Haiku 호출 실패: {type(e).__name__}: {e}", file=sys.stderr)

    # Haiku 실패·빈 응답 → 번역만 재시도로 복구 시도
    if parsed is None or parsed.get("is_error") or not parsed.get("result"):
        if parsed is not None and parsed.get("is_error"):
            _haiku_record("morning_news", success=False, reason=f"is_error · {str(parsed.get('result',''))[:60]}")
        retry_map = _retry_translate(intl_titles) if intl_titles else {}
        _notify_translation_status(retry_map, intl_titles)
        return "", retry_map, {}

    out = parsed["result"]
    _haiku_record("morning_news", success=True)

    # 2) 토큰 기록 — 부가기능. 실패가 번역/요약을 삼키지 않도록 격리
    try:
        token_ledger.record_from_parsed(parsed, "Morning News (haiku)", notify=True)
    except Exception as e:
        print(f"[morning_news] token_ledger 기록 실패 (무시): {type(e).__name__}: {e}", file=sys.stderr)

    # 3) 파싱 — try 밖. 진짜 파싱 예외는 외부에서 감지
    norm = re.sub(r'\[([^\]]+)\]', lambda m: '[' + m.group(1).replace(' ', '') + ']', out)

    def parse_map(tag: str) -> dict:
        m = re.search(rf'\[{re.escape(tag)}\](.*?)(?=\[(?!http)|$)', norm, re.S)
        d = {}
        if m:
            block = m.group(1).strip()
            for line in block.splitlines():
                line = line.strip().strip('"- •*`')
                if not line:
                    continue
                if "|||" in line:
                    k, _, v = line.partition("|||")
                elif " | " in line:
                    k, _, v = line.partition(" | ")
                elif " → " in line or " -> " in line:
                    sep = " → " if " → " in line else " -> "
                    k, _, v = line.partition(sep)
                elif line.count(": ") == 1 and re.search(r'[a-zA-Z]', line.split(": ")[0]):
                    k, _, v = line.partition(": ")
                else:
                    continue
                k, v = k.strip().strip('"- •*`'), v.strip().strip('"')
                if k and v:
                    d[k] = v
            if not d:
                print(f"[morning_news] [{tag}] 파싱 실패. 원문:\n{block[:500]}", file=sys.stderr)
        else:
            print(f"[morning_news] [{tag}] 섹션 미발견", file=sys.stderr)
        return d

    summary_map = parse_map("뉴스요약")

    title_ko_map = {}
    trans_m = re.search(r'\[영문번역\](.*?)(?=\[(?!http)|$)', norm, re.S)
    if trans_m:
        for line in trans_m.group(1).splitlines():
            m = re.match(r'\s*(\d+)\s*[.)]\s*(.+)', line.strip().strip('"- •*`'))
            if m:
                idx = int(m.group(1)) - 1
                if 0 <= idx < len(intl_titles):
                    title_ko_map[intl_titles[idx]] = m.group(2).strip().strip('"')
    else:
        print(f"[morning_news] [영문번역] 섹션 미발견", file=sys.stderr)

    matched, total = len(title_ko_map), len(intl_titles)
    print(f"[morning_news] 번역 매칭 {matched}/{total}", file=sys.stderr)

def cluster(articles: list) -> list:
    n = len(articles)
    parent = list(range(n))

    def find(x):
        while parent[x] != x:
            parent[x] = parent[parent[x]]
            x = parent[x]
        return x

    def union(x, y):
        parent[find(x)] = find(y)

    for i in range(n):
        for j in range(i + 1, n):
            if articles[i]["source"] == articles[j]["source"]:
                continue
            if len(articles[i]["kw"] & articles[j]["kw"]) >= KW_THRESHOLD:
                union(i, j)

    groups: dict = defaultdict(list)
    for i in range(n):
        groups[find(i)].append(i)
    return list(groups.values())


# ── 상태 파일 ─────────────────────────────────────────────────────────────────

def load_state() -> dict:
    return load_json(STATE_FILE, default={"sent": {}})


def save_state(state: dict):
    save_json(STATE_FILE, state)


def purge_old(state: dict) -> dict:
    cutoff = (datetime.now(timezone.utc)
              - timedelta(hours=STATE_TTL_HRS)).isoformat()
    def get_time(v):
        return v["time"] if isinstance(v, dict) else v
    state["sent"] = {k: v for k, v in state["sent"].items() if get_time(v) >= cutoff}
    return state


def story_hash(kw: frozenset) -> str:
    # 길이 긴 키워드(핵심어) 상위 8개로 해시 — 클러스터 변동 대비 넉넉히
    top = sorted(kw, key=lambda w: -len(w))[:8]
    return hashlib.md5("|".join(sorted(top)).encode()).hexdigest()


def story_hash_stable(group: list) -> str:
    """클러스터 내 가장 오래된(첫 보도) 기사의 제목으로 안정적 해시 생성.
    기사가 추가되어도 초기 기사는 유지되므로 해시가 변하지 않음."""
    with_pub = [a for a in group if a.get("pub")]
    if with_pub:
        earliest = min(with_pub, key=lambda a: a["pub"])
    else:
        earliest = group[0]
    return hashlib.md5(earliest["title"].lower().strip().encode()).hexdigest()

        tg += f"\n🔗 <a href=\"{link}\">기사 원문</a>"
    return tg


# ── 메인 ──────────────────────────────────────────────────────────────────────

def main():
    now    = datetime.now(timezone.utc)
    cutoff = now - timedelta(hours=WINDOW_HOURS)
    state  = purge_old(load_state())

    # 1. RSS 수집
    all_articles = []
    failed_sources = 0  # 수집 실패(None) 소스 수
    for source, url, is_gnews in RSS_SOURCES:
        fetched = fetch_rss(source, url, is_gnews, cutoff)
        if fetched is None:
            failed_sources += 1
            continue
        for a in fetched:
            a["kw"] = extract_keywords(a["title"] + " " + a["desc"])
        all_articles.extend(fetched)

    print(f"[breaking_news] 수집 기사 수: {len(all_articles)}", file=sys.stderr)

    if failed_sources == len(RSS_SOURCES):
        print("[breaking_news] 전 소스 수집 실패", file=sys.stderr)
        return 1

    if not all_articles:
        print("[breaking_news] 수집된 기사 없음", file=sys.stderr)
        return 0

    # 소스별 수집 현황
    src_counts = defaultdict(int)
    for a in all_articles:
        src_counts[a["source"]] += 1
    print(f"[breaking_news] 소스: {dict(src_counts)}", file=sys.stderr)

    # 2. 클러스터링
    groups = cluster(all_articles)

    # 3. 속보 판별 → 알림 발송
    alerts_sent = 0
    send_failed = False  # 텔레그램 발송 실패 여부 (최종 rc 판정용)
    sent_group_indices = set()
    for gi, idx_list in enumerate(groups):
        group = [all_articles[i] for i in idx_list]
        unique_sources = {a["source"] for a in group}
        if len(unique_sources) < MIN_SOURCES:
            continue

        # 해외 소스만 있는 클러스터는 "속보/Breaking" 타이틀 없이도 허용
        # (BBC·CNN·WSJ 등은 RSS 제목에 breaking 표기 안 함)
        is_foreign_only = unique_sources.issubset(FOREIGN_SOURCES)
        if not is_foreign_only:
            breaking_sources = {a["source"] for a in group if BREAKING_KEYWORDS.search(a["title"])}
            if len(breaking_sources) < MIN_BREAKING:
                continue

        combined_kw = frozenset().union(*[a["kw"] for a in group])
        h = story_hash(combined_kw)
        h_stable = story_hash_stable(group)

        if h in state["sent"] or h_stable in state["sent"]:
            continue

        rep_title = _representative(group)["title"]

        if is_title_sent(rep_title, state):
            print(f"[breaking_news] 동일 제목 속보 이미 발송됨 (중복 건너뜀): {rep_title[:50]}", file=sys.stderr)
            continue

        # 클러스터 내 모든 기사 제목도 중복 체크 (대표 제목이 바뀌어도 기사가 겹치면 차단)
        any_title_sent = any(is_title_sent(a["title"], state) for a in group)
        if any_title_sent:
            print(f"[breaking_news] 클러스터 내 기존 발송 제목 발견 (중복 건너뜀): {unique_sources}", file=sys.stderr)
            continue

        if is_similar_to_sent(combined_kw, state):
            print(f"[breaking_news] 유사 속보 이미 발송됨 (중복 건너뜀): {unique_sources}", file=sys.stderr)
            continue

        tg_msg = format_message(group)

        if not send_telegram(tg_msg):
            print(f"[breaking_news] 속보 텔레그램 발송 실패: {unique_sources}", file=sys.stderr)
            send_failed = True
            continue  # 발송 실패 시 sent-state 미기록 → 다음 회차 자연 재시도

        top_kw = sorted(combined_kw, key=lambda w: -len(w))[:10]
        all_title_hashes = list({title_hash(a["title"]) for a in group})
        sent_info = {
            "time": now.isoformat(), "kw": top_kw,
            "title_hash": title_hash(rep_title), "title_hashes": all_title_hashes,
            "sources": list(unique_sources),
            "last_alert_ts": now.isoformat(),
        }
        state["sent"][h] = sent_info
        sent_group_indices.add(gi)
        if h_stable != h:
            state["sent"][h_stable] = sent_info
        alerts_sent += 1
        print(f"[breaking_news] 속보 발송: {unique_sources}", file=sys.stderr)

    # 4. 클러스터 진화 추적 (후속 보도 재알림)
    for gi, idx_list in enumerate(groups):
        if gi in sent_group_indices:
            continue
        group = [all_articles[i] for i in idx_list]
        unique_sources = {a["source"] for a in group}
        if len(unique_sources) < MIN_SOURCES:
            continue
        combined_kw = frozenset().union(*[a["kw"] for a in group])

        # 대표 기사 추출 (title 중복 체크용)
        rep_title_evo = _representative(group)["title"]

        # 동일 스토리에 h + h_stable 두 개 키가 저장될 수 있음.
        # break 대신 모든 매칭 항목의 sources를 갱신하고 알림은 1회만 발송.
        evolution_alerted = False
        for sent_key, sent_data in list(state["sent"].items()):
            if not isinstance(sent_data, dict) or not sent_data.get("sources"):
                continue
            sent_kw = frozenset(sent_data.get("kw", []))
            kw_overlap = len(combined_kw & sent_kw)
            # alias 키 sources 동기화는 KW_THRESHOLD 미달이어도 1개 이상 겹치면 수행
            if kw_overlap < 1:
                continue
            old_sources = set(sent_data["sources"])
            new_sources = unique_sources - old_sources

            # sources 갱신은 항상 수행 (alias 키도 동기화 — 중복 발송 방지 핵심)
            sent_data["sources"] = list(old_sources | unique_sources)
            state["sent"][sent_key] = sent_data

            # 알림 발송 조건은 기존 KW_THRESHOLD 유지
            if kw_overlap < KW_THRESHOLD:
                continue

            if evolution_alerted or len(new_sources) < EVOLUTION_MIN_SRC:
                continue

            # 쿨다운: 직전 알림 후 FOLLOWUP_COOLDOWN_MIN 분 이내면 스킵
            last_ts_str = sent_data.get("last_alert_ts") or sent_data.get("time")
            if last_ts_str:
                try:
                    last_ts = datetime.fromisoformat(last_ts_str)
                    if (now - last_ts).total_seconds() < FOLLOWUP_COOLDOWN_MIN * 60:
                        print(f"[breaking_news] 후속보도 쿨다운 — 소스만 갱신 ({int((now-last_ts).total_seconds()/60)}분 경과)", file=sys.stderr)
                        continue
                except Exception:
                    pass

            # 대표 제목이 이미 발송된 경우 → 알림 스킵
            if is_title_sent(rep_title_evo, state):
                print(f"[breaking_news] 후속보도 대표 제목 중복 — 소스 갱신: {rep_title_evo[:50]}", file=sys.stderr)

#!/usr/bin/env python3
"""
일반채권시장 채권가격 10% 이상 변동 알람

- KRX 공식 OpenAPI: 일반채권시장 일별매매정보 (bon/bnd_bydd_trd)
- 오늘 vs 직전 거래일 종가 비교
- 10% 이상 변동 시 ntfy 알람 (2026-07-02: ±5%→±10% 상향 + 채널분리 규칙 정합으로 텔레그램→ntfy 전환)
- 크론: 평일 17:00 종가 기준 (`0 17 * * 1-5`, KRX 당일 반영 후)
- 실시간 크론 폐지(2026-04): --realtime 코드만 보존, 재도입 시 크론+manifest 동시 등록
- 킬스위치: output/state/bond_alert_disabled 존재 시 알림 스킵 (재개: 파일 삭제)

실행:
  python3 bond_price_alert.py [YYYYMMDD]            # 날짜 지정 (생략 시 오늘)
  python3 bond_price_alert.py --realtime [YYYYMMDD] # 장중 실시간 모드
"""
import os, requests, sys
from datetime import datetime, timedelta
from pathlib import Path
from urllib.parse import quote as url_quote

sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "secretary"))
from notifier import send_ntfy, send_telegram
from state_manager import load_json, save_json

KRX_API_KEY = os.environ.get("KRX_API_KEY", "")
KRX_BASE = "https://data-dbg.krx.co.kr/svc/apis"

# 장중 중복 알람 방지용 state 파일
REALTIME_STATE_FILE = Path(__file__).resolve().parent.parent / "dart_capital_report" / "state" / "bond_alert_realtime.json"

ALERT_THRESHOLD = 0.10   # 10% (2026-07-02 알림 피로로 5%→10% 상향)


def alert(msg):
    """급변 알람 — ntfy 전용 (CLAUDE.md 채널분리: 개별 종목=ntfy만, 2026-07-02 전환). 발송 성공 여부 반환."""
    return send_ntfy(msg)


def load_realtime_state(today):
    """당일 이미 알람된 채권코드 세트 반환."""
    data = load_json(REALTIME_STATE_FILE, default={})
    if data.get("date") == today:
        return set(data.get("alerted", []))
    return set()


def save_realtime_state(today, alerted_codes):
    """당일 알람된 채권코드를 저장."""
    save_json(REALTIME_STATE_FILE, {"date": today, "alerted": list(alerted_codes)}, compact=True)


def get_prev_trading_day(date_str, max_lookback=7):
    """주말 + 공휴일 대응: KRX 데이터가 존재하는 직전 거래일을 찾는다."""
    d = datetime.strptime(date_str, "%Y%m%d") - timedelta(days=1)
    for _ in range(max_lookback):
        while d.weekday() >= 5:
            d -= timedelta(days=1)
        candidate = d.strftime("%Y%m%d")
        items = _krx_get("bon/bnd_bydd_trd", {"basDd": candidate})
        if items:
            return candidate
        print(f"  {candidate}: 데이터 없음 (공휴일), 이전일 탐색")
        d -= timedelta(days=1)
    # fallback: 최종 후보 반환
    return d.strftime("%Y%m%d")


def _krx_get(endpoint, params):
    p = {"AUTH_KEY": KRX_API_KEY}
    p.update(params)
    r = requests.get(f"{KRX_BASE}/{endpoint}", params=p, timeout=30)
    data = r.json()
    # HTTP 200이라도 기대 데이터 키 부재(인증 만료·차단 등 오류 body)면 수집 실패로 처리
    # (정상 '데이터 없음'은 키 존재 + 빈 배열 — 기존대로 [] 반환)
    if not isinstance(data, dict) or ("output" not in data and "OutBlock_1" not in data):
        raise RuntimeError(f"KRX 응답에 데이터 키 없음 (인증/차단 의심): {str(data)[:200]}")
    return data.get("output", data.get("OutBlock_1", []))


def fetch_bond_prices(trade_date):
    try:
        items = _krx_get("bon/bnd_bydd_trd", {"basDd": trade_date})
        result = {item.get("ISU_CD", ""): item for item in items if item.get("ISU_CD")}
        print(f"  [{trade_date}] 채권 {len(result)}종목 조회")
        return result
    except Exception as e:
        print(f"  채권가격 조회 실패 ({trade_date}): {e}", file=sys.stderr)
        return None  # 수집 실패 — '데이터 없음'({})과 구분


def get_close_price(item):
    val = item.get("CLSPRC")
    if val not in (None, "", "-"):
        try:
            return float(str(val).replace(",", ""))
        except ValueError:
            pass
    return None


def get_bond_name(item):
    return item.get("ISU_NM", "-")


def get_issuer(item):
    return item.get("ISUR_NM", item.get("MKT_NM", "-"))


def get_yield(item):
    return str(item.get("CLSPRC_YD", "-"))


def naver_bond_link(name):
    return f"https://finance.naver.com/search/searchList.naver?query={url_quote(name)}"


def build_alert_message(alerts, today, mode="closing"):
    mode_label = "장중" if mode == "realtime" else "종가"

    surges = [a for a in alerts if a["chg"] > 0]
    drops  = [a for a in alerts if a["chg"] < 0]

    parts = []
    if surges and drops:
        header = f"🔔 채권가격 급변 알람 [{mode_label}] ({today}): 급등 {len(surges)}건 / 급락 {len(drops)}건"
    elif surges:
        header = f"🔺 채권가격 급등 알람 [{mode_label}] ({today}): {len(surges)}건"
    else:
        header = f"🔻 채권가격 급락 알람 [{mode_label}] ({today}): {len(drops)}건"
    parts.append(header)

    def fmt_group(group, emoji, label):
        if not group:
            return
        parts.append(f"\n{emoji} {label}")
        for a in group[:5]:
            pct = abs(a["chg"]) * 100
            link = naver_bond_link(a["name"])
            parts.append(f"  {pct:.1f}% | {a['name']} ({a['code']})")
            parts.append(f"  {a['prev_px']:,.0f}→{a['today_px']:,.0f}원 | {a['issuer']}")
            parts.append(f"  {link}")
        if len(group) > 5:
            parts.append(f"  ... 외 {len(group)-5}건")

    fmt_group(surges, "🔺", "급등")
    fmt_group(drops,  "🔻", "급락")

    return "\n".join(parts)


def main():
    args = sys.argv[1:]

    # 킬스위치(일시 중단): 플래그 파일이 있으면 알림 없이 즉시 정상종료.
    # 크론은 계속 돌지만 로그만 갱신 → health_check "미실행" 오탐 없음. 재개: 플래그 삭제.
    disable_flag = Path(__file__).resolve().parent.parent / "output" / "state" / "bond_alert_disabled"
    if disable_flag.exists():
        print(f"채권 알람 일시 중단 상태 — 플래그 존재({disable_flag}). 알림 스킵, 종료. 재개: rm '{disable_flag}'")
        return 0  # 정상 스킵

    realtime_mode = "--realtime" in args
    date_args = [a for a in args if not a.startswith("--")]

    today = date_args[0] if date_args else datetime.now().strftime("%Y%m%d")
    try:
        prev = get_prev_trading_day(today)
    except Exception as e:
        print(f"  직전 거래일 탐색 실패: {e}", file=sys.stderr)
        if not realtime_mode:
            if not send_ntfy("⚠️ 채권 알람: KRX 수집 실패 — 직전 거래일 탐색 불가 (API 인증/차단 확인 필요)", tags="warning"):
                print("  경고 ntfy 발송 실패", file=sys.stderr)
        return 1  # 수집 실패 — '데이터 없음'과 구분

    mode_label = "실시간(장중)" if realtime_mode else "종가"
    print(f"채권가격 변동 모니터링 [{mode_label}]: {prev} → {today}")

    today_prices = fetch_bond_prices(today)

    # KRX bnd_bydd_trd는 장 마감 후 수십 분 지연 → today=0이면 D-1 vs D-2 비교로 fallback
    if not today_prices:
        print("  오늘 채권 데이터 미반영 — D-1 vs D-2 fallback 전환", file=sys.stderr)
        fallback_today = prev
        try:
            fallback_prev = get_prev_trading_day(prev)
        except Exception as e:
            print(f"  fallback 직전 거래일 탐색 실패: {e}", file=sys.stderr)
            fallback_prev = None
        today_prices = fetch_bond_prices(fallback_today)
        prev_prices = fetch_bond_prices(fallback_prev) if fallback_prev else None
        if not today_prices or not prev_prices:
            print("  fallback 데이터도 없음 (휴장일 또는 API 오류)")
            if not realtime_mode:
                if not send_ntfy("⚠️ 채권 알람: 최근 데이터 없음 (KRX API 확인 필요)", tags="warning"):
                    print("  경고 ntfy 발송 실패", file=sys.stderr)
            return 1  # 데이터 전무 — 주 기능(가격 비교) 수행 불가
        today = fallback_today
        prev = fallback_prev
        print(f"  fallback 적용: {prev} → {today}")
    else:
        prev_prices = fetch_bond_prices(prev)
        if prev_prices is None:
            print("  전일 채권가격 수집 실패", file=sys.stderr)
            return 1
        if not prev_prices:
            print("  전일 채권 데이터 없음")
            return 0  # 데이터 자체가 없는 날 — 정상 무동작

    # 실시간 모드: 당일 이미 알람된 종목 제외
    already_alerted = load_realtime_state(today) if realtime_mode else set()

    alerts = []
    for code, item in today_prices.items():
        if code not in prev_prices:
            continue
        if realtime_mode and code in already_alerted:
            continue
        today_px = get_close_price(item)
        prev_px  = get_close_price(prev_prices[code])
        if today_px is None or prev_px is None or prev_px == 0:
            continue

    fmt_group(drops,  "🔻", "급락")

    return "\n".join(parts)


def main():
    args = sys.argv[1:]

    # 킬스위치(일시 중단): 플래그 파일이 있으면 알림 없이 즉시 정상종료.
    # 크론은 계속 돌지만 로그만 갱신 → health_check "미실행" 오탐 없음. 재개: 플래그 삭제.
    disable_flag = Path(__file__).resolve().parent.parent / "output" / "state" / "bond_alert_disabled"
    if disable_flag.exists():
        print(f"채권 알람 일시 중단 상태 — 플래그 존재({disable_flag}). 알림 스킵, 종료. 재개: rm '{disable_flag}'")
        return 0  # 정상 스킵

    realtime_mode = "--realtime" in args
    date_args = [a for a in args if not a.startswith("--")]

    today = date_args[0] if date_args else datetime.now().strftime("%Y%m%d")
    try:
        prev = get_prev_trading_day(today)
    except Exception as e:
        print(f"  직전 거래일 탐색 실패: {e}", file=sys.stderr)
        if not realtime_mode:
            if not send_ntfy("⚠️ 채권 알람: KRX 수집 실패 — 직전 거래일 탐색 불가 (API 인증/차단 확인 필요)", tags="warning"):
                print("  경고 ntfy 발송 실패", file=sys.stderr)
        return 1  # 수집 실패 — '데이터 없음'과 구분

    mode_label = "실시간(장중)" if realtime_mode else "종가"
    print(f"채권가격 변동 모니터링 [{mode_label}]: {prev} → {today}")

    today_prices = fetch_bond_prices(today)

    # KRX bnd_bydd_trd는 장 마감 후 수십 분 지연 → today=0이면 D-1 vs D-2 비교로 fallback
    if not today_prices:
        print("  오늘 채권 데이터 미반영 — D-1 vs D-2 fallback 전환", file=sys.stderr)
        fallback_today = prev
        try:
            fallback_prev = get_prev_trading_day(prev)
        except Exception as e:
            print(f"  fallback 직전 거래일 탐색 실패: {e}", file=sys.stderr)
            fallback_prev = None
        today_prices = fetch_bond_prices(fallback_today)
        prev_prices = fetch_bond_prices(fallback_prev) if fallback_prev else None
        if not today_prices or not prev_prices:
            print("  fallback 데이터도 없음 (휴장일 또는 API 오류)")
            if not realtime_mode:
                if not send_ntfy("⚠️ 채권 알람: 최근 데이터 없음 (KRX API 확인 필요)", tags="warning"):
                    print("  경고 ntfy 발송 실패", file=sys.stderr)
            return 1  # 데이터 전무 — 주 기능(가격 비교) 수행 불가
        today = fallback_today
        prev = fallback_prev
        print(f"  fallback 적용: {prev} → {today}")
    else:
        prev_prices = fetch_bond_prices(prev)
        if prev_prices is None:
            print("  전일 채권가격 수집 실패", file=sys.stderr)
            return 1
        if not prev_prices:
            print("  전일 채권 데이터 없음")
            return 0  # 데이터 자체가 없는 날 — 정상 무동작

    # 실시간 모드: 당일 이미 알람된 종목 제외
    already_alerted = load_realtime_state(today) if realtime_mode else set()

    alerts = []
    for code, item in today_prices.items():
        if code not in prev_prices:
            continue
        if realtime_mode and code in already_alerted:
            continue
        today_px = get_close_price(item)
        prev_px  = get_close_price(prev_prices[code])
        if today_px is None or prev_px is None or prev_px == 0:
            continue
        chg = (today_px - prev_px) / prev_px

#!/usr/bin/env python3
"""
개별주식 급등/급락 알람 (네이버 금융 기반)

- 데이터: 네이버 금융 급등/급락 페이지 (KOSPI sosok=0, KOSDAQ sosok=1)
- 지수 기준: 네이버 금융 KOSPI/KOSDAQ 전일 대비
- 임계치: ±10%부터 5% 단위 (10%, 15%, 20% ...)
- 지수가 동일 브래킷 이상 변동 시 개별주식 알람 중단
- 알람: ntfy만 (개별 종목 알림 피로 방지)
- 크론1: 평일 15:35 (종가 기준)
- 크론2: 평일 09:00~15:30 30분마다 (실시간, --realtime)

실행:
  python3 stock_price_alert.py
  python3 stock_price_alert.py --realtime
"""
import sys, requests, re
from datetime import datetime
from pathlib import Path
from lxml import html as lxml_html

sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "secretary"))
sys.path.insert(0, str(Path(__file__).resolve().parent.parent))  # pm_signals·conviction_reco
from notifier import send_ntfy
from state_manager import load_json, save_json

REALTIME_STATE = Path(__file__).resolve().parent.parent / "dart_capital_report" / "state" / "stock_alert_realtime.json"

MARKETS = [
    {"name": "코스피", "sosok": "0", "index_code": "KOSPI"},
    {"name": "코스닥", "sosok": "1", "index_code": "KOSDAQ"},
]

ALERT_MIN_PCT  = 10    # 최소 알람 임계치 (%)
ALERT_STEP_PCT = 5     # 브래킷 단위 (%)


# ── 네이버 급등/급락 스크래핑 ──────────────────────────────

def _parse_naver_sise(url: str) -> list:
    """네이버 급등/급락 페이지 파싱 → [{code, name, price, change_pct}, ...]"""
    r = requests.get(url, headers={"User-Agent": "Mozilla/5.0"}, timeout=15)
    text = r.content.decode("euc-kr", errors="replace")
    doc = lxml_html.fromstring(text)

    results = []
    for table in doc.xpath("//table"):
        headers = [th.text_content().strip() for th in table.xpath(".//th")]
        if "등락률" not in headers:
            continue
        for row in table.xpath(".//tr"):
            cells = row.xpath(".//td")
            if len(cells) < 5:
                continue
            links = row.xpath(".//a/@href")
            code_match = None
            for link in links:
                m = re.search(r"code=(\d{6})", link)
                if m:
                    code_match = m.group(1)
                    break
            if not code_match:
                continue

            name = cells[1].text_content().strip()
            price_str = cells[2].text_content().strip().replace(",", "")
            pct_str = cells[4].text_content().strip().replace("%", "").replace("+", "")

            try:
                price = float(price_str)
                pct = float(pct_str)
            except ValueError:
                continue

            if abs(pct) < 0.01:
                continue

            results.append({
                "code": code_match,
                "name": name,
                "price": price,
                "change_pct": pct,
            })
    return results


def fetch_movers(sosok: str) -> list | None:
    """급등 + 급락 종목 통합 조회. 두 페이지 모두 실패 시 None (수집 실패와 0건 구분)."""
    rise_url = f"https://finance.naver.com/sise/sise_rise.naver?sosok={sosok}"
    fall_url = f"https://finance.naver.com/sise/sise_fall.naver?sosok={sosok}"

    movers = []
    failures = 0
    try:
        movers.extend(_parse_naver_sise(rise_url))
    except Exception as e:
        failures += 1
        print(f"  급등 페이지 실패 (sosok={sosok}): {e}", file=sys.stderr)
    try:
        movers.extend(_parse_naver_sise(fall_url))
    except Exception as e:
        failures += 1
        print(f"  급락 페이지 실패 (sosok={sosok}): {e}", file=sys.stderr)

    if failures == 2:
        return None  # 전면 수집 실패
    return movers


# ── 네이버 지수 ──────────────────────────────────────────

def fetch_index_change(index_code: str):
    """KOSPI/KOSDAQ 전일 대비 변동률(%) 반환. 실패 시 None."""
    try:
        from datetime import timedelta
        today = datetime.now()
        start = (today - timedelta(days=15)).strftime("%Y%m%d") + "000000"
        end   = today.strftime("%Y%m%d") + "235959"
        url = (f"https://api.stock.naver.com/chart/domestic/index/{index_code}/day"
               f"?startDateTime={start}&endDateTime={end}")
        r = requests.get(url, headers={"User-Agent": "Mozilla/5.0"}, timeout=10)
        rows = [row for row in r.json() if row.get("closePrice") is not None]
        if len(rows) < 2:
            return None
        prev   = rows[-2]["closePrice"]
        latest = rows[-1]["closePrice"]
        return (latest - prev) / prev * 100
    except Exception as e:
        print(f"  지수 조회 실패 ({index_code}): {e}", file=sys.stderr)
        return None


# ── 브래킷 로직 ──────────────────────────────────────────

def get_bracket(chg_pct_abs: float):
    """절대 변동률(%) → 브래킷. 10 미만이면 None."""
    if chg_pct_abs < ALERT_MIN_PCT:
        return None
    return int(chg_pct_abs // ALERT_STEP_PCT) * ALERT_STEP_PCT


def index_suppresses(index_pct, stock_bracket: int) -> bool:
    """지수 변동률이 주식 브래킷 이상이면 억제."""
    if index_pct is None:
        return False
    return get_bracket(abs(index_pct)) is not None and abs(index_pct) >= stock_bracket


# ── 알림 ─────────────────────────────────────────────────

def naver_stock_link(code: str) -> str:
    return f"https://finance.naver.com/item/main.naver?code={code}"


# ── 실시간 state ─────────────────────────────────────────

def load_realtime_state(today: str) -> dict:
    """당일 {code: max_bracket_alerted} 반환."""
    data = load_json(REALTIME_STATE, default={})
    if data.get("date") == today:
        return data.get("brackets", {})
    return {}


def save_realtime_state(today: str, brackets: dict):
    save_json(REALTIME_STATE, {"date": today, "brackets": brackets}, compact=True)


# ── 메시지 포맷 ──────────────────────────────────────────

def build_alert_message(surges, drops, market_name, today, mode, index_pct, index_suppressed):
    mode_label = "장중" if mode == "realtime" else "종가"

    if surges and drops:
        header = (f"🔔 {market_name} 급변 알람 [{mode_label}] ({today}): "
                  f"급등 {len(surges)}건 / 급락 {len(drops)}건")
    elif surges:
        header = f"🔺 {market_name} 급등 알람 [{mode_label}] ({today}): {len(surges)}건"
    else:
        header = f"🔻 {market_name} 급락 알람 [{mode_label}] ({today}): {len(drops)}건"

    idx_txt = f"지수: {index_pct:+.1f}%" if index_pct is not None else "지수: N/A"
    if index_suppressed:
        idx_txt += " (지수급변 — 일부 억제됨)"

    parts = [header, idx_txt]

    def fmt_group(group, emoji, label):
        if not group:
            return
        parts.append(f"\n{emoji} {label}")
        for a in group[:5]:
            pct = abs(a["change_pct"])
            bracket = a["bracket"]
            link = naver_stock_link(a["code"])
            parts.append(
                f"  {pct:.1f}% (≥{bracket}%) | {a['name']} ({a['code']})\n"
                f"  {a['price']:,.0f}원\n"
                f"  {link}"
            )
        if len(group) > 5:
            parts.append(f"  ... 외 {len(group)-5}건")

    fmt_group(surges, "🔺", "급등")
    fmt_group(drops,  "🔻", "급락")
    return "\n".join(parts)


# ── 메인 ─────────────────────────────────────────────────

def process_market(market, today, realtime_mode, brackets_state, index_pct):
    """한 시장(KOSPI 또는 KOSDAQ) 처리. (알람 건수, 발송 성공 여부) 반환.
    주 데이터 수집 전면 실패 시 (None, True)."""
    market_name = market["name"]

    movers = fetch_movers(market["sosok"])
    if movers is None:
        print(f"  {market_name}: 등락 종목 수집 실패", file=sys.stderr)
        return None, True
    print(f"  {market_name}: 등락 종목 {len(movers)}건 수집")

        print(f"  지수 조회 실패 ({index_code}): {e}", file=sys.stderr)
        return None


# ── 브래킷 로직 ──────────────────────────────────────────

def get_bracket(chg_pct_abs: float):
    """절대 변동률(%) → 브래킷. 10 미만이면 None."""
    if chg_pct_abs < ALERT_MIN_PCT:
        return None
    return int(chg_pct_abs // ALERT_STEP_PCT) * ALERT_STEP_PCT

    fmt_group(drops,  "🔻", "급락")
    return "\n".join(parts)


# ── 메인 ─────────────────────────────────────────────────

def process_market(market, today, realtime_mode, brackets_state, index_pct):
    """한 시장(KOSPI 또는 KOSDAQ) 처리. (알람 건수, 발송 성공 여부) 반환.
    주 데이터 수집 전면 실패 시 (None, True)."""
    market_name = market["name"]

    movers = fetch_movers(market["sosok"])
    if movers is None:
        print(f"  {market_name}: 등락 종목 수집 실패", file=sys.stderr)
        return None, True
    print(f"  {market_name}: 등락 종목 {len(movers)}건 수집")

    surges, drops = [], []
    any_suppressed = False

    for stock in movers:
        pct = abs(stock["change_pct"])
        bracket = get_bracket(pct)
        if bracket is None:
            continue

        code = stock["code"]

        # 실시간 모드: 이미 이 브래킷 이상으로 알람된 종목 스킵
        if realtime_mode:
            prev_bracket = brackets_state.get(code, 0)
            if bracket <= prev_bracket:
                continue

        # 지수 억제 체크
        suppressed = index_suppresses(index_pct, bracket)
        if suppressed:
            any_suppressed = True
            if realtime_mode:
                brackets_state[code] = bracket
            continue

        entry = {
            "code":       code,
            "name":       stock["name"],
            "price":      stock["price"],
            "change_pct": stock["change_pct"],
            "bracket":    bracket,
        }
        if stock["change_pct"] > 0:
            surges.append(entry)
        else:
            drops.append(entry)

    total = len(surges) + len(drops)
    print(f"  {market_name}: 급등 {len(surges)}건 / 급락 {len(drops)}건 (억제: {any_suppressed})")

    send_ok = True
    if total > 0:
        surges.sort(key=lambda x: abs(x["change_pct"]), reverse=True)
        drops.sort(key=lambda x: abs(x["change_pct"]), reverse=True)

def _collect_and_parse(bgn, end, items=None, skip_enrichment=False):
    """Stage 0~4: 수집 → 파싱 → DS005 보완 → 행별 보완.

    Returns: (rights_rows, bond_rows, all_b_items)
    """
    # Stage 0: DART list
    if items is None:
        days_span = (datetime.strptime(end, "%Y%m%d") - datetime.strptime(bgn, "%Y%m%d")).days
        if days_span > 90:
            items = fetch_dart_list_chunked(bgn, end, "B")
        else:
            items = fetch_dart_list(bgn, end, "B")
        save_items_cache(items, bgn, end)
    print(f"  B유형 전체: {len(items)}건")

    # Stage 1: XML 파싱
    print("[Stage 1] 유상증자 파싱...")
    rights_rows = fetch_rights_offerings(bgn, end, items=items)
    print(f"  유상증자: {len(rights_rows)}건")

    print("[Stage 1] CB/BW 파싱...")
    bond_rows = fetch_bonds(bgn, end, items=items)
    print(f"  CB/BW: {len(bond_rows)}건")

    if skip_enrichment:
        return rights_rows, bond_rows, items

    # Stage 2: DS005 보완
    print("[Stage 2] DS005 보완...")
    ds005_enrich_rights(rights_rows)
    ds005_enrich_bonds(bond_rows)

    # Stage 3: 발행실적 매칭 (자율공시)
    print("[Stage 3] 발행실적 매칭...")
    match_issuance_results(rights_rows, bond_rows, bgn, end)

    # Stage 4: 행별 보완 (KRX 종가 + 재무 + 업종)
    print("[Stage 4] KRX 종가 + 재무 보완...")
    company_enrich_rights(rights_rows)
    company_enrich_bonds(bond_rows)

    return rights_rows, bond_rows, items

def detect_anomalies_rule_based(rights_rows, bond_rows):
    """Python 규칙으로 필드 누락·범위 이탈 탐지."""
    anomalies = []

    for r in rights_rows:
        corp = r[R.회사명]
        rcept_no = r[R.접수번호]
        issue_px = r[R.발행가]
        discount = r[R.할인할증율]
        amt = r[R.조달규모]

        if str(issue_px).strip() in ("-", "", "0"):
            anomalies.append({"tab": "유상증자", "corp": corp, "rcept_no": rcept_no,
                              "issue": f"발행가 누락/0원: {issue_px}"})
        if str(amt).strip() in ("-", "", "0") or amt == 0:
            anomalies.append({"tab": "유상증자", "corp": corp, "rcept_no": rcept_no,
                              "issue": f"조달규모 누락/0: {amt}"})
        try:
            dc = float(discount) if isinstance(discount, (int, float)) else float(str(discount).replace("%", "").strip())
            if dc < -70 or dc > 50:
                anomalies.append({"tab": "유상증자", "corp": corp, "rcept_no": rcept_no,
                                  "issue": f"할인율 이상: {dc}%"})
        except (ValueError, TypeError):
            pass

    for r in bond_rows:
        corp = r[B.회사명]
        rcept_no = r[B.접수번호]
        issue_amt = r[B.채권원금]
        conv_px = r[B.전환가액]

        if str(issue_amt).strip() in ("-", "", "0"):
            anomalies.append({"tab": "CB_BW", "corp": corp, "rcept_no": rcept_no,
                              "issue": f"발행금액 누락: {issue_amt}"})
        if str(conv_px).strip() in ("-", "", "0"):
            anomalies.append({"tab": "CB_BW", "corp": corp, "rcept_no": rcept_no,
                              "issue": f"전환가액 누락: {conv_px}"})

    return anomalies


# ── Haiku: 이상값 검증 (의미론적) ──────────────────────

def haiku_anomaly_check(rights_rows, bond_rows):
    """맥락적 이상값 탐지 (Haiku)."""
    lines = []
    for r in rights_rows[:30]:
        lines.append(f"유상증자|{r[R.회사명]}|rcept={r[R.접수번호]}|발행가={r[R.발행가]}|할인={r[R.할인할증율]}|조달={r[R.조달규모]}")
    for r in bond_rows[:30]:
        lines.append(f"CB_BW|{r[B.회사명]}|rcept={r[B.접수번호]}|발행={r[B.채권원금]}|전환가={r[B.전환가액]}|리픽싱={r[B.리픽싱하한]}")

    if not lines:
        return []

    prompt = (
        "아래 자본조달 공시 데이터에서 맥락적으로 이상한 항목을 JSON으로만 응답하세요.\n\n"
        + "\n".join(lines)
        + '\n\n형식: {"anomalies": [{"tab":"유상증자","corp":"회사명","rcept_no":"접수번호","issue":"설명"}]}'
    )
    try:
        raw = call_haiku_tracked(
            prompt, system="Respond only with valid JSON. No markdown.",
            label="dart_anomaly_check", timeout=60).strip()
        if raw.startswith("[ERROR]"):
            return []
        raw = re.sub(r'^```(?:json)?\s*', '', raw, flags=re.MULTILINE)
        raw = re.sub(r'```\s*$', '', raw, flags=re.MULTILINE)
        m = re.search(r'\{.*\}', raw, re.DOTALL)
        if m:
            result = json.loads(m.group())
            items = result.get("anomalies", [])
            if items and isinstance(items[0], str):
                return [{"tab": "-", "corp": "-", "rcept_no": "", "issue": s} for s in items]
            return items
        return []
    except Exception as e:
        print(f"  [Haiku 검증 실패] {e}")
        return []

    blocks[day] = merged
    keep = sorted(blocks, reverse=True)[:30]
    body = (f"---\ntype: daily-signals\nupdated: {day}\n---\n"
            f"# 🔔 오늘의 시그널 — 부실공시 히트\n\n"
            f"> insolvency_alert(평일 08:15)가 자동 기록. 최근 30일 보존, 히트 없는 날은 무기록.\n\n")
    body += "\n\n".join(f"## {d}\n" + "\n".join(blocks[d]) for d in keep) + "\n"
    os.makedirs(VAULT_INBOX, exist_ok=True)
    tmp = path + ".tmp"
    with open(tmp, "w", encoding="utf-8") as f:
        f.write(body)
    os.replace(tmp, path)

# 감시 대상 3종: report_nm 키워드 → (표시명, ds005 fetcher, 이모지)
EVENT_TYPES = [
    ("회생절차개시신청",       "회생절차 개시",       fetch_ds005_rehab,      "⚖️"),
    ("채권은행등의관리절차개시", "채권단관리 개시",    fetch_ds005_bank_mgmt,  "🏦"),
    ("부도발생",              "부도 발생",          fetch_ds005_default,    "🚨"),
]

# 재무 5지표 account_nm (fnlttSinglAcnt)
FIN_ACCOUNTS = ["자산총계", "부채총계", "자본총계", "매출액", "영업이익"]


# ── State ──────────────────────────────────────────────

def load_state() -> dict:
    if STATE_FILE.exists():
        try:
            return json.loads(STATE_FILE.read_text())
        except Exception:
            return {}
    return {}


def save_state(state: dict):
    STATE_DIR.mkdir(parents=True, exist_ok=True)
    STATE_FILE.write_text(json.dumps(state, ensure_ascii=False, indent=2))


# ── 공시 수집 ──────────────────────────────────────────

def fetch_insolvency_filings(bgn: str, end: str) -> list[dict]:
    """B-type 공시 중 3종 이벤트 필터링. [기재정정]은 제외(원공시 기준)."""
    items = fetch_dart_list(bgn, end, "B", pages=10)
    hits = []
    for item in items:
        nm = item.get("report_nm", "")
        if "[기재정정]" in nm:
            continue
        for kw, label, fetcher, emoji in EVENT_TYPES:
            if f"({kw})" in nm:
                hits.append({
                    "rcept_no": item.get("rcept_no"),
                    "corp_code": item.get("corp_code"),
                    "corp_name": item.get("corp_name"),
                    "stock_code": item.get("stock_code", ""),
                    "corp_cls": item.get("corp_cls", ""),
                    "report_nm": nm,
                    "rcept_dt": item.get("rcept_dt"),
                    "event_kw": kw,
                    "event_label": label,
                    "event_emoji": emoji,
                    "_fetcher": fetcher,
                })
                break
    return hits


# ── 상세 보강 (ds005) ──────────────────────────────────

def enrich_detail(hit: dict):
    """ds005 호출로 이벤트별 상세 필드 추가."""
    fetcher = hit.pop("_fetcher")
    # 공시일 기준 ±30일 범위로 한정 (캐시 효율)
    rcept_dt = hit.get("rcept_dt", "")
    if rcept_dt and len(rcept_dt) == 8:
        d = datetime.strptime(rcept_dt, "%Y%m%d")
        bgn = (d - timedelta(days=30)).strftime("%Y%m%d")
        end = (d + timedelta(days=30)).strftime("%Y%m%d")
    else:
        today = datetime.now()
        bgn = (today - timedelta(days=30)).strftime("%Y%m%d")
        end = today.strftime("%Y%m%d")

    data = fetcher(hit["corp_code"], bgn, end)
    if data.get("status") != "000":

_sys.path.insert(0, "/Users/raccoonfamily/ClaudeCode")
import pm_signals  # PM conviction read-back (관심종목 강조)

VAULT_INBOX = "/Users/raccoonfamily/ObsidianVault/brain/99_Inbox"


def write_vault_weekly(flagged, threshold):
    """볼트 99_Inbox/주간-워닝시그널.md에 주간 스코어 기록 — 텔레그램 휘발 보완.

    insolvency_alert.write_vault_signal 패턴: 주차별 ## 블록(ISO 주차),
    최근 12주 롤링, 동일 주 재실행 시 중복 없이 병합. 호출부 try 래핑.
    """
    path = os.path.join(VAULT_INBOX, "주간-워닝시그널.md")
    week = datetime.now().strftime("%G-W%V")  # ISO 주차 (예: 2026-W32)
    new_lines = []
    for corp, data in flagged:
        corp_s = re.sub(r'[\[\]|#]', '', corp)
        evs = sorted(data["events"], key=lambda e: -e["score"])
        top = f"{evs[0]['emoji']} {evs[0]['kw']}" + (f" 외 {len(evs) - 1}건" if len(evs) > 1 else "")
        new_lines.append(f"- ⚠️ [[{corp_s}]] — **{data['score']}점** · {top}")
    blocks = {}
    if os.path.exists(path):
        text = open(path, encoding="utf-8").read()
        for m in re.finditer(r"(?m)^## (\d{4}-W\d{2})\n((?:- .*\n?)*)", text):
            blocks[m.group(1)] = [l for l in m.group(2).splitlines() if l.strip()]
    merged = blocks.get(week, [])
    merged += [l for l in new_lines if l not in merged]
    blocks[week] = merged
    keep = sorted(blocks, reverse=True)[:12]
    body = (f"---\ntype: weekly-warnings\nupdated: {datetime.now().strftime('%Y-%m-%d')}\n---\n"
            f"# 📊 주간 워닝시그널 — Warning Sign 스코어\n\n"
            f"> weekly_warning_score(월 09:00)가 자동 기록. ⚠️=점수 ≥{threshold} 회사만, 최근 12주 보존.\n\n")
    body += "\n\n".join(f"## {w}\n" + "\n".join(blocks[w]) for w in keep) + "\n"
    os.makedirs(VAULT_INBOX, exist_ok=True)
    tmp = path + ".tmp"
    with open(tmp, "w", encoding="utf-8") as f:
        f.write(body)
    os.replace(tmp, path)


def _pm_watchlist():
    """PM 관심종목 — 실패해도 알림은 정상(안전쪽 빈 dict)."""
    try:
        return pm_signals.watchlist()
    except Exception:
        return {}


# ── 점수 룰북 ──────────────────────────────────────────
# (report_nm 괄호 안 키워드) → (점수, 이모지, 카테고리)
SCORE_RULES = [
    # 부실/파탄 (5점)
    ("부도발생",                    5, "🚨", "부실"),
    ("해산사유발생",                5, "⚰️", "부실"),
    # 회생/법정관리 (4점)
    ("회생절차개시신청",            4, "⚖️", "부실"),
    ("채권은행등의관리절차개시",    4, "🏦", "부실"),
    # 사업 축소/자산 유출 (3점)
    ("영업양도결정",                3, "📉", "사업축소"),
    ("자산양수도(기타),풋백옵션",   3, "🔄", "자산유출"),  # DART 표기 정확히 확인
    # 2점 이벤트
    ("유형자산양도결정",            2, "🏚️", "자산유출"),
    ("타법인주식및출자증권양도결정", 2, "💼", "자산유출"),
    ("감자결정",                    2, "⬇️", "자본잠식"),
    ("소송등의제기",                2, "⚔️", "소송"),
    # 1점 이벤트 (조달 과열 신호)
    ("전환사채권발행결정",          1, "💵", "조달"),
    ("신주인수권부사채권발행결정",  1, "💵", "조달"),
    ("교환사채권발행결정",          1, "💵", "조달"),
    ("유상증자결정",                1, "📈", "조달"),
    ("영업양수결정",                1, "🏢", "M&A"),
]


def classify(report_nm: str) -> tuple | None:
    """report_nm → (kw, score, emoji, category) 또는 None."""
    if "[기재정정]" in report_nm:
        return None
    for kw, score, emoji, cat in SCORE_RULES:
        if f"({kw}" in report_nm:  # 괄호 시작만 매칭해 오탐 방지
            return kw, score, emoji, cat
    return None


def _is_non_operating(corp_name: str) -> bool:
    """SPAC·유동화SPV 등 비영업 껍데기 법인 — 해산은 정상 절차라 제외."""
    noise = ("기업인수목적", "유동화전문", "스팩")
    return any(kw in corp_name for kw in noise)


def collect_weekly_events(bgn: str, end: str) -> list[dict]:
    """주간 B-type 공시 → 점수 대상 이벤트만 추출."""
    items = fetch_dart_list(bgn, end, "B", pages=20)
    print(f"  B-type 전체: {len(items)}건")
    events = []
    for item in items:
        cls = classify(item.get("report_nm", ""))
        if not cls:

def auto_route(query):
    """상장 여부 + 정기보고서 존재 여부 판단."""
    corp = find_corp(query)
    if not corp:
        raise ValueError(f"회사 검색 실패: {query}")
    listed = False
    if corp.get("stock_code"):
        try:
            reports = fetch_periodic_reports(corp["corp_code"], years=3)
            listed = bool(reports)
        except Exception:
            pass
    return ("xbrl+audit" if listed else "audit"), corp


def _merge_assembled(xbrl_assembled, audit_assembled):
    """XBRL + audit annual assembled 병합. XBRL 우선, 결측만 audit 로 채움.

    Shape:
        {"columns": {"BS": [...], "PL": [...], "CF": [...]},
         "cells": {(stmt, consol, qname, col): val},
         "labels": {qname: {...}}}
    """
    cells = dict(xbrl_assembled.get("cells") or {})
    labels = dict(xbrl_assembled.get("labels") or {})
    cols_map = {
        "BS": set(xbrl_assembled.get("columns", {}).get("BS", [])),
        "PL": set(xbrl_assembled.get("columns", {}).get("PL", [])),
        "CF": set(xbrl_assembled.get("columns", {}).get("CF", [])),
    }

    audit_cells = (audit_assembled or {}).get("cells") or {}
    audit_labels = (audit_assembled or {}).get("labels") or {}
    audit_cols = (audit_assembled or {}).get("columns") or {}

    # audit cells 는 결측만 채움
    for key, val in audit_cells.items():
        if key in cells:
            continue
        stmt = key[0]
        col = key[3]
        cells[key] = val
        if stmt in cols_map:
            cols_map[stmt].add(col)

    # labels 는 기존 우선, 없을 때만 audit 추가
    for qname, lab in audit_labels.items():
        labels.setdefault(qname, lab)

    # audit annual 컬럼도 union
    for stmt, cols in audit_cols.items():
        if stmt in cols_map:
            cols_map[stmt] |= set(cols)

    def _sort(s):
        return sorted(s, key=lambda c: c.split("/", 1)[0])

    return {
        "columns": {k: _sort(v) for k, v in cols_map.items()},
        "cells": cells,
        "labels": labels,
    }


def _build_unified(query, years, consol_mode, route, corp):
    """route 에 따라 assembled 구성 + excel_writer.write 호출."""
    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
    out_dir = Path(OUTPUT_DIR)
    out_dir.mkdir(parents=True, exist_ok=True)
    fname = f"{corp['corp_name']}_재무제표_{ts}.xlsx"
    out_path = out_dir / fname

    include_quarterly = "xbrl" in route
    corp_type = "사업보고서" if "xbrl" in route else "감사보고서"
    source_route = route

    xbrl_summary = None
    audit_summary = None
    assembled = None

    # 1) XBRL (상장사) — pipeline.collect_assembled
    if "xbrl" in route:
        try:
            bundle = xbrl_pipeline.collect_assembled(query, years=years)
            assembled = bundle["assembled"]
            xbrl_summary = {
                "reports": len(bundle["reports"]),
                "cells": len(assembled.get("cells") or {}),
                "periods_BS": len(assembled.get("columns", {}).get("BS", [])),
                "periods_PL": len(assembled.get("columns", {}).get("PL", [])),
                "periods_CF": len(assembled.get("columns", {}).get("CF", [])),
            }
        except Exception as e:
            print(f"  [xbrl] skip: {e}", file=sys.stderr)
            assembled = None
            if route == "xbrl":
                raise

    # 1b) W-22 Tier-2 fallback: pre-2023 별도 PL 결측 → fnlttSinglAcntAll OFS 보완
    fallback_summary = None
    if assembled is not None and "xbrl" in route and corp.get("corp_code"):
        this_year = datetime.now().year
        year_window = list(range(this_year - years, this_year))
        missing = _missing_separate_years(assembled, year_window)
        if missing:
            try:
                fb = dart_fallback.collect_fallback_assembled(
                    corp["corp_code"], fiscal_years=missing,
                )
                assembled = _merge_assembled(assembled, fb)
                fallback_summary = {"missing_years": missing,
                                    "cells_added": len(fb.get("cells") or {})}
                source_route = source_route + "+fallback"
            except Exception as e:
                print(f"  [fallback OFS] skip: {e}", file=sys.stderr)

    # 2) 감사보고서 HTML — make_audit_fs.build_parsed (엑셀 파일 생성 없이 parse 만)
    audit_parsed = None
    if "audit" in route:
        try:
            audit_parsed = make_audit_fs.build_parsed(
                query, years=years, consol_mode=consol_mode,
            )
            audit_summary = {
                "kinds": list(audit_parsed.get("by_kind", {}).keys()),
                "years_desc": audit_parsed.get("years_desc", []),
                "sources": {k: v.get("sources", [])
                            for k, v in audit_parsed.get("by_kind", {}).items()},
            }
        except Exception as e:
            print(f"  [audit parsed] skip: {e}", file=sys.stderr)
            audit_parsed = None
            if route == "audit":
                raise

    if assembled is None and audit_parsed is None:
        raise ValueError("모든 소스 실패 (XBRL + audit)")

    # 3) Assembled 구성
    if assembled is None:
        # audit-only
        assembled = extract_annual_for_nice(
            audit_parsed.get("by_kind", {}),
            audit_parsed.get("years_desc", []),
        )
    elif audit_parsed is not None:
        # XBRL + audit 병합 (연간 결측 보완)
        audit_assembled = extract_annual_for_nice(
            audit_parsed.get("by_kind", {}),
            audit_parsed.get("years_desc", []),
        )
        assembled = _merge_assembled(assembled, audit_assembled)

"""End-to-end XBRL → assembled 파이프라인.

make_fs.build_for_company 와 smoke/hook 테스트가 공용으로 사용.
Excel 출력은 본 모듈의 책임이 아님 (excel_writer 에 위임).

반환:
  {
    'corp':      {'corp_code', 'corp_name', 'stock_code', 'modify_date'},
    'reports':   [{'rcept_no','reprt_code','report_nm','rcept_dt','zip'}, ...],
    'assembled': period_builder.assemble 결과를 별도/연결 양쪽 병합한 dict.
  }
"""
from __future__ import annotations

import sys
from typing import Any, Optional

from xbrl import downloader, parser, period_builder


def _auto_detect_consol(parsed: dict) -> str:
    """parsed.facts 의 context_id 로 연결/별도 판별. 모호하면 '연결'."""
    has_cfs = False
    has_sep = False
    for f in parsed.get("facts", [])[:500]:
        cid = (f.get("context_id") or "").lower()
        if "cfs" in cid or "consolidat" in cid:
            has_cfs = True
        elif "separate" in cid or "sepfs" in cid:
            has_sep = True
    if has_cfs and not has_sep:
        return "연결"
    if has_sep and not has_cfs:
        return "별도"
    return "연결"


def _merge_assembled(parts: list[tuple[dict, str]]) -> dict[str, Any]:
    """period_builder.assemble 결과 리스트(consol 별) 를 1개 assembled 로 병합."""
    out_cells: dict = {}
    out_labels: dict = {}
    cols_set: dict = {"BS": set(), "PL": set(), "CF": set()}
    for a, _consol in parts:
        out_cells.update(a["cells"])
        out_labels.update(a["labels"])
        for k, v in a["columns"].items():
            cols_set[k] = set(cols_set[k]) | set(v)
    columns = {
        k: sorted(v, key=lambda c: c.split("/", 1)[0])
        for k, v in cols_set.items()
    }
    return {"columns": columns, "cells": out_cells, "labels": out_labels}


def collect_assembled(
    query: str,
    *,
    years: int = 10,
    warn_stream=sys.stderr,
) -> dict[str, Any]:
    """회사 식별 → XBRL zip → parse → assemble 을 1-step 으로 수행."""
    collected = downloader.collect(query, years=years)
    corp = collected["corp"]
    reports = [r for r in collected["reports"] if r.get("zip")]
    if not reports:
        raise RuntimeError(f"XBRL zip 수집 실패 또는 공시 없음: {corp['corp_name']}")

    parsed_sep: list[dict] = []
    parsed_con: list[dict] = []
    for rep in reports:
        try:
            p = parser.parse_zip(rep["zip"])
        except Exception as e:  # noqa: BLE001
            if warn_stream is not None:
                print(f"[WARN] parse 실패 {rep['rcept_no']}: {e}", file=warn_stream)
            continue
        cons = _auto_detect_consol(p)
        (parsed_con if cons == "연결" else parsed_sep).append(p)

    parts: list[tuple[dict, str]] = []
    if parsed_sep:
        parts.append((period_builder.assemble(parsed_sep, consol_hint="별도"), "별도"))
    if parsed_con:
        parts.append((period_builder.assemble(parsed_con, consol_hint="연결"), "연결"))
    assembled = _merge_assembled(parts)

    return {"corp": corp, "reports": reports, "assembled": assembled}


def pick_consol(assembled: dict, preference: Optional[str] = None) -> Optional[str]:
    """assembled 에서 사용할 consol 결정. preference 우선, 없으면 연결 → 별도 순."""
    from xbrl.fs_views import available_consols
    avail = available_consols(assembled)
    if preference and preference in avail:
        return preference
    for c in ("연결", "별도"):
        if c in avail:
            return c
    return None

def compute_individual_quarters(quarter_data, years):
    """분기 개별값 산출. DART API 데이터 convention:

    IS (sj_div: IS, CIS): 개별 분기 3개월 값으로 제공됨
      - Q1/H1/Q3 값을 그대로 사용 (이미 개별 분기)
      - Q4 = FY - Q1 - H1값 - Q3값

    CF (sj_div: CF): 누적 값으로 제공됨 (K-IFRS 1034)
      - Q2 = H1 - Q1, Q3 = 9M - H1, Q4 = FY - 9M

    BS (sj_div: BS): 시점 데이터 → 변환 불필요

    SCE (sj_div: SCE): 누적 (CF와 동일 처리)

    Returns:
        result: {(year, "Q1"/"Q2"/"Q3"/"Q4"): {item_key: amount}}
        all_keys: [item_key...] 순서 보존
        key_info: {item_key: (sj_div, account_nm, account_detail, ord)}
    """
    result = {}
    all_keys = []
    key_info = {}
    seen_keys = set()

    # 먼저 모든 항목 키와 순서 수집
    for (year, period), items in sorted(quarter_data.items()):
        for item in items:
            key = build_item_key(item)
            if key not in seen_keys:
                seen_keys.add(key)
                all_keys.append(key)
                key_info[key] = (
                    item.get("sj_div", ""),
                    item.get("account_nm", ""),
                    item.get("account_detail", ""),
                    item.get("ord", "999"),
                )

    # 항목별 정렬: sj_div → ord
    sj_order = {"BS": 0, "CIS": 1, "IS": 1, "CF": 2, "SCE": 3}
    all_keys.sort(key=lambda k: (sj_order.get(key_info[k][0], 9), int(key_info[k][3]) if key_info[k][3].isdigit() else 999))

    for year in years:
        # 각 기간 데이터를 딕셔너리화
        raw = {}
        for period in ["Q1", "H1", "Q3", "FY"]:
            items = quarter_data.get((year, period), [])
            raw[period] = {}
            for item in items:
                key = build_item_key(item)
                amt = parse_amount(item.get("thstrm_amount", ""))
                raw[period][key] = amt

        # 개별 분기값 계산
        for q_label in ["Q1", "Q2", "Q3", "Q4"]:
            col = {}
            for key in all_keys:
                sj_div = key_info[key][0]
                sheet = classify_sj_div(sj_div)

                if sheet == "BS":
                    # BS: 시점 데이터 → 해당 기간말 잔액
                    period_map = {"Q1": "Q1", "Q2": "H1", "Q3": "Q3", "Q4": "FY"}
                    col[key] = raw[period_map[q_label]].get(key)

                elif sheet == "IS":
                    # IS: 이미 개별 분기 값
                    if q_label == "Q1":
                        col[key] = raw["Q1"].get(key)
                    elif q_label == "Q2":
                        col[key] = raw["H1"].get(key)  # H1 값 = Q2 개별
                    elif q_label == "Q3":
                        col[key] = raw["Q3"].get(key)  # Q3 값 = Q3 개별
                    else:  # Q4
                        # Q4 = FY - Q1 - Q2 - Q3
                        fy = raw["FY"].get(key)
                        q1 = raw["Q1"].get(key)
                        q2 = raw["H1"].get(key)
                        q3 = raw["Q3"].get(key)
                        if fy is not None:
                            col[key] = fy - (q1 or 0) - (q2 or 0) - (q3 or 0)
                        else:
                            col[key] = None

                elif sheet == "CF" or sj_div == "SCE":
                    # CF/SCE: 누적 값 → 차감
                    if q_label == "Q1":
                        col[key] = raw["Q1"].get(key)
                    elif q_label == "Q2":
                        col[key] = _subtract(raw["H1"].get(key), raw["Q1"].get(key))
                    elif q_label == "Q3":
                        col[key] = _subtract(raw["Q3"].get(key), raw["H1"].get(key))
                    else:  # Q4
                        col[key] = _subtract(raw["FY"].get(key), raw["Q3"].get(key))

                else:
                    col[key] = None

            result[(year, q_label)] = col

    return result, all_keys, key_info


def _subtract(a, b):

def cmd_compare(company: str, segment: str,
                years_n: int = 3, currency: str | None = None,
                save: bool = False, email: bool = False):
    """비교 분석 실행."""
    seg_info = get_segment_peers(company, segment)
    if seg_info is None:
        print(f"❌ '{company}'의 '{segment}' 세그먼트가 등록되지 않았습니다.")
        segs = list_segments(company)
        if segs:
            print(f"   등록된 세그먼트: {', '.join(segs)}")
        print(f"   peer_registry.json에 등록하거나 Claude에게 경쟁사 식별을 요청하세요.")
        return

    focus_metrics = seg_info.get("focus_metrics", [])
    current_year = datetime.now().year
    years = list(range(current_year - years_n + 1, current_year + 1))

    print(f"\n📊 {company} — {segment} 동종업체 비교")
    print(f"   기간: {years[0]}~{years[-1]} ({years_n}년)")
    if currency:
        print(f"   환산통화: {currency}")
    print(f"   중점지표: {', '.join(focus_metrics) if focus_metrics else '전체'}")
    print("=" * 60)

    # 데이터 수집
    all_data = fetch_all_peers(company, segment, years)
    if not all_data:
        print("❌ 데이터 수집 실패")
        return

    print(f"\n✅ {len(all_data)}개 기업 데이터 수집 완료")

    # 비율 비교 테이블
    if years_n == 1:
        print_ratio_table(all_data, years[-1], segment, focus_metrics)
    else:
        print_multi_year_table(all_data, years, segment, focus_metrics)

    # 절대금액 비교
    if currency:
        # 가장 최근 연도만
        latest_year = max(y for d in all_data for y in d.get("years", {}).keys())
        print_abs_table(all_data, latest_year, segment, currency)

    # 테이크어웨이
    latest_year = max(y for d in all_data for y in d.get("years", {}).keys())
    takeaway = generate_takeaway(all_data, latest_year, focus_metrics)
    if takeaway:
        print(takeaway)

    # CSV
    if save:
        save_csv(all_data, years, segment, company,
                 focus_metrics, currency)

    # Excel + 이메일
    if email:
        try:
            from report_delivery import peer_to_xlsx, send_report_email, notify_report
        except ImportError:
            print("⚠️ --email 비활성: report_delivery 모듈 부재 (리포트 전달/RAC 트랙 보류 중). "
                  "--csv 로 저장 후 수동 전달하세요.", file=sys.stderr)
            return
        from peer_analysis.peer_comparison import build_ratio_table, build_abs_table

        all_years_data = []
        for year in years:
            entry = {"year": year, "ratio_table": build_ratio_table(all_data, year, focus_metrics)}
            if currency:
                entry["abs_table"] = build_abs_table(all_data, year, currency)
            all_years_data.append(entry)

from __future__ import annotations
"""
ratio_engine.py — 비율 산출 + 절대금액 환산.
"""
from peer_analysis.peer_config import (
    RATIO_META, convert_currency, FISCAL_MONTH_LABEL,
)


def compute_ratios(data: dict, year: int) -> dict:
    """
    단일 기업, 단일 연도 비율 산출.
    data: {revenue, gross_profit, op_income, net_income, total_assets,
           total_equity, total_debt, da, capex, ocf}
    returns: {ratio_name: value_float_or_None}
    """
    d = data.get("years", {}).get(year, {})
    if not d:
        return {}

    rev = d.get("revenue")
    gp = d.get("gross_profit")
    oi = d.get("op_income")
    ni = d.get("net_income")
    ta = d.get("total_assets")
    te = d.get("total_equity")
    td = d.get("total_debt")
    da = d.get("da")
    capex = d.get("capex")
    ocf = d.get("ocf")

    ratios = {}

    # 수익성
    if rev and rev != 0:
        if gp is not None:
            ratios["GPM"] = gp / rev
        if oi is not None:
            ratios["OPM"] = oi / rev
        if ni is not None:
            ratios["NPM"] = ni / rev
        if capex is not None:
            ratios["CAPEX/매출"] = capex / rev
        if oi is not None and da is not None:
            ebitda = oi + da
            ratios["EBITDA마진"] = ebitda / rev

    # 자본 효율
    if ni is not None and te and te != 0:
        ratios["ROE"] = ni / te
    if ni is not None and ta and ta != 0:
        ratios["ROA"] = ni / ta

    # 재무 구조
    if td is not None and te and te != 0:
        ratios["D/E"] = td / te

    # 현금흐름
    if ocf is not None and ni and ni != 0:
        ratios["CFO/NI"] = ocf / ni

    # EBITDA 기반
    if oi is not None and da is not None:
        ebitda = oi + da
        if ebitda != 0:
            # Net Debt = 총차입금 - 현금 (현금 데이터 없으면 총차입금만)
            if td is not None:
                net_debt = td  # 현금 정보 없으면 gross debt 사용
                ratios["NetDebt/EBITDA"] = net_debt / ebitda

    return ratios


def compute_abs_amounts(data: dict, year: int,
                        target_ccy: str) -> dict:
    """
    절대금액 비교 항목 산출 + 환율 환산.
    returns: {item_name: converted_value}
    """
    d = data.get("years", {}).get(year, {})
    if not d:
        return {}

    from_ccy = data.get("currency", "USD")
    employees = data.get("employees")

    amounts = {}

    rev = d.get("revenue")
    oi = d.get("op_income")
    da = d.get("da")
    capex = d.get("capex")
    ta = d.get("total_assets")

    if rev is not None:
        amounts["매출액"] = convert_currency(rev, from_ccy, target_ccy, year)
    if oi is not None:
        amounts["영업이익"] = convert_currency(oi, from_ccy, target_ccy, year)
    if oi is not None and da is not None:
        ebitda = oi + da
        amounts["EBITDA"] = convert_currency(ebitda, from_ccy, target_ccy, year)
    if capex is not None:
        amounts["CAPEX"] = convert_currency(capex, from_ccy, target_ccy, year)
    if ta is not None:
        amounts["총자산"] = convert_currency(ta, from_ccy, target_ccy, year)
    if employees:
        amounts["종업원수"] = employees
    if rev is not None and employees:
        per_emp = convert_currency(rev, from_ccy, target_ccy, year) / employees
        amounts["1인당매출"] = per_emp

    return amounts


def format_ratio(value: float | None, ratio_name: str) -> str:
    """비율 값을 포맷팅."""
    if value is None:
        return "N/A"

    meta = RATIO_META.get(ratio_name, {})
    fmt = meta.get("fmt", "pct")

    if fmt == "pct":
        return f"{value * 100:.1f}%"
    elif fmt == "x":
        return f"{value:.2f}x"
    else:
        return f"{value:.2f}"


def format_amount(value: float | None, item_name: str,
                  currency: str = "USD") -> str:
    """절대금액 포맷팅."""
    if value is None:
        return "N/A"

    if item_name == "종업원수":
        return f"{int(value):,}"

    ccy_symbol = {"USD": "$", "KRW": "₩", "TWD": "NT$",
                  "JPY": "¥", "EUR": "€", "CNY": "¥"}.get(currency, currency)

    abs_val = abs(value)
    sign = "-" if value < 0 else ""

    if abs_val >= 1e12:
        formatted = f"{abs_val / 1e12:.1f}T"
    elif abs_val >= 1e9:
        formatted = f"{abs_val / 1e9:.1f}B"
    elif abs_val >= 1e6:
        formatted = f"{abs_val / 1e6:.0f}M"
    elif abs_val >= 1e3:
        formatted = f"{abs_val / 1e3:.0f}K"
    else:
        formatted = f"{abs_val:.0f}"

    return f"{sign}{ccy_symbol}{formatted}"

{
  "삼성전자": {
    "segments": {
      "메모리반도체": {
        "focus_metrics": ["GPM", "OPM", "CAPEX/매출", "EBITDA마진"],
        "peers": [
          {"name": "SK하이닉스",      "source": "DART", "stock_code": "000660"},
          {"name": "Micron",          "source": "YFINANCE", "ticker": "MU"},
          {"name": "Western Digital", "source": "YFINANCE", "ticker": "WDC"}
        ]
      },
      "파운드리": {
        "focus_metrics": ["OPM", "CAPEX/매출", "ROE"],
        "peers": [
          {"name": "TSMC",  "source": "YFINANCE", "ticker": "TSM"},
          {"name": "Intel", "source": "YFINANCE", "ticker": "INTC"},
          {"name": "UMC",   "source": "YFINANCE", "ticker": "UMC"}
        ]
      }
    }
  }
}

# ══════════════════════════════════════════════════════
# ① CLI subprocess 호출
# ══════════════════════════════════════════════════════
def call_llm(
    prompt: str,
    *,
    system: str | None = None,
    model: str = "haiku",
    max_tokens: int = 4096,
    allowed_tools: list[str] | None = None,
    permission_mode: str = "default",
    json_mode: bool = False,
    timeout: int = 120,
    cwd: str | Path | None = None,
    label: str = "call_llm",
) -> str:
    """
    Claude Code CLI를 subprocess로 호출.

    Args:
        prompt: 사용자 메시지 (stdin으로 전달).
        system: 시스템 프롬프트 (--system-prompt 또는 --append-system-prompt).
        model: 모델 별칭 ("haiku", "sonnet", "opus") 또는 정식 ID.
        max_tokens: 최대 응답 토큰 (--max-tokens).
        allowed_tools: 허용 도구 리스트 (미지정 시 도구 없음 = --print 모드).
        permission_mode: "default", "acceptEdits", "bypassPermissions".
        json_mode: True이면 JSON 출력 지시를 시스템 프롬프트에 추가.
        timeout: subprocess 타임아웃 (초).
        cwd: 작업 디렉토리.
        label: 토큰 추적 라벨.

    Returns:
        모델 응답 텍스트.
    """
    model_id = _resolve_model(model)

    # 시스템 프롬프트 구성
    sys_parts = []
    if system:
        sys_parts.append(system)
    if json_mode:
        sys_parts.append("Respond only with valid JSON. No explanation or markdown.")
    sys_prompt = "\n\n".join(sys_parts) if sys_parts else None

    # 명령어 구성
    cmd = [CLAUDE_BIN]

    if allowed_tools:
        # 도구 사용 모드: --output-format json, --allowedTools
        cmd += [
            "--print",
            "--output-format", "json",
            "--model", model_id,
            "--permission-mode", permission_mode,
            "--allowedTools", ",".join(allowed_tools),
        ]
    else:
        # 단순 응답 모드: -p (print only)
        cmd += [
            "--print",
            "--output-format", "json",
            "--model", model_id,
        ]

    # MCP 서버 차단: claude.ai Gmail/Calendar 등 auth 대기 서버 참조 방지
    cmd += ["--strict-mcp-config", "--mcp-config", '{"mcpServers":{}}']

    if sys_prompt:
        cmd += ["--system-prompt", sys_prompt]

    # CLI는 --max-tokens 미지원, --max-budget-usd로 비용 제한 가능

    env = {**os.environ, "PATH": CLAUDE_PATH}
    t0 = time.time()

    try:
        result = subprocess.run(
            cmd,
            input=prompt,
            capture_output=True,
            text=True,
            timeout=timeout,
            cwd=str(cwd or WORK_DIR),
            env=env,
        )
    except subprocess.TimeoutExpired:
        return f"[ERROR] timeout ({timeout}s)"

    elapsed = int((time.time() - t0) * 1000)

    # 응답 파싱
    stdout = result.stdout.strip()
    if not stdout:
        stderr = result.stderr.strip()
        return f"[ERROR] {stderr[:200]}" if stderr else "[ERROR] empty response"

    try:
        parsed = json.loads(stdout)
        text = parsed.get("result", stdout)
        usage = parsed.get("usage", {})
        cost = parsed.get("total_cost_usd")

        # CLI는 인증 실패(크론에서 keychain 미접근 등)도 rc=0 + result 본문으로 반환함
        # — [ERROR] prefix가 없으면 성공으로 집계돼 haiku_monitor 통계가 왜곡되므로 정규화
        if parsed.get("is_error") or _AUTH_FAIL_RX.search(text or ""):

            continue
        title = strip_html(a.get_text(strip=True))
        link = urljoin(base, a.get("href") or "")
        tds = [td.get_text(strip=True) for td in tr.find_all("td")]
        pub, dept = "", ""
        for t in tds:
            if re.fullmatch(r"\d{4}-\d{2}-\d{2}", t):
                pub = t
            elif t.endswith("국") or t.endswith("실") or t.endswith("팀"):
                dept = t
        if title:
            items.append((title, dept[:300], link, pub))
        if len(items) >= max_items:
            break
    return items


_POLICY_PARSERS = {"fsc": _parse_fsc, "fss": _parse_fss}


def get_policy_board(cfg: dict, max_items: int = 5) -> list | None:
    """정책 게시판 HTML 파싱. Returns [(title, desc, link, pub_date)], 실패 시 None."""
    url = cfg["url"]
    try:
        r = requests.get(url, headers={"User-Agent": "Mozilla/5.0"}, timeout=10)
        r.raise_for_status()
        soup = BeautifulSoup(r.text, "html.parser")
        items = _POLICY_PARSERS[cfg["parser"]](soup, cfg["base"], max_items)
        if not items:
            # 목록 0건 = 마크업 변경 신호. 조용히 지나가면 이번처럼 장기간 방치됨
            print(f"[tracker] 정책 게시판 파싱 0건 — 마크업 변경 의심 ({url[:60]})",
                  file=sys.stderr)
        return items
    except Exception as e:
        print(f"[tracker] 정책 게시판 실패 ({url[:60]}): {e}", file=sys.stderr)
        return None  # '수집 실패'를 '0건'과 구분


def get_conviction_companies() -> list:
    """pm_signals watchlist 회사명 로드. 실패 시 빈 리스트 (주 수집 기능 보호)."""
    base = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
    try:
        if base not in sys.path:
            sys.path.insert(0, base)
        import pm_signals
        return list(pm_signals.watchlist().keys())
    except Exception as e:
        print(f"[tracker] pm_signals 로드 실패 — 컨빅션 종목 편입 스킵: {e}",
              file=sys.stderr)
        return []


def keyword_match(text: str, keywords: list) -> bool:
    """텍스트에 키워드가 하나라도 포함되면 True."""
    text_lower = text.lower()
    return any(kw.lower() in text_lower for kw in keywords)


def should_collect_today(frequency: str, last_collected: str) -> bool:
    """수집 주기에 따라 오늘 수집할지 판단."""
    if frequency == "daily":
        return True
    today = datetime.now().date()
    if not last_collected:
        return True
    last = datetime.strptime(last_collected, "%Y-%m-%d").date()
    if frequency == "weekly":
        return (today - last).days >= 7
    if frequency == "biweekly":
        return (today - last).days >= 14
    return True


def collect_topic(slug: str) -> tuple:
    """단일 주제 수집. Returns (신규 기사 수, 전소스 실패 여부)."""
    topic_dir = os.path.join(BASE_DIR, slug)

    # LLM 호출 단일 경계: token_ledger·haiku_monitor·MCP차단·cwd=/tmp·모델별칭 자동
    text = call_haiku_tracked(prompt, system=system, label="topic_reporter", timeout=120)
    if text.startswith("[ERROR]"):
        print(f"[reporter] Haiku 오류: {text[:200]}", file=sys.stderr)
        raise ReportFailure(text[:200])
    return text


def generate_report(slug: str, as_of: datetime | None = None) -> str:
    """단일 주제의 주간 리포트 생성.

    as_of: 기준일 지정 (기본 오늘). 크론 실패로 누락된 주차를 사후 백필할 때 사용.
    """
    topic_dir = os.path.join(BASE_DIR, slug)
    meta_path = os.path.join(topic_dir, "meta.json")
    articles_path = os.path.join(topic_dir, "articles.json")

    meta = load_json(meta_path, default={})
    articles = load_json(articles_path, default=[])

    topic_name = meta["topic_name"]
    today = as_of or datetime.now()
    week_ago = (today - timedelta(days=7)).strftime("%Y-%m-%d")
    today_str = today.strftime("%Y-%m-%d")
    week_label = today.strftime("%Y-W%W")

    # 최근 7일 기사 필터
    recent = [a for a in articles if a.get("collected", "") >= week_ago]

    if not recent:
        return ""

    # 기사 목록 텍스트
    article_list = "\n".join(
        f'- [{a.get("source", "?")}] {a["title"]}\n  {a.get("desc", "")[:150]}'
        for a in recent[:30]
    )

    # 과거 주 기사 수 (트렌드 비교용)
    two_weeks_ago = (today - timedelta(days=14)).strftime("%Y-%m-%d")
    prev_week = [a for a in articles
                 if two_weeks_ago <= a.get("collected", "") < week_ago]

    prompt = f"""주제: "{topic_name}"
기간: {week_ago} ~ {today_str}
금주 수집 기사: {len(recent)}건 (전주: {len(prev_week)}건)

[수집된 기사 목록]
{article_list}

아래 형식으로 주간 리포트를 작성하세요:

[정책변화]
이번 주 새로운 정책·규제 변화가 있으면 bullet으로 정리. 없으면 "해당 없음".

[주요기사]
카테고리별로 분류하여 정리. 각 기사 1줄 요약.
형식: • [카테고리] 기사제목 — 요약 1줄

[트렌드]
전주 대비 변화, 주목할 흐름 2~3줄.

[타임라인추가]
timeline.md에 추가할 만한 중요 정책/이벤트가 있으면 아래 형식으로. 없으면 "없음".
- [YYYY-MM] 내용 — 의미"""

    report_text = call_haiku(
        prompt,
        "당신은 한국 금융·산업 전문 리서치 어시스턴트입니다. 한국어로 간결하게 작성하세요.")

    # ── 주간 리포트 저장 ──
    report_path = os.path.join(topic_dir, "weekly", f"{week_label}.md")
    os.makedirs(os.path.dirname(report_path), exist_ok=True)
    with open(report_path, "w") as f:
        f.write(f"# {topic_name} 주간 리포트 ({week_ago} ~ {today_str})\n\n")
        f.write(f"수집 기사: {len(recent)}건 (전주: {len(prev_week)}건)\n\n")
        f.write(report_text)

    # ── timeline.md 업데이트 ──
    # [타임라인추가]는 리포트 마지막 섹션. 경계는 다음 '한글 섹션헤더'([정책변화]/[주요기사]/[트렌드])
    # 또는 문자열 끝. 과거 (?=\[|$) 는 본문의 [YYYY-MM] 날짜마커에서 잘려 빈 스텁만 저장됐음.
    tl_match = re.search(
        r'\[타임라인추가\]\s*(.*?)(?=\n\s*\[(?:정책변화|주요기사|트렌드)\]|\Z)',
        report_text, re.S)
    if tl_match:
        tl_text = tl_match.group(1).strip()
        if tl_text and tl_text != "없음":
            tl_path = os.path.join(topic_dir, "timeline.md")
            with open(tl_path, "a") as f:
                f.write(f"\n\n### {today_str} 업데이트\n{tl_text}")

    # ── Google Doc 업데이트 ──
    # 백필은 Doc에 prepend하면 최신 주차 위로 과거 주차가 올라가 순서가 뒤집힘 → 생략
    doc_id = None if as_of else meta.get("doc_id")
    if doc_id:
        try:
            token = docs_api.get_token()
            section = (
                f"\n{'─' * 40}\n"
                f"📋 주간 리포트 ({week_ago} ~ {today_str})\n"
                f"수집: {len(recent)}건 | 전주: {len(prev_week)}건\n"
                f"{'─' * 40}\n\n"
                f"{report_text}\n\n"
            )
            # 연혁 섹션 바로 위 (문서 하단)에 삽입하지 않고, 리포트 영역 상단에 prepend
            docs_api.prepend_section(token, doc_id, section)
        except Exception as e:
            print(f"[reporter] Doc 업데이트 실패: {e}", file=sys.stderr)

def setup(topic_name: str, notify: bool = False) -> dict:
    """주제 셋업 메인 로직. Returns meta dict."""
    slug = slugify(topic_name)
    topic_dir = os.path.join(BASE_DIR, slug)
    os.makedirs(topic_dir, exist_ok=True)

    if notify:
        send_ntfy(f"⏳ 주제 트래커 셋업 시작: {topic_name}", tags="hourglass_flowing_sand")

    # ── Step 1: Sonnet — 키워드 + 수집주기 + Google News 쿼리 ──
    system = ("당신은 한국 금융·산업 전문 리서치 어시스턴트입니다. "
              "출력은 반드시 지정된 JSON 형식으로만 작성하세요. 마크다운 코드블록 없이 순수 JSON만.")
    prompt1 = f"""주제: "{topic_name}"

이 주제에 대한 뉴스·정책 모니터링을 설계해주세요.
순수 JSON으로만 응답하세요 (```json 블록 없이):

{{
  "keywords": ["키워드1", "키워드2", ...],
  "google_news_queries": ["검색어1 OR 검색어2", ...],
  "policy_sources": ["관련 정부기관/사이트명", ...],
  "frequency": "daily|weekly|biweekly",
  "frequency_reason": "주기 선택 이유 1줄",
  "description": "이 주제 모니터링의 목적 1줄"
}}

키워드: 5~10개, 한국어 + 영문 혼합 가능
google_news_queries: Google News RSS에 사용할 최적 검색 쿼리 2~3개
policy_sources: 관련 정부기관/규제기관명
frequency: 뉴스 발생 빈도와 주제 특성에 맞는 수집 주기 제안"""

    raw1 = call_sonnet(prompt1, system)
    if not raw1:
        print("[setup_topic] Step 1 실패", file=sys.stderr)
        return {}

    # JSON 파싱 (코드블록 감싸기 대응)
    json_match = re.search(r'\{[\s\S]*\}', raw1)
    if not json_match:
        print(f"[setup_topic] JSON 파싱 실패: {raw1[:200]}", file=sys.stderr)
        return {}
    meta = json.loads(json_match.group())

    # ── Step 2: Sonnet — 과거 5~10년 정책 연혁 ──
    kw_str = ", ".join(meta.get("keywords", []))
    prompt2 = f"""주제: "{topic_name}"
관련 키워드: {kw_str}

이 주제와 관련된 한국의 과거 5~10년간(2016~2026) 주요 정책 변화와 산업 이벤트를 연혁 형태로 정리하세요.

형식:
## {topic_name} 정책·산업 연혁 (2016~2026)

### 2024
- [2024-MM] 정책/이벤트 내용 — 영향·의미 1줄

### 2023
...

규칙:
- 연도별 역순 (최신 → 과거)
- 각 항목: 시기 + 내용 + 의미/영향 1줄
- 확인 가능한 사실만 포함 (추측 금지)
- 주요 법률 개정, 감독 규정 변경, 대형 M&A, 산업 구조 변화 중심
- 항목이 없는 연도는 생략"""

    timeline_text = call_sonnet(prompt2, "당신은 한국 금융·산업 정책 전문가입니다. 사실 기반으로만 작성하세요.")
    if not timeline_text:
        timeline_text = f"## {topic_name} 정책·산업 연혁\n\n(초기 생성 실패 — 수동 보완 필요)"

    # ── Step 3: 저장 ──
    meta.update({
        "topic_name": topic_name,
        "slug": slug,
        "created": datetime.now().strftime("%Y-%m-%d %H:%M"),
        "status": "active",
        "doc_id": None,
        "doc_url": None,
    })

    save_json(os.path.join(topic_dir, "meta.json"), meta)

    # timeline.md
    with open(os.path.join(topic_dir, "timeline.md"), "w") as f:
        f.write(timeline_text)

    # articles.json (빈 초기화)
    save_json(os.path.join(topic_dir, "articles.json"), [])

    # weekly 디렉토리
    os.makedirs(os.path.join(topic_dir, "weekly"), exist_ok=True)

    # ── Step 4: Google Doc 생성 + 공유 ──
    try:
        token = docs_api.get_token()
        doc_id, doc_url = docs_api.create_doc(token, f"📋 {topic_name}")
        docs_api.share_doc(token, doc_id)

        # 초기 내용 작성
        doc_content = f"{topic_name}\n{'=' * 40}\n\n"
        doc_content += f"생성일: {meta['created']}\n"
        doc_content += f"키워드: {', '.join(meta['keywords'])}\n"
        doc_content += f"수집 주기: {meta['frequency']} ({meta.get('frequency_reason', '')})\n"
        doc_content += f"정책 소스: {', '.join(meta.get('policy_sources', []))}\n"
        doc_content += "\n" + "=" * 40 + "\n\n"
        doc_content += timeline_text
        doc_content += "\n\n" + "=" * 40 + "\n"
        doc_content += "\n[주간 리포트는 아래에 역순으로 추가됩니다]\n"

        docs_api.replace_body(token, doc_id, doc_content)

        meta["doc_id"] = doc_id
        meta["doc_url"] = doc_url
        save_json(os.path.join(topic_dir, "meta.json"), meta)
    except Exception as e:
        print(f"[setup_topic] Google Doc 생성 실패: {e}", file=sys.stderr)

    # ── Step 5: config.json 업데이트 ──
    cfg = load_json(CONFIG_PATH, default={"topics": {}})
    cfg.setdefault("topics", {})[slug] = {
        "name": topic_name,
        "frequency": meta.get("frequency", "daily"),
        "status": "active",
        "doc_url": meta.get("doc_url"),
    }
    save_json(CONFIG_PATH, cfg)

    # ── Step 6: 알림 ──
    kw_display = ", ".join(meta["keywords"][:6])
    freq = meta.get("frequency", "daily")
    report = (
        f"📋 <b>주제 트래커 셋업 완료</b>\n\n"
        f"<b>주제:</b> {topic_name}\n"
        f"<b>키워드:</b> {kw_display}\n"
        f"<b>수집 주기:</b> {freq}\n"
        f"<b>정책 소스:</b> {', '.join(meta.get('policy_sources', [])[:3])}\n"
        f"<b>Google Doc:</b> {meta.get('doc_url', 'N/A')}\n\n"
        f"📜 연혁 {timeline_text.count(chr(10))}줄 생성됨"
    )
    if notify:
        send_telegram(report, disable_web_page_preview=True)
        send_ntfy(f"✅ 주제 트래커 셋업 완료: {topic_name}", tags="white_check_mark")

    print(f"✅ 셋업 완료: {topic_name} → {topic_dir}")
    print(f"   키워드: {kw_display}")
    print(f"   주기: {freq}")
    print(f"   Doc: {meta.get('doc_url', 'N/A')}")
    return meta

"""
Google Docs API 헬퍼.
- 문서 생성, 텍스트 삽입, 공유
"""
import requests
import sys
sys.path.insert(0, "/Users/raccoonfamily/ClaudeCode/dart_capital_report")
import config

_DOCS_V1 = "https://docs.googleapis.com/v1/documents"
_DRIVE_V3 = "https://www.googleapis.com/drive/v3/files"


def get_token():
    return config.get_google_token()


def _h(token):
    return {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}


def create_doc(token: str, title: str) -> tuple:
    """새 Google Doc 생성. Returns (doc_id, url)."""
    r = requests.post(_DOCS_V1, headers=_h(token), json={"title": title})
    r.raise_for_status()
    doc = r.json()
    doc_id = doc["documentId"]
    return doc_id, f"https://docs.google.com/document/d/{doc_id}"


def share_doc(token: str, doc_id: str, email: str = None):
    """문서를 이메일에 공유 (writer 권한)."""
    target = email or "byungho.kim.kor@gmail.com"
    requests.post(
        f"{_DRIVE_V3}/{doc_id}/permissions",
        headers=_h(token),
        json={"type": "user", "role": "writer", "emailAddress": target}
    )


def insert_text(token: str, doc_id: str, text: str, index: int = 1):
    """문서 특정 위치에 텍스트 삽입."""
    requests.post(
        f"{_DOCS_V1}/{doc_id}:batchUpdate",
        headers=_h(token),
        json={"requests": [{"insertText": {"location": {"index": index}, "text": text}}]}
    )


def replace_body(token: str, doc_id: str, content: str):
    """문서 전체 내용을 교체 (기존 내용 삭제 후 삽입)."""
    # 현재 문서 길이 확인
    r = requests.get(f"{_DOCS_V1}/{doc_id}", headers=_h(token))
    r.raise_for_status()
    doc = r.json()
    body = doc.get("body", {})
    content_elems = body.get("content", [])
    if content_elems:
        end_index = content_elems[-1].get("endIndex", 1)
    else:
        end_index = 1

    reqs = []
    # 기존 내용 삭제 (index 1 ~ end-1)
    if end_index > 2:
        reqs.append({
            "deleteContentRange": {
                "range": {"startIndex": 1, "endIndex": end_index - 1}
            }
        })
    # 새 내용 삽입
    reqs.append({"insertText": {"location": {"index": 1}, "text": content}})

    requests.post(
        f"{_DOCS_V1}/{doc_id}:batchUpdate",
        headers=_h(token), json={"requests": reqs}
    )


def prepend_section(token: str, doc_id: str, section_text: str):
    """문서 맨 앞(index 1)에 섹션 추가. 기존 내용은 아래로 밀림."""
    insert_text(token, doc_id, section_text + "\n\n", index=1)


def get_doc_text(token: str, doc_id: str) -> str:
    """문서 전체 텍스트 추출."""
    r = requests.get(f"{_DOCS_V1}/{doc_id}", headers=_h(token))
    r.raise_for_status()
    doc = r.json()
    texts = []
    for elem in doc.get("body", {}).get("content", []):
        if "paragraph" in elem:
            for run in elem["paragraph"].get("elements", []):
                if "textRun" in run:
                    texts.append(run["textRun"]["content"])
    return "".join(texts)

def complete_task(page_id):
    """태스크 완료 처리. 반복 태스크면 다음 인스턴스 생성."""
    page = get_task(page_id)
    if not page:
        return None

    # 완료 처리
    update_task(page_id, status="Done")

    # 부모 태스크 자동 완료 확인
    parent_ids = _get_relation_ids(page, "Parent Task")
    for pid in parent_ids:
        _sync_parent(pid)

    # 반복 처리
    recurrence = _get_select(page, "Recurrence")
    if recurrence:
        due_str = _get_date(page, "Due")
        if due_str:
            next_due = _calc_next_due(due_str, recurrence)
            remind_str = _get_date(page, "Remind At")
            next_remind = None
            if remind_str:
                next_remind = _calc_next_due(remind_str, recurrence)
            return add_task(
                _get_title(page),
                due=next_due,
                priority=_get_select(page, "Priority") or "🟡보통",
                assignee=_get_text(page, "Assignee"),
                tags=[s["name"] for s in page["properties"].get("Tags", {}).get("multi_select", [])],
                project_id=(_get_relation_ids(page, "Project") or [None])[0],
                remind_at=next_remind,
                recurrence=recurrence,
            )
    return None


def delete_task(page_id):
    """태스크 아카이브(삭제)."""
    return _patch(f"https://api.notion.com/v1/pages/{page_id}", {"archived": True})


def get_task(page_id):
    """단일 태스크 조회."""
    r = requests.get(f"https://api.notion.com/v1/pages/{page_id}",
                     headers=HEADERS, timeout=30)
    data = r.json()
    return data if "id" in data else None


def list_children(parent_task_id: str) -> list:
    """부모 태스크의 하위 태스크 목록 (완료 포함)."""
    result = _post(f"https://api.notion.com/v1/databases/{TASKS_DB}/query", {
        "filter": {"property": "Parent Task", "relation": {"contains": parent_task_id}},
        "page_size": 50,
    })
    return result.get("results", [])


def _sync_parent(parent_id: str, _visited: set = None):
    """하위 태스크 완료 여부 확인 → 부모 자동 완료 + Due 동기화.
    _visited: 재귀 순환 방지."""
    if _visited is None:
        _visited = set()
    if parent_id in _visited:
        return
    _visited.add(parent_id)

    parent = get_task(parent_id)
    if not parent:
        return

    siblings = list_children(parent_id)
    if not siblings:
        return

    all_done = all(_get_select(s, "Status") in ("Done", "Cancelled") for s in siblings)

    # 하위 최대 Due 계산
    due_dates = sorted(filter(None, (_get_date(s, "Due") for s in siblings)))
    if due_dates and not _get_date(parent, "Due"):
        update_task(parent_id, due=due_dates[-1])

    if all_done and _get_select(parent, "Status") not in ("Done", "Cancelled"):
        update_task(parent_id, status="Done")
        # 부모의 부모도 재귀 확인
        grandparent_ids = _get_relation_ids(parent, "Parent Task")
        for gp_id in grandparent_ids:
            _sync_parent(gp_id, _visited)


def list_tasks(*, status=None, project_id=None, include_done=False, page_size=50):
    """태스크 목록 조회. 필터 지원."""
    filters = []
    if status:
        filters.append({"property": "Status", "select": {"equals": status}})
    elif not include_done:
        filters.append({"property": "Status", "select": {"does_not_equal": "Done"}})
        filters.append({"property": "Status", "select": {"does_not_equal": "Cancelled"}})
    if project_id:
        filters.append({"property": "Project", "relation": {"contains": project_id}})

    body = {
        "page_size": page_size,
        "sorts": [
            {"property": "Priority", "direction": "ascending"},
            {"property": "Due", "direction": "ascending"},
        ],
    }
    if len(filters) == 1:
        body["filter"] = filters[0]
    elif len(filters) > 1:
        body["filter"] = {"and": filters}

    result = _post(f"https://api.notion.com/v1/databases/{TASKS_DB}/query", body)
    return result.get("results", [])


def list_due_soon(minutes=60):
    """마감 임박 태스크 (지금 ~ minutes분 후)."""
    now = datetime.now(KST)
    cutoff = now + timedelta(minutes=minutes)
    result = _post(f"https://api.notion.com/v1/databases/{TASKS_DB}/query", {
        "filter": {"and": [
            {"property": "Status", "select": {"does_not_equal": "Done"}},
            {"property": "Status", "select": {"does_not_equal": "Cancelled"}},
            {"property": "Due", "date": {"on_or_before": cutoff.isoformat()}},
            {"property": "Due", "date": {"on_or_after": now.isoformat()}},
        ]},
    })
    return result.get("results", [])


def list_overdue():
    """지연(overdue) 태스크."""
    now = datetime.now(KST)
    result = _post(f"https://api.notion.com/v1/databases/{TASKS_DB}/query", {
        "filter": {"and": [
            {"property": "Status", "select": {"does_not_equal": "Done"}},
            {"property": "Status", "select": {"does_not_equal": "Cancelled"}},
            {"property": "Due", "date": {"before": now.isoformat()}},
        ]},
    })
    return result.get("results", [])


def list_reminders_due():
    """Remind At이 현재 시각 이전인 미완료 태스크."""
    now = datetime.now(KST)
    result = _post(f"https://api.notion.com/v1/databases/{TASKS_DB}/query", {
        "filter": {"and": [
            {"property": "Status", "select": {"does_not_equal": "Done"}},
            {"property": "Status", "select": {"does_not_equal": "Cancelled"}},
            {"property": "Remind At", "date": {"on_or_before": now.isoformat()}},
        ]},
    })
    return result.get("results", [])

def main():
    try:
        now = datetime.now(KST)
        state = load_json(STATE_FILE, default={"notified": {}})
        notified = state.get("notified", {})
        changed = False

        # 1. Remind At 도달 → 텔레그램
        reminders = list_reminders_due()
        for task in reminders:
            tid = task["id"]
            key = f"remind_{tid}"
            if key in notified:
                continue
            title = _get_title(task)
            send_telegram(f"🔔 <b>리마인더:</b> {title}", parse_mode="HTML")
            # Remind At 클리어 (재알림 방지)
            update_task(tid, remind_at=None)
            notified[key] = now.isoformat()
            changed = True

        # 2. 마감 1시간 이내 → 텔레그램
        due_soon = list_due_soon(minutes=60)
        for task in due_soon:
            tid = task["id"]
            key = f"due_soon_{tid}"
            if key in notified:
                continue
            title = _get_title(task)
            due = _get_date(task, "Due")
            try:
                dt = datetime.fromisoformat(due)
                due_str = dt.strftime("%H:%M")
            except (ValueError, TypeError):
                due_str = due[:10] if due else "?"
            send_telegram(f"⏰ <b>마감 임박:</b> {title} (마감 {due_str})", parse_mode="HTML")
            notified[key] = now.isoformat()
            changed = True

        # 3. 지연(overdue) → 텔레그램 + ntfy (하루 1회)
        overdue = list_overdue()
        if overdue:
            today_key = f"overdue_{now.strftime('%Y-%m-%d')}"
            if today_key not in notified:
                lines = [f"🚨 <b>지연 태스크 {len(overdue)}건</b>", ""]
                for t in overdue[:10]:
                    lines.append(format_task(t))
                msg = "\n".join(lines)
                send_telegram(msg, parse_mode="HTML")
                send_ntfy(f"🚨 지연 태스크 {len(overdue)}건", tags="warning")
                notified[today_key] = now.isoformat()
                changed = True

        # state 정리: 7일 이상 오래된 항목 제거
        cutoff = (now - timedelta(days=7)).isoformat()
        old_keys = [k for k, v in notified.items() if v < cutoff]
        for k in old_keys:
            del notified[k]
            changed = True

        if changed:
            state["notified"] = notified
            save_json(STATE_FILE, state)

        # 실제 발송/상태변경이 있을 때만 로깅 (디둡으로 알림 안 나간 회차는 로그도 생략 — */5 폭증 방지)
        if changed:
            print(f"[task_reminder] 알림 발송: remind={len(reminders)}, due_soon={len(due_soon)}, overdue={len(overdue)}")

def _fetch_events(calendar_id: str, headers: dict, start: datetime, end: datetime) -> list:
    r = requests.get(
        f"https://www.googleapis.com/calendar/v3/calendars/{calendar_id}/events",
        headers=headers,
        params={
            "timeMin":      start.isoformat(),
            "timeMax":      end.isoformat(),
            "singleEvents": "true",
            "orderBy":      "startTime",
            "timeZone":     "Asia/Seoul",
        }, timeout=10
    )
    return r.json().get("items", [])


# ── 조회 ──────────────────────────────────────────────────────────────────────

def get_events(start: datetime, end: datetime) -> list:
    """rc.secretary.kor + byungho.kim.kor 통합 조회, 시간순 정렬"""
    rc_events = _fetch_events(RC_CALENDAR_ID, _h_rc(), start, end)
    try:
        byungho_events = _fetch_events(BYUNGHO_CALENDAR_ID, _h_byungho(), start, end)
    except Exception as exc:
        # 조회 실패를 stderr에 기록 (return 시맨틱은 유지 — 호출자 영향 없음)
        print(f"⚠️ 캘린더 조회 실패 ({BYUNGHO_CALENDAR_ID}): {exc}", file=sys.stderr)
        byungho_events = []

    def sort_key(e):
        s = e.get("start", {})
        return s.get("dateTime", s.get("date", ""))

    return sorted(rc_events + byungho_events, key=sort_key)


def get_today_events() -> list:
    now   = datetime.now(KST)
    start = now.replace(hour=0, minute=0, second=0, microsecond=0)
    return get_events(start, start + timedelta(days=1))


def get_tomorrow_events() -> list:
    now   = datetime.now(KST)
    start = (now + timedelta(days=1)).replace(hour=0, minute=0, second=0, microsecond=0)
    return get_events(start, start + timedelta(days=1))


def get_week_events() -> list:
    now   = datetime.now(KST)
    start = now.replace(hour=0, minute=0, second=0, microsecond=0)
    return get_events(start, start + timedelta(days=7))


def get_date_events(date_str: str) -> list:
    """YYYY-MM-DD 형식 날짜의 일정"""
    start = datetime.fromisoformat(date_str).replace(
        hour=0, minute=0, second=0, tzinfo=KST)
    return get_events(start, start + timedelta(days=1))


# ── 등록 ──────────────────────────────────────────────────────────────────────

def add_event(title: str, start_str: str, end_str: str,
              description: str = "", location: str = "") -> dict:
    """
    start_str / end_str: YYYY-MM-DDTHH:MM  또는  YYYY-MM-DD (종일)
    """
    if "T" in start_str:
        # 시간 이벤트 — KST offset 자동 추가
        if "+" not in start_str and "Z" not in start_str:
            start_str += ":00+09:00"
        if "+" not in end_str and "Z" not in end_str:
            end_str += ":00+09:00"
        start_body = {"dateTime": start_str, "timeZone": "Asia/Seoul"}
        end_body   = {"dateTime": end_str,   "timeZone": "Asia/Seoul"}
    else:
        # 종일 이벤트
        start_body = {"date": start_str}
        end_body   = {"date": end_str}

    body = {
        "summary":     title,
        "description": description,
        "start":       start_body,
        "end":         end_body,
    }
    if location:
        body["location"] = location
    r = requests.post(
        f"https://www.googleapis.com/calendar/v3/calendars/{RC_CALENDAR_ID}/events",
        headers={**_h_rc(), "Content-Type": "application/json"},
        json=body, timeout=10

def main() -> int:
    tomorrow = (datetime.now(KST) + timedelta(days=1)).strftime("%m월 %d일 (%a)")
    events = get_tomorrow_events()

    if not events:
        print("내일 일정 없음 — 알림 생략")
        return 0

    lines = [f"📅 <b>내일 일정 알림</b> — {tomorrow}"]
    for e in events:
        lines.append(fmt_event(e))
        desc = e.get("description", "").strip()
        if desc:
            lines.append(f"    └ {desc[:80]}")

    # send_telegram은 실패 시 False 반환 (예외 없음) — 발송 실패는 rc=1
    if not send_telegram("\n".join(lines)):

def main():
    today = date.today()
    month_key = f"{today.year}-{today.month:02d}"
    final_day = today.day >= 13

    state = load_json(STATE_FILE, default={})
    month_state = state.get(month_key, {
        "completed": False, "attempts": 0, "missing": [],
        "decision_token": None, "pending_decision": None,
    })

    if month_state.get("completed"):
        print(f"[dispatcher] {month_key} 이미 완료 — 종료")
        return

    present = detect_staging()
    missing = [c for c in REQUIRED_CARDS if c not in present]
    print(f"[dispatcher] {today} day={today.day} present={present} missing={missing}")

    # Case 1: 4사 완비
    if not missing:
        rc = run_pipeline()
        month_state.update({"completed": rc == 0, "missing": []})
        state[month_key] = month_state
        save_json(STATE_FILE, state, compact=True)
        if rc == 0:
            send_ntfy(f"✅ 카드 분석 완료 ({month_key}, 4사 완비)", tags="white_check_mark")
        else:
            send_ntfy(f"❌ 카드 분석 실패 (rc={rc})", tags="warning", priority="urgent")
        return

    # Case 2: D+3 마지막 (day 13) — 강제 실행
    if final_day:
        # 데이터 전무: staging도 없고 기존 CSV도 없으면 분석 불가 → 스킵
        from datetime import date as _date
        ref = today
        csv_path = CARD_DIR / "data" / f"monthly_{ref.year}_{ref.month:02d}.csv"
        if not present and not csv_path.exists():
            print(f"[dispatcher] 데이터 전무 (staging=없음, CSV=없음) — 분석 스킵")
            send_ntfy(
                f"⚠️ 카드 분석 스킵 ({month_key}): 명세서 미수령 + 기존 데이터 없음",
                tags="warning",
            )
            month_state.update({"completed": True, "missing": missing, "skipped": True})
            state[month_key] = month_state
            save_json(STATE_FILE, state, compact=True)
            return

        send_telegram(
            f"<b>⚠️ 카드 D+3 강제 실행</b>\n누락 카드: {', '.join(missing)} — 제외 진행",
            parse_mode="HTML", html_fallback=True,
        )
        rc = run_pipeline(missing=missing)
        month_state.update({"completed": rc == 0, "missing": missing})
        state[month_key] = month_state
        save_json(STATE_FILE, state, compact=True)
        return

    # Case 3: 누락 + day < 13 — state["pending_decision"] 분기
    decision = month_state.get("pending_decision")

    if decision == "skip":
        # 사용자가 어제 "제외 진행" 응답함 → 즉시 실행
        send_ntfy(f"▶️ 카드 분석 진행 (어제 '제외 진행' 응답 반영) — 누락 {','.join(missing)}",
                  tags="zap")
        rc = run_pipeline(missing=missing)
        month_state.update({
            "completed": rc == 0, "missing": missing,
            "pending_decision": None,  # 소진
        })
        state[month_key] = month_state
        save_json(STATE_FILE, state, compact=True)
        return

    # decision is "wait" 또는 None — 새 승인 요청 발송 + 즉시 종료 (cron 비점유)
    if not month_state.get("decision_token"):
        month_state["decision_token"] = uuid4().hex[:8]
    month_state["attempts"] = month_state.get("attempts", 0) + 1
    month_state["missing"] = missing
    month_state["pending_decision"] = None  # 새 요청
    state[month_key] = month_state
    save_json(STATE_FILE, state, compact=True)

    send_approval_request(missing, month_state["decision_token"])
    print(f"[dispatcher] 승인 요청 발송 + 즉시 종료 (응답 ntfy_inbox_watcher 처리)")

def dispatch_alerts(result: dict, missing_cards: list = None):
    """4단계 알림 분기 — CLAUDE.md 채널 분리 룰 준수"""
    s1 = result["step1"]
    s3 = result["step3"]
    s4 = result["step4"]
    s6 = result["step6"]
    days_left = result["days_left"]
    ref = result["ref_date"]

    # (a) Mandatory 미달 + 잔여 ≤ 7일 → 텔레그램+ntfy
    critical_lines = []
    if days_left <= 7:
        for key, info in s1.items():
            if not info.get("done") and info.get("gap", 0) > 0:
                critical_lines.append(
                    f"⚠️ {info['label']}: {info['current']:,}/{info['target']:,}원 "
                    f"· D-{days_left} — {info['gap']:,}원 추가 결제 필요"
                )

    if critical_lines:
        tg_msg = f"<b>🪪 카드 Mandatory 미달 경고 [{ref}]</b>\n\n" + "\n".join(critical_lines)
        if result.get("step5"):
            tg_msg += "\n\n<b>행동 추천:</b>"
            for a in result["step5"][:3]:
                tg_msg += f"\n• [{a['card']}] {a['action']}"
        send_telegram(tg_msg, parse_mode="HTML", html_fallback=True)
        send_ntfy("⚠️ 카드 Mandatory 미달 — 텔레그램 확인", tags="warning", priority="high")
        return

    # (b) 한도 80%+ 도달
    life = s3.get("life", {})
    if life.get("discount", 0) >= SHINHAN_LIFE_LIMIT * 0.8:
        send_ntfy(
            f"신한 Life {life['discount']:,}/{life['limit']:,}원 (80%+) "
            f"— 잔여 {life['remain']:,}원, 다음달 분배 검토",
            tags="warning"
        )
        return

    # (c) AMEX 특별적립 미발동 + 월말 임박 (잔여 ≤ 5일)
    if not s4.get("special_on") and days_left <= 5:
        send_ntfy(
            f"현대 AMEX 전월실적 미달 ({s4['prev_perf']:,}원) "
            f"— 다음달 기본 1.5X만 적용",
            tags="warning"
        )
        return

    # (d) 평시 완료 (요약)
    missing_note = f" · ⚠️미수령: {','.join(missing_cards)}" if missing_cards else ""
    send_ntfy(
        f"✅ 카드 분석 완료 [{ref}]: 이달 예상 혜택 {s6['total']:,}원{missing_note}",
        tags="white_check_mark"
    )


@contextlib.contextmanager
def _pipeline_lock():
    """run_pipeline 동시 실행 방지 (file_watcher + cron + 봇 트리거 race 대응)"""
    lock_dir = CARD_DIR / "state"
    lock_dir.mkdir(parents=True, exist_ok=True)
    lock_path = lock_dir / "pipeline.lock"
    f = open(lock_path, "w")
    try:
        try:
            fcntl.flock(f.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
        except BlockingIOError:
            print(f"[lock] 다른 run_pipeline 진행 중 — 즉시 종료 ({lock_path})")
            f.close()
            sys.exit(0)
        f.write(f"{os.getpid()} {datetime.now().isoformat()}\n")
        f.flush()
        yield
    finally:
        try:
            fcntl.flock(f.fileno(), fcntl.LOCK_UN)
            f.close()
        except Exception:
            pass


def main():
    with _pipeline_lock():
        _main_inner()

def run_engine(df: pd.DataFrame, mode: str = 'strategy',
               ref_date: date = None) -> dict:
    """
    mode: 'strategy' (10일) | 'check' (25일)
    ref_date: 분석 기준일 (None이면 오늘)
    """
    if ref_date is None:
        ref_date = date.today()

    s1 = step1_mandatory(df, ref_date)
    s2 = step2_nh(df, ref_date)
    s3 = step3_shinhan(df, ref_date)
    s3_5 = step3_5_woori(df, ref_date)
    s4 = step4_amex(df, ref_date)
    s5 = step5_actions(s1, s2, s3, s4, ref_date)
    s6 = step6_summary(s2, s3, s4, s3_5=s3_5)

    cur_start, cur_end = _month_range(ref_date, 0)
    prev_start, prev_end = _month_range(ref_date, -1)
    m3_start, _ = _month_range(ref_date, -3)
    _, m1_end = _month_range(ref_date, -1)
    days_left = (cur_end - ref_date).days

    basis = {
        'today': ref_date.isoformat(),
        'current_month': f"{cur_start.isoformat()} ~ {cur_end.isoformat()}",
        'prev_month':    f"{prev_start.isoformat()} ~ {prev_end.isoformat()}",
        'last_3_months': f"{m3_start.isoformat()} ~ {m1_end.isoformat()}",
        'year_to_date':  f"{date(ref_date.year,1,1).isoformat()} ~ {ref_date.isoformat()}",
        # 룰별 기준 시점 매핑
        'M1_NH':          {'label': '직전 3개월 합산 (당월 제외)', 'window': f"{m3_start.isoformat()} ~ {m1_end.isoformat()}"},
        'M2_우리신용':    {'label': '당월 누적',                    'window': f"{cur_start.isoformat()} ~ {ref_date.isoformat()} (말일 {cur_end.isoformat()})"},
        'M3_우리체크':    {'label': '당월 누적',                    'window': f"{cur_start.isoformat()} ~ {ref_date.isoformat()} (말일 {cur_end.isoformat()})"},
        'NH_구간_판정':   {'label': '전월 실적인정금액 ≥ 50만 → 적립 발동', 'window': f"{prev_start.isoformat()} ~ {prev_end.isoformat()}"},
        'NH_적립':        {'label': '당월 5개 영역(주유·공과금·통신·보험·GS) × 15% (영역당 월 1.5만P 한도)', 'window': f"{cur_start.isoformat()} ~ {ref_date.isoformat()}"},
        'NH_연간_페이스': {'label': 'YTD 실적인정금액 → 12개월 환산', 'window': f"{date(ref_date.year,1,1).isoformat()} ~ {ref_date.isoformat()}"},
        '신한_혜택_발동': {'label': '전월 실적인정금액 ≥ 30만원',   'window': f"{prev_start.isoformat()} ~ {prev_end.isoformat()}"},
        '신한_Life_할인': {'label': '당월 5개 카테고리 사용 × 5%', 'window': f"{cur_start.isoformat()} ~ {ref_date.isoformat()}"},
        'AMEX_특별적립': {'label': '전월 실적인정금액 ≥ 50만원',   'window': f"{prev_start.isoformat()} ~ {prev_end.isoformat()}"},
        'AMEX_MR':       {'label': '당월 사용 × 발동 시 3X/4.5X', 'window': f"{cur_start.isoformat()} ~ {ref_date.isoformat()}"},
        '우리_혜택_발동': {'label': '전월 30만 → 청구할인 발동',   'window': f"{prev_start.isoformat()} ~ {prev_end.isoformat()}"},
        '우리_할인':     {'label': '당월 커피55%/대중교통33%/편의점11% 청구할인', 'window': f"{cur_start.isoformat()} ~ {ref_date.isoformat()}"},
    }

    return {
        'mode':      mode,
        'ref_date':  ref_date.isoformat(),
        'days_left': days_left,
        'basis':     basis,
        'step1':     s1,
        'step2':     s2,
        'step3':     s3,
        'step3_5':   s3_5,
        'step4':     s4,
        'step5':     s5,
        'step6':     s6,
    }

# ── 표준 스키마 ───────────────────────────────────────────────
UNIFIED_COLS = [
    'date',          # YYYY-MM-DD
    'time',          # HH:MM  (없으면 '')
    'card',          # 현대카드 | 신한카드 | NH농협 | 우리신용 | 우리체크
    'merchant',      # 가맹점명
    'amount',        # 이용금액 (원, 정수, 취소 건은 음수)
    'is_cancelled',  # True/False
    'is_installment',# True/False
    'category',      # classify() 결과
    'is_simple_pay', # 간편결제 여부
    'perf_amount',   # 실적인정금액 (카드별 제외 항목 반영 후)
    'source_file',   # 원본 파일명
]

# ── 간편결제 키워드 ───────────────────────────────────────────
SIMPLE_PAY_KW = ['네이버페이', '카카오페이', '토스페이', 'NAVER PAY',
                 'KAKAO PAY', 'TOSS', '삼성페이', '애플페이', 'APPLE PAY',
                 '페이코', 'PAYCO', 'SSG페이', 'L페이', '머니']

# ── 카테고리 분류 ─────────────────────────────────────────────
# 우선순위: 앞에 올수록 먼저 매칭

CATEGORY_RULES = [
    # ── 고정지출 (NH 우선 포인트 대상) ──
    ('고정_보험',     ['메리츠화재', '삼성화재', '현대해상', '흥국화재', 'DB손보', '한화생명',
                      '교보생명', '신한생명', '삼성생명', '농협생명', '보험료']),
    ('고정_통신',     ['SKT', 'KT', 'LGU+', 'SK텔레콤', 'LG유플러스', '통신료', 'SKB', 'SK브로드밴드']),
    ('고정_구독',     ['넷플릭스', 'NETFLIX', '유튜브', 'YOUTUBE', '스포티파이', 'SPOTIFY',
                      '왓챠', '웨이브', '티빙', 'TVING', 'COUPANG', '쿠팡', 'ANTHROPIC',
                      'OPENAI', 'ADOBE', '어도비', 'CHATGPT', 'CLAUDE']),
    ('고정_공과금',   ['한국전력', '도시가스', '수도료', '관리비', '아파트']),

    # ── 커피/음료 ──
    ('커피',          ['스타벅스', 'STARBUCKS', '투썸', 'TWOSOME', '할리스', 'HOLLYS',
                      '커피빈', 'COFFEEBEAN', '폴바셋', 'PAUL BASSETT', '이디야', 'EDIYA',
                      '메가커피', '컴포즈', '블루보틀', '커피나인', '커피앳웍스',
                      '후니드', '미켈레커피', '베이징카페', '커피', 'COFFEE']),

    # ── 택시/교통 ──
    ('택시',          ['카카오T택시', '카카오택시', '우티', 'UT택시', '타다', 'TADA',
                      'UBER', '우버', 'T택시', '택시']),
    ('대중교통',      ['티머니', 'T-money', '한국철도', 'KORAIL', '코레일', '지하철',
                      '버스', 'GS리테일-카카오T', '서울교통', '인천교통', '카카오T대중교통',
                      '고속도로', '도로공사', '톨게이트', '하이패스', '서해안고속',
                      '경부고속', '제이서해']),

    # ── 편의점 ──
    ('편의점',        ['CU', 'GS25', 'GS 25', '세븐일레븐', '7-ELEVEN', '미니스톱', 'MINISTOP',
                      '이마트24', 'emart24']),

    # ── 마트/대형쇼핑 ──
    ('대형마트',      ['이마트', 'E-MART', '홈플러스', 'HOMEPLUS', '롯데마트', 'LOTTE MART',
                      '코스트코', 'COSTCO', '트레이더스', '킴스클럽', 'KIMS']),

    # ── 영화 ──
    ('영화',          ['CGV', '롯데시네마', 'LOTTE CINEMA', '메가박스', 'MEGABOX']),

    # ── 제과/베이커리 ──
    ('제과',          ['파리바게뜨', '뚜레쥬르', '베이커리', '빵집']),

    # ── 화장품 ──
    ('화장품',        ['올리브영', 'OLIVE YOUNG', '이니스프리', '아리따움', '에뛰드',
                      '미샤', 'MISSHA', '더샘', 'CJ올리브']),

    # ── 주유 ──
    ('주유_GS',       ['GS칼텍스', 'GS CALTEX', 'GS주유', 'GS칼텍']),
    ('주유',          ['SK에너지', 'S-OIL', '현대오일뱅크', '오일뱅크', '알뜰주유소', '주유소']),

    # ── 항공/면세 ──
    ('항공_진에어',   ['진에어', 'JINAIR']),
    ('항공',          ['대한항공', 'KOREAN AIR', '아시아나', 'ASIANA', '에어서울',
                      '티웨이', '이스타', '제주항공']),
    ('면세점',        ['JDC면세', '롯데면세', '신라면세', '신세계면세', '현대면세',
                      '롯데인터넷면세', '신라인터넷면세', 'DUTY FREE', '면세']),

    # ── 호텔/골프 ──
    ('호텔',          ['롯데호텔', '신라호텔', '조선호텔', '파크하얏트', '그랜드하얏트',
                      '인터컨티넨탈', '포시즌스', '리츠칼튼', '호텔']),
    ('골프',          ['골프', 'GOLF', '골프장', '골프연습장', '스크린골프']),

    # ── 식사 (넓게) ──
    ('식사',          ['식당', '음식점', '레스토랑', '치킨', '피자', '중식', '일식', '한식',
                      '분식', '횟집', '고기', '삼겹살', '갈비', '냉면', '국밥', '라멘',

# ─── 암호화 ───────────────────────────────────────────────────

def encrypt(plaintext: str, password: str) -> str:
    salt = os.urandom(SALT_LEN)
    iv = os.urandom(IV_LEN)
    key = PBKDF2HMAC(
        algorithm=hashes.SHA256(), length=KEY_LEN, salt=salt, iterations=PBKDF2_ITER,
    ).derive(password.encode("utf-8"))
    ct = AESGCM(key).encrypt(iv, plaintext.encode("utf-8"), None)
    return base64.b64encode(salt + iv + ct).decode("ascii")


# ─── 인젝션 ───────────────────────────────────────────────────

def _build_nav_button(tab: dict) -> str:
    cls = "nav-tab appendix" if tab.get("appendix") else "nav-tab"
    return f'<button class="{cls}" onclick="switchTab(\'{tab["tab_id"]}\',this)">{tab["tab_label"]}</button>'


def _build_panel(tab: dict) -> str:
    """잠금 화면 + content 컨테이너. sessionStorage 자동 unlock 제거 (v3.4 보안 강화)."""
    return f"""
<div class="panel" id="panel-{tab['tab_id']}" style="max-width:{tab.get('panel_max_width', 720)}px;margin:0 auto">
<div id="{tab['lock_id']}" style="text-align:center;padding:60px 20px;color:#666">
  <div style="font-size:2rem;margin-bottom:10px">🔒</div>
  <div style="font-size:.95rem;margin-bottom:20px">{tab['lock_message']}</div>
  <input type="password" id="{tab['lock_pw_input_id']}" placeholder="대시보드 비번" style="padding:10px 14px;border:1.5px solid #c8d4e8;border-radius:10px;font-size:.95rem;text-align:center;letter-spacing:.1em;width:200px" onkeydown="if(event.key==='Enter'){tab['unlock_fn_name']}()">
  <br><br>
  <button onclick="{tab['unlock_fn_name']}()" style="padding:9px 24px;background:#4f7ef8;color:#fff;border:none;border-radius:10px;font-size:.9rem;font-weight:600;cursor:pointer">열기</button>
  <div id="{tab['err_id']}" style="color:#ff6b6b;font-size:.8rem;margin-top:12px;min-height:18px"></div>
</div>
<div id="{tab['content_id']}"></div>
</div>
"""


def _build_script(tab: dict) -> str:
    """비번 1회용 — sessionStorage 저장 X, DOMContentLoaded 자동 unlock X.
    탭 전환할 때마다 재입력. XSS 방지."""
    return f"""
<script type="application/octet-stream" id="{tab['payload_script_id']}">{tab['payload_mark_start']}{tab['payload_mark_end']}</script>
<script>
async function {tab['unlock_fn_name']}(){{
  const pw = document.getElementById('{tab['lock_pw_input_id']}').value;
  const err = document.getElementById('{tab['err_id']}');
  err.textContent = '';
  if (!pw) {{ err.textContent = '⚠️ 비밀번호를 입력하세요'; return; }}
  const raw = document.getElementById('{tab['payload_script_id']}').textContent;
  const payload = raw.replace(/<!--[\\s\\S]*?-->/g,'').trim();
  if (!payload) {{ err.textContent = '⚠️ 아직 게시된 데이터가 없습니다'; return; }}
  try {{
    const blob = Uint8Array.from(atob(payload), c=>c.charCodeAt(0));
    const salt = blob.slice(0,16), iv = blob.slice(16,28), ct = blob.slice(28);
    const enc = new TextEncoder();
    const baseKey = await crypto.subtle.importKey('raw', enc.encode(pw), 'PBKDF2', false, ['deriveKey']);
    const key = await crypto.subtle.deriveKey(
      {{name:'PBKDF2', salt, iterations:{PBKDF2_ITER}, hash:'SHA-256'}},
      baseKey, {{name:'AES-GCM', length:256}}, false, ['decrypt']
    );
    const pt = await crypto.subtle.decrypt({{name:'AES-GCM', iv}}, key, ct);
    const html = new TextDecoder().decode(pt);
    document.getElementById('{tab['lock_id']}').style.display='none';
    document.getElementById('{tab['content_id']}').innerHTML = html;
    // 동적 삽입된 <script> 강제 실행 (Leaflet 등)
    document.getElementById('{tab['content_id']}').querySelectorAll('script').forEach(s => {{
      const ns = document.createElement('script');
      if (s.src) ns.src = s.src; else ns.textContent = s.textContent;
      document.body.appendChild(ns);
    }});
    // 비번은 메모리에서 즉시 휘발 (변수 스코프 끝나면 GC)
  }} catch(e) {{
    err.textContent = '❌ 비밀번호가 올바르지 않습니다';
    document.getElementById('{tab['lock_pw_input_id']}').value='';
  }}
}}
</script>
"""


def setup_index_if_needed(html: str, tab: dict) -> str:
    """index.html에 nav-tab + panel + payload script 골격 자동 삽입 (멱등).

def render_inner(result: dict = None) -> str:
    if result is None:
        result = _load_latest_result()
    s1, s2, s3, s4, s5, s6 = (result[f"step{i}"] for i in range(1, 7))
    basis = result.get("basis", {})
    ref = result["ref_date"]
    mode_label = "전략 수립 (10일 정기)" if result["mode"] == "strategy" else "잔여 점검 (25일 정기)"
    days_left = result["days_left"]
    missing = result.get("missing_cards", [])
    generated = datetime.now().strftime("%Y-%m-%d %H:%M")

    m1 = s1.get("M1_NH", {}); m2 = s1.get("M2_우리신용", {}); m3 = s1.get("M3_우리체크", {})
    life = s3.get("life", {})
    b = lambda k: basis.get(k, {}).get("window", "")

    gauges = (
        _gauge("M-1  NH농협 (3개월 합산, 목표 50만)", b("M1_NH"), m1.get("current",0), m1.get("target",1))
      + _gauge("M-2  우리카드 신용 (당월 30만)",       b("M2_우리신용"), m2.get("current",0), m2.get("target",1))
      + _gauge("M-3  우리카드 체크 (당월 20만)",       b("M3_우리체크"), m3.get("current",0), m3.get("target",1))
      + _gauge("신한 Life 청구할인 수령액 (월 한도 2만, 5%×최대 40만 지출 시 도달 · 전월 30만↑ 실적 발동)",  b("신한_Life_할인"), life.get("discount",0), life.get("limit",20000))
      + _gauge("NH 연간 페이스 (YTD vs 목표 1,800만)", b("NH_연간_페이스"), s2.get("annual_perf_ytd",0), s2.get("annual_target",18000000))
    )

    shin_active = s3.get("active"); shin_perf = s3.get("prev_perf", 0)
    amex_on = s4.get("special_on"); amex_perf = s4.get("prev_perf", 0)
    nh_tier = s2.get("tier", {}).get("label", ""); nh_prev = s2.get("prev_perf", 0)

    status_grid = f"""<div class="cs-status-grid">
  <div>
    <small>신한 혜택 발동 (전월 30만 ≥)</small>
    <div>{'✅ 활성' if shin_active else '❌ 비활성'} <span style="color:#888">(전월 {shin_perf:,}원)</span></div>
    <span class="cs-basis">📅 기준: {b('신한_혜택_발동')}</span>
  </div>
  <div>
    <small>현대 AMEX 특별적립 (전월 50만 ≥)</small>
    <div>{'✅ 발동 (3X/4.5X)' if amex_on else '⚠️ 기본 1.5X'} <span style="color:#888">(전월 {amex_perf:,}원)</span></div>
    <span class="cs-basis">📅 기준: {b('AMEX_특별적립')}</span>
  </div>
  <div>
    <small>NH 구간 (전월 실적인정금액)</small>
    <div>{nh_tier} <span style="color:#888">(전월 {nh_prev:,}원)</span></div>
    <span class="cs-basis">📅 기준: {b('NH_구간_판정')}</span>
  </div>
  <div>
    <small>당월 NH 적립 (위 구간 기준)</small>
    <div>{s2.get('total_earned',0):,}P</div>
    <span class="cs-basis">📅 기준: {b('NH_적립')}</span>
  </div>
</div>"""

    # NH 5영역 도넛 (v3.4: 주유 GS+일반 합산 → '주유' 1개)
    nh_cats = s2.get("categories", {})
    nh_donuts_html = ""
    for area, info in nh_cats.items():
        limit = info.get("limit", 15000)
        earned = info.get("earned", 0)
        label = info.get("label", area)
        pct = min(100, round(earned / limit * 100, 1)) if limit else 0
        color = gauge_color(pct) if earned > 0 else GAUGE_COLOR['neutral']
        r = 28; c = 2 * 3.14159 * r
        dash = c * pct / 100
        nh_donuts_html += f"""<div class="cs-donut-card">
  <div class="cs-donut-label">{label}</div>
  <svg class="cs-donut-svg" width="64" height="64" viewBox="0 0 64 64">
    <circle cx="32" cy="32" r="{r}" fill="none" stroke="#F2EEE6" stroke-width="6"/>
    <circle cx="32" cy="32" r="{r}" fill="none" stroke="{color}" stroke-width="6"
            stroke-dasharray="{dash:.1f} {c-dash:.1f}" stroke-dashoffset="0"
            transform="rotate(-90 32 32)" stroke-linecap="round"/>
    <text x="32" y="36" text-anchor="middle" font-size="11" font-weight="600" fill="#222">{pct:.0f}%</text>
  </svg>
  <div class="cs-donut-val">{earned:,}P / {limit:,}P</div>
</div>"""
    nh_donut_section = (
        f'<div class="cs-section">NH 5영역 적립 한도 (영역당 월 {nh_cats.get("주유",{}).get("limit",15000):,}P)</div>\n'
        f'<div class="cs-nh-areas">{nh_donuts_html}</div>'
    ) if nh_donuts_html else ""

    actions_html = ""
    if s5:
        for a in s5:
            amt = f"  {a['amount']:,}원" if a.get('amount') else ""
            p = a['priority']
            cls = f"p{p}" if p >= 4 else ""
            actions_html += f"""<div class="cs-action">
  <div class="cs-action-pri {cls}">{p}</div>
  <div><b>[{a['card']}]{amt}</b><small>{a['reason']}</small><div class="cs-do">→ {a['action']}</div></div>
</div>"""
    else:
        actions_html = '<p style="color:#3B6D11;font-size:13px">✅ 모든 Mandatory 달성 — 현재 전략 유지</p>'

    by_card_rows = "".join(
        f'<tr><td>{c}</td><td style="text-align:right">{a:,}원</td></tr>'
        for c, a in s6["by_card"].items()
    )

    missing_banner = (
        f'<div class="cs-banner-warn">⚠️ 미수령 카드: {", ".join(missing)} — 해당 카드 제외하고 분석됨</div>'
        if missing else ''
    )

    basis_summary = f"""<div class="cs-basis-summary">
<b>📌 기준 시점 요약</b>&nbsp;&nbsp;오늘: <b>{ref}</b> · 잔여 {days_left}일<br>
• <b>당월</b> 누적 = {basis.get('current_month','')}<br>
• <b>전월</b> 실적 (신한/AMEX 혜택 발동·NH 구간 판정) = {basis.get('prev_month','')}<br>
• <b>직전 3개월</b> 합산 (M-1 NH Mandatory) = {basis.get('last_3_months','')}<br>
• <b>YTD</b> 누적 (NH 연간 1,800만 페이스) = {basis.get('year_to_date','')}
</div>"""

    return f"""{CSS_INLINE}
<div class="card-status">
  <div class="cs-summary">
    <div><h2>{ref[:7]} 카드 현황</h2><div class="cs-meta">{mode_label} · 잔여 {days_left}일</div></div>
    <div style="text-align:right"><div class="cs-meta">이달 예상 혜택</div><div class="cs-total">{s6['total']:,}원</div></div>
  </div>
  {missing_banner}
  {basis_summary}
  <div class="cs-section">Mandatory 실적 + 혜택 한도</div>
  {gauges}
  <div class="cs-section">혜택 발동 상태 (전월 실적 기반)</div>
  {status_grid}
  {nh_donut_section}
  <div class="cs-section">행동 추천 (우선순위)</div>
  {actions_html}
  <div class="cs-section">카드별 혜택 합계 (당월 예상)</div>
  <table class="cs-table">{by_card_rows}<tr><td>합계</td><td style="text-align:right">{s6['total']:,}원</td></tr></table>
  <div class="cs-foot">마지막 업데이트: {generated} · AES-256-GCM 암호화 게시 · MR=10원 가정</div>
</div>"""


def publish_status(result: dict = None, *, push: bool = True) -> str:
    inner_fn = (lambda: render_inner(result)) if result else render_inner
    return publish(TAB_STATUS, inner_fn, push=push, commit_label="card dashboard update")

def rollup_year(year: int) -> dict:
    """카드사별 연간 통합 .xlsx 생성. 반환: {카드사: 건수}"""
    if not ARCHIVE_DIR.exists():
        return {}

    summary = {}
    for card_dir in ARCHIVE_DIR.iterdir():
        if not card_dir.is_dir():
            continue
        card = card_dir.name
        month_files = sorted(card_dir.glob(f"{year}*.xls*"))
        # 연간 통합 파일은 매칭에서 제외
        month_files = [f for f in month_files if "_연간통합" not in f.name]
        if not month_files:
            continue

        file_dict = {card: str(month_files[-1])}  # 최신 1건만 우선 (parse_all은 단일 파일/카드 가정)
        # 12개월치 누적: parse_all을 카드별로 각 월마다 호출하여 concat
        frames = []
        for mf in month_files:
            try:
                df = parse_all({card: str(mf)})
                frames.append(df)
            except Exception as e:
                print(f"[rollup] 파싱 실패 {mf}: {e}")
                continue

        if not frames:
            continue

        combined = pd.concat(frames)
        # 중복 제거: time + source_file 포함 → 동일 가맹점·동일 금액 일상결제 보호
        dedup_keys = ["date", "card", "merchant", "amount"]
        if "time" in combined.columns:
            dedup_keys.insert(1, "time")
        if "source_file" in combined.columns:
            dedup_keys.append("source_file")
        combined = combined.drop_duplicates(subset=dedup_keys).reset_index(drop=True)

        out_path = card_dir / f"{year}_연간통합.xlsx"
        combined.to_excel(out_path, index=False, engine="openpyxl")
        summary[card] = len(combined)
        print(f"  {card}: {len(combined)}건 → {out_path.name}")

    return summary


def main():
    year = date.today().year
    print(f"=== {year}년 카드 연간 통합 시작 ===")
    summary = rollup_year(year)
    if not summary:
        send_ntfy(f"⚠️ 카드 연간통합({year}): 처리 대상 없음", tags="warning")
        return
    lines = [f"{c}: {n:,}건" for c, n in summary.items()]
    send_ntfy(
        f"✅ 카드 연간통합 {year} 완료\n" + "\n".join(lines),
        tags="white_check_mark",
    )

def main():
    today = date.today()
    # 이번 달 staging에 뭐가 있는지 점검
    present = []
    if STAGING.exists():
        for f in STAGING.iterdir():
            if f.is_file() and f.suffix.lower().startswith(".xls"):
                present.append(f.name)

    needed = ["현대카드(실시간)", "신한카드", "NH농협", "우리카드"]
    msg = (
        f"<b>📥 카드 업로드 리마인드</b> (D-1: 내일 09:00 잔여 점검)\n\n"
        f"내일 {today.year}-{today.month:02d}-25 09:00에 card_check cron이 잔여 점검을 실행합니다.\n"
        f"<b>새 데이터가 없으면 옛 분석 결과로 평가되어 의미 없음</b> → "
        f"이용내역 .xls을 텔레그램에 던져주세요.\n\n"
        f"<b>권장:</b>\n"
        f"• 현대카드 실시간내역 (월말 누적 핵심)\n"
        f"• 가능하면 다른 3사 최신본도\n\n"
        f"현재 staging: <code>{', '.join(present) if present else '(비어있음)'}</code>\n\n"
        f"미응답 시 25일 09:00 cron은 기존 CSV로 분석 진행."
    )
    send_telegram(msg, parse_mode="HTML", html_fallback=True, disable_web_page_preview=True)
    send_ntfy(
        f"📥 내일 09:00 카드 잔여 점검 — 현대카드 실시간내역 업로드 권장 (현재 staging: {len(present)}건)",
        tags="hourglass_flowing_sand", priority="high",
    )
    print(f"[upload_reminder] D-1 알림 발송 — staging {len(present)}건")

def notify(subject, sender, msg_id, g_token):
    import html
    received_at = datetime.now().strftime("%m/%d %H:%M")
    auth_subject_keywords = [
        '인증', 'verification', 'verify', 'code', 'otp', 'pin',
        '확인번호', '인증번호', '로그인', 'sign in', 'sign-in', 'login',
        '2fa', 'two-factor', 'one-time', '일회용', '보안코드', '본인확인',
        'passcode', 'activate', '활성화', '가입', '이메일 확인', 'confirm'
    ]
    auth_sender_keywords = [
        'noreply', 'no-reply', 'verify', 'security', 'account',
        'auth', 'notification', '인증', 'otp',
    ]
    subj_l = subject.lower()
    send_l = sender.lower()
    is_auth = (
        any(k in subj_l for k in auth_subject_keywords)
        or any(k in send_l for k in auth_sender_keywords)
    )

    if is_auth:
        msg = get_full_message(g_token, msg_id)
        raw_body = extract_body(msg.get("payload", {}))
        plain_body = re.sub(r'<[^>]+>', ' ', raw_body)
        code = extract_auth_code(subject + " " + plain_body)
        if code:
            send_rcmail(
                f"🔑 <b>인증번호: <code>{code}</code></b>\n"
                f"From: {html.escape(sender)}\n"
                f"제목: {html.escape(subject)}\n"
                f"수신: {received_at}"
            )
            return
        # 숫자 코드 없음 → 링크형 인증 (secretary로, reveal 버튼 보안 게이트)
        link = extract_auth_link(raw_body)
        if link:
            link_id = save_link_pending(link)
            send_secretary(
                f"🔗 <b>인증 링크 감지</b>\n"
                f"From: {html.escape(sender)}\n"
                f"제목: {html.escape(subject)}\n"
                f"수신: {received_at}\n\n"
                f"⚠️ 링크는 숨김 상태입니다. 본인 요청이 맞는 경우에만 공개하세요.",
                reply_markup={
                    "inline_keyboard": [[
                        {"text": "🔓 링크 공개", "callback_data": f"reveal_link:{link_id}"}
                    ]]
                }
            )
            return

    # 첨부파일 저장
    saved_files = []
    try:
        saved_files = save_attachments(g_token, msg_id, subject, sender)
    except Exception as e:
        print(f"[{time.strftime('%H:%M:%S')}] 첨부파일 오류: {e}")

    text = (
        f"📬 <b>새 메일</b>\n"
        f"제목: {html.escape(subject)}\n"
        f"From: {html.escape(sender)}\n"
        f"수신: {received_at}"
    )
    if saved_files:
        text += "\n📎 " + ", ".join(saved_files)

def extract_auth_code(text):
    clean = re.sub(r'<[^>]+>', ' ', text)
    clean = re.sub(r'#[0-9a-fA-F]{3,6}\b', '', clean)
    clean = re.sub(r'\b\d+px\b|\b\d+%', '', clean)

    # 숫자 코드 패턴 (OTP, 인증번호 등 4~8자리)
    numeric_patterns = [
        r'(?:인증번호|인증\s*코드|검증\s*코드|보안\s*코드|보안번호|verification code|security code|access code|OTP|PIN)[^\d]{0,40}(\d{4,8})',
        r'(?:enter|use|your|입력)[^\d]{0,12}(?:code|코드)[^\d]{0,50}(\d{4,8})',
        r'\[\s*(\d{4,8})\s*\]',
        r'(?:code|number|번호|코드)[:\s]+(\d{4,8})',
        r'letter-spacing[^>]*>\s*(\d{4,8})',
    ]
    for p in numeric_patterns:
        m = re.search(p, clean, re.IGNORECASE)
        if m:
            code = m.group(1)
            if code not in ('777777', '000000', '111111', '123456'):
                return code

    # 영문+숫자 혼합 API 키 패턴 (인증키, API Key 등)
    alphanumeric_patterns = [
        r'\[\s*([A-Za-z0-9\-_]{8,})\s*\]',                          # [ KEY ] 형식
        r'(?:인증키|api\s*key|apikey)[^A-Za-z0-9]*([A-Za-z0-9\-_]{16,})',  # 인증키는 [ KEY ] 형식
        r'(?:key|token|토큰)\s*[:=]\s*([A-Za-z0-9\-_]{16,})',        # key = VALUE 형식
    ]
    for p in alphanumeric_patterns:
        m = re.search(p, clean, re.IGNORECASE)
        if m:
            return m.group(1)

def categorize(subject, sender, label_ids):
    """Gmail 레이블 + 키워드로 카테고리 분류"""
    subj = subject.lower()
    sndr = sender.lower()

    if "accounts.google.com" in sndr or "보안" in subj or "security" in subj:
        return "🔒 보안알림"
    # 쿠팡 인증/확인 메일 → 삭제 대상 (링크 클릭 방식, 보관 불필요)
    if "coupang.com" in sndr and any(k in subj for k in ["인증", "확인", "verification", "로그인", "login"]):
        return "📢 광고"
    if any(k in subj for k in ["인증", "otp", "pin", "verification", "확인번호", "인증번호"]):
        return "🔑 인증번호"
    if "CATEGORY_PROMOTIONS" in label_ids:
        return "📢 광고"
    if "CATEGORY_UPDATES" in label_ids or "CATEGORY_FORUMS" in label_ids or "CATEGORY_SOCIAL" in label_ids:
        return "📰 뉴스레터"
    return "📌 기타"

def fetch_since(g_token, since_iso):
    """last_run 이후 수신된 메일 조회 (기타 메일은 Haiku 분류+요약 적용)"""
    headers = {"Authorization": f"Bearer {g_token}"}
    since_dt = datetime.fromisoformat(since_iso)
    after_ts = int(since_dt.timestamp())

    r = requests.get("https://www.googleapis.com/gmail/v1/users/me/messages",
        headers=headers,
        params={"q": f"after:{after_ts}", "labelIds": "INBOX", "maxResults": 50},
        timeout=15
    )
    messages = r.json().get("messages", [])
    results = []

    for m in messages:
        msg = requests.get(
            f"https://www.googleapis.com/gmail/v1/users/me/messages/{m['id']}",
            headers=headers,
            params={"format": "metadata", "metadataHeaders": ["From", "Subject", "Date"]},
            timeout=15
        ).json()

        hdrs = {h["name"]: h["value"] for h in msg.get("payload", {}).get("headers", [])}
        snippet = msg.get("snippet", "")[:120]
        label_ids = msg.get("labelIds", [])

        subject = hdrs.get("Subject", "(제목 없음)")
        sender  = hdrs.get("From", "")[:50]
        category = categorize(subject, sender, label_ids)
        haiku_summary = ""

        # 기타 메일만 Haiku로 본문 분석
        if category == "📌 기타":
            body = fetch_body(g_token, m["id"])
            category, haiku_summary = haiku_classify(subject, sender, body)

        results.append({
            "gmail_id":     m["id"],
            "subject":      subject,
            "from":         sender,
            "snippet":      snippet,
            "category":     category,
            "haiku_summary": haiku_summary,
        })

    return results

#!/usr/bin/env python3
"""
Gmail 정기 정리 (매주 일요일 자정 크론)
- 광고 메일: 7일 이상 → 삭제
- 뉴스레터/구독: 90일 이상 → 삭제
- 시스템 알림: 30일 이상 → 삭제 (보안알림 제외)
"""
import requests, sys
from datetime import datetime, timedelta
from pathlib import Path

sys.path.insert(0, str(Path(__file__).parent.parent / "secretary"))
from google_auth import get_access_token
from notifier import send_ntfy

def trash_messages(headers, query, label):
    r = requests.get("https://www.googleapis.com/gmail/v1/users/me/messages",
        headers=headers, params={"q": query, "maxResults": 100}, timeout=15)
    msgs = r.json().get("messages", [])
    for m in msgs:
        requests.post(
            f"https://www.googleapis.com/gmail/v1/users/me/messages/{m['id']}/trash",
            headers=headers, timeout=10
        )
    if msgs:
        print(f"  [{label}] {len(msgs)}건 삭제")
    return len(msgs)

def main():
    now = datetime.now()
    print(f"=== Gmail 정리 ({now.strftime('%Y-%m-%d')}) ===")

    token = get_access_token()
    headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
    total = 0

    cutoff_7d  = (now - timedelta(days=7)).strftime("%Y/%m/%d")
    cutoff_30d = (now - timedelta(days=30)).strftime("%Y/%m/%d")
    cutoff_90d = (now - timedelta(days=90)).strftime("%Y/%m/%d")

    total += trash_messages(headers,
        f"category:promotions before:{cutoff_7d}", "광고")

    total += trash_messages(headers,
        f"category:updates before:{cutoff_90d} -from:accounts.google.com", "뉴스레터/구독")

    total += trash_messages(headers,
        f"from:(noreply OR no-reply OR notification) before:{cutoff_30d} -subject:보안 -from:accounts.google.com",
        "시스템알림")

    # 쿠팡 인증/확인 메일 (링크 클릭 방식 — 보관 불필요, 7일 후 삭제)
    total += trash_messages(headers,
        f"from:coupang.com (subject:인증 OR subject:확인 OR subject:verification OR subject:로그인) before:{cutoff_7d}",
        "쿠팡 인증메일")

    print(f"\n총 {total}건 삭제 완료")
    send_ntfy(f"✅ Gmail 정리 완료: {total}건 삭제 ({now.strftime('%Y-%m-%d')})",
              tags="white_check_mark")

if __name__ == "__main__":
    main()

    services = []
    for label, svc in m.get("services", {}).items():
        log_path = str(BASE_DIR / svc["log"]) if svc.get("log") else ""
        services.append({
            "label": label,
            "name": svc.get("purpose", label),
            "log": log_path,
            # 스케줄형 LaunchAgent도 cron_run.py 래퍼 경유 시 heartbeat 생성 (라벨 키)
            "heartbeat": str(hb_dir / f"{label}.json"),
            "check_log": svc.get("monitor_log", False),
            "max_age_min": svc.get("max_stale_min", 15),
            "timeout_min": svc.get("timeout_min", 60),
            "scheduled": svc.get("scheduled", False),
        })
    crons = []
    for name, cfg in m.get("crons", {}).items():
        if name == "health_check":
            continue  # 자기 자신은 감시하지 않음
        script = cfg.get("script", "")
        crons.append({
            "name": name,
            "script": str(BASE_DIR / script),
            "log": str(BASE_DIR / cfg["log"]),
            # 생존·오류 판정의 1차 소스는 cron_run.py 래퍼가 쓰는 heartbeat JSON
            # {ts, rc, streak, stderr_tail}. 로그 mtime은 실행 증거가 못 되고(313회 오탐),
            # 로그 텍스트 스캔은 heartbeat 미생성(미전환) 크론의 폴백으로만 유지.
            "heartbeat": str(hb_dir / f"{name}.json"),
            "max_age_min": cfg.get("max_stale_min", 1500),
            "alert_after": cfg.get("alert_after", 1),
            "timeout_min": cfg.get("timeout_min", 60),
            # launchagent 구동 크론(archive_refresh)은 crontab에 없어도 래퍼 경유
            "launchagent": bool(cfg.get("launchagent")),
            "schedule": cfg.get("schedule", ""),

    (2026-08-06 감사: 직접 실행은 args를 버려 stock_alert_realtime이 종가 모드로 돌았음)
    CRON_RUN_NO_NOTIFY=1 — 디버깅 재실행의 실패는 health_check가 보고, 래퍼 알림 중복 방지.
    """
    env = {**os.environ, "PATH": CLAUDE_PATH,
           "PYTHONPATH": "/Users/raccoonfamily/ClaudeCode",
           "CRON_RUN_NO_NOTIFY": "1"}
    # start_new_session: 타임아웃 시 래퍼만 죽고 손자(실제 스크립트)가 고아로 남아
    # flock 해제 + heartbeat 미기록 상태로 계속 도는 것을 방지 — 그룹째 kill
    proc = subprocess.Popen(
        ["/opt/homebrew/bin/python3.13",
         str(Path(__file__).parent / "cron_run.py"), cron["name"]],
        stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, env=env,
        start_new_session=True,
    )
    try:
        out, errs = proc.communicate(timeout=300)
    except subprocess.TimeoutExpired:
        try:
            os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
        except (ProcessLookupError, PermissionError):
            pass
        proc.wait()
        raise
    # 자식 출력은 래퍼가 로그·heartbeat에 기록 — 진단용 tail은 heartbeat에서 회수
    hb = read_heartbeat(cron["heartbeat"])
    return proc.returncode, (out or "")[-800:], (hb.get("stderr_tail") or errs or "")[-800:]


def claude_fix(script: str, stdout: str, stderr: str) -> str:
    """
    Claude에게 스크립트 직접 수정 요청.
    CLAUDE.md '자동 디버깅 권한' 범위 내에서 파일 편집.
    수정 결과 요약 반환.
    """
    prompt = (
        f"자동 디버깅 임무 (CLAUDE.md '자동 디버깅 권한' 범위).\n\n"
        f"아래 스크립트에서 오류가 발생했습니다. 파일을 직접 읽고 수정하세요.\n"
        f"수정 범위: 버그 수정, 환경변수 처리, 예외 처리에 한함. 기능 변경 금지.\n\n"
        f"스크립트: {script}\n"
        f"STDOUT:\n{stdout or '(없음)'}\n"
        f"STDERR:\n{stderr or '(없음)'}\n\n"
        f"수정 완료 후 변경 내용을 한 줄로만 답하세요."
    )
    try:
        r = subprocess.run(
            ["claude", "--model", "haiku", "--print", "--output-format", "json",
             "--permission-mode", "acceptEdits", prompt],
            capture_output=True, text=True, timeout=120,
            # --model haiku 명시 필수: .zshrc의 ANTHROPIC_MODEL=sonnet이 env로 상속되므로
            # 미지정 시 무인 자기수정이 Sonnet으로 실행됨 (CLAUDE.md 'Haiku for 자동화' 위반)
            env={**os.environ, "PATH": CLAUDE_PATH, "ANTHROPIC_MODEL": "claude-haiku-4-5-20251001"}
        )
        if r.returncode != 0:
            return f"(Claude 수정 실패: {r.stderr[:100]})"
        parsed = json.loads(r.stdout.strip())
        try:
            token_ledger.record_from_parsed(parsed, f"health_check 자동수정 ({Path(script).name})")
        except Exception:
            pass
        return parsed.get("result", "(응답 없음)")
    except Exception as e:
        return f"(Claude 호출 오류: {e})"

        try:
            json.loads(sf.read_text())
        except Exception as e:
            # 리셋/삭제 전 원본 사본 보존 — 복구 불가 손실 방지 (2026-08-06)
            sf.with_name(f"{sf.name}.corrupt-{now.strftime('%Y%m%d')}").write_bytes(sf.read_bytes())
            if sf.parent == heartbeat_dir:
                # heartbeat는 부재가 {}보다 의미 명확 — cron_run이 다음 실행에서 재생성
                sf.unlink()
                auto_fixed("데이터흐름", f"heartbeat/{sf.name}: JSON 파싱 실패 → 사본 보존 후 삭제 ({e})")
            else:
                sf.write_text("{}")
                auto_fixed("데이터흐름", f"{sf.name}: JSON 파싱 실패 → 사본 보존 후 빈 객체로 리셋 ({e})")
            broken += 1
    print(f"  ✅ state JSON {len(state_files)}개 검사, 리셋 {broken}건")


    # ════════════════════════════════════════════════════════════
    # 2. 리소스 위생
    # ════════════════════════════════════════════════════════════

    print(f"\n{'─'*50}\n🔍 2a. 로그 로테이션")

    LOG_MAX_BYTES = 500 * 1024  # 500KB — 경고 즉시 로테이션

    ALL_LOGS = list((BASE / "output" / "logs").glob("*.log")) + \
               list((BASE / "output" / "backups").glob("*.log")) + \
               list((BASE / "gmail_notify").glob("*.log")) + \
               list((BASE / "secretary").glob("*.log")) + \
               list((BASE / "secretary" / "logs").glob("*.log")) + \
               list((BASE / "dart_capital_report").glob("*.log"))

    for lf in ALL_LOGS:
        if lf.stat().st_size > LOG_MAX_BYTES:
            old_size_kb = lf.stat().st_size / 1024
            lines = lf.read_text(errors="replace").splitlines()
            lf.write_text("\n".join(lines[-200:]) + "\n")
            new_size_kb = lf.stat().st_size / 1024
            auto_fixed("리소스", f"{lf.name}: {old_size_kb:.0f}KB → {new_size_kb:.0f}KB (로테이션)")
        else:
            size_kb = lf.stat().st_size / 1024
            print(f"  ✅ {lf.name}: {size_kb:.1f}KB")


    print(f"\n{'─'*50}\n🔍 2b. 백업 정리")

    backup_dir = BASE / "output" / "backups"
    if backup_dir.exists():

def snapshot() -> dict:
    """현재 환경 스냅샷 수집."""
    snap = {
        "ts": datetime.now().isoformat(timespec="seconds"),
        "macos_version": _run(["sw_vers", "-productVersion"]),
        "macos_build": _run(["sw_vers", "-buildVersion"]),
        "claude_cli_version": _run(["/opt/homebrew/bin/claude", "--version"]),
        "python_version": _run(["/opt/homebrew/bin/python3.13", "--version"]),
        "node_version": _run(["/opt/homebrew/bin/node", "--version"]),
        "brew_packages": {},
        "keychain_item_mtime": _keychain_mtime(),
    }
    for pkg in ["python@3.13", "node", "openssl@3"]:
        v = _run(["brew", "list", "--versions", pkg])
        if v:
            snap["brew_packages"][pkg] = v.split()[1] if len(v.split()) > 1 else v
    return snap


def _keychain_mtime() -> str:
    """Claude Code-credentials item의 mdat (수정 시각)."""
    r = subprocess.run(
        ["security", "find-generic-password", "-s", "Claude Code-credentials"],
        capture_output=True, text=True, timeout=5,
    )
    if r.returncode != 0:
        return ""
    for line in r.stdout.splitlines():
        if '"mdat"' in line:
            # "mdat"<timedate>=0x323032362...  "20260419004923Z\000"
            q = line.split('"')
            return q[-2] if len(q) >= 2 else ""
    return ""


def _compare(prev: dict, cur: dict) -> list[tuple[str, str, str, str]]:
    """
    (field, severity, old, new) 튜플 반환.
    severity: critical / warning / info
    """
    changes = []
    # macOS: critical
    if prev.get("macos_version") != cur.get("macos_version"):
        changes.append(("macos_version", "critical", prev.get("macos_version", "?"), cur.get("macos_version", "?")))
    elif prev.get("macos_build") != cur.get("macos_build"):
        # build 번호만 변경 = 보안 패치 가능성
        changes.append(("macos_build", "critical", prev.get("macos_build", "?"), cur.get("macos_build", "?")))
    # Claude CLI: warning
    if prev.get("claude_cli_version") != cur.get("claude_cli_version"):
        changes.append(("claude_cli_version", "warning", prev.get("claude_cli_version", "?"), cur.get("claude_cli_version", "?")))
    # Python
    if prev.get("python_version") != cur.get("python_version"):
        changes.append(("python_version", "warning", prev.get("python_version", "?"), cur.get("python_version", "?")))
    # brew packages
    for pkg, ver in cur.get("brew_packages", {}).items():
        old = prev.get("brew_packages", {}).get(pkg)
        if old and old != ver:
            changes.append((f"brew/{pkg}", "info", old, ver))
    # keychain mtime: info만 (정상 refresh도 여기 잡힘)
    # - 기록만 남기고 알림 안 함
    return changes


def _notify(changes: list[tuple[str, str, str, str]]) -> None:
    critical = [c for c in changes if c[1] == "critical"]
    warnings = [c for c in changes if c[1] == "warning"]

    if critical:
        lines = ["⚠️ 환경 변화 감지 (critical)"]
        for f, sev, old, new in critical:
            lines.append(f"• {f}: {old} → {new}")
        lines.append("")
        lines.append("점검 사항:")
        lines.append("- LaunchAgent launchctl list | grep com.rc")
        lines.append("- 모닝 크론 로그 (/output/logs/morning_*.log)")
        lines.append("- keychain 접근: claude --print hi 테스트")
        send_ntfy("\n".join(lines), priority="urgent", tags="warning")
    elif warnings:
        lines = ["🔔 환경 변화 감지"]
        for f, sev, old, new in warnings:
            lines.append(f"• {f}: {old} → {new}")
        send_ntfy("\n".join(lines), priority="default", tags="bell")

def record(cost_usd: float, input_tokens: int, output_tokens: int,
           cache_creation: int = 0, cache_read: int = 0,
           label: str = "", duration_ms: int = 0, notify: bool = False):
    """사용량 기록 + 선택적 ntfy 알림"""
    today = datetime.now().strftime("%Y-%m-%d")
    data  = _load()
    day   = data.setdefault(today, {
        "calls": 0, "input": 0, "output": 0,
        "cache_creation": 0, "cache_read": 0, "cost_usd": 0.0
    })
    day["calls"]         += 1
    day["input"]         += input_tokens
    day["output"]        += output_tokens
    day["cache_creation"] += cache_creation
    day["cache_read"]    += cache_read
    day["cost_usd"]      = round(day["cost_usd"] + cost_usd, 6)
    _save(data)

    if notify:
        secs  = f"{duration_ms/1000:.1f}초" if duration_ms else ""
        daily = day["cost_usd"]
        msg   = (
            f"✅ {label}\n"
            f"입력 {input_tokens:,} / 출력 {output_tokens:,} 토큰"
            + (f" | {secs}" if secs else "") + "\n"
            f"일일 누계: {day['calls']}회 / ${daily:.4f}"
        )
        send_ntfy(msg, tags="white_check_mark")


def record_from_parsed(parsed: dict, label: str, *, notify: bool = False):
    """claude --output-format json 결과를 그대로 기록.

    parsed: subprocess.run 의 stdout 을 json.loads 한 dict.
    """
    usage = parsed.get("usage", {}) or {}
    record(
        cost_usd       = parsed.get("total_cost_usd", 0),
        input_tokens   = usage.get("input_tokens", 0),
        output_tokens  = usage.get("output_tokens", 0),
        cache_creation = usage.get("cache_creation_input_tokens", 0),
        cache_read     = usage.get("cache_read_input_tokens", 0),
        duration_ms    = parsed.get("duration_ms", 0),
        label          = label,
        notify         = notify,
    )


def today_summary() -> dict:
    today = datetime.now().strftime("%Y-%m-%d")
    return _load().get(today, {})


def ntfy_daily_summary():
    """일일 요약 ntfy 발송 (크론용)"""
    today = datetime.now().strftime("%Y-%m-%d")
    data  = _load()

    # 오늘 + 이번 달 누계
    day   = data.get(today, {})
    month = datetime.now().strftime("%Y-%m")
    monthly_cost = sum(
        v["cost_usd"] for k, v in data.items() if k.startswith(month)
    )

    msg = (
        f"📊 Claude 일일 사용량 ({today})\n"
        f"호출: {day.get('calls', 0)}회\n"
        f"입력: {day.get('input', 0):,} 토큰\n"
        f"출력: {day.get('output', 0):,} 토큰\n"
        f"캐시: {day.get('cache_read', 0):,} 읽기 / {day.get('cache_creation', 0):,} 생성\n"
        f"오늘 비용: ${day.get('cost_usd', 0):.4f}\n"
        f"이번 달 누계: ${monthly_cost:.4f}"
    )
    # send_ntfy는 실패 시 False 반환 (예외 안 던짐) — 호출부에서 검사

def main():
    today = datetime.now()
    cred_content = extract_credentials()
    current_hash = compute_hash(cred_content)
    state = load_state()

    changed = current_hash != state["last_hash"]
    last_day = is_last_day_of_month()

    if not changed and not last_day:
        print(f"변경 없음, 월말 아님 → 발송 생략")
        return

    reason = []
    if changed:
        reason.append("크리덴셜 변경")
    if last_day:
        reason.append("월말 정기")
    reason_str = " + ".join(reason)

    password = secrets.token_hex(32)  # 64자 랜덤 키 (256비트)
    encrypted = encrypt(cred_content, password)
    filename = f"credentials_{today.strftime('%Y%m%d')}.enc"

    g_token = get_access_token()
    send_email(g_token, encrypted, filename, today, reason_str)
    key_sent = send_key_via_telegram(password, filename, today, reason_str)
    save_state(current_hash)

    status = "키: 텔레그램 발송" if key_sent else "⚠️ 키 텔레그램 발송 실패"
    print(f"✅ 크리덴셜 백업 발송 완료 → {RECIPIENT} ({reason_str}) / {status}")

        impact,
        "",
        "진단 제안:",
        "- 인터랙티브 터미널에서 `claude --print hi` 재현",
        "- keychain 상태: `security find-generic-password -s 'Claude Code-credentials'`",
        "- macOS 업데이트 이력: env_monitor 로그",
    ]
    text = "\n".join(msg_lines)
    try:
        send_ntfy(text, priority="urgent", tags="warning")
    except Exception:
        pass
    try:
        send_telegram(text)
    except Exception:
        pass


def probe() -> tuple[bool, str, str]:
    """
    1-token probe. 반환: (ok, reason, raw_output)
    """
    try:
        r = subprocess.run(
            [CLAUDE_BIN, "--model", MODEL, "--print", "--output-format", "json", "hi"],
            capture_output=True, text=True, timeout=30,
        )
    except subprocess.TimeoutExpired:
        return False, "subprocess timeout (30s)", ""
    except Exception as e:
        return False, f"exception {type(e).__name__}", str(e)

    raw = (r.stdout or "") + (r.stderr or "")
    if r.returncode != 0:
        return False, f"rc={r.returncode}", raw[:500]

    try:
        parsed = json.loads(r.stdout.strip().splitlines()[-1])
    except Exception:
        return False, "JSON 파싱 실패", raw[:500]

    if parsed.get("is_error"):

        r'^export\s+([A-Z_]+)=', zshrc.read_text(), re.MULTILINE
    ))
    return set(manifest.get("env_vars", [])) - zshrc_keys


def check_memory_index(memory_dir: Path) -> tuple[set[str], set[str]] | None:
    """MEMORY.md 인덱스 ↔ 디스크 파일 차이.

    Returns:
        (missing_in_index, missing_on_disk) — MEMORY.md 없으면 None
    """
    idx = memory_dir / "MEMORY.md"
    if not idx.exists():
        return None
    indexed = set(re.findall(r'\]\(([^)]+\.md)\)', idx.read_text()))
    actual = {f.name for f in memory_dir.glob("*.md") if f.name != "MEMORY.md"}
    return actual - indexed, indexed - actual


def check_llm_call_bypass() -> set[str]:
    """llm_client 단일 경계를 우회해 claude를 직접 호출하는 비허용 파일 집합.

    LLM 호출 효율화 회귀(backsliding) 방지 — 신규 직접 호출 탐지 (토큰 0, 순수 정적 스캔).
    """
    root = Path(__file__).parent
    violators: set[str] = set()
    for py in root.rglob("*.py"):
        rel = py.relative_to(root).as_posix()
        if _LLM_SCAN_EXCLUDE.search(rel) or rel in _LLM_DIRECT_ALLOWLIST:
            continue
        try:
            txt = py.read_text(encoding="utf-8", errors="ignore")
        except Exception:
            continue
        if _LLM_DIRECT_FINGERPRINT.search(txt):
            violators.add(rel)
    return violators


def collect_drifts(memory_dir: Path | None = None) -> list[str]:
    """모든 drift 메시지를 한 줄씩 모아 반환. memory_updater 출력 형식 호환."""
    drifts: list[str] = []

    cron = check_cron_count()
    if cron is None:
        drifts.append("system_manifest.json 없음 또는 crontab 조회 실패")
    else:
        actual, expected = cron
        if actual != expected:
            drifts.append(f"크론 수 불일치: crontab {actual}개 vs manifest {expected}개")

    missing = check_env_vars()
    if missing:
        drifts.append(f"manifest 환경변수 zshrc 미등록: {', '.join(sorted(missing))}")

    bypass = check_llm_call_bypass()

def load_plist_env(name: str) -> dict:
    p = PLIST_DIR / f"{name}.plist"
    if not p.exists():
        return {}
    with open(p, "rb") as f:
        data = plistlib.load(f)
    return data.get("EnvironmentVariables", {})

ENV = {}
for plist in ["com.rc.secretary", "com.rc.gmail-notify", "com.rc.filebot"]:
    ENV.update(load_plist_env(plist))

# 크론탭 환경변수 추가 로드 (RCNEWS_BOT_TOKEN, GOOGLE_CALENDAR_REFRESH_TOKEN 등)
try:
    ct = subprocess.run(["crontab", "-l"], capture_output=True, text=True)
    for line in ct.stdout.splitlines():
        if re.match(r'^[A-Z_]+=', line.strip()):
            k, _, v = line.strip().partition("=")
            if k not in ENV:
                ENV[k] = v
except Exception:
    pass

os.environ.update({k: v for k, v in ENV.items() if k not in os.environ})

# ── Google access token (1회 발급 후 모든 섹션에서 공유) ──
from secretary.google_auth import get_access_token

_REFRESH_TOKEN = os.environ.get("GOOGLE_REFRESH_TOKEN", "")
_GOOGLE_TOKEN_CACHE: str | None = None


def google_token() -> str:
    """Google access token (모듈 전역 캐싱). refresh_token 미설정 시 빈 문자열."""
    global _GOOGLE_TOKEN_CACHE
    if _GOOGLE_TOKEN_CACHE is None:
        _GOOGLE_TOKEN_CACHE = (
            get_access_token(_REFRESH_TOKEN) if _REFRESH_TOKEN else ""
        )
    return _GOOGLE_TOKEN_CACHE


# ── 결과 수집 ────────────────────────────────────────────────────────────────

results = []  # (category, name, ok, detail)

def ok(cat, name, detail=""):
    results.append((cat, name, True, detail))
    print(f"  ✅ {name}" + (f" — {detail}" if detail else ""))

def fail(cat, name, detail=""):
    results.append((cat, name, False, detail))
    print(f"  ❌ {name}" + (f" — {detail}" if detail else ""))

def warn(cat, name, detail=""):
    results.append((cat, name, True, f"⚠️ {detail}"))
    print(f"  ⚠️ {name}" + (f" — {detail}" if detail else ""))

def section(title):

#!/bin/bash
# ============================================================
# datahub Seafile 원격 → 로컬 Mac 백업 (3-2-1의 오프사이트 사본)
#   복사본: ①서버 라이브 ②로컬 Mac(이 스크립트) ③netcup 스냅샷(수동)
# 내용: MariaDB 3개(ccnet/seafile/seahub) 덤프 + seafile/data tar
# 접속: SSH 키(패스프레이즈+Keychain/agent). LaunchAgent(GUI세션)에서 실행.
#   DB 비번은 서버 seafile/.env 에서만 읽음(로컬 미노출). data는 root소유→sudo tar.
# ============================================================
set -uo pipefail

DATE=$(date +%Y-%m-%d-%H%M)
HOST="mydatabricks@v2202606370248472075.luckysrv.de"
REMOTE_SEAFILE="/home/mydatabricks/mydatabricks-deploy/seafile"
BACKUP_ROOT="/Users/raccoonfamily/ClaudeCode/output/backups/seafile"
DEST="$BACKUP_ROOT/$DATE"
KEEP=4
NTFY="https://ntfy.sh/RCMySecretary-raccoon-work-done"
SSHC="ssh -o ConnectTimeout=20 -o BatchMode=yes"

fail() {
  curl -s -H "Priority: high" -H "Tags: warning" \
    -d "❌ datahub Seafile 백업 실패: $1 ($DATE)" "$NTFY" >/dev/null 2>&1 || true
  echo "FAIL: $1"
  exit 1
}

mkdir -p "$DEST" || fail "로컬 디렉토리 생성"
echo "=== datahub Seafile 백업 시작: $DATE ==="

# 1) 원격 MariaDB 덤프 → 서버 /tmp (gzip). 비번은 서버 .env에서만.
echo "[1/4] MariaDB 덤프 (ccnet/seafile/seahub)..."
$SSHC "$HOST" 'bash -s' <<'REMOTE' || fail "DB 덤프"
set -e
cd /home/mydatabricks/mydatabricks-deploy/seafile
set -a; . ./.env; set +a
docker exec -e PW="$SEAFILE_DB_ROOT_PASSWD" seafile-db \
  sh -c 'exec mariadb-dump -uroot -p"$PW" --single-transaction --routines --databases ccnet_db seafile_db seahub_db' \
  2>/tmp/sfdump.err | gzip > /tmp/seafile_db.sql.gz
test -s /tmp/seafile_db.sql.gz
REMOTE

# 2) DB 덤프 다운로드
echo "[2/4] DB 덤프 다운로드..."
$SSHC "$HOST" 'cat /tmp/seafile_db.sql.gz' > "$DEST/seafile_db_$DATE.sql.gz" || fail "DB 덤프 다운로드"
test -s "$DEST/seafile_db_$DATE.sql.gz" || fail "DB 덤프 빈 파일"

# 3) seafile 파일 데이터 tar (data/seafile 만 — data/db 는 위 덤프가 정본이라 제외).
#    root 소유 → sudo tar over ssh.
echo "[3/4] seafile 파일데이터(data/seafile) 아카이브..."
$SSHC "$HOST" "sudo tar czf - -C $REMOTE_SEAFILE data/seafile" > "$DEST/seafile_data_$DATE.tar.gz" || fail "data tar"
test -s "$DEST/seafile_data_$DATE.tar.gz" || fail "data tar 빈 파일"

# 4) 서버 임시정리 + 메타 + 보존(최신 KEEP개)
echo "[4/4] 정리..."
$SSHC "$HOST" 'rm -f /tmp/seafile_db.sql.gz /tmp/sfdump.err' 2>/dev/null || true
SIZE=$(du -sh "$DEST" | cut -f1)
printf '{"date":"%s","host":"%s","size":"%s","db_dump":["ccnet_db","seafile_db","seahub_db"],"file_data":"data/seafile tar (data/db 제외=덤프가 정본)"}\n' \
  "$DATE" "$HOST" "$SIZE" > "$DEST/backup_manifest.json"
ls -1dt "$BACKUP_ROOT"/*/ 2>/dev/null | tail -n +$((KEEP+1)) | xargs -I{} rm -rf {} 2>/dev/null || true

echo "✅ 백업 완료: $DEST ($SIZE)"
curl -s -H "Tags: white_check_mark" \
  -d "✅ datahub Seafile 백업 완료: $DATE ($SIZE) — DB+data, 로컬 보관 최신 ${KEEP}개" "$NTFY" >/dev/null 2>&1 || true
echo "$DEST"

def check() -> tuple[bool, str]:
    hb, ntfy_t = poll_latest_ntfy()
    if hb is not None:
        try:
            CACHE.parent.mkdir(parents=True, exist_ok=True)
            CACHE.write_text(json.dumps({"hb": hb, "ntfy_time": ntfy_t}, ensure_ascii=False))
        except Exception:
            pass
    elif CACHE.exists():
        try:
            c = json.loads(CACHE.read_text())
            hb, ntfy_t = c.get("hb"), c.get("ntfy_time")
        except Exception:
            hb = None
    if hb is None:
        return False, "heartbeat 없음 (ntfy 빈 상태 — VM emitter 미가동, 준비 상태)"

    now = datetime.now(timezone.utc).timestamp()
    issues = []
    # 신선도 = ntfy 수신시각 기준
    if ntfy_t:
        age_min = (now - ntfy_t) / 60
        if age_min > MAX_AGE_MIN:
            issues.append(f"stale {age_min:.0f}분(>{MAX_AGE_MIN})")
    # 시계드리프트 = VM 시계 vs ntfy 수신시각(동일 발신 시점)
    vmc = hb.get("vm_clock_utc")
    if vmc and ntfy_t:
        try:
            vm_epoch = datetime.fromisoformat(str(vmc).replace("Z", "+00:00")).timestamp()
            drift = abs(vm_epoch - ntfy_t)
            if drift > MAX_DRIFT_SEC:
                issues.append(f"시계드리프트 {drift:.0f}s(>{MAX_DRIFT_SEC})")
        except Exception:
            pass
    if hb.get("bot_status") not in (None, "ok"):
        issues.append(f"bot={hb.get('bot_status')}")
    age_disp = f"{(now - ntfy_t) / 60:.0f}분" if ntfy_t else "?"
    return (False, "; ".join(issues)) if issues else (True, f"정상(age {age_disp})")

#!/bin/zsh
# PTAI VM IP 드리프트 자동 보정 (호스트측).
# DHCP 리스에서 VM(pinetree-corporate)의 현재 도달가능 IP를 찾아 ~/.ssh/config HostName 갱신.
# 'No route to host' 재발 시 실행: zsh ptai_host_ops/fix_pinetree_ip.sh
# (영구 해결은 VM측 고정IP 권장 — HEARTBEAT-CONTRACT.md / Cowork 도메인. 본 스크립트는 호스트 안전망.)
set -u
LEASES=/var/db/dhcpd_leases
SSHCFG="$HOME/.ssh/config"
VMNAME="pinetree-corporate"

# 리스 블록에서 VM 이름과 매칭되는 ip_address 후보 수집
candidates=$(awk -v n="$VMNAME" '
  /^{/{ip="";nm=""}
  /ip_address=/{ip=$0; sub(/.*ip_address=/,"",ip)}
  /name=/{nm=$0; sub(/.*name=/,"",nm)}
  /^}/{ if(nm==n && ip!="") print ip }' "$LEASES" 2>/dev/null | sort -u)

[ -z "$candidates" ] && { echo "리스에서 $VMNAME IP 후보 없음"; exit 1; }

live=""
for ip in ${(f)candidates}; do
  if ping -c1 -t2 "$ip" >/dev/null 2>&1 && nc -z -G2 "$ip" 22 >/dev/null 2>&1; then
    live="$ip"; break
  fi
done
[ -z "$live" ] && { echo "도달 가능한 IP 없음 (후보: $(echo $candidates | tr '\n' ' '))"; exit 1; }

cur=$(awk '/^Host pinetree$/{f=1;next} f&&/HostName/{print $2; exit} /^Host /{f=0}' "$SSHCFG")
if [ "$cur" = "$live" ]; then
  echo "이미 최신: pinetree → $live (port22 OK)"; exit 0
fi
sed -i '' "/^Host pinetree\$/,/^Host /{ s/\(HostName \).*/\1$live/; }" "$SSHCFG"
echo "갱신 완료: pinetree HostName $cur → $live"

def record_failure(crash_state: dict, name: str) -> bool:
    """실패 기록. crash loop이면 True 반환."""
    entry = crash_state.get(name, {"failures": [], "suppressed": False})
    entry["failures"].append(datetime.now().isoformat())
    cutoff = datetime.now().timestamp() - CRASH_LOOP_WINDOW_MIN * 60
    entry["failures"] = [
        t for t in entry["failures"]
        if datetime.fromisoformat(t).timestamp() > cutoff
    ]
    is_loop = len(entry["failures"]) >= CRASH_LOOP_THRESHOLD
    if is_loop:
        entry["suppressed"] = True
    crash_state[name] = entry
    save_json(CRASH_STATE_FILE, crash_state)
    return is_loop


def record_success(crash_state: dict, name: str) -> None:
    """성공 시 실패 카운터 리셋(crash loop 윈도우 초기화).
    복구 알림은 alert_state resolved_keys 경로에서만 생성 — 여기선 관여 안 함."""
    if name in crash_state:
        del crash_state[name]
        save_json(CRASH_STATE_FILE, crash_state)


def is_crash_looping(crash_state: dict, name: str) -> bool:
    """suppressed면 True. 단, 마지막 실패가 CRASH_LOOP_RELEASE_MIN 경과 시
    suppression 자동 해제(엔트리 삭제) → debug_cron 재시도 허용.

    except Exception as e:  # pragma: no cover
        msgs.append(f"manifest 제거 예외: {e}")
    return "; ".join(msgs)


def main() -> int:
    state = _load_state()
    now = _now()

    if state.get("resolved"):
        print(f"[{now}] already resolved — no-op")
        return 0

    first = state.get("first_run")
    if first:
        try:
            d0 = datetime.strptime(first, "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=timezone.utc)
            if (datetime.now(timezone.utc) - d0).days >= MAX_WINDOW_DAYS:
                if not state.get("window_alerted"):
                    send_ntfy(
                        f"WARP enrollment {MAX_WINDOW_DAYS}일째 미해소 — 폴링 크론 자가 제거. "
                        f"재시도 시 크론 재등록 필요.",
                        priority="default", tags="warning",
                    )
                    state["window_alerted"] = True
                    _save_state(state)
                # 만료 시에도 자가 삭제 — no-op 좀비 크론 방지 (2026-07-02 리뷰)
                _self_remove()
                print(f"[{now}] window exceeded — cron self-removed")
                return 0
        except Exception:
            pass
    else:
        state["first_run"] = now

    code, body = _probe()
    state["last_run"] = now
    state["last_http_code"] = code

    # 프로브 실패(네트워크 등) → 조용히
    if code == -1:
        state["last_status"] = "probe_error"
        _save_state(state)
        print(f"[{now}] probe error — quiet")
        return 0

    blocked = (code == 400) or bool(BLOCKED_RE.search(body))

    if blocked:
        # ⚠️ Cloudflare Access 에러 페이지 본문에는 "Error" 문자열이 들어 있어
        # health_check.last_errors() 의 오류 키워드 스캔을 오탐시킨다(무한 재실행 루프).
        # 막힘은 예상된 정상 상태이므로 원시 본문을 기록하지 않고 깨끗한 상태만 남긴다.
        state["last_status"] = "blocked"
        _save_state(state)
        print(f"[{now}] HTTP {code} — still blocked (enrollment not provisioned) — quiet")
        return 0

    # 막힘이 아닌 경우에만 진단용 본문 스니펫 기록 (키워드 오탐 영향 없음)
    snippet = re.sub(r"\s+", " ", body).strip()[:200]
    print(f"[{now}] HTTP {code} | {snippet!r}")

    # 400/invalid 사라짐 → 프로비저닝된 것으로 판단
    if code in (200, 302, 301):
        state["resolved"] = True
        state["resolved_at"] = now
        state["last_status"] = "ready"
        _save_state(state)
        # 해소 시 자가 제거(사용자 지시: warp문제 해결 시 삭제)
        cleanup = _self_remove()
        send_ntfy(
            "WARP enrollment 가능해진 듯 (URL이 더 이상 invalid 아님, HTTP "
            f"{code}). 수동 등록 진행: WARP 앱 로그인(spring-grass-9f18, byungho OTP) "

# (파일 없음: output/datahub_revised_20260618/website/index.html)

def call_haiku_summarizer(
    prompt: str,
    *,
    script: str = "memory_updater",
    system_prompt: str = _DEFAULT_SUMMARIZER_SYSTEM,
    timeout: int = 90,
) -> tuple[str, str]:
    """단일 Haiku CLI 호출. (text, fail_reason) 반환.
    성공 시 fail_reason='', 실패 시 text=''.

    cwd=/tmp 로 CLAUDE.md 자동 로드 차단, 도구 권한 부여 안 함.
    """
    # LLM 호출 단일 경계: cwd=/tmp(CLAUDE.md 미로드) + token_ledger + haiku_monitor(label=script) 자동
    text = call_haiku_tracked(prompt, system=system_prompt, label=script, timeout=timeout)
    if text.startswith("[ERROR]"):
        reason = text.replace("[ERROR]", "").strip()[:60] or "error"
        low = reason.lower()
        if "timeout" in low:
            reason = "timeout"            # _RETRYABLE_REASONS 매칭 보존
        elif "rate" in low:
            reason = "rate limit"
        print(f"[{script}] Haiku 실패: {reason}", file=sys.stderr)
        return "", reason
    return text.strip(), ""


_call_haiku = call_haiku_summarizer


def summarize_with_haiku(conv_text: str) -> str | None:
    """Haiku로 대화 요약 → bullet 형태. 일시 오류만 1회 재시도.

    반환: 성공=요약 문자열, Haiku/CLI 오류=None ('요약 없음'과 '오류' 구분용)
    """
    import time
    prompt = (
        "아래 텔레그램 대화(주인님↔비서봇)에서 향후 대화에 유용한 핵심 사실, "
        "결정사항, 선호도, 시스템 변경 내용만 추출해서 bullet 7줄 이내 한국어로 답해. "
        "불필요한 설명·인사말 없이. 대화 내용이 없거나 일상적이면 '변경사항 없음'만 출력. "
        "참고: 히스토리 드롭 시 [auto-drop] 태그로 이미 기록된 내용은 중복하지 말고 새로운 사항만.\n\n"
        f"{conv_text}"
    )
    try:
        text, reason = call_haiku_summarizer(prompt)
        if text:
            return text
        if not reason:
            return ""  # 오류 없이 빈 응답 — 정상 '요약 없음'
        if reason not in _RETRYABLE_REASONS:
            print(f"[memory_updater] 재시도 무용 ({reason}), 중단", file=sys.stderr)
            return None
        print(f"[memory_updater] {reason} 재시도 (10초 후)...", file=sys.stderr)
        time.sleep(10)
        text, reason = call_haiku_summarizer(prompt)
        if text:
            return text
        return "" if not reason else None
    except Exception as e:
        print(f"[memory_updater] Haiku 오류: {e}", file=sys.stderr)
        return None


def check_drift() -> list:
    """메모리 파일 ↔ 실제 시스템 상태 drift 감지 (AI 호출 없음).

    sysops_drift.collect_drifts 를 얇게 래핑 — smoke_test 와 동일 검증 로직 공유.
    """
    from sysops_drift import collect_drifts
    return collect_drifts(MEMORY_DIR)


def main() -> int:
    now_kst   = datetime.now(KST)
    today_str = now_kst.strftime("%Y-%m-%d")
    print(f"[memory_updater] 실행: {today_str}", file=sys.stderr)

    # ── Drift Detection (AI 호출 없음) ──
    drifts = check_drift()
    if drifts:
        drift_msg = "⚠️ 메모리 drift 감지:\n" + "\n".join(f"• {d}" for d in drifts)
        print(f"[memory_updater] {drift_msg}", file=sys.stderr)
        send_ntfy(drift_msg, tags="warning")
    else:
        print("[memory_updater] drift 없음", file=sys.stderr)

    # ── 대화 요약 (기존 로직) ──
    history = load_history()
    if not history:
        print("[memory_updater] 히스토리 없음, 종료", file=sys.stderr)
        return 0

    # 모든 히스토리 포함 (daily summary는 전체 context 기준)
    conv_lines = []
    for turn in history:
        role = "주인님" if turn["role"] == "user" else "비서"
        content = turn["content"][:400].replace("\n", " ")
        conv_lines.append(f"{role}: {content}")

    conv_text = "\n".join(conv_lines)
    if not conv_text.strip():
        print("[memory_updater] 대화 내용 없음, 종료", file=sys.stderr)
        return 0

    print(f"[memory_updater] Haiku 요약 시작 ({len(conv_lines)}턴)", file=sys.stderr)
    summary = summarize_with_haiku(conv_text)

    if summary is None:  # Haiku/CLI 오류 — '대화 없음'과 구분해 실패로 처리
        print("[memory_updater] Haiku 요약 실패, 종료", file=sys.stderr)
        return 1

    if not summary or summary == "변경사항 없음":
        print("[memory_updater] 요약 없음 또는 변경사항 없음, 종료", file=sys.stderr)

def detect_candidates(conv: str, hist: str, existing: list[dict]) -> list[dict]:
    existing_str = "\n".join(f"- {s['name']}: {s['description']}" for s in existing) or "(없음)"
    prompt = (
        "## 기존 스킬 (이것과 중복되는 후보는 절대 제안하지 말 것)\n"
        f"{existing_str}\n\n"
        "## 최근 대화 요약 (반복 신호)\n"
        f"{conv or '(없음)'}\n\n"
        "## 최근 사용자 요청\n"
        f"{hist or '(없음)'}\n\n"
        "## 지시\n"
        "위 활동에서 '반복되며 + 기존 스킬로 커버 안 되는' 다단계 작업 패턴을 찾아라. "
        "없으면 빈 배열. 최대 3개. 각 후보는 다음 JSON 스키마로:\n"
        '{"candidates":[{"name":"kebab-case-영문명","trigger":"발동 키워드/맥락 한 줄",'
        '"recurrence_evidence":"반복 근거 한 줄(한국어)","outline":["단계1","단계2","단계3"]}]}'
    )
    raw = call_llm(prompt, system=SYSTEM, model="haiku", json_mode=True,
                   cwd="/tmp", timeout=120, label="skill_synthesizer")
    if raw.startswith("[ERROR]"):
        print(f"[skill_synthesizer] Haiku 실패: {raw}", file=sys.stderr)
        return []
    data = extract_json(raw) or {}
    cands = data.get("candidates", []) if isinstance(data, dict) else []
    # 최소 정합성 필터
    out = []
    for c in cands:
        if isinstance(c, dict) and c.get("name") and c.get("outline"):
            c["name"] = re.sub(r"[^a-z0-9\-]", "-", str(c["name"]).lower()).strip("-")[:40]
            if c["name"]:
                out.append(c)
    return out[:3]


# ──────────────────────────────────────────────────────
# 초안 작성 (staging only)
# ──────────────────────────────────────────────────────
def write_draft(c: dict, today: str) -> Path:
    skill_dir = STAGING_DIR / c["name"]
    skill_dir.mkdir(parents=True, exist_ok=True)
    outline = "\n".join(f"{i+1}. {step}" for i, step in enumerate(c.get("outline", [])))
    content = (
        f"---\n"
        f"name: {c['name']}\n"
        f"description: {c.get('trigger', '')}\n"
        f"status: DRAFT — skill_synthesizer 자동 생성, 미설치\n"
        f"generated: {today}\n"
        f"---\n\n"
        f"# {c['name']} (초안)\n\n"
        f"> ⚠️ skill_synthesizer 가 자동 생성한 **초안**입니다.\n"
        f"> 검토 후 `.claude/skills/{c['name']}/` 로 이동하면 활성화됩니다.\n\n"
        f"## 발동 조건\n{c.get('trigger', '')}\n\n"
        f"## 반복 근거\n{c.get('recurrence_evidence', '')}\n\n"
        f"## 절차 (초안)\n{outline}\n\n"
        f"## 검토 체크리스트\n"
        f"- [ ] 절차 정확성 확인\n"
        f"- [ ] 기존 스킬과 중복 여부 재확인\n"
        f"- [ ] skill-creator 로 정식화 후 이동\n"
    )
    (skill_dir / "SKILL.md").write_text(content, encoding="utf-8")
    return skill_dir / "SKILL.md"