v2.8.0: 도전과제 시스템 + 다크 디자인 리뉴얼 + 안정성 강화

Added — 도전과제 시스템 (153개 자동 평가)
- core/achievements.py: 16개 카테고리, 5단계 등급, 시크릿 9개, 메타 도전과제
- ui/achievements_view.py: 4탭 다이얼로그 (전체/진행중/완료/시크릿)
- 5분 throttle 자동 평가 + 시스템 알림 + Discord embed push
- achievements 테이블 확장 (code/category/tier/is_secret/progress/target)
- hire_date 자동 추적, 뷰 진입 카운터 8개 settings 키

Changed — 다크 테마 디자인 리뉴얼
- ui/dark_components.py: 재사용 가능한 다크 컴포넌트 (header/card/button/progress)
- 통계/도움말/도전과제 다이얼로그 일관 다크 톤
- matplotlib 차트 다크 테마 적용 (figure/axes/grid/legend)
- 등급별 카드 그라디언트 (브론즈/실버/골드/플래티넘/레전드)

Fixed — 안정성·일관성
- 타임존 자정 경계 버그 (has_notification_today UTC vs localtime mismatch)
- DB 연결 누수: _conn() 컨텍스트 매니저 도입, 40+ 메서드 변환
- DB 이중 부트스트랩 제거 (MainWindow(db=None) 옵션 인자)
- crash_handler 다단계 폴백 (DB → 파일 → stderr)
- updater PID race: 지수 backoff 재시도 (총 ~9초)
- Discord URL 형식 검증 (snowflake regex)
- 일일 보고서 저녁 섹션, MealTimeDialog 출/퇴근 범위 검증
- check_dinner_reminder 신규, 알림 임계값 5개 설정화
- closeEvent timer/notifier 정리 (aboutToQuit hook)
- 마이그레이션 12개 모두 _conn() + try/finally
- DB 인덱스 5개 추가 (break/overtime/leave date)

Tests
- pytest 116/116 PASS, 통합 시나리오 48/48 PASS

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

utils/backup.py

@@ -71,5 +71,7 @@ def _rotate(directory: Path, keep: int) -> None:
     for old in files[keep:]:
         try:
             old.unlink()
-        except OSError:
-            pass
+        except OSError as e:
+            # 회전 실패 시 로그만 — 다음 실행에 재시도. 누적 시 디스크 압박 가능.
+            from utils.debug_log import dlog
+            dlog(f"backup rotation failed for {old}: {e}")

utils/crash_handler.py

@@ -20,24 +20,79 @@ USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) ClockOutCalculator/2.4'
 
 
 def install_global_handler(db, app_version: str = 'unknown') -> None:
-    """sys.excepthook 등록. db는 crash_log 저장용."""
+    """sys.excepthook 등록. db는 crash_log 저장용.
+
+    각 단계(log → dialog → 파일 fallback → original hook)는 모두 독립 try로 감싸
+    하나가 실패해도 다음 단계가 동작. 가장 최후 fallback은 stderr + 로컬 파일.
+    """
     original = sys.excepthook
 
     def hook(exc_type, exc_value, exc_tb):
         if exc_type is KeyboardInterrupt:
             original(exc_type, exc_value, exc_tb)
             return
+
+        # 1단계: traceback 직렬화 (실패하면 minimal fallback)
         try:
             tb_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_tb))
-            _log_crash(db, exc_type.__name__, str(exc_value), tb_str, app_version)
-            _show_dialog(db, exc_type.__name__, str(exc_value), tb_str, app_version)
         except Exception:
-            pass  # 후킹 자체 실패는 silent
-        original(exc_type, exc_value, exc_tb)
+            tb_str = f"{exc_type}: {exc_value} (traceback formatting failed)"
+
+        type_name = getattr(exc_type, '__name__', str(exc_type))
+        msg = str(exc_value)
+
+        # 2단계: DB 로깅 (DB 잠금/디스크 풀 등으로 실패 가능 — 단계 분리)
+        log_ok = False
+        try:
+            _log_crash(db, type_name, msg, tb_str, app_version)
+            log_ok = True
+        except Exception as log_err:
+            _fallback_to_file(type_name, msg, tb_str, app_version,
+                                f"DB log failed: {log_err}")
+
+        # 3단계: 다이얼로그 (PyQt 미초기화/이미 종료 등으로 실패 가능)
+        try:
+            _show_dialog(db, type_name, msg, tb_str, app_version)
+        except Exception as dlg_err:
+            # 다이얼로그 실패 시 stderr + 파일에 기록 (DB 로깅도 실패했으면 이게 유일한 흔적)
+            if not log_ok:
+                _fallback_to_file(type_name, msg, tb_str, app_version,
+                                    f"DB+dialog both failed; dialog err: {dlg_err}")
+            try:
+                print(f"\n[CRASH] {type_name}: {msg}\n{tb_str}", file=sys.stderr)
+            except Exception:
+                pass
+
+        # 4단계: 원래 hook도 호출 (콘솔 출력 + 종료)
+        try:
+            original(exc_type, exc_value, exc_tb)
+        except Exception:
+            pass  # 마지막 단계라 더 할 게 없음
 
     sys.excepthook = hook
 
 
+def _fallback_to_file(exc_type: str, message: str, tb: str,
+                        version: str, reason: str) -> None:
+    """DB 로깅이 실패한 경우 ~/.clockout_logs/crashes.log에 append.
+
+    Best-effort — 파일 쓰기 실패도 silent (이 시점엔 뭐 할 게 없음).
+    """
+    try:
+        from pathlib import Path
+        log_dir = Path.home() / '.clockout_logs'
+        log_dir.mkdir(parents=True, exist_ok=True)
+        log_file = log_dir / 'crashes.log'
+        with open(log_file, 'a', encoding='utf-8') as f:
+            f.write(
+                f"\n=== {datetime.now().isoformat(timespec='seconds')} ===\n"
+                f"version={version} reason={reason}\n"
+                f"{exc_type}: {message}\n{tb}\n"
+            )
+    except Exception:
+        pass
+
+
 def _log_crash(db, exc_type: str, message: str, tb: str, version: str) -> None:
     """crash_log 테이블에 기록."""
     try:

utils/csv_exporter.py

@@ -11,12 +11,15 @@ class CSVExporter:
     """CSV 내보내기 클래스"""
 
     @staticmethod
-    def export_work_records(records: List[Dict], filename: str = None) -> str:
+    def export_work_records(records: List[Dict], filename: str = None,
+                             db=None) -> str:
         """
-        근무 기록을 CSV로 내보내기
+        근무 기록을 CSV로 내보내기 (사람이 읽는 한글 헤더 + 사용/미사용 표기).
+
         Args:
             records: 근무 기록 리스트
             filename: 저장할 파일명 (None이면 자동 생성)
+            db: 점심/저녁 기본 분(minutes)을 표시용으로 읽을 Database 인스턴스 (옵션)
         Returns:
             str: 저장된 파일 경로
         """
@@ -24,31 +27,70 @@ class CSVExporter:
             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
             filename = f"work_records_{timestamp}.csv"
 
-        # CSV 파일 작성
+        # 표시용 기본 분 (옵션)
+        lunch_default = db.get_setting_int('lunch_duration_minutes', 60) if db else 60
+        dinner_default = db.get_setting_int('dinner_duration_minutes', 60) if db else 60
+
         with open(filename, 'w', newline='', encoding='utf-8-sig') as csvfile:
             fieldnames = [
-                '날짜', '출근시간', '퇴근시간', '점심시간',
-                '총근무시간', '연장근무(분)', '적립(분)', '메모'
+                '날짜', '출근시간', '퇴근시간',
+                '점심시간', '점심(분)', '저녁시간', '저녁(분)',
+                '총근무시간', '연장근무(분)', '적립(분)', '메모',
             ]
-
             writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
             writer.writeheader()
 
             for record in records:
+                lunch_on = bool(record.get('lunch_break'))
+                dinner_on = bool(record.get('dinner_break'))
                 row = {
                     '날짜': record.get('date', ''),
                     '출근시간': record.get('clock_in', ''),
                     '퇴근시간': record.get('clock_out', '미기록'),
-                    '점심시간': '사용' if record.get('lunch_break') else '미사용',
+                    '점심시간': '사용' if lunch_on else '미사용',
+                    '점심(분)': lunch_default if lunch_on else 0,
+                    '저녁시간': '사용' if dinner_on else '미사용',
+                    '저녁(분)': dinner_default if dinner_on else 0,
                     '총근무시간': f"{record.get('total_hours', 0):.1f}시간",
                     '연장근무(분)': record.get('overtime_minutes', 0),
                     '적립(분)': record.get('overtime_earned', 0),
-                    '메모': record.get('memo', '')
+                    '메모': record.get('memo', ''),
                 }
                 writer.writerow(row)
 
         return filename
 
+    @staticmethod
+    def export_work_records_for_reimport(records: List[Dict], filename: str = None,
+                                           db=None) -> str:
+        """csv_importer가 직접 다시 읽을 수 있는 round-trip 포맷으로 내보내기.
+
+        헤더: date,clock_in,clock_out,lunch_minutes,dinner_minutes,memo
+        """
+        if filename is None:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = f"work_records_reimport_{timestamp}.csv"
+
+        lunch_default = db.get_setting_int('lunch_duration_minutes', 60) if db else 60
+        dinner_default = db.get_setting_int('dinner_duration_minutes', 60) if db else 60
+
+        with open(filename, 'w', newline='', encoding='utf-8-sig') as csvfile:
+            fieldnames = ['date', 'clock_in', 'clock_out',
+                           'lunch_minutes', 'dinner_minutes', 'memo']
+            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+            writer.writeheader()
+            for record in records:
+                writer.writerow({
+                    'date': record.get('date', ''),
+                    'clock_in': record.get('clock_in', ''),
+                    'clock_out': record.get('clock_out', '') or '',
+                    'lunch_minutes': lunch_default if record.get('lunch_break') else 0,
+                    'dinner_minutes': dinner_default if record.get('dinner_break') else 0,
+                    'memo': record.get('memo', '') or '',
+                })
+
+        return filename
+
     @staticmethod
     def export_overtime_summary(db, filename: str = None) -> str:
         """

utils/csv_importer.py

@@ -1,14 +1,15 @@
 """
 CSV 가져오기 — 우리 표준 포맷.
 
-표준 포맷:
-    date,clock_in,clock_out,lunch_minutes,memo
-    2026-04-01,09:00:00,18:30:00,60,"메모"
+표준 포맷 (v2.7.1+):
+    date,clock_in,clock_out,lunch_minutes,dinner_minutes,memo
+    2026-04-01,09:00:00,18:30:00,60,0,"메모"
 
 - 헤더 첫 줄 필수
 - date: YYYY-MM-DD
-- clock_in/out: HH:MM:SS 또는 HH:MM
+- clock_in/out: HH:MM:SS 또는 HH:MM (clock_out이 clock_in보다 빠르면 익일로 간주)
 - lunch_minutes: 정수 (0이면 점심 미포함)
+- dinner_minutes: 정수 (옵션, 0/누락이면 저녁 미포함)
 - memo: 선택 (따옴표 가능)
 
 기존 일자와 충돌 시 import 호출자가 'overwrite'/'skip' 정책 결정.
@@ -45,6 +46,20 @@ def parse_csv(path: str) -> List[Dict]:
     return rows
 
 
+def _parse_minutes(raw: str, field_name: str) -> int:
+    """0 이상 정수 파싱. 빈 값이면 0."""
+    s = (raw or '').strip()
+    if not s:
+        return 0
+    try:
+        v = int(s)
+        if v < 0:
+            raise ValueError
+    except ValueError:
+        raise ValueError(f"{field_name}는 0 이상 정수여야 함: '{raw}'")
+    return v
+
+
 def _normalize_row(row: Dict) -> Dict:
     """단일 행 검증 + 정규화."""
     date_str = (row.get('date') or '').strip()
@@ -59,15 +74,8 @@ def _normalize_row(row: Dict) -> Dict:
     co_raw = (row.get('clock_out') or '').strip()
     co = _normalize_time(co_raw, 'clock_out') if co_raw else None
 
-    lunch = 0
-    lm = (row.get('lunch_minutes') or '').strip()
-    if lm:
-        try:
-            lunch = int(lm)
-            if lunch < 0:
-                raise ValueError
-        except ValueError:
-            raise ValueError(f"lunch_minutes는 0 이상 정수여야 함: '{lm}'")
+    lunch = _parse_minutes(row.get('lunch_minutes', ''), 'lunch_minutes')
+    dinner = _parse_minutes(row.get('dinner_minutes', ''), 'dinner_minutes')
 
     memo = (row.get('memo') or '').strip()
     return {
@@ -75,6 +83,7 @@ def _normalize_row(row: Dict) -> Dict:
         'clock_in': ci,
         'clock_out': co,
         'lunch_minutes': lunch,
+        'dinner_minutes': dinner,
         'memo': memo,
     }
 
@@ -111,9 +120,11 @@ def import_records(db, rows: List[Dict], on_conflict: str = 'skip') -> Tuple[int
 
     added = updated = skipped = 0
 
+    from datetime import timedelta
     from core.time_calculator import TimeCalculator
     work_minutes = db.get_work_minutes()
     lunch_default = db.get_setting_int('lunch_duration_minutes', 60)
+    dinner_default = db.get_setting_int('dinner_duration_minutes', 60)
 
     for row in rows:
         existing = db.get_work_record(row['date'])
@@ -131,6 +142,9 @@ def import_records(db, rows: List[Dict], on_conflict: str = 'skip') -> Tuple[int
                 cursor.execute("DELETE FROM break_records WHERE date = ?", (row['date'],))
                 cursor.execute("DELETE FROM work_records WHERE date = ?", (row['date'],))
                 conn.commit()
+            except Exception:
+                conn.rollback()
+                raise
             finally:
                 conn.close()
             updated += 1
@@ -141,16 +155,27 @@ def import_records(db, rows: List[Dict], on_conflict: str = 'skip') -> Tuple[int
         if row.get('clock_out'):
             ci_dt = datetime.strptime(f"{row['date']} {row['clock_in']}", '%Y-%m-%d %H:%M:%S')
             co_dt = datetime.strptime(f"{row['date']} {row['clock_out']}", '%Y-%m-%d %H:%M:%S')
-            calc = TimeCalculator(work_minutes=work_minutes,
-                                   lunch_duration_minutes=row.get('lunch_minutes') or lunch_default)
-            include_lunch = (row.get('lunch_minutes') or 0) > 0
+            # 자정 경계: 퇴근이 출근보다 빠르면 익일로 간주
+            if co_dt <= ci_dt:
+                co_dt += timedelta(days=1)
+            lunch_min = row.get('lunch_minutes') or 0
+            dinner_min = row.get('dinner_minutes') or 0
+            calc = TimeCalculator(
+                work_minutes=work_minutes,
+                lunch_duration_minutes=lunch_min or lunch_default,
+                dinner_duration_minutes=dinner_min or dinner_default,
+            )
+            include_lunch = lunch_min > 0
+            include_dinner = dinner_min > 0
             total = (co_dt - ci_dt).total_seconds() / 3600
             ot_actual, ot_earned = calc.calculate_overtime(
-                ci_dt, co_dt, include_lunch=include_lunch
+                ci_dt, co_dt, include_lunch=include_lunch, include_dinner=include_dinner,
             )
             db.update_clock_out(row['date'], row['clock_out'], total, ot_actual, ot_earned)
             if include_lunch:
                 db.update_lunch_break(row['date'], True)
+            if include_dinner:
+                db.update_dinner_break(row['date'], True)
             if ot_earned > 0:
                 db.add_overtime_earned(wid, ot_earned, row['date'])
 

utils/discord_webhook.py

@@ -5,6 +5,7 @@ URL 1개로 끝. 봇 등록·서버 운영 0. 실패 시 silent (앱 동작 안
 """
 from __future__ import annotations
 import json
+import re
 import urllib.request
 import urllib.error
 from datetime import datetime
@@ -21,6 +22,23 @@ COLOR_YELLOW = 0xFEE75C
 COLOR_PINK = 0xEB459E
 COLOR_ORANGE = 0xED4245
 
+# Discord 웹훅 URL 패턴: https://(discord.com|discordapp.com|...)/api/webhooks/{ID:digits}/{TOKEN}
+# canary./ptb. 서브도메인도 허용. PTB 모바일 앱이 종종 그 URL 발급.
+_WEBHOOK_RE = re.compile(
+    r'^https://(?:(?:canary|ptb)\.)?discord(?:app)?\.com/api/webhooks/\d{17,20}/[\w-]{50,}$'
+)
+
+
+def is_valid_webhook_url(url: str) -> bool:
+    """입력된 URL이 Discord webhook 형식인지 검증.
+
+    형식만 확인 — 실제 도달성·토큰 유효성은 send_test()로 검증해야 함.
+    빈 문자열이나 공백은 False (비활성 상태로 간주).
+    """
+    if not url or not isinstance(url, str):
+        return False
+    return bool(_WEBHOOK_RE.match(url.strip()))
+
 
 def send(webhook_url: str, title: str, description: str,
          color: int = COLOR_BLUE, fields: Optional[List[dict]] = None,
@@ -37,7 +55,7 @@ def send(webhook_url: str, title: str, description: str,
     Returns:
         성공 시 True. URL 비었거나 네트워크/4xx/5xx 시 False.
     """
-    if not webhook_url or not webhook_url.startswith('https://'):
+    if not is_valid_webhook_url(webhook_url):
         return False
 
     payload = {