Merge pull request 'v0.2.8 Cut A — 이미지 렌더링 + 앱 아이콘 (F22 + chore)' (#26) from worktree-v028-cut-a-image-icon into main

Reviewed-on: #26

.gitignore

@@ -7,3 +7,7 @@ dist/
 coverage/
 playwright-report/
 test-results/
+
+# build/ 산출물 — icon.{ico,icns,png} 만 커밋, 중간 산출물은 무시
+build/icons/
+build/icon-source.png

assets/icon.svg

@@ -0,0 +1,24 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1024 1024" role="img" aria-label="Inkling">
+  <!-- 배경 -->
+  <rect width="1024" height="1024" rx="192" fill="#1a6b6e"/>
+
+  <!-- 화살표 marker -->
+  <defs>
+    <marker id="head" markerWidth="14" markerHeight="14" refX="6" refY="7" orient="auto" markerUnits="strokeWidth">
+      <path d="M 0 0 L 12 7 L 0 14 Z" fill="#5fdbc8"/>
+    </marker>
+  </defs>
+
+  <!-- sync 호 1개 (270도, 시작점 + 끝 화살표) -->
+  <path d="M 512 132 A 380 380 0 1 1 132 512"
+        stroke="#5fdbc8" stroke-width="36" stroke-linecap="round" fill="none"
+        marker-end="url(#head)"/>
+  <circle cx="512" cy="132" r="28" fill="#5fdbc8"/>
+
+  <!-- 노트 1장 (단일 흰색 paper) -->
+  <rect x="332" y="332" width="360" height="360" rx="32" fill="#ffffff"/>
+
+  <!-- 텍스트 라인 2개 -->
+  <rect x="376" y="436" width="272" height="28" rx="14" fill="#1a6b6e"/>
+  <rect x="376" y="510" width="200" height="28" rx="14" fill="#1a6b6e"/>
+</svg>

docs/superpowers/specs/2026-04-25-dogfood-feedback.md

@@ -1,13 +1,31 @@
 # Dogfood 피드백 수집
 
-**작성일:** 2026-04-25 (open)
+**작성일:** 2026-04-25 (open, ongoing — v0.4 slice → v0.2.x cuts 까지 누적)
+**최종 갱신:** 2026-05-05 (v0.2.6 정식 cut 후, F8~F13 dogfood 발견 추가)
 **저자:** 김태현 (dlsrks0734@gmail.com)
-**문서 성격:** 슬라이스 v0.4 dogfood 중 발견된 본인 피드백을 수집·정제하는 living document. 각 항목은 후속 spec 으로 승격될 후보다. 정식 spec 이 분기될 만큼 성숙하면 별도 파일로 추출하고 여기엔 링크만 남긴다.
+**문서 성격:** v0.4 slice → v0.2.x cuts 동안 누적된 본인 dogfood 피드백 수집·정제 living document. 각 항목은 후속 spec/cut 으로 승격될 후보다.
 
 **선행 문서:**
 - `docs/superpowers/specs/2026-04-24-inkling-vertical-slice-design.md` v0.4 (슬라이스 본문)
+- `docs/superpowers/specs/2026-05-01-v023-feedback-roadmap-design.md` (v0.2.3 7항목 cut 로드맵)
 - `docs/superpowers/strategy/strategy.md` (심리학 전략)
-- `docs/superpowers/strategy/dogfood-strategy.md` (dogfood 운영안 — 본 문서와 의존 없음)
+- `docs/superpowers/strategy/dogfood-strategy.md` (dogfood 운영안)
+- `docs/superpowers/v024-backlog.md` (PR review deferred + dogfood 발견 누적 backlog, 잔여 24건)
+
+---
+
+## 진척 흐름 요약 (2026-05-05 기준)
+
+본 문서가 작성된 v0.4 slice 시점 이후 흐름:
+
+| 시점 | Cut | 주요 피드백 / 발견 |
+|---|---|---|
+| 2026-05-01 | v0.2.3 7항목 roadmap (PR #13~#19) | v0.2.2 dogfood 발견 6건 (`memory/project_v022_feedback.md`) → telemetry skeleton + 휴지통 + 만료 추천 + Ollama 회복 + AI retry + 태그 vocab + RecallBanner |
+| 2026-05-04 | v0.2.3.1 (PR #21) → v0.2.4 (PR #22, semver 우회) | **F8 11434 reserved**, **F9 multi-instance**, **F10 버전 정보 부재** |
+| 2026-05-05 | v0.2.5 critical hotfix (PR #23) | **F11 single-instance lock 부재** (critical, 해결됨) |
+| 2026-05-05 | v0.2.6 정식 cut (PR #24) | **F12 autostart 풀림**, **F13 hidden-start race** (해결됨) |
+
+**v0.2.7 brainstorm 트리거**: dogfood ≥1주 soak 후 telemetry export + 신규 피드백 + 잔여 backlog 24건 일괄 triage.
 
 ---
 
@@ -925,6 +943,441 @@ slice §1.3 종료 조건 ("크래시 0회") 와 별개로, **"데이터 손실
 
 ---
 
+## F8. Windows 11434 포트 OS-level reserved (🚀 promoted → v0.2.3.1/v0.2.4)
+
+**진행 상태:** 🚀 promoted → PR #21 (in-app Ollama 설정), v0.2.4 release.
+
+**발견:** 2026-05-04 dogfood 시작 시도 직후, Windows 머신.
+
+### 관찰
+
+v0.2.3 binary 설치 후 첫 실행 시 OllamaBanner 가 "unreachable" 상태 지속. `curl http://localhost:11434/api/tags` 응답 없음. 하지만 `ollama app.exe` 프로세스는 떠있음. 진단 결과:
+- Ollama server 가 11434 bind 무한 실패: `Error: listen tcp 127.0.0.1:11434: bind: An attempt was made to access a socket in a way forbidden by its access permissions.`
+- `netsh int ipv4 show excludedportrange protocol=tcp` → 11242–11941 범위 (8개 100-port 블록) reserved
+- 원인: WSL2 (Ubuntu Running) + Hyper-V `hns` (Host Network Service) 가 부팅 시 동적 NAT 용 포트 블록 할당 — 11434 가 포함됨
+
+### 제안 방향
+
+**v0.2.3.1 → v0.2.4 cut**: env var 의존 제거, in-app endpoint/model 설정 UI 추가. 트레이 메뉴 + OllamaBanner "설정" 링크 → modal → JSON 영속화 (`<profileDir>/settings.json`).
+
+추가: 사용자가 빈 포트 (11942 등) 로 Ollama 재시작 후 in-app 에서 endpoint 변경 — 시스템 설정 변경 (excludedportrange 등) 없이 dogfood 즉시 unblock.
+
+### 결정 대기
+
+- (해결됨) endpoint + model 둘 다 in-app 설정 가능해야 하는가 → Q1=B 결정 (v0.2.3.1 spec)
+- (해결됨) JSON 영속화 vs SQLite 새 테이블 → Q3=B JSON (migration 회피)
+- (해결됨) Settings precedence → settings > env > default
+
+### 가설·측정
+
+| # | 가설 | 측정 |
+|---|------|------|
+| H8.1 | dogfood 사용자 의 ≥30% 가 비기본 endpoint 사용 (LAN 또는 다른 포트) | telemetry `ollama_settings_changed` (count-only, v0.2.7) |
+| H8.2 | 11434 reserved 가 다른 머신에도 발생 | LAN 머신 / 동료 dogfood |
+
+### 범위
+
+- **In:** SettingsService + ProviderHolder + OllamaSettingsModal + IPC + 트레이 메뉴 항목
+- **Out:** Multi-provider abstraction (OpenAI 등), Settings dropdown UI (v0.2.4 freetext)
+
+### 영향
+
+- **Spec:** `docs/superpowers/specs/2026-05-04-v0231-ollama-settings-design.md`
+- **Backlog 잔여:** #39 (`ollama_unreachable.reason` 의 endpoint URL PII 우회 노출 — telemetry 하드닝 v0.2.7)
+
+---
+
+## F9. 앱 다중 인스턴스 spawn — SQLite race 위험 (🚀 promoted → v0.2.5 critical hotfix)
+
+**진행 상태:** 🚀 promoted → PR #23 critical hotfix, v0.2.5 release.
+
+**발견:** 2026-05-05 dogfood 도중. v0.2.4 설치 후 단축키 / 트레이 / 시작메뉴 클릭 반복 시.
+
+### 관찰
+
+앱 아이콘 클릭 시마다 새 process spawn. 트레이 아이콘 여러 개 누적. 작업관리자 에서 `Inkling.exe` process 다중 확인. 잠재 영향:
+- SQLite WAL 동시 write → DB 손상 가능
+- AiWorker 중복 polling → 같은 pending_jobs 두 process race
+- HealthChecker 중복 polling → Ollama 부하 + telemetry 이중 emit
+- `settings.json` atomic write 의 temp/rename race
+
+### 제안 방향
+
+**Critical hotfix** — `app.requestSingleInstanceLock()` 호출 + `second-instance` event handler 로 기존 inbox 창 restore + show + focus.
+
+### 결정 대기
+
+(해결됨) — Electron 표준 패턴 직접 적용.
+
+### 범위
+
+- **In:** `src/main/index.ts` 진입점 (whenReady 전 lock 획득). 단일 21줄 변경.
+- **Out:** None — cross-platform 자동 동작.
+
+### 영향
+
+- v0.2.5 critical hotfix release (`Inkling Setup 0.2.5.exe`)
+- **Backlog 잔여:** #46 hidden-start race (NSIS 직후 사용자 클릭 + autostart `--hidden` 동시 시도) — v0.2.6 (PR #24) 에서 `additionalData` 패턴으로 해결 완료.
+
+### 비고
+
+dogfood 발견 → 4시간 안에 hotfix release. 잠재 데이터 손실급 버그라 patch increment (v0.2.5) 사용. v0.2.4 사용자 즉시 업그레이드 권장.
+
+---
+
+## F10. 버전 / 빌드 정보 표시 surface 부재 (🚀 promoted → v0.2.4)
+
+**진행 상태:** 🚀 promoted → PR #22, v0.2.4 release.
+
+**발견:** 2026-05-04 dogfood 도중. 머신 간 버전 일치 검증 시도 시.
+
+### 관찰
+
+설치된 Inkling 의 버전을 UI 어디서도 확인 못함. 트레이 메뉴 / Inbox 푸터 / About 모달 모두 부재. 핸드오프 후 다른 머신 (Mac vs Windows) 에서 같은 버전인지 검증 path 없음. issue report 시 첨부할 디버그 정보 (Electron / Node / OS / profileDir) 도 노출 안 됨.
+
+### 제안 방향
+
+트레이 메뉴 마지막 항목 (종료 직전) "Inkling 정보..." → native `dialog.showMessageBox`. 표시:
+- 버전 (`app.getVersion()`)
+- Electron / Node 버전
+- OS (`platform()` + `release()`)
+- 데이터 위치 (`app.getPath('userData')`)
+
+버튼: 확인 / 데이터 위치 열기 (`shell.openPath`) / 정보 복사 (`clipboard.writeText`).
+
+### 영향
+
+- v0.2.4 cut 동봉. 별도 spec 없음 (단순 추가).
+- **Backlog 잔여:** Inbox footer 형태 검토 (v0.2.7 — 항상 보이는 작은 버전 라벨)
+
+---
+
+## F11. Single-instance lock 부재 (🚀 promoted)
+
+**진행 상태:** 🚀 promoted → F9 와 동일 cut (v0.2.5 hotfix).
+
+F9 와 root cause 동일. 원래 별개 발견이었지만 fix 가 같음 — 본 항목은 F9 의 부분으로 흡수.
+
+---
+
+## F12. 윈도우 자동 실행 옵션이 재시작 후 풀려있는 버그 (🚀 promoted — v0.2.7 deeper fix)
+
+**진행 상태:** 🚀 promoted → docs/superpowers/specs/2026-05-06-v027-cross-platform-design.md §9. v0.2.7 진단 노출 (withArgs/noArgs/registry/execPath + mismatch 경고 + 재등록 버튼) 적용 — 설정 페이지 "자동 실행" 섹션에서 사용자가 진단 정보 직접 확인 + 1-클릭 재등록 가능.
+
+**발견:** 2026-05-05 dogfood 도중. autostart 토글 후 재시작.
+
+### 관찰
+
+트레이 메뉴 "윈도우 시작 시 자동 실행" 체크 → 종료 → 재실행 → 체크박스 풀려있음. `app.setLoginItemSettings({ openAtLogin, args: ['--hidden'] })` 호출 후 다음 부팅 시 `app.getLoginItemSettings()` 가 `openAtLogin=false` 반환.
+
+### 제안 방향 (현 cut: 진단 fallback)
+
+추정 원인:
+- (a) Windows registry path mismatch (NSIS 설치 위치 변경 / 버전 업데이트 시 새 디렉터리)
+- (b) Electron `setLoginItemSettings` Windows 구현 의 path canonicalization
+- (c) `args: ['--hidden']` 와 actual launch args 비교 mismatch — `getLoginItemSettings()` 가 args 없이 호출되면 mismatch
+
+**v0.2.6 적용**:
+- `getLoginItemSettings({ args: ['--hidden'] })` 명시 → 트레이 checkbox checked 상태 가 실제 args 와 정합 비교
+- `autostart.state` 진단 로그 (withArgs vs noArgs 비교 + executableWillLaunchAtLogin) — dogfood 에서 실제 동작 로그 수집
+
+### 결정 대기
+
+dogfood 후 `autostart.state` 로그 분석:
+- args 명시 fix 만으로 충분 → close
+- 여전히 mismatch → registry 직접 inspect (HKCU\Software\Microsoft\Windows\CurrentVersion\Run\inkling) → exe path 확인 → executable path canonicalization 검토
+
+### 영향
+
+- dogfood UX 핵심 마찰 — autostart 가 핸드오프 시 매번 수동 재설정 필요. 자동 실행 의도 자체가 dogfood "잊지 않고 매일 사용" 목적인데 깨짐.
+- v0.2.6 진단 fallback 로 일단 시도, **v0.2.7 deeper fix 영역**.
+
+---
+
+## F13. PR review 발견: restoreNote production path dead code (🚀 promoted → v0.2.6 round 1 Critical fix)
+
+**진행 상태:** 🚀 promoted → PR #24 round 1 Critical fix, v0.2.6 release.
+
+**발견:** 2026-05-05 PR #24 round 1 reviewer (Claude code-reviewer subagent).
+
+### 관찰
+
+v0.2.6 cut 의 B1 (#10 restoreNote) 작업이 새 메서드 `NoteRepository.restoreNote(id)` 추가했지만 — **production path 가 옛 메서드 `repo.restore()` 호출 중**. CaptureService.restoreNote (line 93) 가 `this.repo.restore(noteId)` 호출 → `deleted_at = NULL` 만 set, `ai_status='failed'` 그대로 + `pending_jobs` 미재생성.
+
+즉 새 메서드는 unit test 만 검증, 실제 사용자가 trash → AI fail → restore 흐름 시 영구 fail 상태 그대로.
+
+### Fix
+
+**Round 1 Critical fix (commit `a991008`)**:
+- `CaptureService.restoreNote` 가 `repo.restoreNote` 호출 (production path 활성화)
+- `before` 의 `ai_status` 가 `failed` 또는 `pending` 이면 `worker.enqueue(noteId)` 추가 호출 — in-memory AiWorker queue 갱신 (다음 app start 까지 대기 X)
+
+테스트 +2 (CaptureService 의 enqueue 호출 검증).
+
+### 비고
+
+Round 1 reviewer 의 발견 가치 = **production path 와 unit test 가 갈라진 dead code 패턴**. 비슷한 패턴 다른 곳도 점검 가치. v0.2.7 brainstorm 시 grep 으로 "신 메서드 vs 옛 메서드 둘 다 존재 + 호출자 옛 사용" 패턴 검사.
+
+---
+
+## F14. macOS dock 클릭 시 hidden 창 재현 안 됨 (🚀 promoted → v0.2.7)
+
+**진행 상태:** 🚀 promoted → docs/superpowers/specs/2026-05-06-v027-cross-platform-design.md §8. 2026-05-05 v0.2.6 dogfood 발견.
+
+**발견:** 2026-05-05 김태현 macOS dogfood 도중.
+
+### 관찰
+
+- macOS 에서 inbox 창 닫음 (빨간 신호등) → 창 사라짐.
+- Dock 에는 Inkling 아이콘이 "켜져 있음" 표시 (점) 으로 그대로.
+- Dock 아이콘 클릭 → **창이 안 뜸**. 클릭이 그냥 무시됨.
+- 트레이 메뉴 "보관한 메모 보기" 로는 정상 호출 가능 (별 이슈 없음).
+- 앱을 완전히 종료 후 재실행 해야만 창이 다시 뜸.
+
+### 제안 방향
+
+추정 원인 (코드 확인 결과):
+
+- [src/main/windows/inboxWindow.ts:39-44](src/main/windows/inboxWindow.ts#L39-L44) — close 이벤트에서 `app.isQuitting === false` 면 `e.preventDefault()` + `inboxWindow.hide()`. 즉 창은 살아있고 단지 hidden.
+- [src/main/index.ts:411-413](src/main/index.ts#L411-L413) — `app.on('activate', () => { if (BrowserWindow.getAllWindows().length === 0) createInboxWindow(); })`. 하지만 hidden 창은 destroy 되지 않았으므로 `getAllWindows().length === 1`. 분기 안 타고 no-op.
+
+따라서 fix 방향은 단순:
+
+```ts
+app.on('activate', () => {
+  const win = getInboxWindow();
+  if (win && !win.isDestroyed()) {
+    win.show();
+    win.focus();
+  } else {
+    createInboxWindow();
+  }
+});
+```
+
+(B4 #46 second-instance 핸들러의 windows-restore 로직과 동일 패턴 — 거기서는 macOS dock 이 아닌 Windows multi-launch 경로지만 의도가 같음.)
+
+### 결정 대기
+
+- macOS 에서 트레이 (menubar extra) 도 사용 중인가? Windows 에서 트레이가 핵심 surface 인 반면 macOS 에서는 dock 클릭이 자연스러운 1차 surface.
+- 현재 macOS 빌드는 "기본 동작 유지" 수준 (메모리 우선순위 정책). dogfood 1차 타깃이 Windows 라 macOS 마찰을 어디까지 잡을지 cost-benefit 결정 필요.
+
+### 가설·측정
+
+- Fix 후 macOS dogfood 시 dock click → 창 즉시 등장 (1 클릭, < 100ms 체감).
+- regression 측정: Windows 에서 close→tray 메뉴 경로 영향 없음 (activate 이벤트는 macOS 전용 흐름이라 Windows 무관해야 함).
+
+### 범위
+
+- 1-file edit (`src/main/index.ts` activate 핸들러 5줄).
+- 단위 테스트 추가 어려움 (BrowserWindow + activate 이벤트 mocking 비용 ↑) — manual dogfood 검증 으로 충분.
+- v0.2.7 telemetry export 와 함께 묶어 cut.
+
+### 영향
+
+- macOS dogfood UX 마찰. "앱이 떠 있는데 안 보임 + 클릭 무반응" 은 사용자가 "고장났나?" 의심하게 만드는 첫 신호 — 신뢰 손상 큼.
+- Windows 는 트레이 중심이라 동일 증상 없음. macOS 단독 이슈.
+- v0.2.7 우선순위: F12 autostart 풀림 (Windows) 와 동급의 "잊지 않고 매일 쓰는" 흐름 마찰.
+
+---
+
+## F15. Linux 앱 빌드 (🚀 promoted → v0.2.7 / CLI 부분 거부)
+
+**진행 상태:** 🚀 promoted (Linux 빌드만) → `docs/superpowers/specs/2026-05-06-v027-cross-platform-design.md` §5. CLI 부분은 ❌ rejected (DB/Ollama 동시접근 race + monorepo 부담 대비 본인 dogfood metric 직접 기여 적음).
+
+**발견:** 2026-05-05 dogfood 외부 피드백 + 본인 후속 결정.
+
+### 관찰
+
+- Linux 터미널 사용자가 "Inkling 을 터미널에서 쓰고 싶다" 요청.
+- 본인 macOS 흐름에서도 GUI quick-capture 띄우는 비용 > `ink "한 줄"` 한 방 비용.
+- 현재 빌드 타겟: Windows NSIS x64 + macOS DMG arm64. Linux 타겟 자체 없음 → Linux 사용자에게 입구 자체 부재.
+
+### 결정된 방향 (narrow scope)
+
+**범위 (v0.2.7 narrow):**
+- CLI **capture-only**: `inkling capture "한 줄"` 만 노출. search/recall/restore/edit 등 v0.3+ 로 deferred.
+- 플랫폼: **Linux + macOS** (Windows CLI 제외 — 본인 Windows 는 GUI 흐름).
+- Linux 앱 빌드 추가: **AppImage + deb** 1차. rpm 은 외부 demand 후.
+
+**아키텍처 — race-free 설계:**
+- CLI = SQLite WAL writer 로 `notes` INSERT (raw_text) + `pending_jobs` INSERT (note_id) 만 수행.
+- AI 워커는 **Electron 메인 단일 보유**. CLI 는 워커 안 띄움.
+- Electron 떠있으면 → 워커가 즉시 pending_jobs poll → AI 처리.
+- Electron 안 떠있으면 → 다음 launch 시 처리 (기존 pending_jobs 큐 모델 그대로).
+- 동일 DB 파일 동시 접근은 SQLite WAL 로 안전 (1 writer + N readers). Single-instance lock 은 **Electron 인스턴스 끼리만** 적용 — CLI 는 짧은 transaction 만 수행 후 종료, lock 우회 무관.
+
+**플랫폼별 build 비용:**
+
+| 타겟 | 빌드 비용 | 커버 |
+|---|---|---|
+| AppImage | 매우 낮음 (Mac/Linux cross-build 가능) | 모든 desktop linux 배포판 (1-file portable) |
+| deb | 낮음 (Mac brew `dpkg` `fakeroot`) | Debian/Ubuntu/Mint |
+| rpm | 중간 (Linux 호스트 또는 Docker) — **defer** | Fedora/RHEL/openSUSE |
+
+**CLI 패키징:**
+- pkg / nexe 로 Node CLI → 단일 바이너리. Linux + macOS 각각 빌드.
+- 또는 Electron 앱 안에 `inkling` 심볼릭 링크 노출 (Mac: `/Applications/Inkling.app/Contents/MacOS/inkling`, Linux: AppImage 내 path 노출 / deb postinst hook).
+- 결정 대기 — v0.2.7 brainstorm 때 spike.
+
+### 결정 대기 (v0.2.7 brainstorm)
+
+- CLI 패키징: 별도 단일 바이너리 vs Electron 앱 번들 내 노출 — install UX 영향 큼.
+- AI 처리 시점 표기: capture 시 즉시 stdout 으로 "queued" 만 회신할지, `--wait` 플래그로 처리 완료 대기할지.
+- AppImage + deb 동시 vs 단계적.
+
+### 가설·측정
+
+- 본인 macOS 흐름에서 quick-capture window 호출 vs `ink "..."` time-to-capture 비교. 후자가 의미 있게 빠르면 본인 Aha metric (7일/3일) 에도 기여 가능.
+- 외부 Linux 사용자 1주 soak 후 capture 발생 빈도 (telemetry) — 채널 살아있는지 확인.
+
+### 범위
+
+- Linux 앱 빌드 + AppImage + deb: 1~2일.
+- CLI capture-only (Mac/Linux 양쪽): 2~3일.
+- better-sqlite3 prebuild 매트릭스 확장 (linux-x64): 부수 작업, 0.5일.
+- 합 약 4~5일 spike — v0.2.7 cut 1개로 가능.
+
+### 영향
+
+- 본인 macOS dogfood capture 가속 (직접 효용).
+- Linux 사용자 입구 제공 (외부 확장 첫걸음).
+- v0.4 slice 자기 종료 조건 (본인 2주 완주) 와 병행 가능 — capture 만 노출하므로 v0.4 핵심 흐름 (recall, AI tag, due) 변경 없음.
+- Risk: Linux native ABI 첫 진입 — better-sqlite3 prebuild 가 linux-x64 에서 깔끔히 떨어질지 dogfood 검증 필요.
+
+---
+
+## F16. 트레이 의존도 ↓ + 별도 설정 페이지 (🚀 promoted → v0.2.7)
+
+**진행 상태:** 🚀 promoted → docs/superpowers/specs/2026-05-06-v027-cross-platform-design.md §6, §7. 트레이 = quick-capture / 보관함 / 설정 / 종료 4-항목 minimum 으로 강등 + inbox window 안 SettingsPage (AI provider · 자동 실행 · 백업/복원 · 내보내기/가져오기 · 텔레메트리 · 정보 6 섹션) 신설.
+
+**발견:** 2026-05-05 dogfood 후속 결정.
+
+### 관찰
+
+- 현재 [src/main/tray.ts](src/main/tray.ts) 가 **13개 항목** 보유: 보관함 열기, 한 줄 적기, 백업, 내보내기, 복원, 동기화, telemetry export, Ollama 재확인, AI 재처리, **Ollama 설정...**, **자동 실행 토글**, 정보, 종료.
+- Windows: SysTray 잘 보임 → 핵심 surface 로 기능했음.
+- **macOS**: menubar extra 로 뜨지만 사용자가 메뉴바 가득찼을 때 가려짐. dock 사용자 흐름과 분리되어 발견성 ↓.
+- **Linux**: 모던 GNOME 등 일부 DE 는 system tray 자체 없음 (extension 필요). KDE/Cinnamon 은 보임.
+- 결과: macOS / Linux 사용자가 **Ollama 설정 / 자동 실행 토글 등 핵심 설정에 접근 불가**.
+
+### 결정된 방향 (정책 변화)
+
+**1. 트레이 = 최소 surface 로 강등.**
+- 잔류: 한 줄 적기 (quick capture), 보관함 열기, 종료.
+- 이동: Ollama 설정, 자동 실행, 백업/복원/내보내기, telemetry export, AI 재처리, Ollama 재확인, 정보 → **설정 페이지** 또는 inbox window 안 메뉴.
+
+**2. 별도 설정 페이지 신설 (inbox window 안 또는 별도 윈도우).**
+- 예상 섹션: AI provider (Ollama endpoint/model — 기존 OllamaSettingsModal 흡수), 자동 실행, 백업/복원, 내보내기/가져오기, 텔레메트리, 정보.
+- 현재 OllamaSettingsModal 은 inbox 안 modal — 그대로 활용하거나 페이지화 검토.
+
+**3. 1차 액션 진입점 재설계.**
+- macOS: dock 클릭 (F14 fix 와 동시) → inbox 창 → 메뉴 또는 톱니바퀴 → 설정.
+- Linux: 앱 launcher 또는 CLI (`inkling settings` 후보) → inbox 창 → 설정.
+- Windows: 트레이 우클릭 "한 줄 적기" + "보관함 열기" 만 잔류 + 트레이에서 "설정..." 한 항목 추가 (inbox 안 설정 페이지로 라우팅).
+
+### 결정 대기 (v0.2.7 brainstorm)
+
+- 설정 surface 형태:
+  - (a) inbox 안 별도 라우트 (e.g., `/settings`) — SPA 내부 페이지
+  - (b) 별도 BrowserWindow — 독립 윈도우
+  - (c) 메뉴바 (Application Menu) 사용 — macOS 표준이지만 Win/Linux 와 일관성 깨짐
+  - 추천 잠정: (a) — 최소 비용, 기존 inbox UI 연속성, OllamaSettingsModal 흡수 자연스러움.
+- 트레이 잔류 항목: "설정..." 1줄 잔류 vs 완전 제거 (Windows 사용자 경험 시 trade-off).
+- 자동 실행 토글의 실제 동작 — F12 deeper fix 가 설정 페이지 안에서 더 명확한 진단 노출 가능 (registry path 확인, args 미스매치 표시 등).
+
+### 가설·측정
+
+- 새 사용자 (macOS) 가 Ollama endpoint 변경 작업 완료까지 클릭 수: 현재 (트레이 메뉴에 가려짐) vs 설정 페이지 (inbox → 설정) — 후자가 의미 있게 짧으면 채택.
+- 트레이 메뉴 항목별 사용 빈도 telemetry — v0.2.7 export 후 실제 어떤 항목이 자주 클릭되는지 보고 잔류 우선순위 결정.
+
+### 범위
+
+- 1~2일: OllamaSettingsModal 을 설정 페이지 섹션으로 흡수.
+- 1~2일: 자동 실행 / 백업 / 복원 / 내보내기 등 트레이 click 핸들러를 설정 페이지 버튼으로 이동 (메인 IPC 는 그대로).
+- 0.5일: 트레이 메뉴 슬림화 (3~4 항목으로).
+- 합 3~5일. CLI (F15) 와 묶으면 v0.2.7 한 cut 가능.
+
+### 영향
+
+- **macOS / Linux 입구 정상화** — F14 (dock 클릭) + F15 (CLI 입구) 와 정합. 외부 Linux 사용자 + 본인 macOS 모두 설정 접근 가능.
+- **F12 autostart 영향**: 자동 실행 토글이 설정 페이지로 이동하면 진단 정보 (registry path, args 비교 결과) 노출 가능 → deeper fix 자연스럽게 결합.
+- **트레이 코드 단순화**: 13 항목 → 3~4 항목. v0.2.6 의 TrayCallbacks 객체화 (C2) 효과 가시화.
+- Risk: Windows 사용자 흐름 변경 — 트레이 한 클릭으로 끝나던 동작이 inbox 열기 → 설정 → 항목 클릭 으로 늘어남. 단, 빈도 낮은 동작 (Ollama 설정 변경, 백업 등) 만 이동하고 자주 쓰는 캡처/보관함 은 트레이 잔류 → 체감 마찰 ↓ 예상.
+
+---
+
+## F22. NoteCard 이미지가 회색 placeholder 만 표시 (🚀 promoted → docs/superpowers/specs/2026-05-09-v028-cut-a-design.md)
+
+**진행 상태:** 🚀 promoted → v0.2.8 Cut A. inkling-media:// custom protocol + NoteCard `<img>` + IPC inbox:open-media + OS viewer 클릭. (commit 470384b + f6bea62 + 9cdea15)
+
+**발견:** 2026-05-09 v0.2.7 release 후 본인 dogfood. 사용자 표현: "이미지 렌더링이 제대로 되지 않는 것 같아".
+
+### 관찰
+
+[src/renderer/inbox/components/NoteCard.tsx:334-340](src/renderer/inbox/components/NoteCard.tsx#L334-L340):
+
+```tsx
+{local.media.length > 0 && (
+  <div style={{ marginTop: 10, display: 'flex', gap: 6 }}>
+    {local.media.map((m) => (
+      <div key={m.id} style={{ width: 48, height: 48, background: '#eee', borderRadius: 4 }} title={m.relPath} />
+    ))}
+  </div>
+)}
+```
+
+**`<img>` 가 아니라 회색 `<div>`**. 즉 capture 시 첨부한 이미지가 보관함에서 회색 48x48 사각형만 표시 — title attribute (relPath) 만 hover tooltip 으로 보임. 실제 이미지 렌더링 자체 부재.
+
+`MediaStore` 는 `<profileDir>/media/<noteId>/<filename>` 절대 경로로 파일 보존. relPath = `media/<noteId>/<filename>` 형태. Electron renderer 에서 직접 `file://` 또는 custom protocol 로 src 매핑 필요.
+
+### 추정 원인 (placeholder 인 이유)
+
+- 초기 v0.4 slice 단계에 thumbnail 렌더는 후순위로 미루고 placeholder 로 둔 채 그대로 잔류.
+- Electron renderer 가 raw `file://` 경로 보안 정책상 직접 접근 어려움 — custom protocol (`inkling-media://`) 또는 IPC handle 로 base64 변환 필요.
+
+### 제안 방향
+
+**A. Custom protocol 등록** (권장):
+- main process 에서 `protocol.registerFileProtocol('inkling-media', ...)` 등록 — `<profileDir>/media/` 하위 경로를 `inkling-media://<noteId>/<filename>` 으로 매핑
+- NoteCard: `<img src={`inkling-media://${m.relPath.slice(6)}`} alt="" />`
+- 보안: scheme 별 allowlist + protocol handler 가 path traversal 검사
+
+**B. IPC 로 base64 변환** (작은 이미지에 한정):
+- `inboxApi.getMediaDataUrl(relPath)` → main 이 file 읽고 `data:image/png;base64,...` 반환
+- renderer 에 `<img src={dataUrl} />`
+- 큰 이미지 (수 MB) 시 메모리 부담
+
+**C. file:// 직접** (Electron 특수 설정 필요):
+- `webPreferences.webSecurity: false` — 보안 약화 risk. **Reject**.
+
+### 결정 대기
+
+- thumbnail 표시 vs 클릭 시 full-size modal — UX 선택
+- 다중 이미지 (현재 capture 가 N개 첨부 가능) 의 grid layout
+- 이미지 alt text — capture 시 입력 또는 AI 자동 생성 (옵션)
+
+### 가설·측정
+
+- 본인 dogfood: capture 시 이미지 첨부 빈도 — 현재 추정치 < 일 1건. ≥ 일 1건이면 이미지 흐름 가치 큼.
+- 옵션 A 도입 후 NoteCard 클릭 시 modal full-size 사용 빈도 — UX 선택 검증.
+
+### 범위
+
+- A (custom protocol + thumbnail): 1-2일.
+- A + click → full-size modal: + 0.5일.
+- alt text AI 생성: 별도 cut.
+
+### 영향
+
+- 명확한 bug 수정 — 사용자 마찰 명백.
+- F19 (recall) 의 시각적 단서 — 이미지 보일 때 메모 회상 ↑.
+- v0.2.8 narrow scope 에 포함 가치 (1-2일 작업).
+
+---
+
 ## (다음 항목 자리)
 
-새 피드백 추가 시 `## F8. 짧은 제목 (🌱 raw)` 헤더로 시작. 표준 슬롯 6개 채우거나 비워둔 채 시작 가능.
+새 피드백 추가 시 `## F23. 짧은 제목 (🌱 raw)` 헤더로 시작. 표준 슬롯 6개 채우거나 비워둔 채 시작 가능.
+
+v0.2.8 release 후 dogfood ≥1주 soak 동안 새 발견 항목들 여기 누적 → v0.2.9 brainstorm 트리거.

docs/superpowers/specs/2026-05-04-v0231-ollama-settings-design.md

@@ -0,0 +1,334 @@
+# v0.2.3.1 Ollama 설정 In-App UI — Design Spec
+
+> 작성: 2026-05-04 · v0.2.3 dogfood unblock 용 patch cut. 환경변수 의존 제거, 사용자 친화 endpoint/model 변경 path.
+
+## 1. Goal
+
+Inkling 사용자가 트레이 메뉴 / OllamaBanner 에서 Ollama endpoint + model 을 직접 변경 가능하도록. 현재는 `INKLING_OLLAMA_ENDPOINT` env var 만 지원 — Windows 의 dynamic port 점유 (Hyper-V/WSL2 NAT) 같은 환경 이슈에 즉시 대응 못함. patch cut 으로 dogfood unblock 후 1주 soak 진입.
+
+## 2. Decisions (mini-brainstorm 합의)
+
+| # | 질문 | 선택 | 이유 |
+|---|---|---|---|
+| Q1 | Model 설정 포함 여부 | **B** Endpoint + Model 둘 다 | endpoint 만으로는 커버 불충분 (LAN 서버 fallback 시 model 도 다를 수 있음) |
+| Q2 | Model input 형태 | **A** Freetext | "급한" patch cut, healthCheck 가 검증, dropdown 은 v0.2.4 영역 |
+| Q3 | Settings 영속화 | **B** JSON file (`<profileDir>/settings.json`) | migration v4 회피, 항목 2개 라 transaction 불필요, user 직접 편집 가능 |
+
+자명 결정 (질문 없이 패턴 따름):
+- env var precedence: **settings > env > default**
+- in-flight job 처리: **AbortController abort + provider re-create**
+- UI placement: **트레이 메뉴 "Ollama 설정..." + OllamaBanner 의 "설정" 링크**
+- validation: **save 전 healthCheck**
+
+## 3. Architecture & data flow
+
+```
+사용자 액션:
+  1. 트레이 → "Ollama 설정..." 클릭 (또는 OllamaBanner 의 "설정" 링크)
+  2. Settings modal 열림 — endpoint + model 입력란 + "저장" 버튼
+  3. 사용자 endpoint/model 입력 → "저장" 클릭
+
+저장 흐름:
+  ├─ Renderer: inboxApi.saveOllamaSettings({ endpoint, model })
+  ├─ Main IPC: 임시 LocalOllamaProvider 생성 → healthCheck()
+  │   ├─ ok=true → JSON 영속화 + provider/health 교체
+  │   └─ ok=false → 저장 거부 + reason 반환 (modal 안에 inline 에러)
+  ├─ 기존 in-flight AI job 처리:
+  │   └─ AbortController abort → 현재 generate 중단 → unreachable 분류 →
+  │      AiWorker 의 무한 retry 가 새 endpoint 로 재시도 (자동 회복)
+  └─ HealthChecker.recheck() → OllamaBanner 즉시 갱신
+
+부팅 흐름 (precedence: settings > env > default):
+  index.ts:
+    const settings = await settingsSvc.load()   // JSON 또는 빈 객체
+    const endpoint = settings.ollama?.endpoint
+                   ?? process.env.INKLING_OLLAMA_ENDPOINT
+                   ?? 'http://localhost:11434'
+    const model = settings.ollama?.model ?? 'gemma4:e4b'
+```
+
+### 3.1 핵심 invariants
+
+1. **저장 = 검증 통과 전제** — healthCheck ok=false 면 JSON 안 씀. 사용자 잘못된 값 영속화 방지
+2. **Provider mutability via re-create** — `setEndpoint()` 메서드 추가 X. `ProviderHolder` 가 새 인스턴스 보유, listeners 알림. `AbortController` 가 in-flight 중단
+3. **Settings precedence**: settings.json > env var > hardcoded default. UI 가 source of truth
+4. **단일 settings file** — `<profileDir>/settings.json`. atomic write (`writeFile` temp → `rename`). 손상 시 빈 객체 fallback (no app crash)
+5. **HealthChecker rebind** — `ProviderHolder.onReplace` 통해 새 provider 받아 polling endpoint 즉시 갱신
+6. **Backward compat** — settings.json 없는 첫 부팅: env var → default 순. 기존 사용자 영향 0
+7. **Cross-platform 자동** — `app.getPath('userData')` + `node:path.join` + `node:fs/promises` 가 OS 별 경로/separator/UTF-8 자동. 별도 분기 0
+
+## 4. Components
+
+### 4.1 `SettingsService` (신규)
+
+**파일**: `src/main/services/SettingsService.ts`
+
+```typescript
+import { readFile, writeFile, mkdir, rename } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { z } from 'zod';
+
+const OllamaSettingsSchema = z.object({
+  endpoint: z.string().url(),
+  model: z.string().min(1)
+}).strict();
+
+const SettingsSchema = z.object({
+  ollama: OllamaSettingsSchema.optional()
+}).strict();
+
+export type Settings = z.infer<typeof SettingsSchema>;
+export type OllamaSettings = z.infer<typeof OllamaSettingsSchema>;
+
+export class SettingsService {
+  private filePath: string;
+  private cache: Settings | null = null;
+
+  constructor(profileDir: string) {
+    this.filePath = join(profileDir, 'settings.json');
+  }
+
+  async load(): Promise<Settings> {
+    if (this.cache !== null) return this.cache;
+    try {
+      const raw = await readFile(this.filePath, 'utf8');
+      const parsed = JSON.parse(raw);
+      this.cache = SettingsSchema.parse(parsed);
+    } catch {
+      this.cache = {}; // 파일 없음 또는 손상 → 빈 객체 fallback
+    }
+    return this.cache;
+  }
+
+  async setOllama(value: OllamaSettings): Promise<void> {
+    const validated = OllamaSettingsSchema.parse(value);
+    const current = await this.load();
+    const next: Settings = { ...current, ollama: validated };
+    await mkdir(dirname(this.filePath), { recursive: true });
+    const tmpPath = this.filePath + '.tmp';
+    await writeFile(tmpPath, JSON.stringify(next, null, 2), 'utf8');
+    await rename(tmpPath, this.filePath);
+    this.cache = next;
+  }
+}
+```
+
+### 4.2 `ProviderHolder` (신규)
+
+**파일**: `src/main/ai/ProviderHolder.ts`
+
+```typescript
+import type { LocalOllamaProvider } from './LocalOllamaProvider.js';
+
+export class ProviderHolder {
+  private current: LocalOllamaProvider;
+  private listeners: Array<(p: LocalOllamaProvider) => void> = [];
+
+  constructor(initial: LocalOllamaProvider) {
+    this.current = initial;
+  }
+
+  get(): LocalOllamaProvider {
+    return this.current;
+  }
+
+  replace(next: LocalOllamaProvider): void {
+    this.current = next;
+    for (const fn of this.listeners) fn(next);
+  }
+
+  onReplace(fn: (p: LocalOllamaProvider) => void): void {
+    this.listeners.push(fn);
+  }
+}
+```
+
+### 4.3 `LocalOllamaProvider` AbortController + 사용처 변경
+
+**파일**: `src/main/ai/LocalOllamaProvider.ts` (수정)
+
+```typescript
+export class LocalOllamaProvider implements InferenceProvider {
+  private abortController: AbortController | null = null;
+
+  async generate(input: GenerateInput): Promise<AiResponse> {
+    this.abortController = new AbortController();
+    const timer = setTimeout(() => this.abortController?.abort(), this.timeoutMs);
+    try {
+      const res = await request(`${this.endpoint}/api/generate`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+          model: this.model,
+          prompt: buildPrompt(input.text, input.todayKst, input.dueDateCandidates, input.vocab ?? []),
+          format: 'json',
+          stream: false,
+          options: { temperature: this.temperature, num_predict: this.numPredict }
+        }),
+        signal: this.abortController.signal
+      });
+      // ... 기존 응답 처리 ...
+    } finally {
+      clearTimeout(timer);
+      this.abortController = null;
+    }
+  }
+
+  abort(): void {
+    this.abortController?.abort();
+  }
+}
+```
+
+기존 `signal: controller.signal` 부분에서 `controller` 가 method-local 이었음 → `this.abortController` 로 이동 (외부 abort 가능).
+
+### 4.4 `AiWorker` + `HealthChecker` 가 `ProviderHolder` 사용
+
+`AiWorker` constructor: `provider: InferenceProvider` → `private holder: ProviderHolder`
+- `processJob` 내 `this.provider.generate(...)` → `this.holder.get().generate(...)`
+- `provider: this.provider.name` → `provider: this.holder.get().name`
+
+`HealthChecker` 도 동일 패턴 + `onReplace` listener 등록 → 새 provider 즉시 polling.
+
+### 4.5 IPC + Preload + InboxApi types
+
+```typescript
+// src/main/ipc/inboxApi.ts
+ipcMain.handle('inbox:loadOllamaSettings', async () => {
+  const s = await deps.settings.load();
+  return s.ollama ?? null;
+});
+
+ipcMain.handle('inbox:saveOllamaSettings', async (_e, value: { endpoint: string; model: string }) => {
+  // 검증: 새 인스턴스로 healthCheck
+  const trial = new LocalOllamaProvider({ endpoint: value.endpoint, model: value.model });
+  const r = await trial.healthCheck();
+  if (!r.ok) return { ok: false, reason: r.reason };
+  await deps.settings.setOllama(value);
+  // in-flight 중단 후 holder 교체
+  deps.providerHolder.get().abort();
+  deps.providerHolder.replace(trial);
+  await deps.health.recheck();
+  return { ok: true };
+});
+```
+
+```typescript
+// src/preload/index.ts
+loadOllamaSettings: () => ipcRenderer.invoke('inbox:loadOllamaSettings'),
+saveOllamaSettings: (v: { endpoint: string; model: string }) => ipcRenderer.invoke('inbox:saveOllamaSettings', v),
+```
+
+```typescript
+// src/shared/types.ts InboxApi
+loadOllamaSettings(): Promise<{ endpoint: string; model: string } | null>;
+saveOllamaSettings(v: { endpoint: string; model: string }): Promise<{ ok: true } | { ok: false; reason: string }>;
+```
+
+### 4.6 `OllamaSettingsModal` 컴포넌트
+
+**파일**: `src/renderer/inbox/components/OllamaSettingsModal.tsx`
+
+- Props: `open: boolean`, `onClose: () => void`
+- 입력란 2개 (endpoint, model) + "저장" / "취소"
+- 마운트 시 `inboxApi.loadOllamaSettings()` → 초기값 prefill
+- 저장 시 `saveOllamaSettings(...)` → 성공 닫기 + 토스트, 실패 inline 에러
+- React `<dialog>` 또는 portal — 별도 BrowserWindow X (단순함)
+
+### 4.7 OllamaBanner "설정" 링크
+
+기존 `OllamaBanner.tsx` 에 endpoint 변경 링크 추가:
+```typescript
+<button onClick={() => setSettingsOpen(true)}>설정</button>
+```
+modal state 는 App.tsx 가 보유 + OllamaBanner 와 OllamaSettingsModal 둘 다에 넘김.
+
+### 4.8 트레이 메뉴 + IPC 채널
+
+`tray.ts` 의 `createTray` 가 10번째 positional callback 받음 → backlog #4/#26 (TrayCallbacks object refactor) 와 합산 가능. 본 cut 에선 일관성 우선 positional 추가:
+
+```typescript
+{ label: 'Ollama 설정...', click: () => runOpenOllamaSettings() }
+```
+
+`index.ts` 가 `runOpenOllamaSettings = () => mainWindow.webContents.send('inbox:openOllamaSettings')` 푸시. Renderer App.tsx 가 이 channel 구독해 modal 열기.
+
+### 4.9 `index.ts` 부팅 흐름 변경
+
+```typescript
+const settingsSvc = new SettingsService(paths.profileDir);
+const settings = await settingsSvc.load();
+
+const resolvedEndpoint = settings.ollama?.endpoint
+                       ?? process.env.INKLING_OLLAMA_ENDPOINT
+                       ?? 'http://localhost:11434';
+const resolvedModel = settings.ollama?.model ?? 'gemma4:e4b';
+
+logger.info('ai.endpoint', {
+  endpoint: resolvedEndpoint,
+  source: settings.ollama?.endpoint
+    ? 'settings'
+    : (process.env.INKLING_OLLAMA_ENDPOINT ? 'env' : 'default')
+});
+
+const provider = new LocalOllamaProvider({ endpoint: resolvedEndpoint, model: resolvedModel });
+const holder = new ProviderHolder(provider);
+
+const health = new HealthChecker(holder, { ... });
+const aiWorker = new AiWorker(repo, holder, { ... });
+```
+
+## 5. Privacy invariant
+
+- `settings.json` 은 local only, telemetry emit X
+- 잠재적 `ollama_settings_changed` event 추가 시 endpoint URL 노출 → privacy 위반 → **emit 안 함** (본 cut)
+- 향후 v0.2.4 dogfood telemetry 에서 변경 빈도 측정 필요 시 `{ count: number }` payload (URL 자체 X) 형태로 추가
+
+## 6. Tests (≥10개)
+
+### SettingsService.test.ts (신규, 6)
+1. `load()` 파일 없음 → 빈 객체
+2. `load()` 손상 JSON (parse 실패) → 빈 객체 fallback (no throw)
+3. `load()` 캐시 동작 — 두 번째 호출 시 file read 안 함
+4. `setOllama()` zod 검증 실패 (non-URL endpoint) → throw
+5. `setOllama()` 정상 저장 → 디스크 file 존재 + 내용 일치
+6. `setOllama()` atomic write — temp file 남지 않음 (rename 후 cleanup)
+
+### ProviderHolder.test.ts (신규, 2)
+7. `replace()` 시 listener 발화 + `get()` 가 새 인스턴스 반환
+8. listener 여러 개 등록 시 모두 발화
+
+### LocalOllamaProvider.test.ts (확장, 2)
+9. `abort()` 호출 시 in-flight `generate()` rejects (AbortError)
+10. constructor `model` 파라미터 적용 (default `gemma4:e4b` 외 임의 model)
+
+총 신규 단위 **10개**. 기존 403 + 10 = **413**.
+
+(Renderer modal 컴포넌트 단위 테스트 X — Inkling 패턴 따라 store-only. IPC handler 자체도 service-level test 가 logic 보유.)
+
+## 7. Out of scope
+
+- Multi-provider abstraction (OpenAI, Anthropic, etc) — strategy.md local-first 정책 충돌, v0.2.4+
+- Settings UI 안에서 다른 기능 (telemetry retention, vocab top-N 등) — 별 cut
+- Cross-machine settings sync — 단일 머신 dogfood 패턴
+- Model dropdown / 자동 list refresh — Q2=A 결정 (freetext)
+- `ollama pull` 자동 안내 — over-scope
+- Settings export/import / version migration — over-scope
+- Settings 변경 history / undo — over-scope
+- Settings UI 안에 model healthCheck 결과 시각화 (loading spinner 등) — minimal toast 만
+- `ollama_settings_changed` telemetry — privacy invariant 보호 (v0.2.4 검토 시 count-only)
+- Settings 변경 로그 파일 — env-debug 영역, v0.2.4 검토
+
+## 8. Gates (roadmap §3.1)
+
+- typecheck 0
+- 단위 403 → 413 (+10)
+- e2e 1/1 (smoke 회귀 X)
+- backward compat: settings.json 없는 부팅 → env var → default 폴백 정상
+- cross-platform: SettingsService.test 가 `app.getPath` mock 으로 Win/macOS/Linux 시뮬레이션 (별도 case 또는 path matrix)
+
+## 9. Roadmap relation
+
+- v0.2.3 dogfood unblock 패치. 정식 v0.2.3 cut (#1~#7) 와 별개 patch
+- 머지 후 v0.2.3.1 binary 재빌드 + Gitea release (existing `v0.2.3` tag → `v0.2.3.1` 신규 tag, release 별도)
+- ≥1주 dogfood soak 후 telemetry export + 신규 피드백 + v0.2.4 backlog 38건 일괄 triage → v0.2.4 brainstorm

docs/superpowers/specs/2026-05-05-v024-patch-cleanup-design.md

@@ -0,0 +1,54 @@
+# v0.2.4 Patch Cleanup — Design Spec (Brief)
+
+> 작성: 2026-05-05 · 0.2.3.1 semver 위반 (`X.Y.Z.W` 4-part) → 0.2.4 minor bump 이용해 backlog 의 simple cleanup 5건 + 사용자 가치 1건 합쳐서 묶음 cut. v0.2.4 정식 brainstorm 은 v0.2.5 로 이동.
+
+## 1. Goal
+
+PR #21 머지 후 0.2.3.1 binary 빌드 시도가 electron-builder 의 semver validation 으로 실패. 0.2.4 minor bump 으로 우회. 이번 cut 에는 dogfood unblock 외 backlog 의 risk 낮은 cleanup + 사용자 가치 항목 동봉.
+
+## 2. Scope (5 backlog 항목 + version bump)
+
+| backlog # | 항목 | 가치 | 작업량 |
+|---|---|---|---|
+| #1 | `TelemetryService.emit` 의 `now()` 2번 호출 → 1번 추출 | cosmetic (KST midnight straddle 이론) | 1줄 |
+| #2 | `DAY_MS = 24*60*60*1000` magic number → 모듈 상단 상수 | cosmetic | 1줄 |
+| #6 | `media.gc.run()` `.catch` 누락 → backup pattern 통일 | consistency | 1줄 |
+| #13 | NoteCard `mode='trash'` 의 `onDeleted` dead-code prop 제거 | API 청소 | 작음 |
+| #44 | 트레이 메뉴 + Inbox footer 에 "Inkling 0.2.4" 버전 정보 | **사용자 dogfood 가치** | 1 task |
+| - | version bump 0.2.3.1 → 0.2.4 | semver 표준 | trivial |
+
+## 3. Out of scope
+
+- **#45 (자동실행 버그)**: Windows registry 디버깅 필요, simple X. 별도 cut.
+- **#3/#4/#26 (KST 통합 / TrayCallbacks refactor)**: multi-file, 크다. 별도.
+- **#5/#22 (Union 통합 / hydrate cleanup)**: repo-wide.
+- **#39~#43 (PR #21 deferred)**: telemetry masking 등 의미 있는 결정 필요. v0.2.5 brainstorm 영역.
+- 기타 backlog 39건.
+
+## 4. Architecture changes
+
+본 cut 은 의미 있는 architecture 변경 없음. 기존 pattern 강화만:
+- `TelemetryService.emit` 의 atomic timestamp 보장 (now() 1회)
+- 모듈 상단 magic number 상수화 패턴 (다른 파일은 이미 그 패턴, TelemetryService 만 예외)
+- `.catch` consistency (backup.runDaily / telemetry.cleanupOldFiles 와 동일 wrapper)
+- React props 청소 (현재 호출되지 않는 prop 제거)
+- 신규 surface: 트레이 메뉴 "Inkling 정보..." → modal 또는 dialog
+
+## 5. Tests
+
+테스트 추가 없음 (모두 cosmetic / refactor). 기존 단위 413/413 회귀 X 확인만.
+
+#44 의 modal 은 컴포넌트 단위 테스트 X (Inkling 패턴 — store-only).
+
+## 6. Gates
+
+- typecheck 0
+- 단위 413/413 (회귀 X)
+- e2e 1/1
+- backward compat: 기존 사용자 영향 0 (cosmetic + 새 surface)
+
+## 7. Roadmap relation
+
+- 0.2.3 cut 7/7 (PR #13~#19) + 0.2.3.1 patch (PR #21) 누적 후 binary 빌드를 위한 v0.2.4 minor bump
+- v0.2.5 brainstorm 트리거: dogfood ≥1주 soak + telemetry export + backlog 39건 (=45-5-1) + 신규 피드백 일괄 triage
+- backlog 명명 `v024-backlog.md` → 본 cut 후 `v025-backlog.md` 로 rename 검토 (또는 v024-backlog.md 유지하고 내용만 갱신)

docs/superpowers/specs/2026-05-05-v026-bugs-cleanup-design.md

@@ -0,0 +1,133 @@
+# v0.2.6 Bugs + Cleanup — Design Spec
+
+> 작성: 2026-05-05 · 정식 v0.2.6 cut. backlog 16건 (bug 4 + cleanup 12, 13 task 로 cluster) 통합 처리. dogfood telemetry 미수집 영역 (#7/#16/#18/#25/#33/#35/#36/#39/#40 등 14건) 은 v0.2.7 brainstorm 영역으로 별도.
+
+## 1. Goal
+
+dogfood UX 마찰 (autostart 풀림, trashCount 부정확, restore 시 AI 미재처리) 즉시 해소 + 코드베이스 cleanup (KST helper 통합, TrayCallbacks 객체화, AiFailedReason union 통합 등) 으로 v0.2.7 brainstorm 시 신규 feature 작업 friction 제거.
+
+## 2. Scope (16 backlog 항목 → 13 task)
+
+### Bug fixes (B1~B4)
+
+| Task | 항목 | 작업 요약 |
+|---|---|---|
+| **B1** | #10 | `NoteRepository.restoreNote(id)` 가 `ai_status='failed'` 인 노트 복구 시 `ai_status='pending'` reset + `pending_jobs INSERT` |
+| **B2** | #12 | `NoteRepository.countTrashed()` 추가 + IPC `inbox:trashCount` 가 SQL 정확 N 반환 (UI 200 cap 제거) |
+| **B3** | #45 | autostart 풀림: `app.getLoginItemSettings({ args: ['--hidden'] })` (args 비교 정확도) + path canonicalization 검토. fallback: 진단 로그만 추가 시 backlog 유지 |
+| **B4** | #46 | `app.requestSingleInstanceLock(additionalData)` + `second-instance(event, argv, cwd, additionalData)` 에서 hidden flag 체크 → 두 번째 hidden 이면 inbox 창 안 띄움 |
+
+### Cleanup refactor (C1~C9)
+
+| Task | 항목 (cluster) | 작업 요약 |
+|---|---|---|
+| **C1** | #3 + #19 + #34 | KST helper 통합 → `src/shared/util/kstDate.ts`. 4 callsite migrate (`TelemetryService.todayKstIso`, `telemetryStats.kstDate`, `AiWorker.todayKstAsDate/Iso`, store `snoozeExpired/snoozeRecall`) |
+| **C2** | #4 + #23 + #26 | `interface TrayCallbacks` + `createTray(callbacks: TrayCallbacks)` 1-arg refactor. positional 10개 → object |
+| **C3** | #27 | `refreshTrayFailedCount` module-scoped state 제거 → TrayCallbacks 객체 안 reactive 함수 또는 store-driven 패턴 |
+| **C4** | #5 | `export type AiFailedReason = 'unreachable' \| 'schema' \| 'timeout' \| 'other'` 단일 export + zod `z.enum` 의 `z.infer` 로 type 파생. 3 callsite migrate |
+| **C5** | #21 | `hasNoteId(ev: TelemetryEvent): ev is TelemetryEventWithNoteId` type predicate helper → `tests/unit/TelemetryService.test.ts` 의 4-line narrowing 체인 단축 |
+| **C6** | #22 | NoteRepository hydrate 의 `as any[]` → `Record<string, unknown>[]` (또는 explicit row interface) 일괄 cleanup |
+| **C7** | #24 + #41 | `<Banner severity="warning"\|"error"\|"info">` shared component → ExpiryBanner / OllamaBanner / FailedBanner / RecallBanner / OllamaSettingsModal 5 callsite migrate |
+| **C8** | #8 | `telemetryStats.aggregateStats` if/else if 끝에 `else { const _: never = ev; }` exhaustiveness check |
+| **C9** | #15 + #29 + #42 + #9 | microfixes 묶음: `inbox:delete`→`inbox:trash` rename / `getTopUsedTags(20)` → `VOCAB_TOP_N` const / `OllamaSettingsModal` zod URL pre-check / 휴지통 회수율 ratio 코멘트 1줄 |
+
+## 3. Out of scope
+
+- Telemetry 데이터 필요 (14건): #7 reason 분포 / #16 permanent_delete 빈도 / #18 loadExpired consumer / #20 telemetry .catch silent / #25 HealthChecker dedup / #28 unreachableBackoffStep / #29 top-N 튜닝값 (extract 만 본 cut, 튜닝은 v0.2.7) / #30 LIMIT-then-filter 정책 / #31 vocabSet COLLATE / #32 per-tag emit 병렬화 / #33 promptVersion payload / #35 recall_shown lifetime / #36 IPC handle vs on / #39 ollama reason PII / #40 Settings race flicker
+- 별도 brainstorm 영역 (3건): #11 restoreNote precondition / #14 ARIA 패턴 / #17 dialog 버튼 순서 / #37 NoteCard id ref-forwarding
+
+## 4. Architecture changes
+
+대부분 cosmetic refactor 또는 isolated bug fix. 주목할 architecture-level 변경:
+
+### 4.1 KST helper 통합 (C1)
+- 신규 `src/shared/util/kstDate.ts` (main + renderer 양쪽 import 가능)
+- 기존 4 callsite 의 inline KST 계산 제거
+- API: `kstTodayIso(now?: Date): string`, `nextKstMidnightMs(now?: Date): number`
+- KST_OFFSET_MS 상수 단일
+
+### 4.2 TrayCallbacks 객체화 (C2 + C3)
+- `interface TrayCallbacks` — 10+ 개 callback + state getter
+- `createTray(callbacks: TrayCallbacks): void` — 1-arg signature
+- module state (_failedCount, _todayCount, _ollamaOk) 는 TrayCallbacks 의 reactive getter / setter 패턴 또는 explicit refresh 함수 (`refreshTray(state: { todayCount, failedCount, ollamaOk })`)
+
+### 4.3 Banner shared component (C7)
+- `<Banner severity="warning"|"error"|"info" icon? title? children>` — wrapping/styling 일원화
+- 5 callsite 가 themed inline style 제거 → severity prop
+- CSS variables 또는 hardcoded theme map (single source)
+
+### 4.4 NoteRepository.restoreNote behavior change (B1)
+- 기존: `UPDATE notes SET deleted_at = NULL WHERE id = ?`
+- 변경: 추가로 `ai_status='failed'` 였을 경우 → `ai_status='pending'` reset + `INSERT OR IGNORE INTO pending_jobs`
+- atomic transaction
+- AiWorker 가 자동으로 다음 loop iteration 에서 처리
+
+## 5. Tests
+
+추정 +17 cases (413 → 430):
+
+| Task | 신규 단위 |
+|---|---|
+| B1 | +3 (restore failed note re-enqueues, restore done note 영향 X, restore cancelled note 영향 X) |
+| B2 | +2 (countTrashed 정확, dialog message 정확 N) |
+| B3 | +1-2 (autostart args 비교, 가능하다면 mock electron app) |
+| B4 | +1 (additionalData hidden flag 가 second-instance 에 전달, mock test) |
+| C1 | +2 (kstTodayIso, nextKstMidnightMs) — 기존 4 callsite test 가 자동 검증 |
+| C2 | refactor only, 기존 tray 테스트 유지 |
+| C3 | refactor only |
+| C4 | refactor only |
+| C5 | +2 (hasNoteId predicate) |
+| C6 | refactor only |
+| C7 | refactor only (UI 컴포넌트 unit test X 패턴) |
+| C8 | +1 (exhaustive guard 컴파일 단계) |
+| C9 | +1 (Modal URL pre-check), 나머지 refactor only |
+
+총 신규: ~13-15 (보수적). 단위 413 → **~426-428** 예상.
+
+## 6. Privacy invariant
+
+- B1/B2: telemetry 영향 없음
+- B3/B4: telemetry emit 없음 (autostart event 미수집)
+- C 시리즈: 모두 cosmetic refactor — invariant 영향 0
+- 본 cut 에서 신규 telemetry kind 추가 0
+
+## 7. Gates (roadmap §3.1)
+
+- typecheck 0
+- 단위 413 → ~427 (+13~15)
+- e2e 1/1
+- backward compat: 기존 사용자 데이터 + UI 동작 영향 0 (단 B1 은 의도적 동작 추가, B2 는 UI N 표시 정확화)
+
+## 8. Risk + Fallback
+
+### B3 (autostart 풀림) 진단 불확실
+가장 risky. Windows registry 디버깅 결과 깨끗한 fix 안 나올 수 있음. **Fallback 정책**:
+- 진단 절차 적용해도 fix 안 되면 → 진단 로그만 추가 (`logger.info('autostart.state', { stored, current, mismatch })`) → backlog #45 유지 → 본 cut 에서 task drop
+- 다른 task 영향 없음 (각 task 독립적)
+
+### C1 KST helper 의 alias 경계
+`src/shared/util/kstDate.ts` 가 main + renderer 양쪽에서 import 되어야. 기존 `@main/util/kstDate.ts` 는 renderer 에서 import 불가 (alias 분리). `src/shared/` 가 양쪽 가능 패턴. 검증 필요.
+
+### C2 TrayCallbacks 객체화 의 backward compat
+기존 createTray 호출자 (index.ts 1곳) 한 군데만 변경 → 안전. tray 테스트 영향 최소.
+
+## 9. 작업 순서
+
+순서대로 subagent dispatch. 의존성:
+- B1, B2: 독립
+- B3: 독립 (Windows-specific, mock 어려움)
+- B4: 독립
+- C1 → 다른 task 영향 X (shared util 추가)
+- C2 → C3 (TrayCallbacks 객체에 refreshTrayFailedCount 흡수)
+- C4, C5, C6, C7, C8, C9: 독립
+
+권장 순서: **B1 → B2 → B4 → B3 → C1 → C4 → C5 → C6 → C8 → C2 → C3 → C7 → C9**.
+
+이유: B3 (위험) 을 cleanup 시작 직전에 두어 fail 시 빠르게 회피. C2/C3 cluster 는 묶어서. C7 (Banner shared) 는 isolated UI cleanup, 마지막 그룹.
+
+## 10. Roadmap relation
+
+- v0.2.6 정식 cut (이전 v0.2.4/v0.2.5 는 patch / hotfix)
+- 머지 후 binary 빌드 v0.2.6 (Windows + Mac) + Gitea release
+- v0.2.7 brainstorm 트리거: dogfood ≥1주 soak + telemetry export 모인 후, 잔여 backlog 14건 (data-dependent) + 신규 피드백 일괄 triage
+- backlog file 본 cut 후 prune (16 건 처리 완료 표기) + rename 검토 (`v027-backlog.md` 또는 `feature-backlog.md`)

docs/superpowers/specs/2026-05-06-v027-cross-platform-design.md

@@ -0,0 +1,407 @@
+# v0.2.7 — Cross-Platform 입구 정상화 (Design)
+
+**작성일:** 2026-05-06
+**저자:** 김태현 (dlsrks0734@gmail.com)
+**선행 문서:**
+
+- `docs/superpowers/specs/2026-04-25-dogfood-feedback.md` (F12, F14, F15, F16)
+- `docs/superpowers/v024-backlog.md` (잔여 24건)
+- `docs/superpowers/strategy/dogfood-strategy.md` (운영안)
+
+**Cut 라벨:** v0.2.7 (semver 엄밀히는 MINOR — 새 플랫폼 + 새 surface — 이지만 본 프로젝트 관습상 v0.2.x 를 feature lane 으로 사용 중이므로 v0.2.7 라벨 유지)
+
+---
+
+## 1. Cut 정체성
+
+**"Cross-platform 입구 정상화" cut.** F12 / F14 / F15 / F16 4개 항목을 한 묶음으로 처리. 핵심 동기:
+
+> Windows 트레이 의존을 끊고 macOS / Linux 사용자에게 동등한 입구를 제공한다.
+
+현재 13개 트레이 메뉴 항목이 macOS / Linux (특히 모던 GNOME) 에서 발견 / 접근성이 떨어져 핵심 설정 (Ollama endpoint, 자동 실행 등) 진입이 막히는 구조적 문제. 트레이를 deemphasis 하고 inbox 윈도우 안에 통합 설정 페이지를 둔다. 동시에 macOS dock 동작 정상화 (F14) + Linux 앱 빌드 추가 (F15 축소판) + 자동 실행 진단 노출 (F12 deeper fix) 까지 함께 처리한다.
+
+**의도적으로 빠진 것:**
+
+- ~~CLI (`inkling capture` 등)~~ — DB / Ollama 동시접근 race + monorepo 재구성 부담 대비 본인 dogfood metric 직접 기여 적음. v0.2.7 에서 제외. 외부 demand 누적 시 v0.3+ 재거론.
+
+---
+
+## 2. 범위
+
+| 항목 | 출처 | 작업 |
+|---|---|---|
+| **F15 (축소판)** | dogfood F15 | Linux 앱 빌드 (AppImage + deb x64) + better-sqlite3 prebuild linux-x64 매트릭스 |
+| **F16** | dogfood F16 | 트레이 슬림 (13 → 4) + inbox 안 설정 페이지 (4 섹션) |
+| **F14** | dogfood F14 | macOS dock 클릭 시 hidden 창 show/focus (activate 핸들러 5줄 수정) |
+| **F12 deeper fix** | dogfood F12 (v0.2.6 진단 fallback 후속) | 설정 페이지 "자동 실행" 섹션 안에 진단 패널 노출 (withArgs vs noArgs / executableWillLaunchAtLogin / registry path) |
+
+---
+
+## 3. Architecture 변화
+
+| 영역 | 현재 (v0.2.6) | v0.2.7 |
+|---|---|---|
+| 설정 진입 | 트레이 메뉴 13개 항목 | 트레이 4개 + 설정 페이지 (inbox 내부 라우트) |
+| Ollama 설정 | OllamaSettingsModal (트레이에서만 진입) | 설정 페이지 안 "AI 제공자" 섹션 (modal 흡수) |
+| 자동 실행 | 트레이 checkbox + args 명시 | 설정 페이지 안 섹션 + 진단 패널 |
+| macOS dock 클릭 | activate 핸들러 no-op (length===0 분기 못 탐) | `getInboxWindow().show() + focus()` 분기 추가 |
+| Linux 배포 | 없음 | AppImage + deb 산출물 |
+| 빌드 매트릭스 | win-x64 + mac-arm64 | + linux-x64 |
+
+---
+
+## 4. 구현 순서 (Approach 2: Risk-reduction first)
+
+```
+1. Linux 빌드 (가장 unknown — better-sqlite3 prebuild linux-x64 검증)
+   ↓ AppImage + deb 산출 + Linux VM/WSL2 smoke test
+2. 설정 페이지 (inbox 내부 라우트 + 4 섹션)
+   ↓ OllamaSettingsModal 흡수
+3. 트레이 슬림 (13 → 4)
+   ↓ 제거된 click 핸들러 → 설정 페이지 버튼으로 이동
+4. F14 macOS dock 클릭 fix
+   ↓ activate 핸들러 5줄
+5. F12 deeper fix (자동 실행 진단 노출)
+   ↓ IPC settings:autostart-state + 진단 panel UI
+```
+
+Linux 빌드를 먼저 두는 이유: native ABI 트랩 (메모 `project_inkling_status.md`) 이 linux-x64 에서 재발할 수 있음. 만약 prebuild 가 깔끔히 떨어지지 않으면 v0.2.7 scope 조정 (예: AppImage 만, deb 는 v0.2.8) 여유. 설정 페이지 / 트레이 슬림 / F14 / F12 는 모두 코드 작성 risk 가 낮은 영역이라 후순위로 안전.
+
+---
+
+## 5. Linux 빌드 디테일
+
+### 5-1. electron-builder config 추가
+
+```json
+"linux": {
+  "target": [
+    { "target": "AppImage", "arch": ["x64"] },
+    { "target": "deb", "arch": ["x64"] }
+  ],
+  "category": "Utility",
+  "synopsis": "로컬 메모 캡처 + AI 태그",
+  "description": "Inkling — 잠깐 스친 생각을 잡아두는 로컬-우선 메모 도구."
+}
+```
+
+### 5-2. npm scripts 추가
+
+```json
+"predist:linux": "npm run rebuild:electron && npm run build",
+"dist:linux": "electron-builder --linux --x64"
+```
+
+`rebuild:electron` 의 `--target=41.3.0` 그대로. `prebuild-install` 이 linux-x64 prebuild 를 npm 레지스트리에서 받아오는지 검증. 없으면 `node-gyp` fallback 으로 로컬 컴파일.
+
+### 5-3. 빌드 호스트 전략
+
+**1차: macOS 호스트** (이미 DMG 빌드 호스트). brew 로 도구 설치:
+
+```bash
+brew install dpkg fakeroot
+```
+
+electron-builder 가 cross-build 지원. AppImage 는 Mac 에서 직접 빌드 가능 (Linux 유저랜드 도구만 필요한 부분은 electron-builder 내장 + AppImageKit 자동 다운로드). deb 는 dpkg-deb 필요.
+
+**Fallback (1차 실패 시): Docker on Mac/Windows.** `electronuserland/builder` 이미지로 Linux 빌드 환경 격리. v0.2.7 scope 안에서 결정.
+
+### 5-4. Smoke test
+
+`dist/` 산출물:
+
+- `Inkling-0.2.7.AppImage` (x64) — Linux VM 또는 WSL2 에서 chmod +x → 실행 → 마이그레이션 통과 확인 → capture / recall 한 사이클.
+- `inkling_0.2.7_amd64.deb` — Ubuntu/Debian VM 또는 WSL2 에서 `sudo dpkg -i` → `inkling` 실행 → 동일 검증.
+
+검증 항목:
+
+1. better-sqlite3 native module 로드 성공 (마이그레이션 0 → m003 통과)
+2. Ollama 연결 시도 (settings.json 의 endpoint 또는 `INKLING_OLLAMA_ENDPOINT` env) — 본인 LAN 서버 `http://192.168.0.47:11434` 사용
+3. capture 한 줄 → AI 처리 → tag 표시
+4. 트레이 (KDE/Cinnamon DE 가정) 4 항목 표시
+5. 트레이 없는 DE (모던 GNOME) — launcher 에서 앱 실행 → inbox 윈도우 → 톱니바퀴 → 설정 페이지 진입
+
+---
+
+## 6. 설정 페이지 디테일
+
+### 6-1. 라우팅 방식
+
+React Router 도입 안 함 (의존성 + 학습 비용). zustand store 의 `view: 'inbox' | 'trash' | 'settings'` state + 조건부 렌더 — 기존 trash view 와 동일 패턴. 새 의존성 0.
+
+### 6-2. 진입점
+
+| 진입 | 동작 |
+|---|---|
+| 트레이 "설정..." 클릭 | main → IPC `inbox:navigate` 'settings' → renderer store action `setView('settings')` + inbox 윈도우 show/focus |
+| inbox 헤더 톱니바퀴 아이콘 | renderer store action `setView('settings')` |
+| 설정 페이지 안 "← 돌아가기" 버튼 | `setView('inbox')` |
+
+### 6-3. 섹션 4개
+
+#### 6-3-1. AI 제공자
+
+흡수 대상: OllamaSettingsModal 전체 + 트레이 "Ollama 재확인".
+
+UI 요소:
+
+- Endpoint URL 입력 (zod 검증 — 기존 modal 의 `safeParse` 재활용)
+- Model 입력 (빈 값 guard)
+- "지금 재확인" 버튼 → ProviderHolder 의 health check trigger
+- 마지막 ping 결과 표시 (성공 시각 또는 실패 사유)
+- "기본값으로 되돌리기" 버튼
+
+저장: 기존 SettingsService (atomic temp+rename + zod) 그대로.
+
+#### 6-3-2. 자동 실행
+
+흡수 대상: 트레이 "윈도우 시작 시 자동 실행" checkbox.
+
+UI 요소:
+
+- 토글 ("앱 시작 시 자동으로 실행")
+- 진단 패널 (펼치기 가능 — 평소엔 접혀 있음)
+- "재등록" 버튼 (setLoginItemSettings 강제 재호출)
+
+진단 패널 디테일은 §9 (F12 deeper fix) 참조.
+
+#### 6-3-3. 백업 / 복원 / 내보내기
+
+흡수 대상: 트레이의 5개 항목 — "지금 백업" / "내보내기..." / "백업에서 복원..." / "지금 동기화" / "사용 로그 내보내기...".
+
+UI 요소: 5개 버튼 + 각 작업 마지막 실행 시각 (가능하면) + 결과 toast.
+
+IPC 핸들러는 기존 그대로 — 트레이 click 핸들러였던 함수를 IPC 핸들러로 등록 + renderer 에서 invoke.
+
+#### 6-3-4. 정보
+
+흡수 대상: 트레이 "Inkling 정보..." dialog.
+
+UI 요소: 버전 / Electron / Node / OS / 데이터 위치 텍스트 + "데이터 위치 열기" 버튼 + "정보 복사" 버튼.
+
+기존 `showAboutDialog` 의 detail 문자열 그대로 활용 — clipboard.writeText / shell.openPath 호출도 동일.
+
+### 6-4. 제외 항목
+
+- "지금 AI 처리 (실패 N건)" — 이미 inbox FailedBanner 가 surface. 트레이 / 설정 둘 다 제거.
+- "Ollama 재확인" 트레이 메뉴 단독 — OllamaBanner (끊김 시) + 설정 페이지 AI 섹션 "지금 재확인" 버튼이 surface. 트레이 단독 메뉴 제거.
+
+---
+
+## 7. 트레이 슬림 디테일
+
+### 7-1. 잔류 4개 (Win / Mac / Linux 동일)
+
+```ts
+items.push({ label: '한 줄 적기', click: cb.showCapture });
+items.push({ label: '보관한 메모 보기', click: cb.showInbox });
+items.push({ type: 'separator' });
+items.push({ label: '설정...', click: cb.showSettings });
+items.push({ type: 'separator' });
+items.push({ label: '종료', click: () => { app.isQuitting = true; app.quit(); } });
+```
+
+todayCount tooltip (`Inkling — 오늘 N`) 잔류. F4-C 의 "오늘 N번 잡아둠" 비활성 라벨도 잔류 (정체성 신호).
+
+### 7-2. TrayCallbacks / TrayState 갱신
+
+```ts
+export interface TrayCallbacks {
+  showInbox: () => void;
+  showCapture: () => void;
+  showSettings: () => void; // NEW — IPC 'inbox:navigate' 'settings' 송출
+}
+
+// 메뉴 영향 state 슬림
+export interface TrayState {
+  todayCount: number;
+}
+```
+
+**제거 대상:**
+
+- `runBackup`, `runExport`, `runImport`, `runSync`, `runExportTelemetry` callback (5개) → 설정 페이지 버튼으로 이동
+- `runOllamaRecheck`, `runRetryAllFailed`, `runOpenOllamaSettings` callback (3개) → 설정 페이지 또는 banner 로 이동
+- `ollamaOk`, `failedCount` state field (2개) → 트레이 메뉴 영향 사라짐 (banner 가 surface)
+- `refreshTray({ ollamaOk })`, `refreshTray({ failedCount })` 호출부 (HealthChecker, AiWorker) → 제거. todayCount 만 남음.
+
+v0.2.6 의 Partial<TrayState> 패턴 그대로 활용 — 인터페이스 좁아질 뿐.
+
+### 7-3. 자동 실행 토글 트레이 잔류 X
+
+기존 트레이 안 checkbox (`type: 'checkbox'`) 는 제거. 설정 페이지 "자동 실행" 섹션 토글이 단일 진입점.
+
+이유: 자동 실행 토글은 빈도 낮은 액션 + F12 진단이 같은 자리에 있어야 의미. 트레이 잔류 시 두 surface mismatch 위험.
+
+---
+
+## 8. F14 macOS dock 클릭 fix
+
+[src/main/index.ts:411-413](src/main/index.ts#L411-L413) 수정:
+
+```ts
+app.on('activate', () => {
+  const win = getInboxWindow();
+  if (win && !win.isDestroyed()) {
+    if (!win.isVisible()) win.show();
+    win.focus();
+  } else {
+    createInboxWindow();
+  }
+});
+```
+
+second-instance 핸들러 (B4 #46) 와 패턴 일치 — 양쪽 모두 "살아있으면 show, 죽었으면 create".
+
+테스트: BrowserWindow + activate 이벤트 mocking 비용 ↑ → manual dogfood 검증으로 충분 (macOS 빨간 신호등 → dock 클릭 → 즉시 창 등장).
+
+---
+
+## 9. F12 deeper fix — 자동 실행 진단 노출
+
+### 9-1. 정보 모델
+
+```ts
+// 신규 IPC: settings:autostart-state
+interface AutostartState {
+  withArgs: { openAtLogin: boolean; executableWillLaunchAtLogin: boolean };
+  noArgs: { openAtLogin: boolean; executableWillLaunchAtLogin: boolean };
+  execPath: string; // process.execPath
+  registryPath?: string; // Windows only
+  registryValue?: string; // Windows only — null 또는 string
+}
+```
+
+### 9-2. main process 핸들러
+
+```ts
+ipcMain.handle('settings:autostart-state', async () => {
+  const withArgs = app.getLoginItemSettings({ args: ['--hidden'] });
+  const noArgs = app.getLoginItemSettings();
+  const state: AutostartState = {
+    withArgs: {
+      openAtLogin: withArgs.openAtLogin,
+      executableWillLaunchAtLogin: withArgs.executableWillLaunchAtLogin
+    },
+    noArgs: {
+      openAtLogin: noArgs.openAtLogin,
+      executableWillLaunchAtLogin: noArgs.executableWillLaunchAtLogin
+    },
+    execPath: process.execPath
+  };
+  if (process.platform === 'win32') {
+    state.registryPath = 'HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run\\Inkling';
+    state.registryValue = await readRegistryValueSilent(state.registryPath);
+  }
+  return state;
+});
+```
+
+`readRegistryValueSilent`: `child_process.execFile('reg', ['query', path, '/v', 'Inkling'])` 1회. 실패 시 null 반환 (silent fallback — 사용자에 에러 노출 X).
+
+새 dependency 추가 X (`winreg` 등 X) — built-in `child_process` + Windows `reg.exe` 만 활용.
+
+### 9-3. UI
+
+설정 페이지 "자동 실행" 섹션:
+
+```
+[ ] 앱 시작 시 자동으로 실행
+   상태: ✅ 등록됨 / ⚠️ 등록 안 됨 / ⚠️ args 미스매치
+   ▾ 진단 정보 (펼치기)
+     - 표준 조회 (args 명시): openAtLogin=true, willLaunch=true
+     - 비교 조회 (args 없이): openAtLogin=false, willLaunch=true   ← mismatch ⚠️
+     - 실행 파일 경로: /Applications/Inkling.app/Contents/MacOS/Inkling
+     - registry 경로 (Windows): HKCU\...\Run\Inkling
+     - registry 값: "C:\Users\...\Inkling.exe" --hidden
+   [ 재등록 ] 버튼
+```
+
+### 9-4. dogfood 시나리오
+
+1. 토글 ON → 재시작 → 풀려있으면 진단 패널 펼침.
+2. withArgs vs noArgs mismatch 보임 → args canonicalization 문제 확인.
+3. registry 값 vs execPath 비교 — 다르면 path canonicalization 문제 (NSIS 재설치 시 path 바뀜).
+4. "재등록" 버튼 → setLoginItemSettings 재호출 → 다시 재시작 → 효과 측정.
+
+수집된 데이터로 v0.2.8 root cause fix 작성.
+
+---
+
+## 10. 테스트 전략
+
+| 영역 | 단위 | e2e | Manual dogfood |
+|---|---|---|---|
+| Linux 빌드 (F15) | - | - | AppImage + deb 산출 + Linux VM 실행 + 마이그레이션/캡처/recall 한 사이클 |
+| 설정 페이지 라우팅 | zustand store action `setView('settings')` 단위 | (선택) 트레이 "설정..." → IPC → view 전환 e2e | 실제 클릭 흐름 |
+| Ollama 섹션 흡수 | 기존 OllamaSettingsModal 단위 + 흡수 후 회귀 | - | 1회 |
+| 자동 실행 진단 IPC | autostart-state 핸들러 단위 (mock electron API + child_process) | - | Win 토글 → 재시작 → 진단 패널 mismatch 검출 |
+| 트레이 슬림 | tray.ts buildMenu 단위 (4 항목 검증 + 제거된 항목 부재) | - | - |
+| F14 dock fix | (mock 비용 ↑) — manual 만 | - | macOS dock 클릭 |
+| F12 진단 UI | mismatch 시 ⚠️ 렌더 단위 | - | F12 시나리오 재현 |
+
+**목표**: 단위 426 → 약 450 (+24), e2e 1 유지 또는 +1.
+
+---
+
+## 11. Risk / Known unknowns
+
+| Risk | 발생 시 대응 |
+|---|---|
+| linux-x64 prebuild 부재 → node-gyp 빌드 실패 | Docker `electronuserland/builder` fallback. 그래도 실패 시 v0.2.7 scope 조정: AppImage 만, deb 는 v0.2.8. [2026-05-07 검증: ✅ prebuild 존재 — electron-v145 (v41.3.0 ABI) 다운로드 성공, better_sqlite3.node 파일 생성] |
+| ELECTRON_RUN_AS_NODE 함정 (메모) 가 Linux 환경에서 재현 | smoke test launch env 에서 strip — 기존 e2e 의 strip 패턴 그대로 |
+| AppImage 가 모던 GNOME 에서 트레이 표시 안 됨 | 의도적 — 그래서 dock/launcher → inbox → 설정 페이지 흐름이 안전망. F14 fix 가 이 흐름의 핵심. |
+| 설정 페이지 라우팅이 inbox 의 keyboard shortcut / hotkey 와 충돌 | view='settings' 시 inbox-only shortcut 비활성. zustand state 분기. |
+| 자동 실행 진단 패널이 Mac/Linux 에선 의미 없는 정보 노출 | 플랫폼 분기 — Mac/Linux 는 registry 행 숨김 + executableWillLaunchAtLogin 만 표시 |
+| 트레이 callback 8개 제거 시 import 그래프에서 dead code 잔존 | 제거 후 typecheck + grep 으로 검증 |
+
+---
+
+### v0.2.7 Linux 빌드 1차 시도 결과 (2026-05-07, Windows 호스트)
+
+`npm run dist:linux` 실행 — Windows 11 호스트.
+
+**진행 단계:**
+
+- ✅ predist:linux (electron rebuild + electron-vite build) — 성공
+- ✅ electron-builder linux x64 패키징 prep — 성공
+- ✅ electron-v41.3.0-linux-x64.zip 다운로드 (117 MB)
+- ✅ `dist/linux-unpacked/` 스테이징 생성 — 322 MB (electron + native modules + app)
+- ✅ appimage-12.0.1.7z 다운로드 (mksquashfs 등 Linux 유저랜드 도구 캐시)
+- ⚠️ **AppImage 패키징 실패** — `mksquashfs` 실행 불가
+- ⏭️ **deb 패키징은 시도조차 못함** (AppImage 실패로 빌드 중단)
+
+**핵심 에러:**
+
+```text
+⨯ cannot execute  cause=exec: "C:\Users\...\electron-builder\Cache\appimage\appimage-12.0.1\linux-x64\mksquashfs": file does not exist
+⨯ failed to build AppImage  error=...app-builder.exe process failed ERR_ELECTRON_BUILDER_CANNOT_EXECUTE
+Exit code: 2
+```
+
+**진단:** `mksquashfs` 파일은 캐시에 존재하나 (270 KB Linux ELF 바이너리), Windows 가 ELF 를 실행 불가 → electron-builder 가 "file does not exist" 로 보고. AppImage cross-build from Windows 는 **근본적으로 불가능** (WSL/Docker/Linux/Mac 호스트 필요).
+
+**결론:**
+
+- AppImage: ⚠️ 실패 (Windows 호스트는 mksquashfs ELF 실행 불가 — 환경 제약)
+- deb: ⚠️ 미시도 (`dpkg-deb` + `fakeroot` 부재 추정. AppImage 실패로 도달 못함)
+
+**Fallback 결정:** Mac (사용자 업무 호스트) 또는 Linux/WSL/Docker 핸드오프 필수. Windows 단독으로는 v0.2.7 Linux 산출물 생성 불가. plan Task 3 은 "시도 + 결과 기록" 이 핵심이었고, **macOS 후속 시도가 본 빌드** — Windows 시도는 환경 한계 확인용.
+
+**권장 후속:**
+
+1. 사용자 macOS 업무 호스트에서 동일 명령 (`npm run dist:linux`) 재시도. brew 로 `dpkg` + `fakeroot` 사전 설치 (`brew install dpkg`). AppImage 는 macOS 에서 정상 cross-build 가능 (mksquashfs Mach-O 바이너리 caching).
+2. macOS 에서도 deb 가 실패할 경우 — v0.2.7 scope 를 **AppImage only** 로 축소, deb 는 v0.2.8 또는 Docker `electronuserland/builder` 환경으로 이동. package.json `linux.target` 에서 deb 제거하거나 별도 task 로 분리.
+3. 향후 자동화: GitHub Actions / Gitea Actions 에서 ubuntu-latest runner 로 Linux build 자동화 (현 수동 cross-build 환경 의존성 제거).
+
+---
+
+## 12. v0.2.7 후
+
+**잔여 backlog (24건)** — `docs/superpowers/v024-backlog.md`:
+
+- v0.2.6 final reviewer minor cleanup 6건 — kstDate 의미 정정 / NoteRepository.test.ts as any / store.ts trashCount race 등
+- telemetry data-dependent 14건 — VOCAB_TOP_N 튜닝, recallBanner 임계값 등 — v0.2.8 후보 (v0.2.7 dogfood soak ≥1주 후 telemetry export 누적)
+- v0.2.7 본 cut 안 신규 발견 — F12 root cause 가 진단 데이터 누적 후 결정될 가능성
+
+**v0.2.8 트리거**: v0.2.7 release 후 dogfood ≥1주 soak + telemetry export + F12 진단 데이터 → v0.2.8 brainstorm.

docs/superpowers/strategy/dogfood-strategy.md

@@ -1,9 +1,11 @@
 # Inkling — Dogfooding 전략
 
 **작성일:** 2026-04-25
-**대상:** 김태현 (저자 본인) — 슬라이스 v0.4 dogfood 단계
+**최종 갱신:** 2026-05-05 (v0.2.6 release 후 — environment step 갱신, 현재 단계 표기)
-**스펙 의존:** `2026-04-24-inkling-vertical-slice-design.md` v0.4 §1.3 (종료 조건)
+**대상:** 김태현 (저자 본인) — 슬라이스 v0.4 → v0.2.6 dogfood 진행 중
+**스펙 의존:** `2026-04-24-inkling-vertical-slice-design.md` v0.4 §1.3 (종료 조건) + `2026-05-01-v023-feedback-roadmap-design.md` (v0.2.3 7항목 cut)
 **전략 의존:** `strategy.md` §1·§2·§5 (행동 정의, Capture→Clarify→Capitalize, 회복 친화 스트릭)
+**현재 binary:** v0.2.6 (`Inkling Setup 0.2.6.exe` — 2026-05-05 release)
 
 ---
 
@@ -27,14 +29,24 @@ dogfood 첫 날 시작 전, 환경을 한 번에 정렬한다.
 
 ### 1.1 환경
 
-- [ ] `.nvmrc` 의 Node 버전 (24.15.0) 활성화
+**v0.2.6 release 기준 (2026-05-05 갱신)**:
-- [ ] `INKLING_OLLAMA_ENDPOINT` 가 LAN Ollama (`http://192.168.0.47:11434`) 를 가리킴
+
-- [ ] LAN Ollama 에 `gemma4:e4b` 가 pull 된 상태 확인 (`curl http://192.168.0.47:11434/api/tags`)
+- [ ] **설치**: Gitea release 페이지 (`https://gitea.altair823.xyz/altair823-org/inkling/releases/tag/v0.2.6`) 에서 `Inkling-Setup-0.2.6.exe` 다운로드 + 설치
-- [ ] `npm run build` 후 `npm start` 로 정식 실행 (dev 모드 아님 — dogfood 는 프로덕션 빌드)
+  - 또는 source 빌드: `npm run dist:win` (Windows) / `npm run dist:mac` (Mac arm64)
-- [ ] 윈도우 트레이에 Inkling 아이콘 떠 있음
+- [ ] **Ollama 설정** (v0.2.3.1 PR #21 부터 in-app 가능):
+  - 트레이 메뉴 → "Ollama 설정..." → endpoint + model 직접 입력
+  - 또는 env var fallback: `INKLING_OLLAMA_ENDPOINT=http://192.168.0.47:11434` (LAN 서버)
+  - 또는 default: `http://localhost:11434` (로컬 ollama serve 시)
+  - **Windows 11434 reserved 머신 (Hyper-V/WSL2 사용 시)**: `OLLAMA_HOST=127.0.0.1:11942` setx + Inkling 설정 endpoint 도 11942 (자세한 내용 F8)
+- [ ] LAN Ollama 에 `gemma4:e4b` 가 pull 된 상태 확인 (`curl <endpoint>/api/tags`)
+- [ ] 윈도우 트레이에 Inkling 아이콘 떠 있음 (단일 instance — v0.2.5 PR #23 hotfix 로 multi-spawn 차단)
 - [ ] `Ctrl+Shift+J` 가 다른 앱(Chrome, Edge DevTools 등)에 충돌 없이 잡힘
 - [ ] OS 알림 권한 허용 — 첫 토스트 후 시스템 트레이에서 확인
-- [ ] `%APPDATA%\Inkling\default\inkling.db` 가 새로 생성됨 (이전 dogfood 데이터 분리하려면 이 파일을 백업·삭제)
+- [ ] **데이터 위치 확인** (v0.2.4 PR #22 트레이 "Inkling 정보..." → "데이터 위치 열기" 로 즉시 확인):
+  - Windows: `%APPDATA%\Inkling\Inkling\profiles\default\inkling.sqlite`
+  - macOS: `~/Library/Application Support/Inkling/Inkling/profiles/default/inkling.sqlite`
+  - 이전 dogfood 데이터 분리하려면 이 디렉터리 백업·삭제
+- [ ] **autostart 확인** (v0.2.6 진단 fallback 적용 중, F12 dogfood verify 영역): 트레이 메뉴 "윈도우 시작 시 자동 실행" 체크 → 종료 → 재실행 → 체크박스 유지 여부 확인 (`autostart.state` 로그 같이 확인 = `<userData>/Inkling/logs/main-YYYY-MM-DD.log`)
 
 ### 1.2 dogfood 로그 파일 준비
 

docs/superpowers/v024-backlog.md

@@ -0,0 +1,212 @@
+# v0.2.x Backlog
+
+> 누적 backlog. v0.2.3 cut (7항목 / PR #13~#19) 시점부터 PR review deferred + dogfood 발견 모두 합산. **파일명은 historic** (`v024-backlog.md`) — v0.2.4 ~ v0.2.6 cut 후에도 이어 사용. **v0.2.7 brainstorm 시** 신규 피드백 + 잔여 일괄 triage.
+
+**누적 시작일:** 2026-05-01 (#7 telemetry skeleton 머지 시점)
+**최종 갱신:** 2026-05-07 (v0.2.7 cross-platform cut — #45 자동실행 deeper fix)
+**총 항목 수:** 46 (#1 stale 포함)
+**잔여:** 23건 (=46 − 처리 22 − stale 1)
+
+## 처리 이력 / 진행 흐름
+
+| 항목 | 상태 | Cut |
+|---|---|---|
+| #1 (`now()` 2번 호출) | ✅ 이미 fix (PR #13 round 1 — backlog stale) | - |
+| #2 (`DAY_MS` magic) | ✅ 처리 | v0.2.4 (commit `ef5d3da`) |
+| #6 (`media.gc.run()` `.catch`) | ✅ 처리 | v0.2.4 (commit `ef5d3da`) |
+| #13 (NoteCard `onDeleted` dead-code) | ✅ 처리 | v0.2.4 (commit `c87c248`) |
+| #44 (버전 정보 surface) | ✅ 처리 (트레이 "Inkling 정보..." + native dialog) | v0.2.4 (commit `d3dfe1e`) |
+| **out-of-backlog**: multi-instance bug (single-instance lock) | ✅ critical hotfix | v0.2.5 (PR #23, `7187aea`) |
+| #10 (restoreNote + pending_jobs) | ✅ 처리 (repo 메서드 + CaptureService production path) | v0.2.6 (commit `df27a96` + `a991008`) |
+| #12 (trashCount cap) | ✅ 이미 fix (v0.2.3 #4) — tests +2 추가 | v0.2.6 (commit `e2c53a2`) |
+| #45 (자동실행 풀림 버그) | ✅ 처리 (진단 노출 + 재등록 버튼) | v0.2.7 (commit `8a8652e` + `8368286`) |
+| #46 (hidden-start race) | ✅ 처리 (`additionalData` + handler hidden flag) | v0.2.6 (commit `e485b77`) |
+| #3+#19+#34 (KST helper 통합) | ✅ 처리 → `src/shared/util/kstDate.ts` (4 callsite migrate) | v0.2.6 (commit `3cfa60b`) |
+| #5 (AiFailedReason union) | ✅ 처리 (zod z.infer 단일 export) | v0.2.6 (commit `a2c17a8`) |
+| #21 (hasNoteId predicate) | ✅ 처리 (NO_NOTE_ID_KINDS Set + type predicate) | v0.2.6 (commit `05c45c1`) |
+| #22 (hydrate `as any[]`) | ✅ 처리 (`as Record<string, unknown>[]` 통일) | v0.2.6 (commit `983306e`) |
+| #8 (stats exhaustiveness) | ✅ 처리 (`else { _: never = ev }`) | v0.2.6 (commit `9230ebf`) |
+| #4+#23+#26+#27 (TrayCallbacks 객체화) | ✅ 처리 (1-arg + `Partial<TrayState>`) | v0.2.6 (commit `476a519`) |
+| #24+#41 (Banner shared component) | ✅ 처리 (`Banner severity=...` 4 callsite) | v0.2.6 (commit `0447b69`) |
+| #15 (IPC channel rename) | ✅ 처리 (`inbox:delete` → `inbox:trash`) | v0.2.6 (commit `8b2920f`) |
+| #29 (VOCAB_TOP_N const) | ✅ 처리 (튜닝 자체는 telemetry 후) | v0.2.6 (commit `8b2920f`) |
+| #42 (Modal URL pre-check) | ✅ 처리 (zod safeParse) | v0.2.6 (commit `8b2920f`) |
+| #9 (휴지통 회수율 ratio 코멘트) | ✅ 처리 (1줄 코멘트) | v0.2.6 (commit `8b2920f`) |
+
+### v0.2.6 PR #24 round 1 발견 (Critical fix)
+
+| 항목 | 상태 | Cut |
+|---|---|---|
+| **B1 production path** (CaptureService.restoreNote 가 옛 `repo.restore` 호출) | ✅ Critical fix (commit `a991008`) | v0.2.6 round 1 |
+
+### v0.2.6 final reviewer + round 1 minors (deferred)
+
+| 항목 | 상태 |
+|---|---|
+| NoteRepository.countToday inline KST_OFFSET_MS | v0.2.7 cleanup (C1 spec 외) |
+| BackupService / ContinuityService inline KST_OFFSET_MS | v0.2.7 cleanup |
+| NoteRepository.test.ts:125 `as any` | v0.2.7 (C6 spec 외) |
+| OllamaSettingsModal `#fce4e4` inline (C7 spec 5번째) | modal 컨텍스트라 보류 |
+| `kstDate(ts)` semantic naming (telemetryStats) | v0.2.7 |
+| store.ts:177 trashCount race on `trashExpiredBatch` | pre-existing, v0.2.7 |
+| ExpiryBanner useEffect 24h+ closure | edge case, defer |
+
+**잔여 24건** (= 46 − 처리 21 − stale 1). v0.2.7 brainstorm 시 신규 dogfood 피드백 + #45 deeper fix + 위 deferred 항목 일괄 triage.
+
+## 명명 노트
+
+- v0.2.3.1 / v0.2.4 / v0.2.5 는 **dogfood unblock patch** (semver bump 강제 / hotfix)
+- v0.2.6 = 첫 정식 cut (16 backlog 항목 처리)
+- v0.2.7 = 다음 정식 feature cut (telemetry data-dependent 14건 + 신규 피드백 + 잔여 deferred)
+- 본 backlog 파일은 v0.2.7 cut 시점에 prune + rename 검토 (`v027-backlog.md` 또는 stable 한 `feature-backlog.md`)
+
+## Defer 사유 카테고리
+
+각 항목은 머지 전 inline fix 보다 v0.2.4 영역으로 미룬 명시적 사유 가짐:
+
+1. **Cross-cutting refactor** — 한 PR 안에서 부분만 고치면 inconsistency. 일괄 cleanup task 영역. (예: KST helper 4 callsite 통합, `createTray` positional callbacks 전체 객체화)
+2. **Data-dependent** — dogfood telemetry 분포 보고 결정해야 의미. (예: top-N 튜닝, recall_shown lifetime dedup 정책)
+3. **Cosmetic / style** — 동작 영향 0, 다른 일괄 cleanup task. (예: `now()` 두 번 호출, `as any[]` 통합)
+
+## How to apply
+
+v0.2.6 brainstorm 시 본 리스트를 1차 backlog 로 사용. 항목별로:
+
+- (a) 그대로 cleanup
+- (b) #4~#6 영향 받아 변형
+- (c) defer-further 결정
+- (d) drop (만에 하나 outdated 또는 v0.2.4/v0.2.5 patch 가 우회 처리)
+
+## v0.2.3 #7 Telemetry skeleton 누적 (2026-05-01)
+
+1. **`now()` 두 번 호출** — `TelemetryService.emit` (`src/main/services/TelemetryService.ts:58, :60`) 가 같은 emit 안에서 `this.now()` 두 번. 이론적 midnight straddle 가능 (ts vs filePath 다른 KST 일자), 실제 영향 cosmetic. cleanup: `const nowDate = this.now()` 한 번 추출.
+
+2. **`DAY_MS = 24*60*60*1000` magic number** — `cleanupOldFiles:39` + `readAllRecent:78` (+ `KST_OFFSET_MS` 간접). 모듈 상단에 `const DAY_MS = 24 * 60 * 60 * 1000;` 추출.
+
+3. **KST helper duplication** — `TelemetryService.todayKstIso` + `telemetryStats.kstDate` + `AiWorker.todayKstAsDate`/`todayKstAsIso`. 4번째 caller (예: 회상 schedule, 만료 batching) 등장 시 `src/main/util/kst.ts` 로 통합.
+
+4. **`createTray` positional 폭주** — `tray.ts:51` 가 7 positional callbacks. #1 ollama 회복 / #4 휴지통 비우기 등 트레이 메뉴 추가 시 8+ 도달 → readability threshold 넘김. `TrayCallbacks` object 로 refactor.
+
+5. **`AiFailedReason` union 3 곳 중복** — `'unreachable' | 'schema' | 'timeout' | 'other'` 가 `telemetryEvents.ts:15` (zod), `TelemetryService.ts:21` (EmitInput), `AiWorker.ts:19, :34` (classifier + emitter) 에 분산. `export type AiFailedReason` 하나로 통합. (단 zod enum + TS literal 의 inherent dual-define 은 어쩔 수 없음 — `z.infer` 통해 type 파생만)
+
+6. **`media.gc.run()` 의 `.catch` 누락** — T11 에서 `telemetry.cleanupOldFiles` 의 `.catch` 일관성 처리 시 `media.gc` 도 같은 패턴 (`.catch` 없음) 발견. `backup.runDaily()` 와 컨벤션 통일 위해 `.catch((e) => logger.warn('media.gc.failed', { reason: String(e) }))` 추가.
+
+7. **stats.md 의 reason 분포 미포함** — `telemetryStats.aggregateStats` 가 AI 성공률만 계산, `ai_failed.payload.reason` 의 분포 (unreachable/schema/timeout/other counts) 는 미집계. roadmap §6.2 의 "Ollama unreachable 빈도?" 질문이 부분적으로만 답해짐. v0.2.3 dogfood 후 실제 reason 분포 보고 결정.
+
+## v0.2.3 #4 휴지통 누적 (2026-05-01)
+
+8. **stats.md exhaustiveness check** — `telemetryStats.aggregateStats` 의 7-arm if/else if 가 union 확장 시 silent fall-through. `else { const _: never = ev; }` 추가로 컴파일 단계 가드.
+
+9. **휴지통 회수율 ratio 의미 코멘트** — `restore / trash` 가 event-level ratio (한 노트 trash-restore 반복 시 100% 가능). spec §6.2 의 "회수 도구 동작?" 질문에는 충분, 단 unique-note 회수율로 오해할 여지. 코드 옆 1줄 코멘트.
+
+10. **`restore` 시 AI 결과 보존 + pending_jobs 미재생성** — restore 가 `deleted_at = NULL` 만, pending_jobs 안 재생성. 사용자가 trash 도중 AI fail 한 노트를 restore 시 재처리 경로 부재. v0.2.3 dogfood 에서 빈도 보고 결정 — drop / per-note retry 버튼 / 자동 재처리 중.
+
+11. **`restoreNote(id)` precondition 노출** — store 의 낙관적 갱신이 `trashNotes` 에 노트가 있어야 동작. 명령 팔레트 / 프로그래밍 호출 케이스 시 silently no-op. 현재는 trash view 한정이라 OK. main 이 trash/restore 시 `pushNoteUpdated` 보내도록 변경하면 더 견고.
+
+12. **`inbox:trashCount` cap 200 silent undercount** — UI 만 200 cap, `repo.emptyTrash()` SQL 은 unbounded. 350 노트 trash 시 dialog "200개 영구 삭제" 표시되지만 실제 350 모두 삭제. `repo.countTrashed()` 추가로 둘 다 정확히. **(잠재 UX 버그 — pull-forward 후보)**
+
+13. **NoteCard `mode='trash'` 의 `onDeleted` dead-code** — trash 카드는 `onPermanentDelete`/`onRestore` 만 사용. `onDeleted` prop 은 호출되지 않음 (App.tsx 가 pass-through). API 깔끔히 — `onDeleted?` optional + trash 분기 미전달.
+
+14. **탭 ARIA 패턴** — `aria-pressed` 로 toggle 버튼 표현. canonical 은 `role="tab"` + `aria-selected`. screen reader 동작 OK 지만 a11y audit 시 정정 후보.
+
+15. **`inbox:delete` 채널 rename** — semantic 이 hard → soft 인데 채널 이름 그대로. v0.2.4 에서 `inbox:trash` 로 rename 검토 (기존 호출 0건 보장 후).
+
+16. **per-note 영구 삭제 telemetry 사용량** — v0.2.3 dogfood 에서 `permanent_delete` event 빈도 확인. 거의 0 이면 v0.2.4 에서 per-card "영구 삭제" 버튼 제거 + bulk emptyTrash 만 (UX 단순화). 빈번하면 유지.
+
+## v0.2.3 #5 만료 추천 누적 (2026-05-01)
+
+17. **dialog 버튼 순서 vs spec §5.3** — spec 은 `['취소','옮기기'], default=0`, 구현은 `['옮기기','취소'], defaultId=1, cancelId=1` (`inboxApi.ts:117`). 효과 동일 (default = cancel). v0.2.4 에서 spec 또는 impl 한쪽 통일.
+
+18. **`loadExpired()` 미사용** — `loadInitial`/`refreshMeta` 가 inline fetch, App.tsx 도 호출 안 함 (test 만 exercise). v0.2.4 dogfood 후에도 consumer 미발생 시 제거 검토.
+
+19. **store `KST_OFFSET_MS` inline duplication** — `store.ts:166` 의 `snoozeExpired` 가 inline KST 계산. `@main/util/kstDate.ts` 와 동일 알고리즘이지만 alias 경계 (main vs renderer) 로 import 불가. `src/shared/util/kstDate.ts` 로 lift 검토. (#3, #34 와 합산 가능)
+
+20. **telemetry emit `.catch(() => {})` 가 silent** — `CaptureService.listExpired`/`trashExpiredBatch` 가 그대로. v0.2.4 telemetry 하드닝 시 debug log path (project pattern 통일) 추가 검토.
+
+21. **TelemetryService.test.ts 의 noteId 가드 widening** — `e.kind !== 'empty_trash' && e.kind !== 'expired_banner_shown' && e.kind !== 'expired_batch_trash'` 체인이 #6 추가 시 더 길어짐. `hasNoteId(ev)` type predicate helper 추출 검토.
+
+22. **NoteRepository hydrate 의 `as any[]` 일괄 cleanup** — `findExpiredCandidates` round 1 review 의 nit 가 단독 fix 시 다른 hydrate-using methods 와 inconsistency. `db.prepare().all()` 의 row type 을 `Record<string, unknown>[]` 또는 explicit row interface 로 통일하는 repo-wide refactor.
+
+## v0.2.3 #1 ollama 회복 누적 (2026-05-01)
+
+23. **`createTray` 8 positional callbacks** — #1 cut 에서 8개 도달, v0.2.4 backlog #4 와 정합 (TrayCallbacks object refactor 약속). #2 retry 또는 #6 reminder cut 에서 추가 항목 (예: "재시도 N건") 등장 시 9+ 회피 위해 본격 refactor.
+
+24. **Banner CSS 스타일 inline 중복** — ExpiryBanner (`#fff7e6 / #d99500 / #946100` 황색) / OllamaBanner (동) / FailedBanner (`#fce4e4 / #a33` 적색) / RecallBanner (`#e8f0fe / #4a7ec0` 청색) 모두 색상 hardcode. v0.2.4 에서 CSS variables 또는 banner shared component (`<Banner severity="warning|error|info" />`) 추출 검토.
+
+25. **HealthChecker `inFlight` 가드의 manual emit ordering** — manual emit 이 inFlight 체크 전 발생해 user 가 빠르게 N번 클릭하면 N개 manual telemetry. spec 의도 (1:1 보장) 와 정합이지만, 향후 dedup 정책 (예: 1초 윈도우) 으로 변형 가능성. v0.2.4 dogfood soak 결과로 결정.
+
+## v0.2.3 #2 AI retry 누적 (2026-05-02)
+
+26. **`createTray` 9 positional callbacks** — #2 cut 에서 9개 도달 (refreshTrayFailedCount 포함). #4 `TrayCallbacks` object refactor 가 이제 readability blocker. #3 / #6 cut 어느 쪽이든 추가 callback 더 들어오기 전에 우선 처리.
+
+27. **`refreshTrayFailedCount` exported singleton state** — `tray.ts` 에 `_failedCount` module-scoped state + setter 패턴. 모듈 캡슐화로 작동하지만 multi-window 또는 multi-tray 시 broken. v0.2.4 refactor 시 TrayController class 또는 store-driven 으로 정리.
+
+28. **`AiWorker.unreachableBackoffStep` 단일 카운터 vs job-level** — 모든 job 이 step counter 공유. 1 job timeout → step↑, 다른 job 정상 처리해도 step reset. 현재는 cross-job correlation 없으니 OK 가정 (Ollama daemon 단일이라 모든 job 이 같은 백엔드 의존). multi-provider 가 들어오면 provider-level step 으로 분리 필요.
+
+## v0.2.3 #3 태그 vocab 누적 (2026-05-02)
+
+29. **`getTopUsedTags(20)` magic number** — `AiWorker.processJob:137` 가 `repo.getTopUsedTags(20)` hardcoded. spec §7 Out 에 "top-N 튜닝" 명시. v0.2.4 dogfood telemetry (`tag_vocab_hit/miss` ratio) 보고 `VOCAB_TOP_N` 모듈 상수 추출 + 튜닝 결정.
+
+30. **`getTopUsedTags` LIMIT-then-filter 의미** — SQL 가 limit 만큼 가져온 후 JS regex 가 후처리 → top-20 안에 한글/공백 태그 섞이면 결과 length < limit. dogfood 규모 OK 가정 + 테스트 lock-in (v0.2.3 round 1 m2 fix). v0.2.4 에서 vocab pool 확장 시 SQL `GLOB` 으로 SQL-side 필터 대안 검토 (또는 `LIMIT ?*2` overfetch+slice).
+
+31. **`vocabSet` strict-eq vs DB COLLATE NOCASE 불일치** — `vocabSet = new Set(vocab)` 은 JS 대소문자 strict, `tags.name` 은 COLLATE NOCASE. 현재는 kebab-case 필터로 vocab 이 항상 lowercase + AI prompt 도 lowercase 강제라 충돌 없지만, vocab pool 확장 시 (예: `'Design'` 사용자 직접 추가) `getTagIdByName('Design')` 은 매치하지만 `vocabSet.has('Design')` 은 miss → tagId 없는 hit 가 silently skip. v0.2.4 에서 `vocabSet = new Set(vocab.map(v => v.toLowerCase()))` + `vocabSet.has(tagName.toLowerCase())` 로 normalize 검토.
+
+32. **AiWorker per-tag emit serial await** — `for (const tag of new Set(...))` 안의 `await this.telemetry.emit(...)` 가 직렬. 3 태그 시 file-append 3 round-trip. `Promise.all` 로 병렬화 가능, 단 `ai_succeeded` emit 도 serial 이라 패턴 일관성 우선 skip. v0.2.4 telemetry 하드닝 시 일괄 변경 검토.
+
+33. **`PROMPT_VERSION` telemetry payload 미포함** — v0.2.3 cut 에선 단일 버전 (4) 만 굴러가서 무의미. v0.2.4/v0.2.5 prompt 튜닝 후 어느 버전이 어떤 hit-rate 만든지 추적 시 `tag_vocab_hit/miss` payload 에 `promptVersion` 추가 검토. spec §7 Out 명시.
+
+## v0.2.3 #6 RecallBanner 누적 (2026-05-02)
+
+34. **KST midnight inline calc 4번째 복제** — `store.ts` 의 `snoozeRecall` (#6) + `snoozeExpired` (#5) + `NoteCard.todayKstIso` + 다른 1곳, 그리고 `kstDate.ts` util 도 별도 존재. 4 callsite 모두 동일 알고리즘. v0.2.4 에서 `nextKstMidnightMs()` / `kstTodayIso()` 단일 util 통합 + alias 경계 (main vs renderer) 해결책. backlog #3, #19 와 합산.
+
+35. **`recall_shown` per-banner-lifetime emit 보장** — useState→useRef 로 race 차단했지만 RecallBanner 컴포넌트 unmount/remount 시 reset. 사용자가 페이지 이동 후 돌아오면 같은 노트가 재emit 가능. v0.2.4 dogfood telemetry 에서 동일 noteId 의 `recall_shown` 빈도 보고 결정 (per-noteId 24h dedup 또는 per-noteId 영속 마커).
+
+36. **`emitRecallShown` / `emitRecallSnoozed` 가 fire-and-forget 인데 `ipcMain.handle` 사용** — 더 honest 한 패턴은 `ipcMain.on` (return value 없음). 현재는 다른 IPC 와 패턴 일관성 우선. v0.2.4 IPC 정리 시 `handle` vs `on` 구분 일괄 검토.
+
+37. **NoteCard `id="note-${id}"` load-bearing** — RecallBanner 의 `scrollIntoView` target. 단순 DOM lookup 이라 shadow DOM / portal 미지원. v0.2.4 에서 다른 surface (예: 검색 결과에서 스크롤) 등장 시 ref-forwarding 패턴 검토.
+
+## v0.2.3.1 Ollama Settings 누적 (2026-05-04)
+
+39. **`ollama_unreachable.reason` 에 endpoint URL 노출 (PII 우회)** — `LocalOllamaProvider.healthCheck` 가 catch err 시 `reason: \`unreachable: ${err.message}\`` 로 emit. `err.message` 안에 `http://192.168.x.x:11434/api/tags` 같은 LAN endpoint URL 포함 가능. v0.2.3.1 의 in-app endpoint UI 가 LAN 사용을 흔하게 만들어 PII 우회 노출 경로 확대. v0.2.4 telemetry 하드닝 시: error class only (network/dns/timeout/...) 또는 host 마스킹 (`<host>:11434`) 정책. PR #21 round 1 m2 deferred.
+
+40. **Settings 저장 vs HealthChecker 60s tick race** — `saveOllamaSettings` IPC 가 `health.runOnce()` 호출, 동시에 60s 주기 tick 도 `inFlight` 가드 통해 같이 실행 시도. 정확성 영향 0 (가드로 dedup), 단 modal 닫기 직전 banner flicker 가능. PR #21 round 1 i1 acknowledge only. v0.2.4 dogfood 에서 실제 빈도 확인 후 결정 (visible 빈도 낮으면 무시).
+
+41. **`OllamaSettingsModal` 인라인 스타일** — 60+ 줄 inline style. backlog #24 (banner CSS 추출) 와 합산. v0.2.4 에서 CSS module / theme variables 추출 시 함께.
+
+42. **Modal 의 client-side URL validation 부재** — endpoint freetext 가 잘못된 형식 (예: 빈 문자열, 한글) 일 때 server-side healthCheck 만 검증. zod URL error message 가 opaque ("Invalid url"). v0.2.4 에서 client-side z.string().url() pre-check + 친화적 에러 메시지.
+
+43. **`createTray` 10번째 positional callback** — v0.2.3.1 cut 에서 10개 도달 (`runOpenOllamaSettings` 추가). backlog #4/#26 (TrayCallbacks object refactor) blocker 수준. v0.2.4 첫 cleanup 항목 후보.
+
+## v0.2.3 / v0.2.3.1 dogfood 발견 (2026-05-05)
+
+> 본 cut 들의 머지 후 사용자가 dogfood 중 발견한 항목. PR review deferred 와 달리 raw UX/bug 발견.
+
+44. **버전 및 프로그램 정보 표시 방법 부재** — 현재 사용자가 설치된 Inkling 의 버전 (package.json `0.2.3.1`) 을 UI 에서 확인할 path 없음. 트레이 메뉴 / Inbox 푸터 / 별도 "About Inkling" 모달 어느 surface 에도 정보 없음. 핸드오프 후 다른 머신에서 같은 버전인지 사용자가 직접 검증 불가. v0.2.4 에서 트레이 메뉴 "Inkling 0.2.3.1 정보..." 또는 Inbox 우하단 footer 형태로 추가 검토. 곁들여: 빌드 commit SHA, electron/node 버전, OS, profileDir 경로 등 디버그 정보 노출 (사용자가 issue report 시 첨부 가능).
+
+45. **윈도우 자동 실행 옵션이 재시작 후 풀려있는 버그** — 트레이 메뉴 "윈도우 시작 시 자동 실행" 체크 → 종료 → 재실행 시 체크박스가 풀려서 표시됨. 코드 (`src/main/tray.ts:47-58`) 가 `app.setLoginItemSettings({ openAtLogin, args: ['--hidden'] })` 호출 후 다음 부팅 시 `app.getLoginItemSettings().openAtLogin` 이 false 반환. 추정 원인:
+    - (a) Windows registry 에 쓴 exe path 와 현재 프로세스 path 가 다름 (NSIS 설치 위치 변경 / 버전 업데이트 시 새 디렉터리)
+    - (b) Electron `setLoginItemSettings` Windows 구현 의 path canonicalization 이슈
+    - (c) 우리 `args: ['--hidden']` 와 actual launch 시 args 비교 mismatch
+    - 영향: dogfood UX 핵심 마찰 — autostart 가 핸드오프 시 매번 수동 재설정 필요. 자동 실행 의도 자체가 dogfood "잊지 않고 매일 사용" 목적인데 깨짐.
+    - v0.2.6 에서 우선순위 높음. 진단 절차: (1) `app.getLoginItemSettings({ args: ['--hidden'] })` 형태로 args 전달해 비교 정확도 올리기, (2) registry 직접 inspect (`HKCU\Software\Microsoft\Windows\CurrentVersion\Run\inkling`) 로 path/args 확인, (3) executable path canonicalization (electron 이 short path 변환 적용 여부).
+
+## v0.2.5 critical hotfix 누적 (2026-05-05)
+
+> v0.2.5 single-instance lock hotfix (PR #23) 의 reviewer deferred 항목.
+
+46. **Hidden-start race (NSIS installer 자동 실행 + 사용자 클릭 충돌)** — NSIS installer 가 설치 직후 사용자가 시작메뉴 / 데스크톱 아이콘 클릭 (`inkling.exe`) + autostart entry (`inkling.exe --hidden`) 을 짧은 간격에 둘 다 시도 시 — 첫 lock 보유자에 따라 visible 여부 race. 본 cut 의 `second-instance` handler 는 무조건 inbox 창 띄움 (사용자 클릭 = 보고 싶다는 강한 시그널 가정). 매우 드문 시나리오 + lock 자체는 정상 동작 (한 쪽만 살아남음).
+    - 영향: drm-edge 케이스만, 실 사용 거의 X
+    - v0.2.6 에서: `app.requestSingleInstanceLock(additionalData)` 의 `additionalData: { hidden: startedHidden }` 전달 → `second-instance(event, argv, cwd, additionalData)` 에서 두 번째 호출이 hidden 이면 창 안 띄우는 정책. 첫 instance 가 자기 자신의 hidden 상태와 비교해 visible 결정.
+    - PR #23 round 1 reviewer Important — acknowledge only, defer to v0.2.6.
+
+## post-cut next-step (status, not backlog)
+
+38. **빌드 / release 흐름 (status)** — v0.2.3 cut 7/7 (PR #13~#19) → binary v0.2.3 release → 11434 포트 reserved 발견 → v0.2.3.1 attempt (PR #21) → semver 거부 → v0.2.4 (PR #22, backlog 5건 + Ollama 설정 UI) → release → multi-instance bug 발견 → **v0.2.5 critical hotfix** (PR #23, single-instance lock) → release ✅ (2026-05-05). 다음: dogfood ≥1주 soak → telemetry export + 신규 피드백 → **v0.2.6 brainstorm 트리거** (잔여 backlog 40건 일괄 triage).
+
+## v0.2.3 cut 후 final reviewer 가 칭찬한 부분
+
+- 2-layer privacy invariant (zod outer + payload `.strict()`) 가 강한 defense
+- KST 처리 일관성 — 4 callsites 동일 패턴
+- backward compat — 기존 13 테스트 (Capture 4 + AiWorker 9) 무수정 통과
+- 신규 dep 0 (zip 회피로 폴더 + 2 file 정책)
+- TelemetryService surface 가 깔끔한 foundation — 다음 항목들이 (a) zod schema 추가, (b) EmitInput arm 추가, (c) emit 호출만 하면 됨

package.json

@@ -1,6 +1,6 @@
 {
   "name": "inkling",
-  "version": "0.2.3",
+  "version": "0.2.8",
   "private": true,
   "description": "Inkling — local-first 한 줄 보관 도구",
   "author": "altair823 <dlsrks0734@gmail.com>",
@@ -28,7 +28,11 @@
     "predist:win": "npm run rebuild:electron && npm run build",
     "dist:win": "electron-builder --win --x64",
     "predist:mac": "npm run rebuild:electron && npm run build",
-    "dist:mac": "electron-builder --mac --arm64"
+    "dist:mac": "electron-builder --mac --arm64",
+    "predist:linux": "npm run rebuild:electron && npm run build",
+    "dist:linux": "electron-builder --linux --x64",
+    "build:icons:png": "node scripts/svg-to-png.mjs assets/icon.svg build/icon-source.png 1024",
+    "build:icons": "npm run build:icons:png && electron-icon-builder --input=build/icon-source.png --output=build --flatten && node scripts/finalize-icons.mjs"
   },
   "build": {
     "appId": "xyz.altair823.inkling",
@@ -42,8 +46,14 @@
       "**/*.node"
     ],
     "win": {
+      "icon": "build/icon.ico",
       "target": [
-        { "target": "nsis", "arch": ["x64"] }
+        {
+          "target": "nsis",
+          "arch": [
+            "x64"
+          ]
+        }
       ]
     },
     "nsis": {
@@ -54,11 +64,37 @@
       "shortcutName": "Inkling"
     },
     "mac": {
+      "icon": "build/icon.icns",
       "target": [
-        { "target": "dmg", "arch": ["arm64"] }
+        {
+          "target": "dmg",
+          "arch": [
+            "arm64"
+          ]
+        }
       ],
       "category": "public.app-category.productivity",
       "identity": null
+    },
+    "linux": {
+      "icon": "build/icon.png",
+      "target": [
+        {
+          "target": "AppImage",
+          "arch": [
+            "x64"
+          ]
+        },
+        {
+          "target": "deb",
+          "arch": [
+            "x64"
+          ]
+        }
+      ],
+      "category": "Utility",
+      "synopsis": "로컬 메모 캡처 + AI 태그",
+      "description": "Inkling — 잠깐 스친 생각을 잡아두는 로컬-우선 메모 도구."
     }
   },
   "dependencies": {
@@ -72,6 +108,8 @@
   },
   "devDependencies": {
     "@playwright/test": "1.59.1",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.2",
     "@types/better-sqlite3": "7.6.11",
     "@types/node": "24.0.0",
     "@types/react": "19.0.0",
@@ -79,7 +117,10 @@
     "@vitejs/plugin-react": "5.1.4",
     "electron": "41.3.0",
     "electron-builder": "26.8.1",
+    "electron-icon-builder": "^2.0.1",
     "electron-vite": "5.0.0",
+    "jsdom": "^29.1.1",
+    "sharp": "^0.34.5",
     "typescript": "6.0.3",
     "undici": "8.1.0",
     "vite": "7.3.2",

scripts/finalize-icons.mjs

@@ -0,0 +1,35 @@
+import { copyFileSync, renameSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+// electron-icon-builder --flatten 은 build/icons/ 안에 icon.ico, icon.icns, <size>x<size>.png
+// 들을 만든다. electron-builder 는 build/icon.ico, build/icon.icns, build/icon.png 를
+// 기대 — 정규 위치로 옮긴다.
+const buildDir = 'build';
+const iconsDir = join(buildDir, 'icons');
+
+const moves = [
+  ['icon.ico', 'icon.ico'],
+  ['icon.icns', 'icon.icns'],
+];
+
+for (const [src, dest] of moves) {
+  const from = join(iconsDir, src);
+  const to = join(buildDir, dest);
+  if (existsSync(from)) {
+    renameSync(from, to);
+    console.log(`Moved: ${from} -> ${to}`);
+  } else {
+    console.error(`MISSING: ${from}`);
+    process.exit(1);
+  }
+}
+
+const png1024 = join(iconsDir, '1024x1024.png');
+const pngOut = join(buildDir, 'icon.png');
+if (existsSync(png1024)) {
+  copyFileSync(png1024, pngOut);
+  console.log(`Copied: ${png1024} -> ${pngOut}`);
+} else {
+  console.error(`MISSING: ${png1024}`);
+  process.exit(1);
+}

scripts/svg-to-png.mjs

@@ -0,0 +1,14 @@
+import sharp from 'sharp';
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+const [, , input, output, size = '1024'] = process.argv;
+if (!input || !output) {
+  console.error('Usage: svg-to-png.mjs <input.svg> <output.png> [size]');
+  process.exit(1);
+}
+mkdirSync(dirname(output), { recursive: true });
+const svg = readFileSync(input);
+const png = await sharp(svg).resize(Number(size), Number(size)).png().toBuffer();
+writeFileSync(output, png);
+console.log(`OK: ${output} (${size}x${size})`);

src/main/ai/AiWorker.ts

@@ -1,22 +1,15 @@
 import type { NoteRepository } from '../repository/NoteRepository.js';
-import type { InferenceProvider } from './InferenceProvider.js';
 import type { Note } from '@shared/types';
+import type { AiFailedReason } from '../services/telemetryEvents.js';
+import { ProviderHolder } from './ProviderHolder.js';
 import { parseAllCandidates } from '../services/dueDateParser.js';
 import { ZodError } from 'zod';
+import { kstTodayAsDate, kstTodayIso } from '../../shared/util/kstDate.js';
 
-const KST_OFFSET_MS = 9 * 60 * 60 * 1000;
+// v0.2.6 #29 — backlog 의 top-N 튜닝은 dogfood telemetry 후 (현재 magic 만 추출).
+const VOCAB_TOP_N = 20;
 
-function todayKstAsDate(now: Date): Date {
+function classifyReason(err: unknown): AiFailedReason {
-  // Returns a Date object whose UTC year/month/day match KST today
-  const k = new Date(now.getTime() + KST_OFFSET_MS);
-  return new Date(Date.UTC(k.getUTCFullYear(), k.getUTCMonth(), k.getUTCDate()));
-}
-
-function todayKstAsIso(now: Date): string {
-  return todayKstAsDate(now).toISOString().slice(0, 10);
-}
-
-function classifyReason(err: unknown): 'unreachable' | 'schema' | 'timeout' | 'other' {
   if (err instanceof ZodError) return 'schema';
   const msg = err instanceof Error ? err.message.toLowerCase() : String(err).toLowerCase();
   if (msg.includes('econnrefused') || msg.includes('enotfound') || msg.includes('fetch failed') || msg.includes('econnreset') || msg.includes('unreachable')) {
@@ -31,7 +24,7 @@ function classifyReason(err: unknown): 'unreachable' | 'schema' | 'timeout' | 'o
 export interface AiTelemetryEmitter {
   emit(input:
     | { kind: 'ai_succeeded'; payload: { noteId: string; durationMs: number; attempts: number } }
-    | { kind: 'ai_failed'; payload: { noteId: string; reason: 'unreachable' | 'schema' | 'timeout' | 'other'; attempts: number } }
+    | { kind: 'ai_failed'; payload: { noteId: string; reason: AiFailedReason; attempts: number } }
     | { kind: 'tag_vocab_hit'; payload: { tagId: number; vocabSize: number } }
     | { kind: 'tag_vocab_miss'; payload: { vocabSize: number } }
   ): Promise<void>;
@@ -66,7 +59,7 @@ export class AiWorker {
 
   constructor(
     private repo: NoteRepository,
-    private provider: InferenceProvider,
+    private holder: ProviderHolder,
     opts: AiWorkerOptions = {}
   ) {
     this.backoffsMs = opts.backoffsMs ?? [0, 30_000, 120_000];
@@ -131,11 +124,11 @@ export class AiWorker {
         const note = this.repo.findById(job.noteId);
         if (!note || note.deletedAt !== null || note.aiStatus !== 'pending') return;
         const nowDate = this.now();
-        const todayDate = todayKstAsDate(nowDate);
+        const todayDate = kstTodayAsDate(nowDate);
-        const todayIso = todayKstAsIso(nowDate);
+        const todayIso = kstTodayIso(nowDate);
         const candidates = parseAllCandidates(note.rawText, todayDate);
-        const vocab = this.repo.getTopUsedTags(20);
+        const vocab = this.repo.getTopUsedTags(VOCAB_TOP_N);
-        const res = await this.provider.generate({
+        const res = await this.holder.get().generate({
           text: note.rawText,
           todayKst: todayIso,
           dueDateCandidates: candidates,
@@ -146,7 +139,7 @@ export class AiWorker {
           title: res.title,
           summary: res.summary,
           tags: res.tags,
-          provider: this.provider.name,
+          provider: this.holder.get().name,
           dueDate: res.dueDate ?? null
         });
         this.unreachableBackoffStep = 0;  // 성공 시 step reset

src/main/ai/InferenceProvider.ts

@@ -14,4 +14,6 @@ export interface InferenceProvider {
   readonly name: string;
   generate(input: GenerateInput): Promise<AiResponse>;
   healthCheck(): Promise<HealthResult>;
+  /** v0.2.3.1 — 외부에서 in-flight generate 강제 중단. ProviderHolder.replace 시 사용. */
+  abort?: () => void;
 }

src/main/ai/LocalOllamaProvider.ts

@@ -2,6 +2,7 @@ import { request } from 'undici';
 import { parseAiResponse, type AiResponse } from './schema.js';
 import { buildPrompt } from './prompt.js';
 import type { GenerateInput, HealthResult, InferenceProvider } from './InferenceProvider.js';
+import { DEFAULT_OLLAMA_ENDPOINT, DEFAULT_OLLAMA_MODEL } from '../../shared/constants.js';
 
 export interface LocalOllamaOptions {
   endpoint?: string;
@@ -18,10 +19,11 @@ export class LocalOllamaProvider implements InferenceProvider {
   private timeoutMs: number;
   private temperature: number;
   private numPredict: number;
+  private abortController: AbortController | null = null;
 
   constructor(opts: LocalOllamaOptions = {}) {
-    this.endpoint = opts.endpoint ?? 'http://localhost:11434';
+    this.endpoint = opts.endpoint ?? DEFAULT_OLLAMA_ENDPOINT;
-    this.model = opts.model ?? 'gemma4:e4b';
+    this.model = opts.model ?? DEFAULT_OLLAMA_MODEL;
     this.timeoutMs = opts.timeoutMs ?? 120_000;
     this.temperature = opts.temperature ?? 0.2;
     this.numPredict = opts.numPredict ?? 512;
@@ -29,8 +31,8 @@ export class LocalOllamaProvider implements InferenceProvider {
   }
 
   async generate(input: GenerateInput): Promise<AiResponse> {
-    const controller = new AbortController();
+    this.abortController = new AbortController();
-    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    const timer = setTimeout(() => this.abortController?.abort(), this.timeoutMs);
     try {
       const res = await request(`${this.endpoint}/api/generate`, {
         method: 'POST',
@@ -42,7 +44,7 @@ export class LocalOllamaProvider implements InferenceProvider {
           stream: false,
           options: { temperature: this.temperature, num_predict: this.numPredict }
         }),
-        signal: controller.signal
+        signal: this.abortController.signal
       });
       if (res.statusCode < 200 || res.statusCode >= 300) {
         throw new Error(`ollama http ${res.statusCode}`);
@@ -55,9 +57,15 @@ export class LocalOllamaProvider implements InferenceProvider {
       return parseAiResponse(parsed);
     } finally {
       clearTimeout(timer);
+      this.abortController = null;
     }
   }
 
+  /** v0.2.3.1 — 외부에서 in-flight generate 강제 중단. ProviderHolder.replace 시 사용. */
+  abort(): void {
+    this.abortController?.abort();
+  }
+
   async healthCheck(): Promise<HealthResult> {
     try {
       const res = await request(`${this.endpoint}/api/tags`, { method: 'GET' });

src/main/ai/ProviderHolder.ts

@@ -0,0 +1,36 @@
+import type { InferenceProvider } from './InferenceProvider.js';
+
+/**
+ * v0.2.3.1 — Mutable provider holder. AiWorker / HealthChecker 가 endpoint 변경 시
+ * 새 LocalOllamaProvider 인스턴스를 받도록 indirection layer.
+ *
+ * 사용 패턴:
+ *   const holder = new ProviderHolder(initialProvider);
+ *   aiWorker = new AiWorker(repo, holder, opts);
+ *   health = new HealthChecker(holder, opts);
+ *
+ *   // 사용자가 Settings 저장 시:
+ *   holder.get().abort?.();       // in-flight 중단 (LocalOllamaProvider 전용)
+ *   holder.replace(newProvider);  // 모든 consumer 가 새 인스턴스 사용
+ */
+export class ProviderHolder {
+  private current: InferenceProvider;
+  private listeners: Array<(p: InferenceProvider) => void> = [];
+
+  constructor(initial: InferenceProvider) {
+    this.current = initial;
+  }
+
+  get(): InferenceProvider {
+    return this.current;
+  }
+
+  replace(next: InferenceProvider): void {
+    this.current = next;
+    for (const fn of this.listeners) fn(next);
+  }
+
+  onReplace(fn: (p: InferenceProvider) => void): void {
+    this.listeners.push(fn);
+  }
+}

src/main/index.ts

@@ -1,5 +1,5 @@
 import electron from 'electron';
-const { app, BrowserWindow, Notification, dialog } = electron;
+const { app, Notification, dialog } = electron;
 import '@shared/types';
 import { existsSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
@@ -15,24 +15,59 @@ import { HotkeyService } from './services/HotkeyService.js';
 import { IntentService } from './services/IntentService.js';
 import { HealthChecker } from './services/HealthChecker.js';
 import { LocalOllamaProvider } from './ai/LocalOllamaProvider.js';
+import { ProviderHolder } from './ai/ProviderHolder.js';
 import { AiWorker } from './ai/AiWorker.js';
 import { registerCaptureApi } from './ipc/captureApi.js';
 import { registerInboxApi, pushNoteUpdated, pushOllamaStatus } from './ipc/inboxApi.js';
+import { registerSettingsApi, navigateInbox } from './ipc/settingsApi.js';
 import { createInboxWindow, getInboxWindow } from './windows/inboxWindow.js';
 import {
   createQuickCaptureWindow, showQuickCapture, getQuickCaptureWindow
 } from './windows/quickCaptureWindow.js';
-import { createTray, refreshTray, refreshTrayOllama, refreshTrayFailedCount } from './tray.js';
+import { createTray, refreshTray } from './tray.js';
 import { MediaGc } from './services/MediaGc.js';
 import { BackupService } from './services/BackupService.js';
 import { ExportService } from './services/ExportService.js';
 import { ImportService } from './services/ImportService.js';
 import { SyncService } from './services/SyncService.js';
 import { TelemetryService } from './services/TelemetryService.js';
+import { SettingsService } from './services/SettingsService.js';
+import { collectAutostartState } from './services/AutostartDiagnostic.js';
+import { registerSchemesAsPrivileged, registerInklingMediaProtocol } from './protocol/inklingMedia.js';
+import { DEFAULT_OLLAMA_ENDPOINT, DEFAULT_OLLAMA_MODEL } from '../shared/constants.js';
 
 const HIDDEN_ARG = '--hidden';
 const startedHidden = process.argv.includes(HIDDEN_ARG);
 
+// v0.2.8 Cut A — `inkling-media://` custom protocol 스킴은 app.whenReady() 전에
+// privileged 등록 필수 (Electron 표준). 이미지 asset 을 main process 가 직접
+// 서빙해 file:// hack 없이 작동.
+registerSchemesAsPrivileged();
+
+// CRITICAL — single-instance lock + hidden-flag 전달 (v0.2.6 #46).
+// 두 번째 .exe 가 hidden 으로 spawn 됐다면 (autostart) 첫 instance 의 inbox 창
+// 띄우지 않음 — 사용자가 명시적으로 클릭한 게 아니므로.
+const additionalData = { hidden: startedHidden };
+const gotLock = app.requestSingleInstanceLock(additionalData);
+if (!gotLock) {
+  app.quit();
+} else {
+  app.on('second-instance', (_e, _argv, _cwd, secondData) => {
+    const data = secondData as { hidden?: boolean } | undefined;
+    // 두 번째가 hidden 으로 spawn (autostart 등) — UI 띄우지 않음
+    if (data?.hidden === true) return;
+    // 사용자가 명시적으로 .exe / 단축키 / 트레이로 띄움 → inbox 창 보이게
+    const win = getInboxWindow();
+    if (win) {
+      if (win.isMinimized()) win.restore();
+      if (!win.isVisible()) win.show();
+      win.focus();
+    } else {
+      createInboxWindow();
+    }
+  });
+}
+
 app.whenReady().then(async () => {
   initLogger();
   logger.info('app.start', {
@@ -44,6 +79,9 @@ app.whenReady().then(async () => {
 
   const paths = resolveProfilePaths('default');
 
+  // v0.2.8 Cut A — `inkling-media://` request handler 등록 (profileDir 결정 후).
+  registerInklingMediaProtocol(paths.profileDir);
+
   const telemetry = new TelemetryService(join(paths.profileDir, 'telemetry'), () => new Date(), 14, { silent: true });
   void telemetry.cleanupOldFiles()
     .then((r) => logger.info('telemetry.cleanup', { removed: r.removed.length }))
@@ -56,6 +94,8 @@ app.whenReady().then(async () => {
       writeFileSync(initFlag, new Date().toISOString());
       logger.info('autostart.enabled.firstRun');
     }
+    // v0.2.6 #45 진단 — startup 로그. 같은 정보가 SettingsPage 진단 패널에도 surface (collectAutostartState single source of truth).
+    void collectAutostartState().then((state) => logger.info('autostart.state', { ...state }));
   }
   const db = openDb(paths.dbFile);
   const repo = new NoteRepository(db);
@@ -63,17 +103,28 @@ app.whenReady().then(async () => {
   const continuity = new ContinuityService(db);
   const intent = new IntentService(repo);
 
-  const resolvedEndpoint = process.env.INKLING_OLLAMA_ENDPOINT ?? 'http://localhost:11434';
+  const settingsSvc = new SettingsService(paths.profileDir);
+  const settings = await settingsSvc.load();
+
+  const resolvedEndpoint = settings.ollama?.endpoint
+                         ?? process.env.INKLING_OLLAMA_ENDPOINT
+                         ?? DEFAULT_OLLAMA_ENDPOINT;
+  const resolvedModel = settings.ollama?.model ?? DEFAULT_OLLAMA_MODEL;
+
   logger.info('ai.endpoint', {
     endpoint: resolvedEndpoint,
-    fromEnv: process.env.INKLING_OLLAMA_ENDPOINT !== undefined
+    model: resolvedModel,
+    source: settings.ollama?.endpoint
+      ? 'settings'
+      : (process.env.INKLING_OLLAMA_ENDPOINT ? 'env' : 'default')
   });
-  const provider = new LocalOllamaProvider({ endpoint: resolvedEndpoint });
+
-  const health = new HealthChecker(provider, {
+  const provider = new LocalOllamaProvider({ endpoint: resolvedEndpoint, model: resolvedModel });
+  const providerHolder = new ProviderHolder(provider);
+  const health = new HealthChecker(providerHolder, {
     onUpdate: (status) => {
       logger.info('ai.health', { ...status } as Record<string, unknown>);
       pushOllamaStatus(getInboxWindow, status);
-      refreshTrayOllama(status.ok);
     },
     onTelemetry: (ev) => {
       if (ev.kind === 'ollama_unreachable') {
@@ -87,12 +138,12 @@ app.whenReady().then(async () => {
   });
   health.start();
 
-  const worker = new AiWorker(repo, provider, {
+  const worker = new AiWorker(repo, providerHolder, {
     onUpdate: (note) => {
       pushNoteUpdated(getInboxWindow, note);
       // F4-C: AI 처리 완료 = 새 캡처가 inbox 에 합류한 시점, tray 도 즉시 갱신.
-      refreshTray(repo.countToday());
+      // v0.2.7 Phase 3 — failedCount 메뉴 항목 제거됨 → todayCount 만 갱신.
-      refreshTrayFailedCount(repo.countFailed());
+      refreshTray({ todayCount: repo.countToday() });
     },
     logger,
     telemetry
@@ -114,8 +165,11 @@ app.whenReady().then(async () => {
   registerCaptureApi(capture, getQuickCaptureWindow);
   registerInboxApi({
     repo, continuity, capture, health, intent,
-    getInboxWindow
+    getInboxWindow, settings: settingsSvc, providerHolder,
+    paths: { profileDir: paths.profileDir }
   });
+  // registerSettingsApi 는 backup / exportSvc / importSvc / syncSvc / telemetry 가
+  // 생성된 뒤에 호출 (Task 10) — 아래 BackupService/ExportService/... 초기화 직후로 이동.
 
   const hotkeys = new HotkeyService();
   const reg = hotkeys.register({
@@ -131,7 +185,9 @@ app.whenReady().then(async () => {
   await worker.loadFromDb();
 
   const gc = new MediaGc(db, store);
-  void gc.run().then((r) => logger.info('media.gc', { ...r } as Record<string, unknown>));
+  void gc.run()
+    .then((r) => logger.info('media.gc', { ...r } as Record<string, unknown>))
+    .catch((e) => logger.warn('media.gc.failed', { reason: String(e) }));
 
   const exportSvc = new ExportService(repo, store);
   const importSvc = new ImportService(repo, store);
@@ -142,6 +198,12 @@ app.whenReady().then(async () => {
     .then((r) => logger.info('backup.daily', { ...r } as Record<string, unknown>))
     .catch((e) => logger.warn('backup.daily.failed', { reason: String(e) }));
 
+  // v0.2.7 Task 10 — 설정 페이지 IPC (autostart + backup/export/import/sync/telemetry).
+  // backup / exportSvc / importSvc / syncSvc / telemetry 가 모두 준비된 뒤 등록.
+  registerSettingsApi({
+    backup, exportSvc, importSvc, syncSvc, telemetry, getInboxWindow
+  });
+
   let backupOnQuitDone = false;
   let trayInterval: NodeJS.Timeout | null = null;
   app.on('before-quit', (e) => {
@@ -174,190 +236,34 @@ app.whenReady().then(async () => {
       });
   });
 
-  createTray(
+  // v0.2.7 Phase 3 (Task 16) — TrayCallbacks 슬림: 10 → 3.
-    () => createInboxWindow(),
+  // 백업/내보내기/복원/동기화/사용 로그/Ollama 재확인/AI 재처리/Ollama 설정/정보 →
-    () => showQuickCapture(),
+  // 모두 설정 페이지로 이전 (registerSettingsApi 의 IPC 핸들러가 본문 보유).
-    async () => {
+  createTray({
-      try {
+    showInbox: () => createInboxWindow(),
-        const r = await backup.runDaily();
+    showCapture: () => showQuickCapture(),
-        new Notification({
+    showSettings: () => navigateInbox('settings')
-          title: 'Inkling',
+  });
-          body: r.snapshotted
-            ? `백업 완료 — ${r.removed?.length ?? 0}개 정리`
-            : `오늘 백업이 이미 있습니다`,
-          silent: true
-        }).show();
-      } catch (e) {
-        logger.warn('backup.manual.failed', { reason: String(e) });
-        new Notification({
-          title: 'Inkling',
-          body: '백업을 만들지 못했습니다.',
-          silent: true
-        }).show();
-      }
-    },
-    async () => {
-      const win = getInboxWindow();
-      const dialogOpts: Electron.OpenDialogOptions = {
-        title: '내보낼 폴더 선택',
-        message: '선택한 폴더에 노트를 마크다운으로 내보냅니다. 이미지가 함께 포함됩니다. raw_text 가 평문으로 보관되니 비공개 위치를 권장합니다.',
-        buttonLabel: '여기에 내보내기',
-        properties: ['openDirectory', 'createDirectory']
-      };
-      const result = win
-        ? await dialog.showOpenDialog(win, dialogOpts)
-        : await dialog.showOpenDialog(dialogOpts);
-      if (result.canceled || result.filePaths.length === 0) return;
-      try {
-        const r = await exportSvc.export(result.filePaths[0]!, { includeMedia: true });
-        logger.info('export.done', {
-          outDir: r.outDir,
-          noteCount: r.noteCount,
-          mediaCount: r.mediaCount,
-          bytes: r.bytes
-        });
-        new Notification({
-          title: 'Inkling',
-          body: `내보내기 완료 — 노트 ${r.noteCount}개, 이미지 ${r.mediaCount}개`,
-          silent: true
-        }).show();
-      } catch (e) {
-        logger.warn('export.failed', { reason: String(e) });
-        new Notification({
-          title: 'Inkling',
-          body: '내보내기를 완료하지 못했습니다.',
-          silent: true
-        }).show();
-      }
-    },
-    async () => {
-      const win = getInboxWindow();
-      const dirOpts: Electron.OpenDialogOptions = {
-        title: '복원할 백업 폴더 선택',
-        message: 'F5 export 형식의 폴더를 선택하세요. notes/ 하위의 마크다운 파일이 적재됩니다.',
-        buttonLabel: '여기서 복원',
-        properties: ['openDirectory']
-      };
-      const dirResult = win
-        ? await dialog.showOpenDialog(win, dirOpts)
-        : await dialog.showOpenDialog(dirOpts);
-      if (dirResult.canceled || dirResult.filePaths.length === 0) return;
-      const sourceDir = dirResult.filePaths[0]!;
-      let plan;
-      try {
-        plan = await importSvc.preview(sourceDir);
-      } catch (e) {
-        logger.warn('import.preview.failed', { reason: String(e) });
-        new Notification({
-          title: 'Inkling',
-          body: '백업 폴더를 읽지 못했습니다.',
-          silent: true
-        }).show();
-        return;
-      }
-      const detail = `총 ${plan.total}개 노트\n  · 신규 ${plan.newCount}개\n  · 동일 (스킵) ${plan.unchangedCount}개\n  · 충돌→새 id (${plan.forkedCount}개, raw_text 보존)\n\n이미지 ${plan.mediaCount}개 복사 예정.`;
-      const confirmOpts: Electron.MessageBoxOptions = {
-        type: 'question',
-        buttons: ['복원', '취소'],
-        defaultId: 0,
-        cancelId: 1,
-        title: 'Inkling 복원',
-        message: '복원 미리보기',
-        detail
-      };
-      const confirm = win
-        ? await dialog.showMessageBox(win, confirmOpts)
-        : await dialog.showMessageBox(confirmOpts);
-      if (confirm.response !== 0) return;
-      try {
-        const r = await importSvc.run(sourceDir);
-        logger.info('import.done', {
-          total: r.total,
-          new: r.newCount,
-          unchanged: r.unchangedCount,
-          forked: r.forkedCount,
-          media: r.mediaCount
-        });
-        new Notification({
-          title: 'Inkling',
-          body: `복원 완료 — 신규 ${r.newCount}개, 스킵 ${r.unchangedCount}개, 충돌 ${r.forkedCount}개`,
-          silent: true
-        }).show();
-      } catch (e) {
-        logger.warn('import.run.failed', { reason: String(e) });
-        new Notification({
-          title: 'Inkling',
-          body: '복원을 완료하지 못했습니다.',
-          silent: true
-        }).show();
-      }
-    },
-    async () => {
-      // runSync — 트레이 "지금 동기화"
-      try {
-        const r = await syncSvc.sync();
-        if (!r.ok) {
-          logger.warn('sync.failed', { reason: r.reason });
-          const body = r.reason === 'not_configured'
-            ? `${syncSvc.getSyncDir()} 에서 git init + remote 설정이 필요합니다.`
-            : '동기화를 완료하지 못했습니다.';
-          new Notification({ title: 'Inkling', body, silent: true }).show();
-          return;
-        }
-        if (r.changed) {
-          logger.info('sync.done', { sha: r.sha, pushed: r.pushed });
-          new Notification({ title: 'Inkling', body: '동기화 완료', silent: true }).show();
-        } else {
-          new Notification({ title: 'Inkling', body: '변경 사항 없음', silent: true }).show();
-        }
-      } catch (e) {
-        logger.warn('sync.exception', { reason: String(e) });
-        new Notification({ title: 'Inkling', body: '동기화를 완료하지 못했습니다.', silent: true }).show();
-      }
-    },
-    /* runExportTelemetry */ async () => {
-      const win = getInboxWindow();
-      const dialogOpts: Electron.OpenDialogOptions = {
-        title: '사용 로그를 내보낼 폴더 선택',
-        message: '선택한 폴더에 events.jsonl + stats.md 가 생성됩니다. raw_text/요약/제목/태그 이름은 미포함입니다.',
-        buttonLabel: '여기로 내보내기',
-        properties: ['openDirectory', 'createDirectory']
-      };
-      const result = win
-        ? await dialog.showOpenDialog(win, dialogOpts)
-        : await dialog.showOpenDialog(dialogOpts);
-      if (result.canceled || result.filePaths.length === 0) return;
-      try {
-        const r = await telemetry.exportTo(result.filePaths[0]!);
-        logger.info('telemetry.export', { eventCount: r.eventCount, outDir: result.filePaths[0] });
-        new Notification({
-          title: 'Inkling',
-          body: `사용 로그 내보내기 완료 — ${r.eventCount}개 이벤트`,
-          silent: true
-        }).show();
-      } catch (e) {
-        logger.warn('telemetry.export.failed', { reason: String(e) });
-        new Notification({
-          title: 'Inkling',
-          body: '사용 로그 내보내기를 완료하지 못했습니다.',
-          silent: true
-        }).show();
-      }
-    },
-    /* runOllamaRecheck */ () => { void health.runOnce({ manual: true }); },
-    /* runRetryAllFailed */ () => { void capture.retryAllFailed(); }
-  );
 
   // F4-C 환경 앵커 — tray tooltip + 메뉴 첫 항목을 오늘 KST 캡처 수로 갱신.
   // 초기 1회 + 60s interval. AiWorker.onUpdate 도 별도 갱신 트리거.
   // cleanup 은 위 통합 before-quit 핸들러에서 처리.
-  refreshTray(repo.countToday());
+  // v0.2.7 Phase 3 — failedCount 메뉴 항목 제거됨 → todayCount 만 갱신.
-  refreshTrayFailedCount(repo.countFailed());
+  refreshTray({ todayCount: repo.countToday() });
   trayInterval = setInterval(() => {
-    refreshTray(repo.countToday());
+    refreshTray({ todayCount: repo.countToday() });
   }, 60_000);
 
+  // F14 (v0.2.7) — macOS dock 클릭 시 hidden inbox 창 show/focus.
+  // 기존: BrowserWindow.getAllWindows().length === 0 만 검사 → quickCapture 등이
+  // 떠 있으면 inbox 창이 hidden 인 채로 남았음.
   app.on('activate', () => {
-    if (BrowserWindow.getAllWindows().length === 0) createInboxWindow();
+    const win = getInboxWindow();
+    if (win && !win.isDestroyed()) {
+      if (!win.isVisible()) win.show();
+      win.focus();
+    } else {
+      createInboxWindow();
+    }
   });
 });

src/main/ipc/inboxApi.ts

@@ -1,6 +1,7 @@
 import electron from 'electron';
 import type { BrowserWindow } from 'electron';
-const { ipcMain, dialog } = electron;
+const { ipcMain, dialog, shell } = electron;
+import { join, normalize, sep } from 'node:path';
 import type { NoteRepository } from '../repository/NoteRepository.js';
 import type { ContinuityService } from '../services/ContinuityService.js';
 import type { CaptureService } from '../services/CaptureService.js';
@@ -8,6 +9,9 @@ import type { HealthChecker } from '../services/HealthChecker.js';
 import type { IntentService } from '../services/IntentService.js';
 import type { Note } from '@shared/types';
 import type { HealthResult } from '../ai/InferenceProvider.js';
+import { LocalOllamaProvider } from '../ai/LocalOllamaProvider.js';
+import type { SettingsService } from '../services/SettingsService.js';
+import type { ProviderHolder } from '../ai/ProviderHolder.js';
 
 export interface InboxIpcDeps {
   repo: NoteRepository;
@@ -16,6 +20,10 @@ export interface InboxIpcDeps {
   health: HealthChecker;
   intent: IntentService;
   getInboxWindow: () => BrowserWindow | null;
+  settings: SettingsService;
+  providerHolder: ProviderHolder;
+  // v0.2.8 Cut A — `inbox:open-media` 의 path traversal 검사 baseline.
+  paths: { profileDir: string };
 }
 
 export function registerInboxApi(deps: InboxIpcDeps): void {
@@ -34,7 +42,7 @@ export function registerInboxApi(deps: InboxIpcDeps): void {
     deps.repo.setDueDate(arg.noteId, arg.date);
   });
 
-  ipcMain.handle('inbox:delete', async (_e, noteId: string) => {
+  ipcMain.handle('inbox:trash', async (_e, noteId: string) => {
     await deps.capture.deleteNote(noteId);
   });
 
@@ -142,6 +150,44 @@ export function registerInboxApi(deps: InboxIpcDeps): void {
   ipcMain.handle('inbox:dismissRecall', (_e, id: string) => deps.capture.dismissRecall(id));
   ipcMain.handle('inbox:emitRecallShown', (_e, id: string) => deps.capture.emitRecallShown(id));
   ipcMain.handle('inbox:emitRecallSnoozed', (_e, id: string) => deps.capture.emitRecallSnoozed(id));
+
+  ipcMain.handle('inbox:loadOllamaSettings', async () => {
+    const s = await deps.settings.load();
+    return s.ollama ?? null;
+  });
+
+  // v0.2.8 Cut A — 첨부 이미지 클릭 시 OS 기본 뷰어로 열기 (Task 3).
+  // path traversal 검사는 inkling-media:// protocol handler 와 동일한 패턴 (Task 1).
+  ipcMain.handle('inbox:open-media', async (_e, relPath: string) => {
+    if (typeof relPath !== 'string' || relPath.length === 0) {
+      return { ok: false as const, reason: 'invalid path' as const };
+    }
+    const profileDir = deps.paths.profileDir;
+    const mediaRoot = join(profileDir, 'media');
+    const target = normalize(join(profileDir, relPath));
+    if (!target.startsWith(mediaRoot + sep) && target !== mediaRoot) {
+      return { ok: false as const, reason: 'invalid path' as const };
+    }
+    await shell.openPath(target);
+    return { ok: true as const };
+  });
+
+  ipcMain.handle('inbox:saveOllamaSettings', async (_e, value: { endpoint: string; model: string }) => {
+    // 검증: 새 인스턴스로 healthCheck
+    const trial = new LocalOllamaProvider({ endpoint: value.endpoint, model: value.model });
+    const r = await trial.healthCheck();
+    if (!r.ok) return { ok: false, reason: r.reason ?? 'unknown' };
+    try {
+      await deps.settings.setOllama(value);
+    } catch (e) {
+      return { ok: false, reason: `persist failed: ${(e as Error).message}` };
+    }
+    deps.providerHolder.get().abort?.();
+    deps.providerHolder.replace(trial);
+    // 즉시 health 재확인 → onUpdate callback 통해 OllamaBanner 자동 갱신
+    await deps.health.runOnce();
+    return { ok: true };
+  });
 }
 
 export function pushNoteUpdated(getWin: () => BrowserWindow | null, note: Note): void {

src/main/ipc/settingsApi.ts

@@ -0,0 +1,268 @@
+import electron from 'electron';
+import type { BrowserWindow } from 'electron';
+import { platform, release, EOL } from 'node:os';
+const { ipcMain, app, dialog, Notification, shell, clipboard } = electron;
+import { logger } from '../logger.js';
+import type { BackupService } from '../services/BackupService.js';
+import type { ExportService } from '../services/ExportService.js';
+import type { ImportService } from '../services/ImportService.js';
+import type { SyncService } from '../services/SyncService.js';
+import type { TelemetryService } from '../services/TelemetryService.js';
+import { collectAutostartState } from '../services/AutostartDiagnostic.js';
+import { getInboxWindow as getInboxWindowSingleton } from '../windows/inboxWindow.js';
+
+/**
+ * 외부 (트레이 / second-instance / 기타 main 프로세스 호출자) 에서 inbox 창에 view 전환을
+ * 요청하는 진입점. 창이 숨겨져 있으면 show + focus 후 'inbox:navigate' IPC 이벤트를
+ * renderer 로 전달.
+ *
+ * Task 13 (v0.2.7) — 트레이 "설정..." 메뉴 wiring 은 Task 16 에서 본 함수 호출.
+ */
+export function navigateInbox(view: 'inbox' | 'trash' | 'settings'): void {
+  const win = getInboxWindowSingleton();
+  if (win && !win.isDestroyed()) {
+    if (!win.isVisible()) win.show();
+    win.focus();
+    win.webContents.send('inbox:navigate', view);
+  }
+}
+
+export interface SettingsIpcDeps {
+  backup: BackupService;
+  exportSvc: ExportService;
+  importSvc: ImportService;
+  syncSvc: SyncService;
+  telemetry: TelemetryService;
+  getInboxWindow: () => BrowserWindow | null;
+}
+
+/**
+ * v0.2.7 설정 페이지 IPC 핸들러.
+ *
+ * - 자동 실행 (Task 22 통일): `settings:autostart-state` (조회) / `settings:autostart-set` (변경).
+ *   둘 다 `{ openAtLogin, diagnostic }` 반환 — diagnostic 은 withArgs/noArgs/execPath/registry 진단.
+ *   args=['--hidden'] 명시 — 자동 실행 시 백그라운드 모드로 시작 (Quick Capture only).
+ *
+ * - 백업/내보내기/복원/동기화/사용 로그 (Task 10): 기존 `src/main/index.ts` 트레이 callback
+ *   (runBackup, runExport, runImport, runSync, runExportTelemetry) 본문을 그대로 IPC 핸들러로
+ *   복사. 트레이 callback 자체 제거는 Task 16 (Phase 3) — 본 task 에선 잔류 (의도적 중복).
+ */
+export function registerSettingsApi(deps?: SettingsIpcDeps): void {
+  // v0.2.7 F12 deeper fix (Task 21~22) — 진단 정보 포함된 autostart 상태 조회/변경.
+  // 옛 'settings:get-autostart' / 'settings:set-autostart' 채널은 본 통일에서 제거됨.
+  ipcMain.handle('settings:autostart-state', async () => {
+    const diag = await collectAutostartState();
+    return { openAtLogin: diag.withArgs.openAtLogin, diagnostic: diag };
+  });
+
+  ipcMain.handle('settings:autostart-set', async (_e, open: boolean) => {
+    app.setLoginItemSettings({ openAtLogin: open, args: ['--hidden'] });
+    const diag = await collectAutostartState();
+    return { openAtLogin: diag.withArgs.openAtLogin, diagnostic: diag };
+  });
+
+  // v0.2.7 정보 섹션 (Task 11) — 트레이 showAboutDialog 의 detail 형식 그대로 (clipboard 일관성).
+  // 트레이 showAboutDialog 자체 제거는 Task 25 (Phase 6 cleanup) — 본 task 는 추가만.
+  ipcMain.handle('settings:get-app-info', () => ({
+    version: app.getVersion(),
+    electron: process.versions.electron ?? '?',
+    node: process.versions.node ?? '?',
+    os: `${platform()} ${release()}`,
+    profileDir: app.getPath('userData')
+  }));
+
+  ipcMain.handle('settings:open-profile-dir', async () => {
+    await shell.openPath(app.getPath('userData'));
+  });
+
+  ipcMain.handle('settings:copy-app-info', () => {
+    const v = app.getVersion();
+    const detail = [
+      `버전: ${v}`,
+      `Electron: ${process.versions.electron ?? '?'}`,
+      `Node: ${process.versions.node ?? '?'}`,
+      `OS: ${platform()} ${release()}`,
+      `데이터 위치: ${app.getPath('userData')}`
+    ].join(EOL);
+    clipboard.writeText(`Inkling ${v}${EOL}${detail}`);
+  });
+
+  if (!deps) return;
+  const { backup, exportSvc, importSvc, syncSvc, telemetry, getInboxWindow } = deps;
+
+  ipcMain.handle('settings:run-backup', async () => {
+    try {
+      const r = await backup.runDaily();
+      new Notification({
+        title: 'Inkling',
+        body: r.snapshotted
+          ? `백업 완료 — ${r.removed?.length ?? 0}개 정리`
+          : `오늘 백업이 이미 있습니다`,
+        silent: true
+      }).show();
+    } catch (e) {
+      logger.warn('backup.manual.failed', { reason: String(e) });
+      new Notification({
+        title: 'Inkling',
+        body: '백업을 만들지 못했습니다.',
+        silent: true
+      }).show();
+    }
+    return { ok: true } as const;
+  });
+
+  ipcMain.handle('settings:run-export', async () => {
+    const win = getInboxWindow();
+    const dialogOpts: Electron.OpenDialogOptions = {
+      title: '내보낼 폴더 선택',
+      message: '선택한 폴더에 노트를 마크다운으로 내보냅니다. 이미지가 함께 포함됩니다. raw_text 가 평문으로 보관되니 비공개 위치를 권장합니다.',
+      buttonLabel: '여기에 내보내기',
+      properties: ['openDirectory', 'createDirectory']
+    };
+    const result = win
+      ? await dialog.showOpenDialog(win, dialogOpts)
+      : await dialog.showOpenDialog(dialogOpts);
+    if (result.canceled || result.filePaths.length === 0) return { ok: true } as const;
+    try {
+      const r = await exportSvc.export(result.filePaths[0]!, { includeMedia: true });
+      logger.info('export.done', {
+        outDir: r.outDir,
+        noteCount: r.noteCount,
+        mediaCount: r.mediaCount,
+        bytes: r.bytes
+      });
+      new Notification({
+        title: 'Inkling',
+        body: `내보내기 완료 — 노트 ${r.noteCount}개, 이미지 ${r.mediaCount}개`,
+        silent: true
+      }).show();
+    } catch (e) {
+      logger.warn('export.failed', { reason: String(e) });
+      new Notification({
+        title: 'Inkling',
+        body: '내보내기를 완료하지 못했습니다.',
+        silent: true
+      }).show();
+    }
+    return { ok: true } as const;
+  });
+
+  ipcMain.handle('settings:run-import', async () => {
+    const win = getInboxWindow();
+    const dirOpts: Electron.OpenDialogOptions = {
+      title: '복원할 백업 폴더 선택',
+      message: 'F5 export 형식의 폴더를 선택하세요. notes/ 하위의 마크다운 파일이 적재됩니다.',
+      buttonLabel: '여기서 복원',
+      properties: ['openDirectory']
+    };
+    const dirResult = win
+      ? await dialog.showOpenDialog(win, dirOpts)
+      : await dialog.showOpenDialog(dirOpts);
+    if (dirResult.canceled || dirResult.filePaths.length === 0) return { ok: true } as const;
+    const sourceDir = dirResult.filePaths[0]!;
+    let plan;
+    try {
+      plan = await importSvc.preview(sourceDir);
+    } catch (e) {
+      logger.warn('import.preview.failed', { reason: String(e) });
+      new Notification({
+        title: 'Inkling',
+        body: '백업 폴더를 읽지 못했습니다.',
+        silent: true
+      }).show();
+      return { ok: true } as const;
+    }
+    const detail = `총 ${plan.total}개 노트\n  · 신규 ${plan.newCount}개\n  · 동일 (스킵) ${plan.unchangedCount}개\n  · 충돌→새 id (${plan.forkedCount}개, raw_text 보존)\n\n이미지 ${plan.mediaCount}개 복사 예정.`;
+    const confirmOpts: Electron.MessageBoxOptions = {
+      type: 'question',
+      buttons: ['복원', '취소'],
+      defaultId: 0,
+      cancelId: 1,
+      title: 'Inkling 복원',
+      message: '복원 미리보기',
+      detail
+    };
+    const confirm = win
+      ? await dialog.showMessageBox(win, confirmOpts)
+      : await dialog.showMessageBox(confirmOpts);
+    if (confirm.response !== 0) return { ok: true } as const;
+    try {
+      const r = await importSvc.run(sourceDir);
+      logger.info('import.done', {
+        total: r.total,
+        new: r.newCount,
+        unchanged: r.unchangedCount,
+        forked: r.forkedCount,
+        media: r.mediaCount
+      });
+      new Notification({
+        title: 'Inkling',
+        body: `복원 완료 — 신규 ${r.newCount}개, 스킵 ${r.unchangedCount}개, 충돌 ${r.forkedCount}개`,
+        silent: true
+      }).show();
+    } catch (e) {
+      logger.warn('import.run.failed', { reason: String(e) });
+      new Notification({
+        title: 'Inkling',
+        body: '복원을 완료하지 못했습니다.',
+        silent: true
+      }).show();
+    }
+    return { ok: true } as const;
+  });
+
+  ipcMain.handle('settings:run-sync', async () => {
+    try {
+      const r = await syncSvc.sync();
+      if (!r.ok) {
+        logger.warn('sync.failed', { reason: r.reason });
+        const body = r.reason === 'not_configured'
+          ? `${syncSvc.getSyncDir()} 에서 git init + remote 설정이 필요합니다.`
+          : '동기화를 완료하지 못했습니다.';
+        new Notification({ title: 'Inkling', body, silent: true }).show();
+        return { ok: true } as const;
+      }
+      if (r.changed) {
+        logger.info('sync.done', { sha: r.sha, pushed: r.pushed });
+        new Notification({ title: 'Inkling', body: '동기화 완료', silent: true }).show();
+      } else {
+        new Notification({ title: 'Inkling', body: '변경 사항 없음', silent: true }).show();
+      }
+    } catch (e) {
+      logger.warn('sync.exception', { reason: String(e) });
+      new Notification({ title: 'Inkling', body: '동기화를 완료하지 못했습니다.', silent: true }).show();
+    }
+    return { ok: true } as const;
+  });
+
+  ipcMain.handle('settings:run-export-telemetry', async () => {
+    const win = getInboxWindow();
+    const dialogOpts: Electron.OpenDialogOptions = {
+      title: '사용 로그를 내보낼 폴더 선택',
+      message: '선택한 폴더에 events.jsonl + stats.md 가 생성됩니다. raw_text/요약/제목/태그 이름은 미포함입니다.',
+      buttonLabel: '여기로 내보내기',
+      properties: ['openDirectory', 'createDirectory']
+    };
+    const result = win
+      ? await dialog.showOpenDialog(win, dialogOpts)
+      : await dialog.showOpenDialog(dialogOpts);
+    if (result.canceled || result.filePaths.length === 0) return { ok: true } as const;
+    try {
+      const r = await telemetry.exportTo(result.filePaths[0]!);
+      logger.info('telemetry.export', { eventCount: r.eventCount, outDir: result.filePaths[0] });
+      new Notification({
+        title: 'Inkling',
+        body: `사용 로그 내보내기 완료 — ${r.eventCount}개 이벤트`,
+        silent: true
+      }).show();
+    } catch (e) {
+      logger.warn('telemetry.export.failed', { reason: String(e) });
+      new Notification({
+        title: 'Inkling',
+        body: '사용 로그 내보내기를 완료하지 못했습니다.',
+        silent: true
+      }).show();
+    }
+    return { ok: true } as const;
+  });
+}

src/main/protocol/inklingMedia.ts

@@ -0,0 +1,54 @@
+import electron from 'electron';
+import { readFile } from 'node:fs/promises';
+import { join, normalize, sep, extname } from 'node:path';
+
+const { protocol } = electron;
+
+export function registerSchemesAsPrivileged(): void {
+  protocol.registerSchemesAsPrivileged([
+    { scheme: 'inkling-media', privileges: { secure: true, supportFetchAPI: true, stream: true } }
+  ]);
+}
+
+export function inferMime(filename: string): string {
+  const ext = extname(filename).toLowerCase();
+  switch (ext) {
+    case '.png': return 'image/png';
+    case '.jpg':
+    case '.jpeg': return 'image/jpeg';
+    case '.gif': return 'image/gif';
+    case '.webp': return 'image/webp';
+    default: return 'application/octet-stream';
+  }
+}
+
+export function registerInklingMediaProtocol(profileDir: string): void {
+  const mediaRoot = join(profileDir, 'media');
+  protocol.handle('inkling-media', async (req) => {
+    // Raw URL 에서 `..` 세그먼트 (URL-encoded 포함) 검출 — `new URL()` 이 normalize 하기 전에 차단.
+    const rawLower = req.url.toLowerCase();
+    if (
+      rawLower.includes('/../') ||
+      rawLower.endsWith('/..') ||
+      rawLower.includes('/%2e%2e/') ||
+      rawLower.endsWith('/%2e%2e')
+    ) {
+      return new Response(null, { status: 403 });
+    }
+    const url = new URL(req.url);
+    // inkling-media://media/<noteId>/<file> → host='media', pathname='/<noteId>/<file>'
+    const relPath = decodeURIComponent(`${url.host}${url.pathname}`);
+    const target = normalize(join(profileDir, relPath));
+    if (!target.startsWith(mediaRoot + sep) && target !== mediaRoot) {
+      return new Response(null, { status: 403 });
+    }
+    try {
+      const data = await readFile(target);
+      return new Response(new Uint8Array(data), {
+        headers: { 'content-type': inferMime(target) }
+      });
+    } catch {
+      return new Response(null, { status: 404 });
+    }
+  });
+}

src/main/repository/NoteRepository.ts

@@ -1,7 +1,7 @@
 import type Database from 'better-sqlite3';
 import { v7 as uuidv7, v4 as uuidv4 } from 'uuid';
 import type { Note, NoteMedia, NoteTag } from '@shared/types';
-import { todayInKstString } from '../util/kstDate.js';
+import { kstTodayIso } from '../../shared/util/kstDate.js';
 
 export interface CreateNoteInput { rawText: string; }
 
@@ -78,7 +78,7 @@ export class NoteRepository {
   }
 
   findById(id: string): Note | null {
-    const row = this.db.prepare('SELECT * FROM notes WHERE id=?').get(id) as any;
+    const row = this.db.prepare('SELECT * FROM notes WHERE id=?').get(id) as Record<string, unknown>;
     if (!row) return null;
     return this.hydrate(row);
   }
@@ -92,21 +92,21 @@ export class NoteRepository {
               WHERE deleted_at IS NULL AND created_at < ?
               ORDER BY created_at DESC, id DESC LIMIT ?`
           )
-          .all(opts.cursor, limit) as any[])
+          .all(opts.cursor, limit) as Record<string, unknown>[])
       : (this.db
           .prepare(
             `SELECT * FROM notes
               WHERE deleted_at IS NULL
               ORDER BY created_at DESC, id DESC LIMIT ?`
           )
-          .all(limit) as any[]);
+          .all(limit) as Record<string, unknown>[]);
     return rows.map((r) => this.hydrate(r));
   }
 
   listAll(): Note[] {
     const rows = this.db
       .prepare(`SELECT * FROM notes WHERE deleted_at IS NULL ORDER BY created_at ASC, id ASC`)
-      .all() as any[];
+      .all() as Record<string, unknown>[];
     return rows.map((r) => this.hydrate(r));
   }
 
@@ -410,6 +410,31 @@ export class NoteRepository {
       .run(now, id);
   }
 
+  restoreNote(id: string): void {
+    const tx = this.db.transaction(() => {
+      const before = this.db.prepare(`SELECT ai_status FROM notes WHERE id = ?`).get(id) as { ai_status: string } | undefined;
+      const now = new Date().toISOString();
+      this.db.prepare(`UPDATE notes SET deleted_at = NULL, updated_at = ? WHERE id = ?`).run(now, id);
+
+      // v0.2.6 #10 — failed 노트 restore 시 pending 으로 reset + pending_jobs 재생성
+      if (before?.ai_status === 'failed') {
+        this.db.prepare(
+          `UPDATE notes SET ai_status='pending', ai_error=NULL, updated_at=? WHERE id=?`
+        ).run(now, id);
+        this.db.prepare(
+          `INSERT OR IGNORE INTO pending_jobs (note_id, attempts, next_run_at) VALUES (?, 0, ?)`
+        ).run(id, now);
+      } else if (before?.ai_status === 'pending') {
+        // pending 인 채로 trash 됐다면 pending_jobs 도 미정상 상태일 수 있음 — 재생성 (idempotent)
+        this.db.prepare(
+          `INSERT OR IGNORE INTO pending_jobs (note_id, attempts, next_run_at) VALUES (?, 0, ?)`
+        ).run(id, now);
+      }
+      // done 노트는 재처리 안 함 (이미 결과 있음)
+    });
+    tx();
+  }
+
   permanentDelete(id: string): void {
     this.db.prepare('DELETE FROM notes WHERE id=?').run(id);
   }
@@ -428,7 +453,7 @@ export class NoteRepository {
     const limit = Math.max(1, Math.min(200, opts.limit));
     const rows = this.db
       .prepare(`SELECT * FROM notes WHERE deleted_at IS NOT NULL ORDER BY deleted_at DESC, id DESC LIMIT ?`)
-      .all(limit) as any[];
+      .all(limit) as Record<string, unknown>[];
     return rows.map((r) => this.hydrate(r));
   }
 
@@ -576,7 +601,7 @@ export class NoteRepository {
    * Caller may inject `now` for testability; defaults to `new Date()`.
    */
   findExpiredCandidates(now: Date = new Date()): Note[] {
-    const today = todayInKstString(now);
+    const today = kstTodayIso(now);
     const rows = this.db
       .prepare(
         `SELECT * FROM notes
@@ -586,18 +611,18 @@ export class NoteRepository {
             AND ai_status = 'done'
           ORDER BY created_at DESC, id DESC`
       )
-      .all(today) as any[];
+      .all(today) as Record<string, unknown>[];
     return rows.map((r) => this.hydrate(r));
   }
 
   getAllPendingJobs(): Array<{ noteId: string; attempts: number; nextRunAt: string }> {
     const rows = this.db
       .prepare(`SELECT note_id, attempts, next_run_at FROM pending_jobs`)
-      .all() as any[];
+      .all() as Record<string, unknown>[];
     return rows.map((r) => ({
-      noteId: r.note_id,
+      noteId: r.note_id as string,
-      attempts: r.attempts,
+      attempts: r.attempts as number,
-      nextRunAt: r.next_run_at
+      nextRunAt: r.next_run_at as string
     }));
   }
 
@@ -613,39 +638,39 @@ export class NoteRepository {
       .run(nextRunAt, lastError.slice(0, 500), noteId);
   }
 
-  private hydrate(row: any): Note {
+  private hydrate(row: Record<string, unknown>): Note {
     const tags = this.db
       .prepare(
         `SELECT t.name, nt.source
            FROM note_tags nt JOIN tags t ON t.id = nt.tag_id
           WHERE nt.note_id = ? ORDER BY t.name`
       )
-      .all(row.id) as Array<{ name: string; source: 'ai' | 'user' }>;
+      .all(row.id as string) as Array<{ name: string; source: 'ai' | 'user' }>;
     const media = this.db
       .prepare(
         `SELECT id, kind, rel_path as relPath, mime, bytes FROM media WHERE note_id=?`
       )
-      .all(row.id) as NoteMedia[];
+      .all(row.id as string) as NoteMedia[];
     return {
-      id: row.id,
+      id: row.id as string,
-      rawText: row.raw_text,
+      rawText: row.raw_text as string,
-      aiTitle: row.ai_title,
+      aiTitle: row.ai_title as string | null,
-      aiSummary: row.ai_summary,
+      aiSummary: row.ai_summary as string | null,
-      aiStatus: row.ai_status,
+      aiStatus: row.ai_status as 'pending' | 'done' | 'failed',
-      aiError: row.ai_error,
+      aiError: row.ai_error as string | null,
-      aiProvider: row.ai_provider,
+      aiProvider: row.ai_provider as string | null,
-      aiGeneratedAt: row.ai_generated_at,
+      aiGeneratedAt: row.ai_generated_at as string | null,
-      titleEditedByUser: row.title_edited_by_user === 1,
+      titleEditedByUser: (row.title_edited_by_user as number) === 1,
-      summaryEditedByUser: row.summary_edited_by_user === 1,
+      summaryEditedByUser: (row.summary_edited_by_user as number) === 1,
-      userIntent: row.user_intent,
+      userIntent: row.user_intent as string | null,
-      intentPromptedAt: row.intent_prompted_at,
+      intentPromptedAt: row.intent_prompted_at as string | null,
-      dueDate: row.due_date ?? null,
+      dueDate: (row.due_date as string | null) ?? null,
-      dueDateEditedByUser: row.due_date_edited_by_user === 1,
+      dueDateEditedByUser: (row.due_date_edited_by_user as number) === 1,
-      deletedAt: row.deleted_at ?? null,
+      deletedAt: (row.deleted_at as string | null) ?? null,
-      lastRecalledAt: row.last_recalled_at ?? null,
+      lastRecalledAt: (row.last_recalled_at as string | null) ?? null,
-      recallDismissedAt: row.recall_dismissed_at ?? null,
+      recallDismissedAt: (row.recall_dismissed_at as string | null) ?? null,
-      createdAt: row.created_at,
+      createdAt: row.created_at as string,
-      updatedAt: row.updated_at,
+      updatedAt: row.updated_at as string,
       tags: tags as NoteTag[],
       media
     };

src/main/services/AutostartDiagnostic.ts

@@ -0,0 +1,56 @@
+import electron from 'electron';
+import { execFile } from 'node:child_process';
+const { app } = electron;
+
+/**
+ * v0.2.7 F12 deeper fix — 자동 실행 진단 정보 수집.
+ *
+ * Electron 의 `app.getLoginItemSettings()` 는 args 가 매칭돼야만 정확한 상태를 반환 →
+ * `args: ['--hidden']` 으로 등록 vs `args: undefined` 로 조회하면 mismatch 가 발생할 수 있다.
+ * 그래서 두 호출 결과를 모두 노출 (withArgs / noArgs) + Win 에서는 registry 직접 조회까지.
+ */
+export interface AutostartState {
+  withArgs: { openAtLogin: boolean; executableWillLaunchAtLogin: boolean };
+  noArgs: { openAtLogin: boolean; executableWillLaunchAtLogin: boolean };
+  execPath: string;
+  registryPath?: string;
+  registryValue?: string | null;
+}
+
+const WIN_REGISTRY_PATH = 'HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run';
+const WIN_REGISTRY_KEY = 'Inkling';
+
+export async function collectAutostartState(): Promise<AutostartState> {
+  const w = app.getLoginItemSettings({ args: ['--hidden'] });
+  const n = app.getLoginItemSettings();
+  const state: AutostartState = {
+    withArgs: { openAtLogin: w.openAtLogin, executableWillLaunchAtLogin: w.executableWillLaunchAtLogin },
+    noArgs: { openAtLogin: n.openAtLogin, executableWillLaunchAtLogin: n.executableWillLaunchAtLogin },
+    execPath: process.execPath
+  };
+  if (process.platform === 'win32') {
+    state.registryPath = `${WIN_REGISTRY_PATH}\\${WIN_REGISTRY_KEY}`;
+    state.registryValue = await readRegistrySilent();
+  }
+  return state;
+}
+
+/**
+ * `reg query` 로 HKCU\\...\\Run\\Inkling 의 값을 조회.
+ * 키가 없으면 reg.exe 가 exit 1 → silent fallback (null).
+ *
+ * promisify(execFile) 대신 직접 Promise 로 wrapping — 테스트에서 vi.mock 이
+ * `util.promisify.custom` symbol 을 보전하지 못해 stdout 이 undefined 가 되는 이슈 회피.
+ */
+function readRegistrySilent(): Promise<string | null> {
+  return new Promise((resolve) => {
+    execFile('reg', ['query', WIN_REGISTRY_PATH, '/v', WIN_REGISTRY_KEY], (err, stdout) => {
+      if (err) {
+        resolve(null);
+        return;
+      }
+      const m = stdout.match(/REG_SZ\s+(.+)/);
+      resolve(m && m[1] ? m[1].trim() : null);
+    });
+  });
+}

src/main/services/CaptureService.ts

@@ -88,9 +88,14 @@ export class CaptureService {
 
   async restoreNote(noteId: string): Promise<void> {
     // 이미 active 인 노트는 telemetry emit skip — restore/trash ratio 오염 방지.
-    const note = this.repo.findById(noteId);
+    const before = this.repo.findById(noteId);
-    if (!note || note.deletedAt === null) return;
+    if (!before || before.deletedAt === null) return;
-    this.repo.restore(noteId);
+    // v0.2.6 #10 — production path: repo.restoreNote (ai_status reset + pending_jobs 재생성)
+    this.repo.restoreNote(noteId);
+    // v0.2.6 #10 — in-memory AiWorker queue 갱신: DB 갱신만으로는 다음 앱 실행 시까지 처리 X
+    if (before.aiStatus === 'failed' || before.aiStatus === 'pending') {
+      await this.deps.enqueue(noteId);
+    }
     if (this.deps.telemetry) {
       await this.deps.telemetry.emit({ kind: 'restore', payload: { noteId } }).catch(() => {});
     }

src/main/services/HealthChecker.ts

@@ -1,4 +1,5 @@
-import type { InferenceProvider, HealthResult } from '../ai/InferenceProvider.js';
+import type { HealthResult } from '../ai/InferenceProvider.js';
+import { ProviderHolder } from '../ai/ProviderHolder.js';
 
 export type HealthTelemetryEvent =
   | { kind: 'ollama_unreachable'; reason: string }
@@ -28,7 +29,7 @@ export class HealthChecker {
   private now: () => number;
 
   constructor(
-    private provider: InferenceProvider,
+    private holder: ProviderHolder,
     private opts: HealthCheckerOptions = {}
   ) {
     this.intervalMs = opts.intervalMs ?? DEFAULT_INTERVAL_MS;
@@ -48,7 +49,7 @@ export class HealthChecker {
   }
 
   private async doRunOnce(): Promise<HealthResult> {
-    const next = await this.provider.healthCheck();
+    const next = await this.holder.get().healthCheck();
     const prev = this.last;
     const okChanged = prev.ok !== next.ok;
     const reasonChanged = prev.reason !== next.reason;

src/main/services/SettingsService.ts

@@ -0,0 +1,47 @@
+import { readFile, writeFile, mkdir, rename } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { z } from 'zod';
+
+const OllamaSettingsSchema = z.object({
+  endpoint: z.string().url(),
+  model: z.string().min(1)
+}).strict();
+
+const SettingsSchema = z.object({
+  ollama: OllamaSettingsSchema.optional()
+}).strict();
+
+export type Settings = z.infer<typeof SettingsSchema>;
+export type OllamaSettings = z.infer<typeof OllamaSettingsSchema>;
+
+export class SettingsService {
+  private filePath: string;
+  private cache: Settings | null = null;
+
+  constructor(profileDir: string) {
+    this.filePath = join(profileDir, 'settings.json');
+  }
+
+  async load(): Promise<Settings> {
+    if (this.cache !== null) return this.cache;
+    try {
+      const raw = await readFile(this.filePath, 'utf8');
+      const parsed = JSON.parse(raw);
+      this.cache = SettingsSchema.parse(parsed);
+    } catch {
+      this.cache = {};
+    }
+    return this.cache;
+  }
+
+  async setOllama(value: OllamaSettings): Promise<void> {
+    const validated = OllamaSettingsSchema.parse(value);
+    const current = await this.load();
+    const next: Settings = { ...current, ollama: validated };
+    await mkdir(dirname(this.filePath), { recursive: true });
+    const tmpPath = this.filePath + '.tmp';
+    await writeFile(tmpPath, JSON.stringify(next, null, 2), 'utf8');
+    await rename(tmpPath, this.filePath);
+    this.cache = next;
+  }
+}

src/main/services/TelemetryService.ts

@@ -1,15 +1,9 @@
 import { mkdir, appendFile, readFile, readdir, unlink, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { validateEvent, TelemetryEvent } from './telemetryEvents.js';
+import type { AiFailedReason } from './telemetryEvents.js';
 import { aggregateStats } from './telemetryStats.js';
-
+import { kstTodayIso, DAY_MS } from '../../shared/util/kstDate.js';
-const KST_OFFSET_MS = 9 * 60 * 60 * 1000;
-
-function todayKstIso(now: Date): string {
-  const k = new Date(now.getTime() + KST_OFFSET_MS);
-  return new Date(Date.UTC(k.getUTCFullYear(), k.getUTCMonth(), k.getUTCDate()))
-    .toISOString().slice(0, 10);
-}
 
 export interface TelemetryServiceOptions {
   silent?: boolean;
@@ -18,7 +12,7 @@ export interface TelemetryServiceOptions {
 export type EmitInput =
   | { kind: 'capture'; payload: { noteId: string; rawTextLength: number; hasMedia: boolean } }
   | { kind: 'ai_succeeded'; payload: { noteId: string; durationMs: number; attempts: number } }
-  | { kind: 'ai_failed'; payload: { noteId: string; reason: 'unreachable' | 'schema' | 'timeout' | 'other'; attempts: number } }
+  | { kind: 'ai_failed'; payload: { noteId: string; reason: AiFailedReason; attempts: number } }
   | { kind: 'trash'; payload: { noteId: string } }
   | { kind: 'restore'; payload: { noteId: string } }
   | { kind: 'permanent_delete'; payload: { noteId: string } }
@@ -52,8 +46,8 @@ export class TelemetryService {
     } catch {
       return { removed };
     }
-    const cutoff = new Date(this.now().getTime() - this.retentionDays * 24 * 60 * 60 * 1000);
+    const cutoff = new Date(this.now().getTime() - this.retentionDays * DAY_MS);
-    const cutoffIso = todayKstIso(cutoff);  // KST 일자 비교
+    const cutoffIso = kstTodayIso(cutoff);  // KST 일자 비교
     for (const name of entries) {
       const m = /^events-(\d{4}-\d{2}-\d{2})\.jsonl$/.exec(name);
       if (!m) continue;
@@ -76,7 +70,7 @@ export class TelemetryService {
     const nowDate = this.now();
     const ts = nowDate.toISOString();
     const event = validateEvent({ ts, kind: input.kind, payload: input.payload });
-    const filePath = join(this.dir, `events-${todayKstIso(nowDate)}.jsonl`);
+    const filePath = join(this.dir, `events-${kstTodayIso(nowDate)}.jsonl`);
     try {
       await mkdir(this.dir, { recursive: true });
       await appendFile(filePath, JSON.stringify(event) + '\n', 'utf8');
@@ -94,8 +88,8 @@ export class TelemetryService {
     } catch {
       return events;
     }
-    const cutoffMs = this.now().getTime() - this.retentionDays * 24 * 60 * 60 * 1000;
+    const cutoffMs = this.now().getTime() - this.retentionDays * DAY_MS;
-    const cutoffIso = todayKstIso(new Date(cutoffMs));
+    const cutoffIso = kstTodayIso(new Date(cutoffMs));
     // 회차 1 review (PR #13) — 매직 슬라이스 `n.slice(7, 17)` 대신 정규식 capture 그룹으로
     // 일자를 추출. prefix 변경 시 정규식 한 곳만 고치면 됨.
     const datePattern = /^events-(\d{4}-\d{2}-\d{2})\.jsonl$/;

src/main/services/telemetryEvents.ts

@@ -12,11 +12,12 @@ const AiSucceededPayload = z.object({
   attempts: z.number().int().nonnegative()
 }).strict();
 
-const AiFailedReason = z.enum(['unreachable', 'schema', 'timeout', 'other']);
+export const AiFailedReasonSchema = z.enum(['unreachable', 'schema', 'timeout', 'other']);
+export type AiFailedReason = z.infer<typeof AiFailedReasonSchema>;
 
 const AiFailedPayload = z.object({
   noteId: z.string().min(1),
-  reason: AiFailedReason,
+  reason: AiFailedReasonSchema,
   attempts: z.number().int().nonnegative()
 }).strict();
 
@@ -92,3 +93,23 @@ export type TelemetryKind = TelemetryEvent['kind'];
 export function validateEvent(raw: unknown): TelemetryEvent {
   return TelemetryEventSchema.parse(raw);
 }
+
+/**
+ * v0.2.6 #21 — type predicate helper. payload.noteId 가 있는 event kind 만 narrow.
+ * union 확장 시 NO_NOTE_ID_KINDS Set 한 곳만 갱신.
+ */
+const NO_NOTE_ID_KINDS = new Set<TelemetryKind>([
+  'empty_trash',
+  'expired_banner_shown',
+  'expired_batch_trash',
+  'ollama_unreachable',
+  'ollama_recovered',
+  'ollama_recheck_manual',
+  'ai_retry_manual',
+  'tag_vocab_hit',
+  'tag_vocab_miss'
+]);
+
+export function hasNoteId(ev: TelemetryEvent): ev is Extract<TelemetryEvent, { payload: { noteId: string } }> {
+  return !NO_NOTE_ID_KINDS.has(ev.kind);
+}

src/main/services/telemetryStats.ts

@@ -1,12 +1,8 @@
 import type { TelemetryEvent } from './telemetryEvents.js';
-
+import { kstTodayIso } from '../../shared/util/kstDate.js';
-const KST_OFFSET_MS = 9 * 60 * 60 * 1000;
 
 function kstDate(ts: string): string {
-  const d = new Date(ts);
+  return kstTodayIso(new Date(ts));
-  const k = new Date(d.getTime() + KST_OFFSET_MS);
-  return new Date(Date.UTC(k.getUTCFullYear(), k.getUTCMonth(), k.getUTCDate()))
-    .toISOString().slice(0, 10);
 }
 
 interface DailyRow {
@@ -133,12 +129,18 @@ export function aggregateStats(events: TelemetryEvent[], generatedAt: Date): Sta
     } else if (ev.kind === 'recall_snoozed') {
       row.recall_snoozed += 1;
       recallSnoozedCount += 1;
+    } else {
+      // v0.2.6 #8 — 새 telemetry kind 추가 시 본 함수 분기 누락을 컴파일 단계에서 catch.
+      const _exhaustive: never = ev;
+      void _exhaustive;
     }
   }
   const days = Array.from(byDay.values()).sort((a, b) => a.date.localeCompare(b.date));
   const aiTotal = aiSucceeded + aiFailed;
   const successRate = aiTotal === 0 ? 'N/A' : `${(aiSucceeded / aiTotal * 100).toFixed(1)}% (${aiSucceeded}/${aiTotal})`;
   const avgDuration = durationN === 0 ? 'N/A' : `${Math.round(durationSum / durationN)}`;
+  // v0.2.6 #9 — 회수율 = restore / trash event 비율 (event-level — 한 노트 trash-restore 반복 시
+  // 100% 가능, unique-note 회수율 아님. spec §6.2 "회수 도구 동작?" 질문에 충분).
   const trashRecoveryRate = trashCount === 0
     ? 'N/A'
     : `${(restoreCount / trashCount * 100).toFixed(1)}% (${restoreCount}/${trashCount})`;

src/main/tray.ts

@@ -2,120 +2,80 @@ import electron from 'electron';
 import type { Tray as TrayType, MenuItemConstructorOptions } from 'electron';
 const { app, Tray, Menu, nativeImage } = electron;
 
-let tray: TrayType | null = null;
+// v0.2.7 Phase 3 (Task 15) — showAboutDialog 제거됨.
-let _showInbox: () => void = () => {};
+// "Inkling 정보..." 트레이 항목이 사라짐 → 동일 기능은 설정 페이지의 InfoSection 이 담당.
-let _showCapture: () => void = () => {};
+// settings:get-app-info / settings:copy-app-info IPC 핸들러 (settingsApi.ts) 가 역할 인계.
-let _runBackup: () => void = () => {};
-let _runExport: () => void = () => {};
-let _runImport: () => void = () => {};
-let _runSync: () => void = () => {};
-let _runExportTelemetry: () => void = () => {};
-let _runOllamaRecheck: () => void = () => {};
-let _ollamaOk = true;
-let _todayCount = 0;
-let _runRetryAllFailed: () => void = () => {};
-let _failedCount = 0;
 
-function buildMenu() {
+/**
+ * v0.2.7 Phase 3 (Task 14) — 트레이 메뉴 슬림. 13 → 4 항목.
+ *
+ * 백업/내보내기/복원/동기화/사용 로그/Ollama 재확인/AI 재처리/Ollama 설정/자동실행/정보 →
+ * 모두 설정 페이지로 이전. 트레이는 4 항목만 노출:
+ *   1. 한 줄 적기      (showCapture)
+ *   2. 보관한 메모 보기 (showInbox)
+ *   3. 설정...        (showSettings — 설정 페이지로 navigate)
+ *   4. 종료
+ */
+export interface TrayCallbacks {
+  showInbox: () => void;
+  showCapture: () => void;
+  showSettings: () => void;
+}
+
+/**
+ * v0.2.7 Phase 3 (Task 14) — TrayState 슬림. todayCount 만 잔류 (오늘 N번 잡아둠 라벨).
+ * ollamaOk / failedCount 메뉴 항목이 사라져 더 이상 필요 없음.
+ */
+export interface TrayState {
+  todayCount: number;
+}
+
+let tray: TrayType | null = null;
+let _callbacks: TrayCallbacks | null = null;
+let _state: TrayState = { todayCount: 0 };
+
+function buildMenu(): electron.Menu {
   const items: MenuItemConstructorOptions[] = [];
+  const cb = _callbacks;
+  if (!cb) {
+    // createTray 호출 전이면 빈 메뉴 (defensive)
+    return Menu.buildFromTemplate([{ label: '로딩 중...', enabled: false }]);
+  }
   // F4-C: count > 0 시 비활성 라벨로 정체성 신호 노출. count = 0 시 메뉴를 자연스럽게 시작.
-  if (_todayCount > 0) {
+  if (_state.todayCount > 0) {
-    items.push({ label: `오늘 ${_todayCount}번 잡아둠`, enabled: false });
+    items.push({ label: `오늘 ${_state.todayCount}번 잡아둠`, enabled: false });
     items.push({ type: 'separator' });
   }
-  items.push({ label: '보관한 메모 보기', click: _showInbox });
+  items.push({ label: '한 줄 적기', click: cb.showCapture });
-  items.push({ label: '한 줄 적기', click: _showCapture });
+  items.push({ label: '보관한 메모 보기', click: cb.showInbox });
+  items.push({ type: 'separator' });
+  items.push({ label: '설정...', click: cb.showSettings });
   items.push({ type: 'separator' });
-  items.push({ label: '지금 백업', click: _runBackup });
-  items.push({ label: '내보내기...', click: _runExport });
-  items.push({ label: '백업에서 복원...', click: _runImport });
-  items.push({ label: '지금 동기화', click: _runSync });
-  items.push({ label: '사용 로그 내보내기...', click: _runExportTelemetry });
-  items.push({
-    label: 'Ollama 재확인',
-    enabled: !_ollamaOk,
-    click: _runOllamaRecheck
-  });
-  items.push({
-    label: `지금 AI 처리 (실패 ${_failedCount}건)`,
-    enabled: _failedCount > 0,
-    click: _runRetryAllFailed
-  });
-  if (app.isPackaged) {
-    const { openAtLogin } = app.getLoginItemSettings();
-    items.push({
-      label: '윈도우 시작 시 자동 실행',
-      type: 'checkbox',
-      checked: openAtLogin,
-      click: (item) => {
-        app.setLoginItemSettings({
-          openAtLogin: item.checked,
-          args: ['--hidden']
-        });
-      }
-    });
-    items.push({ type: 'separator' });
-  } else {
-    items.push({ type: 'separator' });
-  }
   items.push({ label: '종료', click: () => { app.isQuitting = true; app.quit(); } });
   return Menu.buildFromTemplate(items);
 }
 
-export function createTray(
+/**
-  showInbox: () => void,
+ * v0.2.6 C2 — 1-arg createTray. 기존 10 positional 폐기.
-  showCapture: () => void,
+ * v0.2.7 Phase 3 — TrayCallbacks 3-필드로 슬림.
-  runBackup: () => void,
+ */
-  runExport: () => void,
+export function createTray(callbacks: TrayCallbacks): TrayType {
-  runImport: () => void,
+  _callbacks = callbacks;
-  runSync: () => void,
-  runExportTelemetry: () => void,
-  runOllamaRecheck: () => void,
-  runRetryAllFailed: () => void
-): TrayType {
-  _showInbox = showInbox;
-  _showCapture = showCapture;
-  _runBackup = runBackup;
-  _runExport = runExport;
-  _runImport = runImport;
-  _runSync = runSync;
-  _runExportTelemetry = runExportTelemetry;
-  _runOllamaRecheck = runOllamaRecheck;
-  _runRetryAllFailed = runRetryAllFailed;
   const icon = nativeImage.createEmpty();
   tray = new Tray(icon);
-  tray.setToolTip(`Inkling — 오늘 ${_todayCount}`);
+  tray.setToolTip(`Inkling — 오늘 ${_state.todayCount}`);
   tray.setContextMenu(buildMenu());
-  tray.on('click', showInbox);
+  tray.on('click', callbacks.showInbox);
   return tray;
 }
 
 /**
- * F4-C 환경 앵커 — tooltip + 메뉴 첫 항목을 오늘 캡처 수로 갱신.
+ * v0.2.6 C3 — 통합 state 갱신. partial 으로 받아 _state merge + 메뉴 재빌드.
- * `src/main/index.ts` 가 60s interval / AiWorker onUpdate 시점에 호출.
+ * v0.2.7 Phase 3 — TrayState 가 todayCount 만 갖도록 슬림.
  */
-export function refreshTray(todayCount: number): void {
+export function refreshTray(state: Partial<TrayState>): void {
-  _todayCount = todayCount;
+  _state = { ..._state, ...state };
-  if (tray === null) return;
-  tray.setToolTip(`Inkling — 오늘 ${todayCount}`);
-  tray.setContextMenu(buildMenu());
-}
-
-/**
- * v0.2.3 #1 — Ollama 상태가 변할 때 main 의 health.onUpdate 가 호출.
- * 메뉴의 "Ollama 재확인" 활성/비활성 상태 갱신.
- */
-export function refreshTrayOllama(ok: boolean): void {
-  _ollamaOk = ok;
-  if (tray === null) return;
-  tray.setContextMenu(buildMenu());
-}
-
-/**
- * v0.2.3 #2 — AiWorker.onUpdate 시 실패 카운트 변하면 메뉴 라벨 + enabled 갱신.
- */
-export function refreshTrayFailedCount(count: number): void {
-  _failedCount = count;
   if (tray === null) return;
+  tray.setToolTip(`Inkling — 오늘 ${_state.todayCount}`);
   tray.setContextMenu(buildMenu());
 }

src/main/util/kstDate.ts

@@ -1,28 +0,0 @@
-const KST_OFFSET_MS = 9 * 60 * 60 * 1000;
-
-/**
- * Calendar date (YYYY-MM-DD) in Asia/Seoul timezone for the given instant.
- *
- * v0.2.3 #5 — used by NoteRepository.findExpiredCandidates to compare against
- * notes.due_date (also stored as YYYY-MM-DD per slice §F1).
- */
-export function todayInKstString(now: Date): string {
-  const k = new Date(now.getTime() + KST_OFFSET_MS);
-  return new Date(
-    Date.UTC(k.getUTCFullYear(), k.getUTCMonth(), k.getUTCDate())
-  ).toISOString().slice(0, 10);
-}
-
-/**
- * Epoch ms of the next 00:00 KST strictly after `now`.
- *
- * v0.2.3 #5 — used by store.snoozeExpired to compute the in-memory snooze
- * deadline ("오늘 그만").
- */
-export function nextKstMidnightMs(now: number): number {
-  const kstNow = now + KST_OFFSET_MS;
-  // Floor to KST midnight, then add one day.
-  const kstMidnightFloor = Math.floor(kstNow / 86_400_000) * 86_400_000;
-  const nextKstMidnight = kstMidnightFloor + 86_400_000;
-  return nextKstMidnight - KST_OFFSET_MS;
-}

src/preload/index.ts

@@ -12,7 +12,7 @@ const api: InklingApi = {
     updateAiFields: (noteId, fields) =>
       ipcRenderer.invoke('inbox:updateAi', { noteId, fields }),
     setDueDate: (noteId, date) => ipcRenderer.invoke('inbox:setDueDate', { noteId, date }),
-    deleteNote: (noteId) => ipcRenderer.invoke('inbox:delete', noteId),
+    deleteNote: (noteId) => ipcRenderer.invoke('inbox:trash', noteId),
     setIntent: (noteId, text) => ipcRenderer.invoke('inbox:setIntent', { noteId, text }),
     dismissIntent: (noteId) => ipcRenderer.invoke('inbox:dismissIntent', noteId),
     getContinuity: () => ipcRenderer.invoke('inbox:continuity'),
@@ -44,7 +44,30 @@ const api: InklingApi = {
     markRecallOpened: (id: string) => ipcRenderer.invoke('inbox:markRecallOpened', id),
     dismissRecall: (id: string) => ipcRenderer.invoke('inbox:dismissRecall', id),
     emitRecallShown: (id: string) => ipcRenderer.invoke('inbox:emitRecallShown', id),
-    emitRecallSnoozed: (id: string) => ipcRenderer.invoke('inbox:emitRecallSnoozed', id)
+    emitRecallSnoozed: (id: string) => ipcRenderer.invoke('inbox:emitRecallSnoozed', id),
+    loadOllamaSettings: () => ipcRenderer.invoke('inbox:loadOllamaSettings'),
+    saveOllamaSettings: (v: { endpoint: string; model: string }) => ipcRenderer.invoke('inbox:saveOllamaSettings', v),
+    // v0.2.7 Task 13 — 외부 (트레이) 에서 view 전환 요청 listener.
+    onNavigate: (cb: (view: 'inbox' | 'trash' | 'settings') => void) => {
+      const listener = (_e: unknown, view: 'inbox' | 'trash' | 'settings') => cb(view);
+      ipcRenderer.on('inbox:navigate', listener);
+      return () => ipcRenderer.off('inbox:navigate', listener);
+    },
+    // v0.2.7 자동 실행 (Task 22 통일) — 진단 정보 포함 응답
+    getAutostart: () => ipcRenderer.invoke('settings:autostart-state'),
+    setAutostart: (open: boolean) => ipcRenderer.invoke('settings:autostart-set', open),
+    // v0.2.7 백업/복원/동기화/텔레메트리 (Task 10) — 트레이 callback 의 IPC 대응
+    runBackup: () => ipcRenderer.invoke('settings:run-backup'),
+    runExport: () => ipcRenderer.invoke('settings:run-export'),
+    runImport: () => ipcRenderer.invoke('settings:run-import'),
+    runSync: () => ipcRenderer.invoke('settings:run-sync'),
+    runExportTelemetry: () => ipcRenderer.invoke('settings:run-export-telemetry'),
+    // v0.2.7 정보 섹션 (Task 11) — 트레이 showAboutDialog 의 IPC 대응
+    getAppInfo: () => ipcRenderer.invoke('settings:get-app-info'),
+    openProfileDir: () => ipcRenderer.invoke('settings:open-profile-dir'),
+    copyAppInfo: () => ipcRenderer.invoke('settings:copy-app-info'),
+    // v0.2.8 Cut A — 첨부 이미지를 OS 기본 뷰어로 열기 (Task 3).
+    openMedia: (relPath: string) => ipcRenderer.invoke('inbox:open-media', relPath),
   }
 };
 

src/renderer/inbox/App.tsx

@@ -12,6 +12,7 @@ import { TagUndoToast } from './components/TagUndoToast.js';
 import { ExpiryBanner } from './components/ExpiryBanner.js';
 import { FailedBanner } from './components/FailedBanner.js';
 import { RecallBanner } from './components/RecallBanner.js';
+import { SettingsPage } from './components/SettingsPage.js';
 
 export function App(): React.ReactElement {
   const {
@@ -20,6 +21,8 @@ export function App(): React.ReactElement {
     continuity, tagFilter, setTagFilter,
     toggleShowTrash, restoreNote, permanentDeleteNote, emptyTrash
   } = useInbox();
+  const showSettings = useInbox((s) => s.showSettings);
+  const setShowSettings = useInbox((s) => s.setShowSettings);
   const [recoveryDismissed, setRecoveryDismissed] = useState(isRecoveryDismissedToday());
 
   useEffect(() => {
@@ -31,13 +34,26 @@ export function App(): React.ReactElement {
     const unsubOllama = inboxApi.onOllamaStatus((status) => {
       useInbox.setState({ ollamaStatus: status });
     });
+    const unsubNav = inboxApi.onNavigate((view) => {
+      if (view === 'settings') {
+        useInbox.getState().setShowSettings(true);
+      } else if (view === 'inbox') {
+        useInbox.getState().setShowSettings(false);
+        if (useInbox.getState().showTrash) void useInbox.getState().toggleShowTrash();
+      } else if (view === 'trash') {
+        useInbox.getState().setShowSettings(false);
+        if (!useInbox.getState().showTrash) void useInbox.getState().toggleShowTrash();
+      }
+    });
     const onFocus = () => { void refreshMeta(); };
     window.addEventListener('focus', onFocus);
-    return () => { unsubNote(); unsubOllama(); window.removeEventListener('focus', onFocus); };
+    return () => { unsubNote(); unsubOllama(); unsubNav(); window.removeEventListener('focus', onFocus); };
     // onOllamaStatus 콜백은 useInbox.setState 직접 호출 — store reference 가 안정적이라
     // deps array 에 추가 불필요. mount 시 1회 구독 + unmount 시 해제.
   }, [loadInitial, refreshMeta, upsertNote]);
 
+  if (showSettings) return <SettingsPage />;
+
   const showRecovery = continuity.showRecoveryToast && !recoveryDismissed;
   const filtered = selectFilteredNotes({ notes, tagFilter });
 
@@ -75,11 +91,25 @@ export function App(): React.ReactElement {
           <ContinuityBadge />
           <IdentityCounter />
         </div>
+        <button
+          aria-label="설정 열기"
+          onClick={() => setShowSettings(true)}
+          style={{
+            background: 'transparent',
+            border: 'none',
+            cursor: 'pointer',
+            padding: 4,
+            fontSize: 16,
+            marginLeft: 8
+          }}
+        >
+          ⚙
+        </button>
       </div>
       <main className="main">
         {!showTrash && (
           <>
-            <OllamaBanner />
+            <OllamaBanner onOpenSettings={() => setShowSettings(true)} />
             <RecoveryToast
               show={showRecovery}
               onDismiss={() => { markRecoveryDismissed(); setRecoveryDismissed(true); }}
@@ -144,7 +174,6 @@ export function App(): React.ReactElement {
               trashNotes.map((n) => (
                 <NoteCard
                   key={n.id} note={n} mode="trash"
-                  onDeleted={() => removeNote(n.id)}
                   onUpdated={(u) => upsertNote(u)}
                   onRestore={() => void restoreNote(n.id)}
                   onPermanentDelete={() => void permanentDeleteNote(n.id)}

src/renderer/inbox/components/Banner.tsx

@@ -0,0 +1,27 @@
+import React from 'react';
+
+/**
+ * v0.2.6 #24+#41 — 4 banner 의 inline style 중복 제거. severity 별 theme map.
+ */
+const THEMES = {
+  warning: { bg: '#fff7e6', border: '#d99500', text: '#946100' },
+  error: { bg: '#fce4e4', border: '#a33', text: '#a33' },
+  info: { bg: '#e8f0fe', border: '#4a7ec0', text: '#234' }
+} as const;
+
+interface Props {
+  severity: 'warning' | 'error' | 'info';
+  children: React.ReactNode;
+}
+
+export function Banner({ severity, children }: Props): React.ReactElement {
+  const t = THEMES[severity];
+  return (
+    <div style={{
+      background: t.bg, border: `1px solid ${t.border}`, color: t.text,
+      borderRadius: 6, padding: '8px 12px', margin: '8px 0', fontSize: 13
+    }}>
+      {children}
+    </div>
+  );
+}

src/renderer/inbox/components/ExpiryBanner.tsx

@@ -1,6 +1,7 @@
 import React, { useEffect, useState } from 'react';
 import type { Note } from '@shared/types';
 import { useInbox } from '../store.js';
+import { Banner } from './Banner.js';
 
 export function ExpiryBanner(): React.ReactElement | null {
   const candidates = useInbox((s) => s.expiredCandidates);
@@ -72,10 +73,7 @@ function ExpiryBannerInner({ candidates, onTrash, onSnooze }: InnerProps): React
   }
 
   return (
-    <div style={{
+    <Banner severity="warning">
-      background: '#fff7e6', border: '1px solid #d99500', borderRadius: 6,
-      padding: '8px 12px', margin: '8px 0', fontSize: 13
-    }}>
       <div style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
         <span>⏰ <b>오늘 기준 만료 {candidates.length}개</b></span>
         <button
@@ -152,6 +150,6 @@ function ExpiryBannerInner({ candidates, onTrash, onSnooze }: InnerProps): React
           </button>
         </>
       )}
-    </div>
+    </Banner>
   );
 }

src/renderer/inbox/components/FailedBanner.tsx

@@ -1,32 +1,31 @@
 import React from 'react';
 import { useInbox } from '../store.js';
+import { Banner } from './Banner.js';
 
 export function FailedBanner(): React.ReactElement | null {
   const count = useInbox((s) => s.failedCount);
   const retryAllFailed = useInbox((s) => s.retryAllFailed);
   if (count === 0) return null;
   return (
-    <div style={{
+    <Banner severity="error">
-      background: '#fce4e4', border: '1px solid #a33', borderRadius: 6,
+      <div style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
-      padding: '8px 12px', margin: '8px 0', fontSize: 13,
+        <span style={{ flex: 1 }}>❌ AI 처리 실패 <b>{count}</b>건</span>
-      display: 'flex', alignItems: 'center', gap: 8
+        <button
-    }}>
+          onClick={() => {
-      <span style={{ flex: 1 }}>❌ AI 처리 실패 <b>{count}</b>건</span>
+            retryAllFailed().catch((e) => {
-      <button
+              // eslint-disable-next-line no-console
-        onClick={() => {
+              console.warn('retryAllFailed failed', e);
-          retryAllFailed().catch((e) => {
+            });
-            // eslint-disable-next-line no-console
+          }}
-            console.warn('retryAllFailed failed', e);
+          style={{
-          });
+            background: '#a33', color: '#fff',
-        }}
+            border: 'none', borderRadius: 4,
-        style={{
+            padding: '4px 12px', fontSize: 12, cursor: 'pointer'
-          background: '#a33', color: '#fff',
+          }}
-          border: 'none', borderRadius: 4,
+        >
-          padding: '4px 12px', fontSize: 12, cursor: 'pointer'
+          재시도
-        }}
+        </button>
-      >
+      </div>
-        재시도
+    </Banner>
-      </button>
-    </div>
   );
 }

src/renderer/inbox/components/NoteCard.tsx

@@ -8,7 +8,7 @@ import { pushTagUndo } from './TagUndoToast.js';
 
 interface Props {
   note: Note;
-  onDeleted: () => void;
+  onDeleted?: () => void;  // inbox mode 전용 (trash mode 에서 미사용)
   onUpdated: (n: Note) => void;
   mode?: 'inbox' | 'trash';  // default 'inbox'
   onRestore?: () => void;
@@ -119,7 +119,7 @@ export function NoteCard({ note, onDeleted, onUpdated, mode = 'inbox', onRestore
   async function handleDelete() {
     if (!window.confirm('이 기억을 버릴까요? 되돌릴 수 없습니다.')) return;
     await inboxApi.deleteNote(note.id);
-    onDeleted();
+    onDeleted?.();
   }
 
   async function saveTitle(next: string) {
@@ -332,9 +332,24 @@ export function NoteCard({ note, onDeleted, onUpdated, mode = 'inbox', onRestore
       )}
 
       {local.media.length > 0 && (
-        <div style={{ marginTop: 10, display: 'flex', gap: 6 }}>
+        <div style={{ marginTop: 10, display: 'flex', flexWrap: 'wrap', gap: 6 }}>
           {local.media.map((m) => (
-            <div key={m.id} style={{ width: 48, height: 48, background: '#eee', borderRadius: 4 }} title={m.relPath} />
+            // alt="" — decorative (relPath 는 사용자 의미 X). title 이 hover tooltip.
+            <img
+              key={m.id}
+              src={`inkling-media://${m.relPath}`}
+              alt=""
+              title={m.relPath}
+              onClick={() => { void inboxApi.openMedia(m.relPath); }}
+              style={{
+                width: 48,
+                height: 48,
+                objectFit: 'cover',
+                borderRadius: 4,
+                cursor: 'pointer',
+                border: '1px solid #e0e0e0'
+              }}
+            />
           ))}
         </div>
       )}

src/renderer/inbox/components/OllamaBanner.tsx

@@ -1,7 +1,12 @@
 import React from 'react';
 import { useInbox } from '../store.js';
+import { Banner } from './Banner.js';
 
-export function OllamaBanner(): React.ReactElement | null {
+interface OllamaBannerProps {
+  onOpenSettings?: () => void;
+}
+
+export function OllamaBanner({ onOpenSettings }: OllamaBannerProps = {}): React.ReactElement | null {
   const status = useInbox((s) => s.ollamaStatus);
   const recheckOllama = useInbox((s) => s.recheckOllama);
   if (status.ok) return null;
@@ -10,7 +15,8 @@ export function OllamaBanner(): React.ReactElement | null {
     ? '`ollama pull gemma4:e4b` 실행 후 앱을 재시작해주세요.'
     : 'Inkling 정리가 잠시 멈췄습니다. Ollama를 실행해주세요.';
   return (
-    <div className="banner warn" style={{ flexDirection: 'column', alignItems: 'flex-start' }}>
+    <Banner severity="warning">
+      <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'flex-start' }}>
       <div style={{ display: 'flex', alignItems: 'center', gap: 8, width: '100%' }}>
         <span style={{ flex: 1 }}>⚠ {message}</span>
         <button
@@ -28,12 +34,26 @@ export function OllamaBanner(): React.ReactElement | null {
         >
           재확인
         </button>
+        {onOpenSettings && (
+          <button
+            onClick={onOpenSettings}
+            style={{
+              background: 'transparent', color: 'inherit',
+              border: '1px solid currentColor', borderRadius: 4,
+              padding: '2px 8px', fontSize: 12, cursor: 'pointer',
+              marginLeft: 6
+            }}
+          >
+            설정
+          </button>
+        )}
       </div>
       {status.reason ? (
         <span style={{ fontSize: 11, opacity: 0.7, marginTop: 4 }}>
           진단: {status.reason}
         </span>
       ) : null}
-    </div>
+      </div>
+    </Banner>
   );
 }

src/renderer/inbox/components/RecallBanner.tsx

@@ -1,6 +1,7 @@
 import React, { useEffect, useRef, useState } from 'react';
 import { useInbox } from '../store.js';
 import { inboxApi } from '../api.js';
+import { Banner } from './Banner.js';
 
 export function RecallBanner(): React.ReactElement | null {
   const candidate = useInbox((s) => s.recallCandidate);
@@ -47,10 +48,7 @@ export function RecallBanner(): React.ReactElement | null {
   }
 
   return (
-    <div style={{
+    <Banner severity="info">
-      background: '#e8f0fe', border: '1px solid #4a7ec0', borderRadius: 6,
-      padding: '8px 12px', margin: '8px 0', fontSize: 13
-    }}>
       <div style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
         <span>💭 <b>오늘 회상해볼 노트</b></span>
         <span style={{ flex: 1, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap', color: '#234' }}>
@@ -90,7 +88,7 @@ export function RecallBanner(): React.ReactElement | null {
           더 이상
         </button>
       </div>
-    </div>
+    </Banner>
   );
 }
 

src/renderer/inbox/components/SettingsPage.tsx

@@ -0,0 +1,45 @@
+import React from 'react';
+import { useInbox } from '../store.js';
+import { AiProviderSection } from './settings/AiProviderSection.js';
+import { AutostartSection } from './settings/AutostartSection.js';
+import { BackupSection } from './settings/BackupSection.js';
+import { InfoSection } from './settings/InfoSection.js';
+
+export function SettingsPage(): React.ReactElement {
+  const setShowSettings = useInbox((s) => s.setShowSettings);
+  return (
+    <div style={{ padding: 16, maxWidth: 720, margin: '0 auto' }}>
+      <div style={{ display: 'flex', alignItems: 'center', gap: 8, marginBottom: 16 }}>
+        <button
+          onClick={() => setShowSettings(false)}
+          style={{
+            background: 'transparent',
+            border: 'none',
+            fontSize: 14,
+            cursor: 'pointer',
+            color: '#0a4b80'
+          }}
+        >
+          ← 돌아가기
+        </button>
+        <h1 style={{ fontSize: 18, margin: 0 }}>설정</h1>
+      </div>
+      <section style={{ marginBottom: 24 }}>
+        <h2 style={{ fontSize: 14, marginBottom: 8 }}>AI 제공자</h2>
+        <AiProviderSection />
+      </section>
+      <section style={{ marginBottom: 24 }}>
+        <h2 style={{ fontSize: 14, marginBottom: 8 }}>자동 실행</h2>
+        <AutostartSection />
+      </section>
+      <section style={{ marginBottom: 24 }}>
+        <h2 style={{ fontSize: 14, marginBottom: 8 }}>백업 / 복원</h2>
+        <BackupSection />
+      </section>
+      <section style={{ marginBottom: 24 }}>
+        <h2 style={{ fontSize: 14, marginBottom: 8 }}>정보</h2>
+        <InfoSection />
+      </section>
+    </div>
+  );
+}

src/renderer/inbox/components/settings/AiProviderSection.tsx

@@ -0,0 +1,131 @@
+import React, { useEffect, useState } from 'react';
+import { z } from 'zod';
+import { inboxApi } from '../../api.js';
+
+const endpointSchema = z.string().url();
+
+export function AiProviderSection(): React.ReactElement {
+  const [endpoint, setEndpoint] = useState('');
+  const [model, setModel] = useState('');
+  const [error, setError] = useState<string | null>(null);
+  const [saveResult, setSaveResult] = useState<string | null>(null);
+  const [recheckResult, setRecheckResult] = useState<string | null>(null);
+
+  useEffect(() => {
+    void (async () => {
+      const s = await inboxApi.loadOllamaSettings();
+      if (s) {
+        setEndpoint(s.endpoint);
+        setModel(s.model);
+      }
+    })();
+  }, []);
+
+  async function onSave(): Promise<void> {
+    const r = endpointSchema.safeParse(endpoint);
+    if (!r.success) {
+      setError('올바른 URL 형식이 아닙니다 (예: http://localhost:11434)');
+      setSaveResult(null);
+      return;
+    }
+    if (model.trim() === '') {
+      setError('모델 이름을 입력해주세요');
+      setSaveResult(null);
+      return;
+    }
+    setError(null);
+    const result = await inboxApi.saveOllamaSettings({ endpoint, model });
+    if (result.ok) {
+      setSaveResult('저장됨');
+    } else {
+      setSaveResult(null);
+      setError(`저장 실패: ${result.reason}`);
+    }
+  }
+
+  async function onRecheck(): Promise<void> {
+    setRecheckResult('확인 중...');
+    const r = await inboxApi.ollamaRecheck();
+    setRecheckResult(r.ok ? '연결됨' : `연결 실패: ${r.reason ?? '알 수 없는 이유'}`);
+  }
+
+  return (
+    <div>
+      <label style={{ display: 'block', marginBottom: 8, fontSize: 12, color: '#666' }}>
+        Endpoint
+        <input
+          type="text"
+          value={endpoint}
+          onChange={(e) => setEndpoint(e.target.value)}
+          placeholder="http://localhost:11434"
+          style={{
+            display: 'block',
+            width: '100%',
+            padding: '6px 8px',
+            marginTop: 4,
+            fontSize: 13,
+            border: '1px solid #ccc',
+            borderRadius: 4
+          }}
+        />
+      </label>
+      <label style={{ display: 'block', marginBottom: 8, fontSize: 12, color: '#666' }}>
+        Model
+        <input
+          type="text"
+          value={model}
+          onChange={(e) => setModel(e.target.value)}
+          placeholder="gemma2:2b"
+          style={{
+            display: 'block',
+            width: '100%',
+            padding: '6px 8px',
+            marginTop: 4,
+            fontSize: 13,
+            border: '1px solid #ccc',
+            borderRadius: 4
+          }}
+        />
+      </label>
+      {error && (
+        <div style={{ color: '#c33', fontSize: 12, marginBottom: 8 }}>{error}</div>
+      )}
+      {saveResult && (
+        <div style={{ fontSize: 12, marginBottom: 8, color: '#0a4b80' }}>{saveResult}</div>
+      )}
+      <div style={{ display: 'flex', gap: 8 }}>
+        <button
+          onClick={() => void onSave()}
+          style={{
+            background: '#0a4b80',
+            color: '#fff',
+            border: 'none',
+            borderRadius: 4,
+            padding: '6px 14px',
+            fontSize: 12,
+            cursor: 'pointer'
+          }}
+        >
+          저장
+        </button>
+        <button
+          onClick={() => void onRecheck()}
+          style={{
+            background: 'transparent',
+            color: '#0a4b80',
+            border: '1px solid #0a4b80',
+            borderRadius: 4,
+            padding: '6px 14px',
+            fontSize: 12,
+            cursor: 'pointer'
+          }}
+        >
+          지금 재확인
+        </button>
+      </div>
+      {recheckResult && (
+        <div style={{ fontSize: 12, marginTop: 8 }}>{recheckResult}</div>
+      )}
+    </div>
+  );
+}

src/renderer/inbox/components/settings/AutostartSection.tsx

@@ -0,0 +1,95 @@
+import React, { useEffect, useState } from 'react';
+import type { AutostartResponse } from '@shared/types';
+import { inboxApi } from '../../api.js';
+
+export function AutostartSection(): React.ReactElement {
+  const [data, setData] = useState<AutostartResponse | null>(null);
+  const [expanded, setExpanded] = useState(false);
+
+  useEffect(() => {
+    void (async () => {
+      const r = await inboxApi.getAutostart();
+      setData(r);
+    })();
+  }, []);
+
+  async function onToggle(e: React.ChangeEvent<HTMLInputElement>): Promise<void> {
+    const r = await inboxApi.setAutostart(e.target.checked);
+    setData(r);
+  }
+
+  // Task 24 — 현재 openAtLogin 값으로 다시 setLoginItemSettings 호출 → mismatch 복구.
+  // (예: registry 누락된 채로 withArgs.openAtLogin=true 인 경우 등.)
+  async function onReregister(): Promise<void> {
+    if (!data) return;
+    const r = await inboxApi.setAutostart(data.openAtLogin);
+    setData(r);
+  }
+
+  if (data === null) {
+    return <div style={{ fontSize: 12, color: '#666' }}>로딩 중...</div>;
+  }
+
+  const d = data.diagnostic;
+  // v0.2.7 F12 deeper fix — withArgs vs noArgs 의 openAtLogin 불일치, 또는
+  // executableWillLaunchAtLogin = false 면 mismatch 로 간주 (등록은 됐지만 실제론
+  // 로그인 시 실행되지 않을 수 있는 상태).
+  const mismatch = d.withArgs.openAtLogin !== d.noArgs.openAtLogin
+    || (data.openAtLogin && !d.withArgs.executableWillLaunchAtLogin);
+
+  return (
+    <div>
+      <label style={{ display: 'flex', gap: 8, alignItems: 'center', fontSize: 13 }}>
+        <input type="checkbox" checked={data.openAtLogin} onChange={onToggle} />
+        앱 시작 시 자동으로 실행
+      </label>
+      {mismatch && (
+        <div style={{ color: '#c33', fontSize: 12, marginTop: 4 }}>
+          ⚠️ 등록 상태 불일치 감지 — 진단 정보 확인 후 재등록을 시도하세요.
+        </div>
+      )}
+      <div style={{ marginTop: 6 }}>
+        <button
+          onClick={() => { void onReregister(); }}
+          style={{ fontSize: 12, padding: '4px 10px' }}
+        >
+          재등록
+        </button>
+      </div>
+      <button
+        onClick={() => setExpanded(!expanded)}
+        style={{
+          background: 'none',
+          border: 'none',
+          cursor: 'pointer',
+          fontSize: 12,
+          color: '#0a4b80',
+          marginTop: 4,
+          padding: 0
+        }}
+      >
+        {expanded ? '▾' : '▸'} 진단 정보
+      </button>
+      {expanded && (
+        <div
+          style={{
+            fontSize: 11,
+            lineHeight: 1.6,
+            marginTop: 4,
+            fontFamily: 'monospace',
+            background: '#f5f5f5',
+            padding: 8,
+            borderRadius: 4,
+            wordBreak: 'break-all'
+          }}
+        >
+          <div>표준 (--hidden 인자): openAtLogin={String(d.withArgs.openAtLogin)}, willLaunch={String(d.withArgs.executableWillLaunchAtLogin)}</div>
+          <div>비교 (인자 없이): openAtLogin={String(d.noArgs.openAtLogin)}, willLaunch={String(d.noArgs.executableWillLaunchAtLogin)}</div>
+          <div>실행 파일 경로: {d.execPath}</div>
+          {d.registryPath !== undefined && <div>registry 경로: {d.registryPath}</div>}
+          {d.registryValue !== undefined && <div>registry 값: {d.registryValue ?? '(없음)'}</div>}
+        </div>
+      )}
+    </div>
+  );
+}

src/renderer/inbox/components/settings/BackupSection.tsx

@@ -0,0 +1,25 @@
+import React, { useState } from 'react';
+import { inboxApi } from '../../api.js';
+
+export function BackupSection(): React.ReactElement {
+  const [status, setStatus] = useState<string | null>(null);
+
+  // IPC 핸들러 (settingsApi.ts) 가 자체 try/catch + Notification 으로 결과를 사용자에게 알림.
+  // 이 컴포넌트의 status 는 보조 진행 표시 — 결과 (성공/실패) 는 native UX 에 의존.
+  async function run(label: string, fn: () => Promise<unknown>): Promise<void> {
+    setStatus(`${label}: 진행 중...`);
+    await fn();
+    setStatus(null);
+  }
+
+  return (
+    <div style={{ display: 'flex', flexDirection: 'column', gap: 8 }}>
+      <button onClick={() => run('지금 백업', () => inboxApi.runBackup())}>지금 백업</button>
+      <button onClick={() => run('내보내기', () => inboxApi.runExport())}>내보내기...</button>
+      <button onClick={() => run('백업에서 복원', () => inboxApi.runImport())}>백업에서 복원...</button>
+      <button onClick={() => run('지금 동기화', () => inboxApi.runSync())}>지금 동기화</button>
+      <button onClick={() => run('사용 로그 내보내기', () => inboxApi.runExportTelemetry())}>사용 로그 내보내기...</button>
+      {status && <div style={{ fontSize: 12 }}>{status}</div>}
+    </div>
+  );
+}

src/renderer/inbox/components/settings/InfoSection.tsx

@@ -0,0 +1,41 @@
+import React, { useEffect, useState } from 'react';
+import { inboxApi } from '../../api.js';
+
+interface AppInfo {
+  version: string;
+  electron: string;
+  node: string;
+  os: string;
+  profileDir: string;
+}
+
+export function InfoSection(): React.ReactElement {
+  const [info, setInfo] = useState<AppInfo | null>(null);
+
+  useEffect(() => {
+    void (async () => setInfo(await inboxApi.getAppInfo()))();
+  }, []);
+
+  if (!info) return <div style={{ fontSize: 12 }}>로딩 중...</div>;
+
+  return (
+    <div>
+      <dl style={{ fontSize: 12, lineHeight: 1.6 }}>
+        <dt style={{ fontWeight: 600 }}>버전</dt>
+        <dd>{info.version}</dd>
+        <dt style={{ fontWeight: 600 }}>Electron</dt>
+        <dd>{info.electron}</dd>
+        <dt style={{ fontWeight: 600 }}>Node</dt>
+        <dd>{info.node}</dd>
+        <dt style={{ fontWeight: 600 }}>OS</dt>
+        <dd>{info.os}</dd>
+        <dt style={{ fontWeight: 600 }}>데이터 위치</dt>
+        <dd style={{ wordBreak: 'break-all' }}>{info.profileDir}</dd>
+      </dl>
+      <div style={{ display: 'flex', gap: 8, marginTop: 8 }}>
+        <button onClick={() => void inboxApi.openProfileDir()}>데이터 위치 열기</button>
+        <button onClick={() => void inboxApi.copyAppInfo()}>정보 복사</button>
+      </div>
+    </div>
+  );
+}

src/renderer/inbox/store.ts

@@ -1,6 +1,7 @@
 import { create } from 'zustand';
 import type { Note, WeeklyContinuity } from '@shared/types';
 import { inboxApi } from './api.js';
+import { nextKstMidnightMs } from '@shared/util/kstDate.js';
 
 export { selectFilteredNotes } from './selectFilteredNotes.js';
 
@@ -9,6 +10,7 @@ interface InboxState {
   trashNotes: Note[];
   trashCount: number;
   showTrash: boolean;
+  showSettings: boolean;
   continuity: WeeklyContinuity;
   pendingCount: number;
   ollamaStatus: { ok: boolean; reason?: string };
@@ -25,6 +27,7 @@ interface InboxState {
   upsertNote: (note: Note) => void;
   removeNote: (id: string) => void;
   setTagFilter: (tag: string | null) => void;
+  setShowSettings: (open: boolean) => void;
   toggleShowTrash: () => Promise<void>;
   loadTrash: () => Promise<void>;
   restoreNote: (id: string) => Promise<void>;
@@ -51,6 +54,7 @@ export const useInbox = create<InboxState>((set, get) => ({
   trashNotes: [],
   trashCount: 0,
   showTrash: false,
+  showSettings: false,
   continuity: emptyContinuity,
   pendingCount: 0,
   ollamaStatus: { ok: true },
@@ -133,6 +137,9 @@ export const useInbox = create<InboxState>((set, get) => ({
   setTagFilter(tag) {
     set({ tagFilter: tag });
   },
+  setShowSettings(open) {
+    set({ showSettings: open });
+  },
   async toggleShowTrash() {
     const next = !get().showTrash;
     set({ showTrash: next });
@@ -177,12 +184,7 @@ export const useInbox = create<InboxState>((set, get) => ({
     });
   },
   snoozeExpired() {
-    const KST_OFFSET_MS = 9 * 60 * 60 * 1000;
+    set({ expiredSnoozeUntilMs: nextKstMidnightMs(Date.now()) });
-    const now = Date.now();
-    const kstNow = now + KST_OFFSET_MS;
-    const kstMidnightFloor = Math.floor(kstNow / 86_400_000) * 86_400_000;
-    const nextKstMidnight = kstMidnightFloor + 86_400_000;
-    set({ expiredSnoozeUntilMs: nextKstMidnight - KST_OFFSET_MS });
   },
   async recheckOllama() {
     const status = await inboxApi.ollamaRecheck();
@@ -212,12 +214,7 @@ export const useInbox = create<InboxState>((set, get) => ({
     set({ recallCandidate, recallSnoozeUntilMs: null });
   },
   async snoozeRecall() {
-    const KST_OFFSET_MS = 9 * 60 * 60 * 1000;
+    set({ recallSnoozeUntilMs: nextKstMidnightMs(Date.now()) });
-    const now = Date.now();
-    const kstNow = now + KST_OFFSET_MS;
-    const kstMidnightFloor = Math.floor(kstNow / 86_400_000) * 86_400_000;
-    const nextKstMidnight = kstMidnightFloor + 86_400_000;
-    set({ recallSnoozeUntilMs: nextKstMidnight - KST_OFFSET_MS });
     // m1 fix — candidate=null 인 race 케이스 (사용자가 banner 닫힌 직후 클릭) 시
     // snooze 는 적용하되 emit 만 skip. telemetry 누락 받아들임 (의도적).
     const candidate = get().recallCandidate;

src/shared/constants.ts

@@ -0,0 +1,2 @@
+export const DEFAULT_OLLAMA_MODEL = 'gemma4:e4b';
+export const DEFAULT_OLLAMA_ENDPOINT = 'http://localhost:11434';

src/shared/types.ts

@@ -57,6 +57,20 @@ export interface CaptureApi {
   hide(): void;
 }
 
+// v0.2.7 F12 deeper fix — 자동 실행 진단 정보 (AutostartDiagnostic.collectAutostartState 결과).
+export interface AutostartDiagnostic {
+  withArgs: { openAtLogin: boolean; executableWillLaunchAtLogin: boolean };
+  noArgs: { openAtLogin: boolean; executableWillLaunchAtLogin: boolean };
+  execPath: string;
+  registryPath?: string;
+  registryValue?: string | null;
+}
+
+export interface AutostartResponse {
+  openAtLogin: boolean;
+  diagnostic: AutostartDiagnostic;
+}
+
 export interface InboxApi {
   listNotes(opts: { limit: number; cursor?: string }): Promise<Note[]>;
   updateAiFields(
@@ -89,6 +103,31 @@ export interface InboxApi {
   dismissRecall(id: string): Promise<{ note: Note }>;
   emitRecallShown(id: string): Promise<void>;
   emitRecallSnoozed(id: string): Promise<void>;
+  loadOllamaSettings(): Promise<{ endpoint: string; model: string } | null>;
+  saveOllamaSettings(v: { endpoint: string; model: string }): Promise<{ ok: true } | { ok: false; reason: string }>;
+  // v0.2.7 Task 13 — 외부 (트레이 등) 에서 view 전환 요청 구독.
+  onNavigate(cb: (view: 'inbox' | 'trash' | 'settings') => void): () => void;
+  // v0.2.7 자동 실행 (Task 22 통일) — 진단 정보 포함 응답
+  getAutostart(): Promise<AutostartResponse>;
+  setAutostart(open: boolean): Promise<AutostartResponse>;
+  // v0.2.7 백업 / 복원 / 동기화 / 텔레메트리 — 트레이 callback 의 IPC 대응 (Task 10)
+  runBackup(): Promise<{ ok: true }>;
+  runExport(): Promise<{ ok: true }>;
+  runImport(): Promise<{ ok: true }>;
+  runSync(): Promise<{ ok: true }>;
+  runExportTelemetry(): Promise<{ ok: true }>;
+  // 정보 섹션 — 트레이 showAboutDialog 의 IPC 대응.
+  getAppInfo(): Promise<{
+    version: string;
+    electron: string;
+    node: string;
+    os: string;
+    profileDir: string;
+  }>;
+  openProfileDir(): Promise<void>;
+  copyAppInfo(): Promise<void>;
+  // v0.2.8 Cut A — 첨부 이미지를 OS 기본 뷰어로 열기 (Task 3).
+  openMedia(relPath: string): Promise<{ ok: true } | { ok: false; reason: string }>;
 }
 
 export interface InklingApi {

src/shared/util/kstDate.ts

@@ -0,0 +1,42 @@
+/**
+ * KST timezone helpers — main + renderer 양쪽에서 import 가능.
+ * v0.2.6 C1: backlog #3+#19+#34 통합 (기존 src/main/util/kstDate.ts 이동).
+ */
+
+export const KST_OFFSET_MS = 9 * 60 * 60 * 1000;
+export const DAY_MS = 24 * 60 * 60 * 1000;
+
+/**
+ * KST 자정 기준 today YYYY-MM-DD.
+ *
+ * 기존 todayInKstString (NoteRepository.findExpiredCandidates),
+ * TelemetryService.todayKstIso, telemetryStats.kstDate, AiWorker.todayKstAsIso
+ * 4 callsite 통합.
+ */
+export function kstTodayIso(now: Date = new Date()): string {
+  const k = new Date(now.getTime() + KST_OFFSET_MS);
+  return new Date(Date.UTC(k.getUTCFullYear(), k.getUTCMonth(), k.getUTCDate()))
+    .toISOString().slice(0, 10);
+}
+
+/**
+ * 다음 KST 자정의 epoch ms (UTC).
+ *
+ * 기존 nextKstMidnightMs (store.snoozeExpired) + store.snoozeRecall inline 통합.
+ */
+export function nextKstMidnightMs(now: number = Date.now()): number {
+  const kstNow = now + KST_OFFSET_MS;
+  const kstMidnightFloor = Math.floor(kstNow / DAY_MS) * DAY_MS;
+  const nextKstMidnight = kstMidnightFloor + DAY_MS;
+  return nextKstMidnight - KST_OFFSET_MS;
+}
+
+/**
+ * KST today (00:00 KST 의 UTC Date 객체). AiWorker 의 dueDateParser 가 candidate 비교용.
+ *
+ * 기존 AiWorker.todayKstAsDate 통합.
+ */
+export function kstTodayAsDate(now: Date = new Date()): Date {
+  const k = new Date(now.getTime() + KST_OFFSET_MS);
+  return new Date(Date.UTC(k.getUTCFullYear(), k.getUTCMonth(), k.getUTCDate()));
+}

tests/unit/AiProviderSection.test.tsx

@@ -0,0 +1,44 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import '@testing-library/jest-dom/vitest';
+import { render, screen, fireEvent, cleanup } from '@testing-library/react';
+
+vi.mock('../../src/renderer/inbox/api.js', () => ({
+  inboxApi: {
+    loadOllamaSettings: vi.fn(async () => ({ endpoint: 'http://localhost:11434', model: 'gemma2:2b' })),
+    saveOllamaSettings: vi.fn(async () => ({ ok: true })),
+    ollamaRecheck: vi.fn(async () => ({ ok: true }))
+  }
+}));
+
+import { AiProviderSection } from '../../src/renderer/inbox/components/settings/AiProviderSection';
+
+describe('AiProviderSection', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    cleanup();
+  });
+
+  it('loads current settings on mount', async () => {
+    render(<AiProviderSection />);
+    expect(await screen.findByDisplayValue('http://localhost:11434')).toBeInTheDocument();
+    expect(screen.getByDisplayValue('gemma2:2b')).toBeInTheDocument();
+  });
+
+  it('rejects invalid endpoint URL', async () => {
+    render(<AiProviderSection />);
+    await screen.findByDisplayValue('http://localhost:11434');
+    const input = screen.getByLabelText(/Endpoint/);
+    fireEvent.change(input, { target: { value: 'not-a-url' } });
+    fireEvent.click(screen.getByRole('button', { name: /저장/ }));
+    expect(await screen.findByText(/올바른 URL/)).toBeInTheDocument();
+  });
+
+  it('"지금 재확인" calls ollamaRecheck and shows result', async () => {
+    const { inboxApi } = await import('../../src/renderer/inbox/api.js');
+    render(<AiProviderSection />);
+    await screen.findByDisplayValue('http://localhost:11434');
+    fireEvent.click(screen.getByRole('button', { name: /지금 재확인/ }));
+    expect(inboxApi.ollamaRecheck).toHaveBeenCalled();
+  });
+});

tests/unit/AiWorker.test.ts

@@ -6,6 +6,7 @@ import { AiWorker } from '@main/ai/AiWorker.js';
 import type { AiTelemetryEmitter } from '@main/ai/AiWorker.js';
 import type { InferenceProvider } from '@main/ai/InferenceProvider.js';
 import type { AiResponse } from '@main/ai/schema.js';
+import { ProviderHolder } from '@main/ai/ProviderHolder.js';
 
 type EmittedEvent = { kind: string; payload: unknown };
 
@@ -33,7 +34,7 @@ describe('AiWorker', () => {
   it('processes a pending job and marks done', async () => {
     const { id } = repo.create({ rawText: 'x' });
     const updates: string[] = [];
-    const w = new AiWorker(repo, makeProvider(), {
+    const w = new AiWorker(repo, new ProviderHolder(makeProvider()), {
       backoffsMs: [0, 0, 0],
       onUpdate: (note) => updates.push(note.aiStatus)
     });
@@ -48,7 +49,7 @@ describe('AiWorker', () => {
     const provider = makeProvider({
       generate: vi.fn(async () => { throw new Error('boom'); })
     });
-    const w = new AiWorker(repo, provider, { backoffsMs: [0, 0, 0] });
+    const w = new AiWorker(repo, new ProviderHolder(provider), { backoffsMs: [0, 0, 0] });
     await w.enqueue(id);
     await w.drain();
     const note = repo.findById(id)!;
@@ -60,7 +61,7 @@ describe('AiWorker', () => {
   it('loadFromDb re-queues all pending', async () => {
     const a = repo.create({ rawText: 'a' }).id;
     const b = repo.create({ rawText: 'b' }).id;
-    const w = new AiWorker(repo, makeProvider(), { backoffsMs: [0, 0, 0] });
+    const w = new AiWorker(repo, new ProviderHolder(makeProvider()), { backoffsMs: [0, 0, 0] });
     await w.loadFromDb();
     await w.drain();
     expect(repo.findById(a)?.aiStatus).toBe('done');
@@ -79,7 +80,7 @@ describe('AiWorker', () => {
         return { title: '제목', summary: 'a\nb\nc', tags: [], dueDate: null };
       })
     });
-    const w = new AiWorker(repo, provider, { backoffsMs: [0, 0, 0] });
+    const w = new AiWorker(repo, new ProviderHolder(provider), { backoffsMs: [0, 0, 0] });
     for (const id of ids) await w.enqueue(id);
     await w.drain();
     expect(max).toBe(1);
@@ -96,7 +97,7 @@ describe('AiWorker', () => {
       }),
       healthCheck: async () => ({ ok: true })
     } as any;
-    const w = new AiWorker(repo, provider, {
+    const w = new AiWorker(repo, new ProviderHolder(provider), {
       backoffsMs: [0],
       now: () => new Date('2026-04-26T00:00:00.000Z')
     });
@@ -118,7 +119,7 @@ describe('AiWorker', () => {
       }),
       healthCheck: async () => ({ ok: true })
     } as any;
-    const w = new AiWorker(repo, provider, {
+    const w = new AiWorker(repo, new ProviderHolder(provider), {
       backoffsMs: [0],
       now: () => new Date('2026-04-26T00:00:00.000Z')
     });
@@ -140,7 +141,7 @@ describe('AiWorker', () => {
       }),
       healthCheck: async () => ({ ok: true })
     } as any;
-    const w = new AiWorker(repo, provider, {
+    const w = new AiWorker(repo, new ProviderHolder(provider), {
       backoffsMs: [0],
       now: () => new Date('2026-04-26T00:00:00.000Z')
     });
@@ -162,7 +163,7 @@ describe('AiWorker', () => {
       },
       healthCheck: async () => ({ ok: true })
     } as any;
-    const w = new AiWorker(repo, provider, {
+    const w = new AiWorker(repo, new ProviderHolder(provider), {
       backoffsMs: [0],
       now: () => new Date('2026-04-26T15:00:00.000Z') // 04-27 00:00 KST
     });
@@ -184,7 +185,7 @@ describe('AiWorker', () => {
       },
       healthCheck: async () => ({ ok: true })
     } as any;
-    const w = new AiWorker(repo, provider, {
+    const w = new AiWorker(repo, new ProviderHolder(provider), {
       backoffsMs: [0],
       now: () => new Date('2026-04-26T00:00:00.000Z')
     });
@@ -216,7 +217,7 @@ describe('AiWorker telemetry emit', () => {
 
   it('emits ai_succeeded with durationMs/attempts on success', async () => {
     const { id } = repo.create({ rawText: '수요일 회의 메모' });
-    const w = new AiWorker(repo, makeProvider(), {
+    const w = new AiWorker(repo, new ProviderHolder(makeProvider()), {
       backoffsMs: [0, 0, 0],
       telemetry: collectingTelemetry
     });
@@ -236,7 +237,7 @@ describe('AiWorker telemetry emit', () => {
     const provider = makeProvider({
       generate: vi.fn(async () => { throw new Error('fetch failed: ECONNREFUSED 11434'); })
     });
-    const w = new AiWorker(repo, provider, {
+    const w = new AiWorker(repo, new ProviderHolder(provider), {
       backoffsMs: [0, 0, 0],
       unreachableBackoffsMs: [10, 10, 10, 10, 10, 10],
       telemetry: collectingTelemetry
@@ -254,7 +255,7 @@ describe('AiWorker telemetry emit', () => {
     const provider = makeProvider({
       generate: vi.fn(async () => { throw new ZodError([]); })
     });
-    const w = new AiWorker(repo, provider, {
+    const w = new AiWorker(repo, new ProviderHolder(provider), {
       backoffsMs: [0, 0, 0],
       telemetry: collectingTelemetry
     });
@@ -270,7 +271,7 @@ describe('AiWorker telemetry emit', () => {
     const provider = makeProvider({
       generate: vi.fn(async () => { throw new Error('mystery'); })
     });
-    const w = new AiWorker(repo, provider, {
+    const w = new AiWorker(repo, new ProviderHolder(provider), {
       backoffsMs: [0, 0, 0],
       telemetry: collectingTelemetry
     });
@@ -300,7 +301,7 @@ describe('AiWorker — deletedAt guard (v0.2.3 #4)', () => {
     db.prepare(`INSERT INTO pending_jobs (note_id, attempts, next_run_at) VALUES (?, 0, ?)`).run(id, '2026-05-01T12:00:00.000Z');
     const generate = vi.fn();
     const provider = makeProvider({ generate: generate as any });
-    const w = new AiWorker(repo, provider, { backoffsMs: [0, 0, 0] });
+    const w = new AiWorker(repo, new ProviderHolder(provider), { backoffsMs: [0, 0, 0] });
     await w.loadFromDb();
     await w.drain();
     expect(generate).not.toHaveBeenCalled();
@@ -322,7 +323,7 @@ describe('AiWorker — unreachable/timeout infinite retry (v0.2.3 #2)', () => {
     const provider = makeProvider({
       generate: vi.fn(async () => { throw new Error('ECONNREFUSED'); })
     });
-    const w = new AiWorker(repo, provider, {
+    const w = new AiWorker(repo, new ProviderHolder(provider), {
       backoffsMs: [0, 30_000, 120_000],
       unreachableBackoffsMs: [10, 10, 10, 10, 10, 10]
     });
@@ -341,7 +342,7 @@ describe('AiWorker — unreachable/timeout infinite retry (v0.2.3 #2)', () => {
     const provider = makeProvider({
       generate: vi.fn(async () => { throw new Error('Request timeout'); })
     });
-    const w = new AiWorker(repo, provider, {
+    const w = new AiWorker(repo, new ProviderHolder(provider), {
       backoffsMs: [0, 30_000, 120_000],
       unreachableBackoffsMs: [10, 10, 10, 10, 10, 10]
     });
@@ -360,7 +361,7 @@ describe('AiWorker — unreachable/timeout infinite retry (v0.2.3 #2)', () => {
       })
     });
     const events: any[] = [];
-    const w = new AiWorker(repo, provider, {
+    const w = new AiWorker(repo, new ProviderHolder(provider), {
       backoffsMs: [0, 0, 0],
       telemetry: { emit: async (e) => { events.push(e); } }
     });
@@ -379,7 +380,7 @@ describe('AiWorker — unreachable/timeout infinite retry (v0.2.3 #2)', () => {
       generate: vi.fn(async () => { throw new Error('something weird'); })
     });
     const events: any[] = [];
-    const w = new AiWorker(repo, provider, {
+    const w = new AiWorker(repo, new ProviderHolder(provider), {
       backoffsMs: [0, 0, 0],
       telemetry: { emit: async (e) => { events.push(e); } }
     });
@@ -392,7 +393,7 @@ describe('AiWorker — unreachable/timeout infinite retry (v0.2.3 #2)', () => {
   });
 
   it('unreachable backoff schedule — nextBackoffMs(step) cap at index 5 (15분)', async () => {
-    const w = new AiWorker(repo, makeProvider(), {
+    const w = new AiWorker(repo, new ProviderHolder(makeProvider()), {
       backoffsMs: [0, 30_000, 120_000],
       unreachableBackoffsMs: [30_000, 60_000, 120_000, 240_000, 480_000, 900_000]
     });
@@ -411,7 +412,7 @@ describe('AiWorker — unreachable/timeout infinite retry (v0.2.3 #2)', () => {
         return { title: 't', summary: 's', tags: [], dueDate: null };
       })
     });
-    const w = new AiWorker(repo, provider, {
+    const w = new AiWorker(repo, new ProviderHolder(provider), {
       backoffsMs: [0, 0, 0],
       unreachableBackoffsMs: [10, 10, 10, 10, 10, 10]
     });
@@ -443,7 +444,7 @@ describe('AiWorker — vocab fetch + per-tag hit/miss (v0.2.3 #3 T7)', () => {
     const generateMock = vi.fn(async () => ({
       title: '제목', summary: 'a\nb\nc', tags: ['design'], dueDate: null
     }));
-    const w = new AiWorker(repo, makeProvider({ generate: generateMock }), {
+    const w = new AiWorker(repo, new ProviderHolder(makeProvider({ generate: generateMock })), {
       backoffsMs: [0, 0, 0]
     });
     await w.enqueue(id);
@@ -467,7 +468,7 @@ describe('AiWorker — vocab fetch + per-tag hit/miss (v0.2.3 #3 T7)', () => {
       }))
     });
     const emits: EmittedEvent[] = [];
-    const w = new AiWorker(repo, provider, {
+    const w = new AiWorker(repo, new ProviderHolder(provider), {
       backoffsMs: [0, 0, 0],
       telemetry: {
         emit: vi.fn(async (input) => { emits.push(input); })
@@ -497,7 +498,7 @@ describe('AiWorker — vocab fetch + per-tag hit/miss (v0.2.3 #3 T7)', () => {
       }))
     });
     const emits: EmittedEvent[] = [];
-    const w = new AiWorker(repo, provider, {
+    const w = new AiWorker(repo, new ProviderHolder(provider), {
       backoffsMs: [0, 0, 0],
       telemetry: { emit: vi.fn(async (input) => { emits.push(input); }) }
     });
@@ -522,7 +523,7 @@ describe('AiWorker — vocab fetch + per-tag hit/miss (v0.2.3 #3 T7)', () => {
       }))
     });
     const emits: EmittedEvent[] = [];
-    const w = new AiWorker(repo, provider, {
+    const w = new AiWorker(repo, new ProviderHolder(provider), {
       backoffsMs: [0, 0, 0],
       telemetry: { emit: vi.fn(async (input) => { emits.push(input); }) }
     });
@@ -546,7 +547,7 @@ describe('AiWorker — vocab fetch + per-tag hit/miss (v0.2.3 #3 T7)', () => {
       }))
     });
     const emits: EmittedEvent[] = [];
-    const w = new AiWorker(repo, provider, {
+    const w = new AiWorker(repo, new ProviderHolder(provider), {
       backoffsMs: [0, 0, 0],
       telemetry: { emit: vi.fn(async (input) => { emits.push(input); }) }
     });

tests/unit/App.test.tsx

@@ -0,0 +1,91 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import '@testing-library/jest-dom/vitest';
+import { render, screen, fireEvent, cleanup, waitFor } from '@testing-library/react';
+
+vi.mock('../../src/renderer/inbox/api.js', () => ({
+  inboxApi: {
+    listNotes: vi.fn(async () => []),
+    getContinuity: vi.fn(async () => ({
+      weekStart: '', weekCount: 0, weekTarget: 7,
+      consecutiveCompleteWeeks: 0, showRecoveryToast: false, lastNoteAt: null
+    })),
+    getPendingCount: vi.fn(async () => 0),
+    getOllamaStatus: vi.fn(async () => ({ ok: true })),
+    getTodayCount: vi.fn(async () => 0),
+    getTrashCount: vi.fn(async () => 0),
+    listExpired: vi.fn(async () => []),
+    getFailedCount: vi.fn(async () => 0),
+    listRecallCandidate: vi.fn(async () => null),
+    onNoteUpdated: vi.fn(() => () => undefined),
+    onOllamaStatus: vi.fn(() => () => undefined),
+    onNavigate: vi.fn(() => () => undefined),
+    // 4 섹션 mounted 시 호출되는 stub
+    loadOllamaSettings: vi.fn(async () => ({ endpoint: '', model: '' })),
+    saveOllamaSettings: vi.fn(async () => ({ ok: true })),
+    ollamaRecheck: vi.fn(async () => ({ ok: true })),
+    getAutostart: vi.fn(async () => ({
+      openAtLogin: false,
+      diagnostic: {
+        withArgs: { openAtLogin: false, executableWillLaunchAtLogin: false },
+        noArgs: { openAtLogin: false, executableWillLaunchAtLogin: false },
+        execPath: '/p'
+      }
+    })),
+    setAutostart: vi.fn(async () => ({
+      openAtLogin: false,
+      diagnostic: {
+        withArgs: { openAtLogin: false, executableWillLaunchAtLogin: false },
+        noArgs: { openAtLogin: false, executableWillLaunchAtLogin: false },
+        execPath: '/p'
+      }
+    })),
+    runBackup: vi.fn(async () => ({ ok: true })),
+    runExport: vi.fn(async () => ({ ok: true })),
+    runImport: vi.fn(async () => ({ ok: true })),
+    runSync: vi.fn(async () => ({ ok: true })),
+    runExportTelemetry: vi.fn(async () => ({ ok: true })),
+    getAppInfo: vi.fn(async () => ({ version: '0.2.7', electron: '?', node: '?', os: '?', profileDir: '?' })),
+    openProfileDir: vi.fn(async () => undefined),
+    copyAppInfo: vi.fn(async () => undefined)
+  }
+}));
+
+import { App } from '../../src/renderer/inbox/App';
+import { useInbox } from '../../src/renderer/inbox/store';
+import { inboxApi } from '../../src/renderer/inbox/api.js';
+
+describe('App — settings view', () => {
+  beforeEach(() => {
+    cleanup();
+    useInbox.setState({ showSettings: false, notes: [], trashNotes: [], trashCount: 0 });
+  });
+
+  it('renders SettingsPage when showSettings=true', async () => {
+    useInbox.setState({ showSettings: true });
+    render(<App />);
+    expect(await screen.findByText('설정')).toBeInTheDocument();
+    expect(screen.getByText('AI 제공자')).toBeInTheDocument();
+  });
+
+  it('header gear icon click sets showSettings=true', async () => {
+    render(<App />);
+    fireEvent.click(await screen.findByLabelText('설정 열기'));
+    expect(useInbox.getState().showSettings).toBe(true);
+  });
+
+  it('inbox:navigate "settings" event sets showSettings=true', async () => {
+    const navHandlers: Array<(view: 'inbox' | 'trash' | 'settings') => void> = [];
+    vi.mocked(inboxApi.onNavigate).mockImplementation((cb) => {
+      navHandlers.push(cb);
+      return () => {
+        const i = navHandlers.indexOf(cb);
+        if (i >= 0) navHandlers.splice(i, 1);
+      };
+    });
+    render(<App />);
+    await waitFor(() => expect(navHandlers.length).toBeGreaterThan(0));
+    navHandlers.forEach((h) => h('settings'));
+    await waitFor(() => expect(useInbox.getState().showSettings).toBe(true));
+  });
+});

tests/unit/AutostartDiagnostic.test.ts

@@ -0,0 +1,96 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const { mockApp, mockExecFile } = vi.hoisted(() => ({
+  mockApp: { getLoginItemSettings: vi.fn() },
+  mockExecFile: vi.fn()
+}));
+
+vi.mock('electron', () => ({
+  default: { app: mockApp }
+}));
+
+vi.mock('node:child_process', () => ({
+  execFile: mockExecFile
+}));
+
+import { collectAutostartState } from '../../src/main/services/AutostartDiagnostic';
+
+const ORIGINAL_PLATFORM = process.platform;
+
+function setPlatform(p: NodeJS.Platform): void {
+  Object.defineProperty(process, 'platform', { value: p, configurable: true });
+}
+
+describe('AutostartDiagnostic — collectAutostartState', () => {
+  beforeEach(() => {
+    mockApp.getLoginItemSettings.mockReset();
+    mockExecFile.mockReset();
+  });
+
+  afterEach(() => {
+    setPlatform(ORIGINAL_PLATFORM);
+  });
+
+  it('returns withArgs / noArgs / execPath structure', async () => {
+    setPlatform('darwin');
+    mockApp.getLoginItemSettings
+      .mockReturnValueOnce({ openAtLogin: true, executableWillLaunchAtLogin: true })
+      .mockReturnValueOnce({ openAtLogin: false, executableWillLaunchAtLogin: true });
+
+    const state = await collectAutostartState();
+
+    expect(state.withArgs).toEqual({ openAtLogin: true, executableWillLaunchAtLogin: true });
+    expect(state.noArgs).toEqual({ openAtLogin: false, executableWillLaunchAtLogin: true });
+    expect(state.execPath).toBe(process.execPath);
+  });
+
+  it('passes args=["--hidden"] for the first call, no args for the second', async () => {
+    setPlatform('darwin');
+    mockApp.getLoginItemSettings
+      .mockReturnValueOnce({ openAtLogin: true, executableWillLaunchAtLogin: true })
+      .mockReturnValueOnce({ openAtLogin: true, executableWillLaunchAtLogin: true });
+
+    await collectAutostartState();
+
+    expect(mockApp.getLoginItemSettings).toHaveBeenNthCalledWith(1, { args: ['--hidden'] });
+    expect(mockApp.getLoginItemSettings).toHaveBeenNthCalledWith(2);
+  });
+
+  it('non-win32: does not set registryPath/registryValue', async () => {
+    setPlatform('darwin');
+    mockApp.getLoginItemSettings.mockReturnValue({ openAtLogin: true, executableWillLaunchAtLogin: true });
+
+    const state = await collectAutostartState();
+
+    expect(state.registryPath).toBeUndefined();
+    expect(state.registryValue).toBeUndefined();
+    expect(mockExecFile).not.toHaveBeenCalled();
+  });
+
+  it('Windows: returns registryPath + registryValue when reg.exe succeeds', async () => {
+    setPlatform('win32');
+    mockApp.getLoginItemSettings.mockReturnValue({ openAtLogin: true, executableWillLaunchAtLogin: true });
+    mockExecFile.mockImplementation((_cmd: string, _args: string[], cb: (err: Error | null, stdout: string, stderr: string) => void) => {
+      cb(null, '\r\nHKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Run\r\n    Inkling    REG_SZ    "C:\\Users\\u\\Inkling.exe" --hidden\r\n', '');
+    });
+
+    const state = await collectAutostartState();
+
+    expect(state.registryPath).toBe('HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run\\Inkling');
+    expect(state.registryValue).toContain('Inkling.exe');
+    expect(state.registryValue).toContain('--hidden');
+  });
+
+  it('Windows: silent fallback on reg.exe error', async () => {
+    setPlatform('win32');
+    mockApp.getLoginItemSettings.mockReturnValue({ openAtLogin: true, executableWillLaunchAtLogin: true });
+    mockExecFile.mockImplementation((_cmd: string, _args: string[], cb: (err: Error | null, stdout: string, stderr: string) => void) => {
+      cb(new Error('not found'), '', '');
+    });
+
+    const state = await collectAutostartState();
+
+    expect(state.registryPath).toBe('HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run\\Inkling');
+    expect(state.registryValue).toBeNull();
+  });
+});

tests/unit/AutostartSection.test.tsx

@@ -0,0 +1,115 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import '@testing-library/jest-dom/vitest';
+import { render, screen, fireEvent, waitFor, cleanup } from '@testing-library/react';
+
+function makeDiag(open: boolean): {
+  withArgs: { openAtLogin: boolean; executableWillLaunchAtLogin: boolean };
+  noArgs: { openAtLogin: boolean; executableWillLaunchAtLogin: boolean };
+  execPath: string;
+} {
+  return {
+    withArgs: { openAtLogin: open, executableWillLaunchAtLogin: open },
+    noArgs: { openAtLogin: open, executableWillLaunchAtLogin: open },
+    execPath: '/path/to/exe'
+  };
+}
+
+vi.mock('../../src/renderer/inbox/api.js', () => ({
+  inboxApi: {
+    getAutostart: vi.fn(async () => ({ openAtLogin: true, diagnostic: makeDiag(true) })),
+    setAutostart: vi.fn(async (open: boolean) => ({ openAtLogin: open, diagnostic: makeDiag(open) }))
+  }
+}));
+
+import { AutostartSection } from '../../src/renderer/inbox/components/settings/AutostartSection';
+
+describe('AutostartSection', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    cleanup();
+  });
+
+  it('renders toggle reflecting current state', async () => {
+    render(<AutostartSection />);
+    const toggle = await screen.findByRole('checkbox');
+    expect(toggle).toBeChecked();
+  });
+
+  it('clicking toggle calls setAutostart', async () => {
+    const { inboxApi } = await import('../../src/renderer/inbox/api.js');
+    render(<AutostartSection />);
+    const toggle = await screen.findByRole('checkbox');
+    fireEvent.click(toggle);
+    await waitFor(() => expect(inboxApi.setAutostart).toHaveBeenCalledWith(false));
+  });
+
+  it('renders diagnostic panel when expanded, shows mismatch warning + execPath', async () => {
+    const { inboxApi } = await import('../../src/renderer/inbox/api.js');
+    vi.mocked(inboxApi.getAutostart).mockResolvedValueOnce({
+      openAtLogin: true,
+      diagnostic: {
+        withArgs: { openAtLogin: true, executableWillLaunchAtLogin: true },
+        noArgs: { openAtLogin: false, executableWillLaunchAtLogin: true },
+        execPath: '/path/to/Inkling.exe'
+      }
+    });
+    render(<AutostartSection />);
+    await screen.findByRole('checkbox');
+    fireEvent.click(screen.getByRole('button', { name: /진단 정보/ }));
+    expect(await screen.findByText(/⚠️/)).toBeInTheDocument();
+    expect(screen.getByText(/path\/to\/Inkling\.exe/)).toBeInTheDocument();
+    expect(screen.getByText(/표준 \(--hidden 인자\)/)).toBeInTheDocument();
+    expect(screen.getByText(/비교 \(인자 없이\)/)).toBeInTheDocument();
+  });
+
+  it('shows registry info when present (Win)', async () => {
+    const { inboxApi } = await import('../../src/renderer/inbox/api.js');
+    vi.mocked(inboxApi.getAutostart).mockResolvedValueOnce({
+      openAtLogin: true,
+      diagnostic: {
+        withArgs: { openAtLogin: true, executableWillLaunchAtLogin: true },
+        noArgs: { openAtLogin: true, executableWillLaunchAtLogin: true },
+        execPath: 'C:\\app.exe',
+        registryPath: 'HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run\\Inkling',
+        registryValue: '"C:\\app.exe" --hidden'
+      }
+    });
+    render(<AutostartSection />);
+    await screen.findByRole('checkbox');
+    fireEvent.click(screen.getByRole('button', { name: /진단 정보/ }));
+    expect(screen.getByText(/registry 경로/)).toBeInTheDocument();
+    expect(screen.getByText(/registry 값/)).toBeInTheDocument();
+  });
+
+  it('no mismatch warning when withArgs == noArgs and willLaunch=true', async () => {
+    const { inboxApi } = await import('../../src/renderer/inbox/api.js');
+    vi.mocked(inboxApi.getAutostart).mockResolvedValueOnce({
+      openAtLogin: true,
+      diagnostic: {
+        withArgs: { openAtLogin: true, executableWillLaunchAtLogin: true },
+        noArgs: { openAtLogin: true, executableWillLaunchAtLogin: true },
+        execPath: '/p'
+      }
+    });
+    render(<AutostartSection />);
+    await screen.findByRole('checkbox');
+    expect(screen.queryByText(/⚠️/)).not.toBeInTheDocument();
+  });
+
+  it('"재등록" button calls setAutostart with current openAtLogin value', async () => {
+    const { inboxApi } = await import('../../src/renderer/inbox/api.js');
+    vi.mocked(inboxApi.getAutostart).mockResolvedValueOnce({
+      openAtLogin: true,
+      diagnostic: {
+        withArgs: { openAtLogin: true, executableWillLaunchAtLogin: true },
+        noArgs: { openAtLogin: true, executableWillLaunchAtLogin: true },
+        execPath: '/p'
+      }
+    });
+    render(<AutostartSection />);
+    await screen.findByRole('checkbox');
+    fireEvent.click(screen.getByRole('button', { name: /재등록/ }));
+    await waitFor(() => expect(inboxApi.setAutostart).toHaveBeenCalledWith(true));
+  });
+});

tests/unit/BackupSection.test.tsx

@@ -0,0 +1,39 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import '@testing-library/jest-dom/vitest';
+import { render, screen, fireEvent, cleanup, waitFor } from '@testing-library/react';
+
+vi.mock('../../src/renderer/inbox/api.js', () => ({
+  inboxApi: {
+    runBackup: vi.fn(async () => ({ ok: true })),
+    runExport: vi.fn(async () => ({ ok: true })),
+    runImport: vi.fn(async () => ({ ok: true })),
+    runSync: vi.fn(async () => ({ ok: true })),
+    runExportTelemetry: vi.fn(async () => ({ ok: true }))
+  }
+}));
+
+import { BackupSection } from '../../src/renderer/inbox/components/settings/BackupSection';
+
+describe('BackupSection', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    cleanup();
+  });
+
+  it('renders 5 buttons', () => {
+    render(<BackupSection />);
+    expect(screen.getByRole('button', { name: /지금 백업/ })).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /^내보내기/ })).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /백업에서 복원/ })).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /지금 동기화/ })).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /사용 로그/ })).toBeInTheDocument();
+  });
+
+  it('clicking 지금 백업 calls runBackup', async () => {
+    const { inboxApi } = await import('../../src/renderer/inbox/api.js');
+    render(<BackupSection />);
+    fireEvent.click(screen.getByRole('button', { name: /지금 백업/ }));
+    await waitFor(() => expect(inboxApi.runBackup).toHaveBeenCalled());
+  });
+});

tests/unit/CaptureService.test.ts

@@ -324,6 +324,52 @@ describe('CaptureService.trashExpiredBatch', () => {
   });
 });
 
+describe('CaptureService.restoreNote — enqueue on failed/pending (#10 production path)', () => {
+  let db: Database.Database;
+  let repo: NoteRepository;
+  let store: MediaStore;
+  let tmp: string;
+  let enqueued: string[];
+  let svc: CaptureService;
+
+  beforeEach(() => {
+    db = new Database(':memory:');
+    runMigrations(db);
+    repo = new NoteRepository(db);
+    tmp = mkdtempSync(join(tmpdir(), 'inkling-restore-'));
+    store = new MediaStore(tmp);
+    enqueued = [];
+    svc = new CaptureService(repo, store, {
+      enqueue: async (id) => { enqueued.push(id); },
+      celebrate: () => {}
+    });
+  });
+
+  it('restoreNote calls worker.enqueue when restoring failed note', async () => {
+    const { id } = repo.create({ rawText: 'x' });
+    repo.markAiFailed(id, 'unreachable');
+    repo.trash(id, new Date().toISOString());
+    enqueued.length = 0; // reset
+
+    await svc.restoreNote(id);
+
+    expect(repo.findById(id)!.aiStatus).toBe('pending');
+    expect(enqueued).toContain(id);
+  });
+
+  it('restoreNote does not enqueue done note', async () => {
+    const { id } = repo.create({ rawText: 'x' });
+    repo.updateAiResult(id, { title: 't', summary: 'a\nb\nc', tags: ['x'], provider: 'p' });
+    repo.trash(id, new Date().toISOString());
+    enqueued.length = 0; // reset
+
+    await svc.restoreNote(id);
+
+    expect(repo.findById(id)!.aiStatus).toBe('done');
+    expect(enqueued).not.toContain(id);
+  });
+});
+
 describe('CaptureService.retryAllFailed', () => {
   let db: Database.Database;
   let repo: NoteRepository;

tests/unit/HealthChecker.test.ts

@@ -2,6 +2,7 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { HealthChecker, type HealthTelemetryEvent } from '@main/services/HealthChecker.js';
 import type { InferenceProvider, HealthResult, GenerateInput } from '@main/ai/InferenceProvider.js';
 import type { AiResponse } from '@main/ai/schema.js';
+import { ProviderHolder } from '@main/ai/ProviderHolder.js';
 
 class FakeProvider implements InferenceProvider {
   readonly name = 'fake';
@@ -24,7 +25,7 @@ describe('HealthChecker — start/stop polling', () => {
   it('start() runs runOnce immediately + every intervalMs', async () => {
     const provider = new FakeProvider();
     provider.results = [{ ok: true }, { ok: true }, { ok: true }];
-    const hc = new HealthChecker(provider, { intervalMs: 1000 });
+    const hc = new HealthChecker(new ProviderHolder(provider), { intervalMs: 1000 });
     hc.start();
     await vi.runOnlyPendingTimersAsync();
     await vi.advanceTimersByTimeAsync(1000);
@@ -36,7 +37,7 @@ describe('HealthChecker — start/stop polling', () => {
   it('start() is idempotent — second call does not duplicate timer', async () => {
     const provider = new FakeProvider();
     provider.results = [{ ok: true }];
-    const hc = new HealthChecker(provider, { intervalMs: 1000 });
+    const hc = new HealthChecker(new ProviderHolder(provider), { intervalMs: 1000 });
     hc.start();
     hc.start();
     // 즉시 1회 + 1s 후 1회 = 정확히 2. 두 timer 가 잘못 등록됐으면 4 (각 timer 마다 즉시+1s).
@@ -48,7 +49,7 @@ describe('HealthChecker — start/stop polling', () => {
   it('stop() clears timer (no further runOnce)', async () => {
     const provider = new FakeProvider();
     provider.results = [{ ok: true }, { ok: true }];
-    const hc = new HealthChecker(provider, { intervalMs: 1000 });
+    const hc = new HealthChecker(new ProviderHolder(provider), { intervalMs: 1000 });
     hc.start();
     await vi.runOnlyPendingTimersAsync();
     const before = (provider as any).idx;
@@ -64,7 +65,7 @@ describe('HealthChecker — delta transitions + telemetry', () => {
     provider.results = [{ ok: true }, { ok: false, reason: 'connection refused' }];
     const updates: HealthResult[] = [];
     const events: HealthTelemetryEvent[] = [];
-    const hc = new HealthChecker(provider, {
+    const hc = new HealthChecker(new ProviderHolder(provider), {
       onUpdate: (s) => updates.push(s),
       onTelemetry: (e) => events.push(e)
     });
@@ -79,7 +80,7 @@ describe('HealthChecker — delta transitions + telemetry', () => {
     provider.results = [{ ok: false, reason: 'refused' }, { ok: true }];
     const events: HealthTelemetryEvent[] = [];
     let nowCounter = 0;
-    const hc = new HealthChecker(provider, {
+    const hc = new HealthChecker(new ProviderHolder(provider), {
       onTelemetry: (e) => events.push(e),
       now: () => { nowCounter += 1; return nowCounter * 1000; }
     });
@@ -97,7 +98,7 @@ describe('HealthChecker — delta transitions + telemetry', () => {
     ];
     const updates: HealthResult[] = [];
     const events: HealthTelemetryEvent[] = [];
-    const hc = new HealthChecker(provider, {
+    const hc = new HealthChecker(new ProviderHolder(provider), {
       onUpdate: (s) => updates.push(s),
       onTelemetry: (e) => events.push(e)
     });
@@ -111,7 +112,7 @@ describe('HealthChecker — delta transitions + telemetry', () => {
     const provider = new FakeProvider();
     provider.results = [{ ok: true }];
     const events: HealthTelemetryEvent[] = [];
-    const hc = new HealthChecker(provider, { onTelemetry: (e) => events.push(e) });
+    const hc = new HealthChecker(new ProviderHolder(provider), { onTelemetry: (e) => events.push(e) });
     await hc.runOnce({ manual: true });
     expect(events).toEqual([{ kind: 'ollama_recheck_manual' }]);
   });

tests/unit/InfoSection.test.tsx

@@ -0,0 +1,49 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import '@testing-library/jest-dom/vitest';
+import { render, screen, fireEvent, cleanup, waitFor } from '@testing-library/react';
+
+vi.mock('../../src/renderer/inbox/api.js', () => ({
+  inboxApi: {
+    getAppInfo: vi.fn(async () => ({
+      version: '0.2.7',
+      electron: '41.3.0',
+      node: '22.x',
+      os: 'darwin 23.6.0',
+      profileDir: '/Users/u/Library/Application Support/Inkling'
+    })),
+    openProfileDir: vi.fn(async () => undefined),
+    copyAppInfo: vi.fn(async () => undefined)
+  }
+}));
+
+import { InfoSection } from '../../src/renderer/inbox/components/settings/InfoSection';
+
+describe('InfoSection', () => {
+  beforeEach(() => { vi.clearAllMocks(); cleanup(); });
+
+  it('renders version, electron, node, OS, profileDir', async () => {
+    render(<InfoSection />);
+    expect(await screen.findByText(/0\.2\.7/)).toBeInTheDocument();
+    expect(screen.getByText(/41\.3\.0/)).toBeInTheDocument();
+    expect(screen.getByText(/22\.x/)).toBeInTheDocument();
+    expect(screen.getByText(/darwin/)).toBeInTheDocument();
+    expect(screen.getByText(/Library\/Application Support\/Inkling/)).toBeInTheDocument();
+  });
+
+  it('"데이터 위치 열기" calls openProfileDir', async () => {
+    const { inboxApi } = await import('../../src/renderer/inbox/api.js');
+    render(<InfoSection />);
+    await screen.findByText(/0\.2\.7/);
+    fireEvent.click(screen.getByRole('button', { name: /데이터 위치 열기/ }));
+    await waitFor(() => expect(inboxApi.openProfileDir).toHaveBeenCalled());
+  });
+
+  it('"정보 복사" calls copyAppInfo', async () => {
+    const { inboxApi } = await import('../../src/renderer/inbox/api.js');
+    render(<InfoSection />);
+    await screen.findByText(/0\.2\.7/);
+    fireEvent.click(screen.getByRole('button', { name: /정보 복사/ }));
+    await waitFor(() => expect(inboxApi.copyAppInfo).toHaveBeenCalled());
+  });
+});

tests/unit/LocalOllamaProvider.test.ts

@@ -89,4 +89,24 @@ describe('LocalOllamaProvider', () => {
     expect(h.ok).toBe(false);
     expect(h.reason).toMatch(/connect|refused|unreachable/i);
   });
+
+  it('abort() cancels in-flight generate (rejects with AbortError)', async () => {
+    mock.get('http://localhost:11434').intercept({
+      path: '/api/generate', method: 'POST'
+    }).reply((async () => {
+      await new Promise<void>((r) => setTimeout(r, 5000)); // long-running
+      return { statusCode: 200, data: '{}' };
+    }) as never);
+    const provider = new LocalOllamaProvider({ timeoutMs: 30_000 });
+    const generatePromise = provider.generate({
+      text: 'x', todayKst: '2026-05-04', dueDateCandidates: []
+    });
+    setTimeout(() => provider.abort(), 50);
+    await expect(generatePromise).rejects.toThrow();
+  });
+
+  it('constructor uses provided model param (not just default)', () => {
+    const provider = new LocalOllamaProvider({ model: 'gemma4:26b' });
+    expect(provider.name).toBe('local-ollama/gemma4:26b');
+  });
 });

tests/unit/NoteCard.test.tsx

@@ -0,0 +1,81 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import '@testing-library/jest-dom/vitest';
+import { render, screen, fireEvent, cleanup } from '@testing-library/react';
+import type { Note } from '@shared/types';
+
+const { mockOpenMedia } = vi.hoisted(() => ({
+  mockOpenMedia: vi.fn(async () => ({ ok: true }))
+}));
+
+vi.mock('../../src/renderer/inbox/api.js', () => ({
+  inboxApi: {
+    openMedia: mockOpenMedia,
+    deleteNote: vi.fn(),
+    restoreNote: vi.fn(),
+    permanentDeleteNote: vi.fn(),
+    updateAiFields: vi.fn(),
+    setDueDate: vi.fn(),
+    setIntent: vi.fn(),
+    dismissIntent: vi.fn()
+  }
+}));
+
+vi.mock('../../src/renderer/inbox/store.js', () => ({
+  useInbox: Object.assign(
+    () => ({}),
+    { getState: () => ({ setTagFilter: vi.fn() }) }
+  )
+}));
+
+import { NoteCard } from '../../src/renderer/inbox/components/NoteCard';
+
+const baseNote: Note = {
+  id: 'n1',
+  rawText: 'test',
+  aiTitle: 'T',
+  aiSummary: 'S',
+  aiStatus: 'done',
+  aiError: null,
+  aiProvider: null,
+  aiGeneratedAt: '2026-05-09T00:00:00Z',
+  titleEditedByUser: false,
+  summaryEditedByUser: false,
+  userIntent: null,
+  intentPromptedAt: '2026-05-09T00:00:00Z',
+  dueDate: null,
+  dueDateEditedByUser: false,
+  deletedAt: null,
+  lastRecalledAt: null,
+  recallDismissedAt: null,
+  createdAt: '2026-05-09T00:00:00Z',
+  updatedAt: '2026-05-09T00:00:00Z',
+  tags: [],
+  media: [
+    { id: 'm1', kind: 'image', relPath: 'media/n1/img1.png', mime: 'image/png', bytes: 100 },
+    { id: 'm2', kind: 'image', relPath: 'media/n1/img2.jpg', mime: 'image/jpeg', bytes: 200 }
+  ]
+};
+
+describe('NoteCard — image rendering', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    cleanup();
+  });
+
+  it('renders <img> for each media item', () => {
+    render(<NoteCard note={baseNote} onUpdated={() => {}} mode="inbox" />);
+    const imgs = screen.getAllByRole('presentation');
+    expect(imgs).toHaveLength(2);
+    expect(imgs[0]?.getAttribute('src')).toBe('inkling-media://media/n1/img1.png');
+    expect(imgs[1]?.getAttribute('src')).toBe('inkling-media://media/n1/img2.jpg');
+  });
+
+  it('clicking <img> calls inboxApi.openMedia', () => {
+    render(<NoteCard note={baseNote} onUpdated={() => {}} mode="inbox" />);
+    const first = screen.getAllByRole('presentation')[0];
+    if (first === undefined) throw new Error('expected at least one img');
+    fireEvent.click(first);
+    expect(mockOpenMedia).toHaveBeenCalledWith('media/n1/img1.png');
+  });
+});

tests/unit/NoteRepository.test.ts

@@ -267,6 +267,49 @@ describe('NoteRepository', () => {
     repo.updateAiResult(d, { title: 't', summary: 'a\nb\nc', tags: ['x'], dueDate: todayKst, provider: 'p' });
     expect(repo.findRecallCandidate()?.id).toBe(d);
   });
+
+  it('restoreNote re-enqueues failed note (ai_status reset to pending + pending_jobs INSERT)', () => {
+    const id = repo.create({ rawText: 'x' }).id;
+    repo.markAiFailed(id, 'unreachable');
+    repo.trash(id, new Date().toISOString());
+    expect(repo.findById(id)!.aiStatus).toBe('failed');
+
+    repo.restoreNote(id);
+
+    const after = repo.findById(id)!;
+    expect(after.deletedAt).toBeNull();
+    expect(after.aiStatus).toBe('pending');
+    expect(after.aiError).toBeNull();
+    const job = db.prepare('SELECT * FROM pending_jobs WHERE note_id=?').get(id);
+    expect(job).toBeDefined();
+  });
+
+  it('restoreNote does not re-enqueue done note', () => {
+    const id = repo.create({ rawText: 'x' }).id;
+    repo.updateAiResult(id, { title: 't', summary: 'a\nb\nc', tags: ['x'], provider: 'p' });
+    repo.trash(id, new Date().toISOString());
+    expect(repo.findById(id)!.aiStatus).toBe('done');
+
+    repo.restoreNote(id);
+
+    expect(repo.findById(id)!.aiStatus).toBe('done');
+    const job = db.prepare('SELECT * FROM pending_jobs WHERE note_id=?').get(id);
+    expect(job).toBeUndefined();
+  });
+
+  it('restoreNote re-enqueues pending note (defensive)', () => {
+    const id = repo.create({ rawText: 'x' }).id;
+    // 인공적으로 pending_jobs 비운 후 trash
+    db.prepare('DELETE FROM pending_jobs WHERE note_id=?').run(id);
+    repo.trash(id, new Date().toISOString());
+    expect(repo.findById(id)!.aiStatus).toBe('pending');
+
+    repo.restoreNote(id);
+
+    expect(repo.findById(id)!.aiStatus).toBe('pending');
+    const job = db.prepare('SELECT * FROM pending_jobs WHERE note_id=?').get(id);
+    expect(job).toBeDefined();
+  });
 });
 
 describe('NoteRepository.trash', () => {
@@ -449,6 +492,19 @@ describe('NoteRepository.countTrashed', () => {
     expect(repo.countTrashed()).toBe(10);
     expect(repo.listTrashed({ limit: 5 })).toHaveLength(5);
   });
+
+  it('countTrashed returns accurate count (>200 not capped)', () => {
+    const now = new Date().toISOString();
+    for (let i = 0; i < 250; i++) {
+      const id = repo.create({ rawText: `n${i}` }).id;
+      repo.trash(id, now);
+    }
+    expect(repo.countTrashed()).toBe(250);
+  });
+
+  it('countTrashed returns 0 for empty trash', () => {
+    expect(repo.countTrashed()).toBe(0);
+  });
 });
 
 describe('Active queries exclude deleted notes', () => {

tests/unit/ProviderHolder.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect, vi } from 'vitest';
+import { ProviderHolder } from '@main/ai/ProviderHolder.js';
+import { LocalOllamaProvider } from '@main/ai/LocalOllamaProvider.js';
+
+describe('ProviderHolder', () => {
+  it('replace() fires listener and get() returns new instance', () => {
+    const a = new LocalOllamaProvider({ endpoint: 'http://a:11434', model: 'm1' });
+    const b = new LocalOllamaProvider({ endpoint: 'http://b:11434', model: 'm2' });
+    const holder = new ProviderHolder(a);
+    const listener = vi.fn();
+    holder.onReplace(listener);
+    expect(holder.get()).toBe(a);
+    holder.replace(b);
+    expect(holder.get()).toBe(b);
+    expect(listener).toHaveBeenCalledWith(b);
+  });
+
+  it('multiple listeners all fire on replace()', () => {
+    const a = new LocalOllamaProvider({ model: 'm1' });
+    const b = new LocalOllamaProvider({ model: 'm2' });
+    const holder = new ProviderHolder(a);
+    const l1 = vi.fn();
+    const l2 = vi.fn();
+    holder.onReplace(l1);
+    holder.onReplace(l2);
+    holder.replace(b);
+    expect(l1).toHaveBeenCalledWith(b);
+    expect(l2).toHaveBeenCalledWith(b);
+  });
+});

tests/unit/SettingsPage.test.tsx

@@ -0,0 +1,74 @@
+// @vitest-environment jsdom
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import '@testing-library/jest-dom/vitest';
+import { render, screen, fireEvent, cleanup } from '@testing-library/react';
+
+// inboxApi 는 window.inkling.inbox 를 참조하므로 jsdom 환경에서 import 자체가 throw.
+// SettingsPage 가 마운트하는 AiProviderSection 의 useEffect 가 loadOllamaSettings 를 호출하므로
+// 빈 객체 대신 필요한 메서드를 stub 한다.
+vi.mock('../../src/renderer/inbox/api.js', () => ({
+  inboxApi: {
+    loadOllamaSettings: vi.fn(async () => null),
+    saveOllamaSettings: vi.fn(async () => ({ ok: true })),
+    ollamaRecheck: vi.fn(async () => ({ ok: true })),
+    getAutostart: vi.fn(async () => ({
+      openAtLogin: false,
+      diagnostic: {
+        withArgs: { openAtLogin: false, executableWillLaunchAtLogin: false },
+        noArgs: { openAtLogin: false, executableWillLaunchAtLogin: false },
+        execPath: '/p'
+      }
+    })),
+    setAutostart: vi.fn(async (open: boolean) => ({
+      openAtLogin: open,
+      diagnostic: {
+        withArgs: { openAtLogin: open, executableWillLaunchAtLogin: open },
+        noArgs: { openAtLogin: open, executableWillLaunchAtLogin: open },
+        execPath: '/p'
+      }
+    })),
+    runBackup: vi.fn(async () => ({ ok: true })),
+    runExport: vi.fn(async () => ({ ok: true })),
+    runImport: vi.fn(async () => ({ ok: true })),
+    runSync: vi.fn(async () => ({ ok: true })),
+    runExportTelemetry: vi.fn(async () => ({ ok: true })),
+    getAppInfo: vi.fn(async () => ({
+      version: '0.2.7',
+      electron: '41.3.0',
+      node: '22.x',
+      os: 'darwin 23.6.0',
+      profileDir: '/tmp/Inkling'
+    })),
+    openProfileDir: vi.fn(async () => undefined),
+    copyAppInfo: vi.fn(async () => undefined)
+  }
+}));
+
+import { SettingsPage } from '../../src/renderer/inbox/components/SettingsPage';
+import { useInbox } from '../../src/renderer/inbox/store';
+
+describe('SettingsPage', () => {
+  beforeEach(() => {
+    cleanup();
+    useInbox.setState({ showSettings: true });
+  });
+
+  it('renders header with "← 돌아가기" button', () => {
+    render(<SettingsPage />);
+    expect(screen.getByRole('button', { name: /돌아가기/ })).toBeInTheDocument();
+  });
+
+  it('renders 4 section headings', () => {
+    render(<SettingsPage />);
+    expect(screen.getByText('AI 제공자')).toBeInTheDocument();
+    expect(screen.getByText('자동 실행')).toBeInTheDocument();
+    expect(screen.getByText('백업 / 복원')).toBeInTheDocument();
+    expect(screen.getByText('정보')).toBeInTheDocument();
+  });
+
+  it('clicking "← 돌아가기" sets showSettings to false', () => {
+    render(<SettingsPage />);
+    fireEvent.click(screen.getByRole('button', { name: /돌아가기/ }));
+    expect(useInbox.getState().showSettings).toBe(false);
+  });
+});

tests/unit/SettingsService.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, rmSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { SettingsService } from '@main/services/SettingsService.js';
+
+describe('SettingsService', () => {
+  let dir: string;
+  let svc: SettingsService;
+
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), 'inkling-settings-'));
+    svc = new SettingsService(dir);
+  });
+  afterEach(() => { rmSync(dir, { recursive: true, force: true }); });
+
+  it('load() returns empty object when file does not exist', async () => {
+    const s = await svc.load();
+    expect(s).toEqual({});
+  });
+
+  it('load() returns empty object on corrupted JSON (no throw)', async () => {
+    writeFileSync(join(dir, 'settings.json'), '{ this is not json');
+    const s = await svc.load();
+    expect(s).toEqual({});
+  });
+
+  it('load() caches result — second call does not re-read file', async () => {
+    await svc.setOllama({ endpoint: 'http://localhost:11434', model: 'gemma4:e4b' });
+    const before = await svc.load();
+    // 외부에서 파일 변경
+    writeFileSync(join(dir, 'settings.json'), JSON.stringify({ ollama: { endpoint: 'http://lan:11434', model: 'gemma4:26b' } }));
+    const after = await svc.load();
+    // 캐시 적용 — 파일 변경 무시
+    expect(after).toEqual(before);
+  });
+
+  it('setOllama() throws on non-URL endpoint', async () => {
+    await expect(
+      svc.setOllama({ endpoint: 'not-a-url', model: 'gemma4:e4b' })
+    ).rejects.toThrow();
+  });
+
+  it('setOllama() persists to disk with valid JSON', async () => {
+    await svc.setOllama({ endpoint: 'http://localhost:11435', model: 'gemma4:e4b' });
+    const raw = readFileSync(join(dir, 'settings.json'), 'utf8');
+    const parsed = JSON.parse(raw);
+    expect(parsed.ollama.endpoint).toBe('http://localhost:11435');
+    expect(parsed.ollama.model).toBe('gemma4:e4b');
+  });
+
+  it('setOllama() atomic write — tmp file does not remain', async () => {
+    await svc.setOllama({ endpoint: 'http://localhost:11434', model: 'gemma4:e4b' });
+    expect(existsSync(join(dir, 'settings.json.tmp'))).toBe(false);
+    expect(existsSync(join(dir, 'settings.json'))).toBe(true);
+  });
+});

tests/unit/TelemetryService.test.ts

@@ -3,6 +3,7 @@ import { mkdtempSync, rmSync, readFileSync, existsSync, readdirSync, writeFileSy
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { TelemetryService } from '@main/services/TelemetryService.js';
+import { hasNoteId } from '@main/services/telemetryEvents.js';
 
 describe('TelemetryService.emit', () => {
   let dir: string;
@@ -147,11 +148,7 @@ describe('TelemetryService.readAllRecent', () => {
     const events = await svc.readAllRecent();
     expect(events).toHaveLength(3);
     // discriminant narrowing — noteId 없는 kind(empty_trash/expired_banner_shown/expired_batch_trash) 가 섞이면 명시적으로 실패
-    expect(events.map((e) =>
+    expect(events.map((e) => hasNoteId(e) ? e.payload.noteId : null)).toEqual(['a', 'b', 'b']);
-      (e.kind === 'empty_trash' || e.kind === 'expired_banner_shown' || e.kind === 'expired_batch_trash' || e.kind === 'ollama_unreachable' || e.kind === 'ollama_recovered' || e.kind === 'ollama_recheck_manual' || e.kind === 'ai_retry_manual' || e.kind === 'tag_vocab_hit' || e.kind === 'tag_vocab_miss')
-        ? null
-        : e.payload.noteId
-    )).toEqual(['a', 'b', 'b']);
   });
 
   it('skips malformed lines (silent — invariant)', async () => {
@@ -164,7 +161,7 @@ describe('TelemetryService.readAllRecent', () => {
     expect(events).toHaveLength(1);
     const ev = events[0]!;
     expect(ev.kind).toBe('capture');
-    if (ev.kind !== 'empty_trash' && ev.kind !== 'expired_banner_shown' && ev.kind !== 'expired_batch_trash' && ev.kind !== 'ollama_unreachable' && ev.kind !== 'ollama_recovered' && ev.kind !== 'ollama_recheck_manual' && ev.kind !== 'ai_retry_manual' && ev.kind !== 'tag_vocab_hit' && ev.kind !== 'tag_vocab_miss') expect(ev.payload.noteId).toBe('a');
+    if (hasNoteId(ev)) expect(ev.payload.noteId).toBe('a');
   });
 
   it('returns [] when dir missing', async () => {

tests/unit/inboxApi-openMedia.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { join } from 'node:path';
+
+const { handlers, mockOpenPath } = vi.hoisted(() => ({
+  handlers: {} as Record<string, (...args: unknown[]) => unknown>,
+  mockOpenPath: vi.fn(async () => '')
+}));
+
+vi.mock('electron', () => ({
+  default: {
+    ipcMain: {
+      handle: (ch: string, fn: (...args: unknown[]) => unknown) => {
+        handlers[ch] = fn;
+      }
+    },
+    dialog: {},
+    shell: { openPath: mockOpenPath }
+  }
+}));
+
+import { registerInboxApi } from '../../src/main/ipc/inboxApi';
+
+function makeDeps(profileDir: string): Parameters<typeof registerInboxApi>[0] {
+  // Minimal stub — `inbox:open-media` 핸들러는 deps.paths.profileDir 만 참조.
+  return {
+    repo: {} as never,
+    continuity: {} as never,
+    capture: {} as never,
+    health: {} as never,
+    intent: {} as never,
+    getInboxWindow: () => null,
+    settings: {} as never,
+    providerHolder: {} as never,
+    paths: { profileDir }
+  };
+}
+
+describe('inbox:open-media IPC', () => {
+  beforeEach(() => {
+    Object.keys(handlers).forEach((k) => delete handlers[k]);
+    mockOpenPath.mockClear();
+  });
+
+  it('opens valid relPath with shell.openPath', async () => {
+    registerInboxApi(makeDeps('/profile'));
+    const handler = handlers['inbox:open-media'];
+    if (handler === undefined) throw new Error('handler not registered');
+    const r = await handler(null, 'media/note1/img.png');
+    expect(r).toEqual({ ok: true });
+    expect(mockOpenPath).toHaveBeenCalledWith(join('/profile', 'media', 'note1', 'img.png'));
+  });
+
+  it('rejects path traversal with reason "invalid path"', async () => {
+    registerInboxApi(makeDeps('/profile'));
+    const handler = handlers['inbox:open-media'];
+    if (handler === undefined) throw new Error('handler not registered');
+    const r = await handler(null, '../etc/passwd') as { ok: boolean; reason?: string };
+    expect(r.ok).toBe(false);
+    expect(r.reason).toBe('invalid path');
+    expect(mockOpenPath).not.toHaveBeenCalled();
+  });
+});

tests/unit/inklingMedia.test.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { join, sep } from 'node:path';
+
+const { mockReadFile, mockHandle, mockRegisterSchemes } = vi.hoisted(() => ({
+  mockReadFile: vi.fn(),
+  mockHandle: vi.fn(),
+  mockRegisterSchemes: vi.fn()
+}));
+
+vi.mock('node:fs/promises', () => ({
+  readFile: mockReadFile
+}));
+
+vi.mock('electron', () => ({
+  default: {
+    protocol: {
+      registerSchemesAsPrivileged: mockRegisterSchemes,
+      handle: mockHandle
+    }
+  }
+}));
+
+import { registerInklingMediaProtocol, inferMime } from '../../src/main/protocol/inklingMedia';
+
+describe('inferMime', () => {
+  it('returns image/png for .png', () => { expect(inferMime('foo.png')).toBe('image/png'); });
+  it('returns image/jpeg for .jpg and .jpeg', () => {
+    expect(inferMime('foo.jpg')).toBe('image/jpeg');
+    expect(inferMime('foo.jpeg')).toBe('image/jpeg');
+  });
+  it('returns image/gif for .gif', () => { expect(inferMime('foo.gif')).toBe('image/gif'); });
+  it('returns image/webp for .webp', () => { expect(inferMime('foo.webp')).toBe('image/webp'); });
+  it('returns application/octet-stream for unknown', () => { expect(inferMime('foo.xyz')).toBe('application/octet-stream'); });
+});
+
+describe('inkling-media protocol handler', () => {
+  beforeEach(() => { vi.clearAllMocks(); });
+
+  function getHandler(profileDir: string): (req: { url: string }) => Promise<Response> {
+    registerInklingMediaProtocol(profileDir);
+    const call = mockHandle.mock.calls[0];
+    if (!call) throw new Error('protocol.handle not called');
+    return call[1] as (req: { url: string }) => Promise<Response>;
+  }
+
+  // 실 운영 (Electron protocol.handle) 에서는 req.url 이 raw 문자열로 전달되지만,
+  // vitest 의 `new Request()` constructor 는 url 을 즉시 normalize (`/../` 제거) 함.
+  // 따라서 traversal 검사 로직이 raw URL 단계에서 작동하는지 검증하려면
+  // raw url 을 보존한 minimal mock 을 직접 전달.
+  function rawReq(url: string): { url: string } { return { url }; }
+
+  it('serves valid file with correct mime', async () => {
+    mockReadFile.mockResolvedValueOnce(Buffer.from([1, 2, 3]));
+    const handler = getHandler('/profile');
+    const res = await handler(rawReq('inkling-media://media/note1/img.png'));
+    expect(res.status).toBe(200);
+    expect(res.headers.get('content-type')).toBe('image/png');
+    expect(mockReadFile).toHaveBeenCalledWith(join('/profile', 'media', 'note1', 'img.png'));
+  });
+
+  it('returns 403 on path traversal attempt', async () => {
+    const handler = getHandler('/profile');
+    const res = await handler(rawReq('inkling-media://media/../etc/passwd'));
+    expect(res.status).toBe(403);
+    expect(mockReadFile).not.toHaveBeenCalled();
+  });
+
+  it('returns 404 when file missing', async () => {
+    mockReadFile.mockRejectedValueOnce(new Error('ENOENT'));
+    const handler = getHandler('/profile');
+    const res = await handler(rawReq('inkling-media://media/note1/missing.png'));
+    expect(res.status).toBe(404);
+  });
+});

tests/unit/kstDate.test.ts

@@ -1,18 +1,29 @@
 import { describe, it, expect } from 'vitest';
-import { todayInKstString, nextKstMidnightMs } from '@main/util/kstDate.js';
+import { kstTodayIso, nextKstMidnightMs, kstTodayAsDate } from '@shared/util/kstDate.js';
 
-describe('todayInKstString', () => {
+describe('kstTodayIso', () => {
   it('returns KST calendar date as YYYY-MM-DD', () => {
     // 2026-05-01 12:00 UTC = 2026-05-01 21:00 KST
-    expect(todayInKstString(new Date('2026-05-01T12:00:00Z'))).toBe('2026-05-01');
+    expect(kstTodayIso(new Date('2026-05-01T12:00:00Z'))).toBe('2026-05-01');
   });
 
   it('handles UTC→KST date rollover (UTC 23:30 → KST next day 08:30)', () => {
-    expect(todayInKstString(new Date('2026-05-01T23:30:00Z'))).toBe('2026-05-02');
+    expect(kstTodayIso(new Date('2026-05-01T23:30:00Z'))).toBe('2026-05-02');
   });
 
   it('handles KST midnight exactly (UTC 15:00 = KST 00:00 next day)', () => {
-    expect(todayInKstString(new Date('2026-05-01T15:00:00Z'))).toBe('2026-05-02');
+    expect(kstTodayIso(new Date('2026-05-01T15:00:00Z'))).toBe('2026-05-02');
+  });
+
+  it('boundary — UTC 14:59:59 still KST 23:59:59 same day', () => {
+    // KST 5/4 23:59:59 = UTC 5/4 14:59:59
+    const utcDate = new Date('2026-05-04T14:59:59Z');
+    expect(kstTodayIso(utcDate)).toBe('2026-05-04');
+  });
+
+  it('KST 5/5 00:30 (UTC 5/4 15:30) returns 2026-05-05', () => {
+    const utcDate = new Date('2026-05-04T15:30:00Z');
+    expect(kstTodayIso(utcDate)).toBe('2026-05-05');
   });
 });
 
@@ -34,4 +45,19 @@ describe('nextKstMidnightMs', () => {
     expect(next - now).toBeGreaterThan(23 * 60 * 60 * 1000);
     expect(next - now).toBeLessThan(24 * 60 * 60 * 1000);
   });
+
+  it('KST 5/5 00:30 → next KST midnight = 5/6 00:00 KST = 5/5 15:00 UTC', () => {
+    const utcMs = new Date('2026-05-04T15:30:00Z').getTime();
+    const next = nextKstMidnightMs(utcMs);
+    expect(new Date(next).toISOString()).toBe('2026-05-05T15:00:00.000Z');
+  });
+});
+
+describe('kstTodayAsDate', () => {
+  it('returns UTC Date at KST 00:00', () => {
+    // KST 5/5 00:30 → KST 5/5 00:00 = UTC 5/4 15:00
+    const utcDate = new Date('2026-05-04T15:30:00Z');
+    const result = kstTodayAsDate(utcDate);
+    expect(result.toISOString()).toBe('2026-05-05T00:00:00.000Z');
+  });
 });

tests/unit/settingsApi.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const { handlers, mockApp, mockCollectAutostartState } = vi.hoisted(() => ({
+  handlers: {} as Record<string, (...args: unknown[]) => unknown>,
+  mockApp: {
+    getLoginItemSettings: vi.fn(),
+    setLoginItemSettings: vi.fn(),
+    getVersion: vi.fn(() => '0.2.7'),
+    getPath: vi.fn(() => '/profile')
+  },
+  mockCollectAutostartState: vi.fn()
+}));
+
+vi.mock('electron', () => ({
+  default: {
+    ipcMain: {
+      handle: (ch: string, fn: (...args: unknown[]) => unknown) => {
+        handlers[ch] = fn;
+      }
+    },
+    app: mockApp,
+    dialog: {},
+    Notification: vi.fn(function (this: unknown) {
+      Object.assign(this as object, { show: vi.fn() });
+    }),
+    shell: { openPath: vi.fn() },
+    clipboard: { writeText: vi.fn() }
+  }
+}));
+
+vi.mock('../../src/main/services/AutostartDiagnostic', () => ({
+  collectAutostartState: mockCollectAutostartState
+}));
+
+vi.mock('../../src/main/windows/inboxWindow.js', () => ({
+  getInboxWindow: vi.fn(() => null)
+}));
+
+import { registerSettingsApi } from '../../src/main/ipc/settingsApi';
+
+describe('settingsApi — autostart IPC', () => {
+  beforeEach(() => {
+    Object.keys(handlers).forEach((k) => delete handlers[k]);
+    mockApp.getLoginItemSettings.mockReset();
+    mockApp.setLoginItemSettings.mockReset();
+    mockCollectAutostartState.mockReset();
+  });
+
+  it('settings:autostart-state returns AutostartState wrapped with openAtLogin', async () => {
+    mockCollectAutostartState.mockResolvedValue({
+      withArgs: { openAtLogin: true, executableWillLaunchAtLogin: true },
+      noArgs: { openAtLogin: false, executableWillLaunchAtLogin: true },
+      execPath: '/path/to/exe'
+    });
+
+    registerSettingsApi();
+
+    const r = await handlers['settings:autostart-state']!() as {
+      openAtLogin: boolean;
+      diagnostic: { withArgs: { openAtLogin: boolean } };
+    };
+
+    expect(r.openAtLogin).toBe(true);
+    expect(r.diagnostic.withArgs.openAtLogin).toBe(true);
+    expect(r.diagnostic).toHaveProperty('noArgs');
+    expect(r.diagnostic).toHaveProperty('execPath');
+  });
+
+  it('settings:autostart-set calls setLoginItemSettings + returns diagnostic', async () => {
+    mockCollectAutostartState.mockResolvedValue({
+      withArgs: { openAtLogin: false, executableWillLaunchAtLogin: false },
+      noArgs: { openAtLogin: false, executableWillLaunchAtLogin: false },
+      execPath: '/path/to/exe'
+    });
+
+    registerSettingsApi();
+
+    const r = await handlers['settings:autostart-set']!({}, false) as {
+      openAtLogin: boolean;
+      diagnostic: { withArgs: { openAtLogin: boolean } };
+    };
+
+    expect(mockApp.setLoginItemSettings).toHaveBeenCalledWith({ openAtLogin: false, args: ['--hidden'] });
+    expect(r.openAtLogin).toBe(false);
+    expect(r.diagnostic.withArgs.openAtLogin).toBe(false);
+  });
+
+  it('Task 22 — old channels removed', async () => {
+    mockCollectAutostartState.mockResolvedValue({
+      withArgs: { openAtLogin: false, executableWillLaunchAtLogin: false },
+      noArgs: { openAtLogin: false, executableWillLaunchAtLogin: false },
+      execPath: '/path/to/exe'
+    });
+    registerSettingsApi();
+    expect(handlers['settings:get-autostart']).toBeUndefined();
+    expect(handlers['settings:set-autostart']).toBeUndefined();
+  });
+});

tests/unit/store.showSettings.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import type { Note } from '@shared/types';
+
+const mockApi = {
+  listNotes: vi.fn(async () => [] as Note[]),
+  listTrash: vi.fn(async () => [] as Note[]),
+  getTrashCount: vi.fn(async () => 0),
+  getContinuity: vi.fn(async () => ({ weekStart: '', weekCount: 0, weekTarget: 7, consecutiveCompleteWeeks: 0, showRecoveryToast: false, lastNoteAt: null })),
+  getPendingCount: vi.fn(async () => 0),
+  getOllamaStatus: vi.fn(async () => ({ ok: true })),
+  getTodayCount: vi.fn(async () => 0),
+  getFailedCount: vi.fn(async () => 0),
+  listExpired: vi.fn(async () => [] as Note[]),
+  listRecallCandidate: vi.fn(async () => null),
+  restoreNote: vi.fn(async () => {}),
+  permanentDeleteNote: vi.fn(async () => ({ confirmed: true })),
+  emptyTrash: vi.fn(async () => ({ confirmed: true, count: 0 })),
+  trashExpiredBatch: vi.fn(async () => ({ confirmed: true, trashedCount: 0 })),
+  onNoteUpdated: vi.fn(() => () => {}),
+  updateAiFields: vi.fn(async () => {}),
+  setDueDate: vi.fn(async () => {}),
+  setIntent: vi.fn(async () => {}),
+  dismissIntent: vi.fn(async () => {}),
+  ollamaRecheck: vi.fn(async () => ({ ok: true })),
+  retryAllFailed: vi.fn(async () => {}),
+  markRecallOpened: vi.fn(async () => {}),
+  dismissRecall: vi.fn(async () => {}),
+  emitRecallSnoozed: vi.fn(async () => {})
+};
+
+vi.mock('../../src/renderer/inbox/api.js', () => ({ inboxApi: mockApi }));
+
+describe('inbox store — showSettings', () => {
+  beforeEach(async () => {
+    const { useInbox } = await import('../../src/renderer/inbox/store.js');
+    useInbox.setState({
+      notes: [], trashNotes: [], trashCount: 0, showTrash: false,
+      loading: false, tagFilter: null, pendingCount: 0, todayCount: 0,
+      ollamaStatus: { ok: true },
+      continuity: { weekStart: '', weekCount: 0, weekTarget: 7, consecutiveCompleteWeeks: 0, showRecoveryToast: false, lastNoteAt: null },
+      expiredCandidates: [], expiredSnoozeUntilMs: null,
+      failedCount: 0, recallCandidate: null, recallSnoozeUntilMs: null,
+      showSettings: false
+    });
+    Object.values(mockApi).forEach((fn) => 'mockClear' in fn && (fn as any).mockClear());
+  });
+
+  it('initial state has showSettings=false', async () => {
+    const { useInbox } = await import('../../src/renderer/inbox/store.js');
+    expect(useInbox.getState().showSettings).toBe(false);
+  });
+
+  it('setShowSettings(true) sets state', async () => {
+    const { useInbox } = await import('../../src/renderer/inbox/store.js');
+    useInbox.getState().setShowSettings(true);
+    expect(useInbox.getState().showSettings).toBe(true);
+  });
+
+  it('setShowSettings(false) toggles back', async () => {
+    const { useInbox } = await import('../../src/renderer/inbox/store.js');
+    useInbox.getState().setShowSettings(true);
+    useInbox.getState().setShowSettings(false);
+    expect(useInbox.getState().showSettings).toBe(false);
+  });
+});

tests/unit/telemetryEvents.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { validateEvent } from '@main/services/telemetryEvents.js';
+import { validateEvent, hasNoteId } from '@main/services/telemetryEvents.js';
 
 describe('validateEvent — happy path', () => {
   it('accepts capture event', () => {
@@ -333,3 +333,19 @@ describe('validateEvent — recall', () => {
   });
 });
 
+describe('hasNoteId', () => {
+  it('returns true for noteId-bearing events', () => {
+    const e1 = validateEvent({ ts: '2026-05-05T00:00:00Z', kind: 'capture', payload: { noteId: 'n1', rawTextLength: 5, hasMedia: false } });
+    const e2 = validateEvent({ ts: '2026-05-05T00:00:00Z', kind: 'recall_shown', payload: { noteId: 'n1', ageDays: 14 } });
+    expect(hasNoteId(e1)).toBe(true);
+    expect(hasNoteId(e2)).toBe(true);
+  });
+
+  it('returns false for noteId-less events', () => {
+    const e1 = validateEvent({ ts: '2026-05-05T00:00:00Z', kind: 'empty_trash', payload: { count: 5 } });
+    const e2 = validateEvent({ ts: '2026-05-05T00:00:00Z', kind: 'tag_vocab_hit', payload: { tagId: 1, vocabSize: 10 } });
+    expect(hasNoteId(e1)).toBe(false);
+    expect(hasNoteId(e2)).toBe(false);
+  });
+});
+

tests/unit/tray.test.ts

@@ -0,0 +1,71 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('electron', () => ({
+  default: {
+    app: {
+      on: vi.fn(),
+      getPath: vi.fn(),
+      getVersion: vi.fn(() => '0.2.7'),
+      isPackaged: false,
+      getLoginItemSettings: vi.fn(() => ({ openAtLogin: false }))
+    },
+    Tray: vi.fn(function (this: unknown) {
+      Object.assign(this as object, {
+        setToolTip: vi.fn(),
+        setContextMenu: vi.fn(),
+        on: vi.fn()
+      });
+    }),
+    Menu: { buildFromTemplate: vi.fn((items: unknown) => ({ items })) },
+    nativeImage: { createEmpty: vi.fn() },
+    dialog: {},
+    shell: {},
+    clipboard: {}
+  }
+}));
+
+import { createTray, type TrayCallbacks } from '../../src/main/tray';
+
+describe('tray menu — slim 4 items', () => {
+  beforeEach(() => { vi.clearAllMocks(); });
+
+  function makeCallbacks(): TrayCallbacks {
+    return {
+      showInbox: vi.fn(),
+      showCapture: vi.fn(),
+      showSettings: vi.fn()
+    };
+  }
+
+  it('builds menu with 4 click items + 2 separators', async () => {
+    createTray(makeCallbacks());
+    const electron = (await import('electron')).default;
+    const calls = (electron.Menu.buildFromTemplate as any).mock.calls;
+    const items = calls[calls.length - 1][0];
+    const labels = items.filter((i: any) => i.type !== 'separator').map((i: any) => i.label);
+    expect(labels).toEqual(['한 줄 적기', '보관한 메모 보기', '설정...', '종료']);
+  });
+
+  it('does not include removed items', async () => {
+    createTray(makeCallbacks());
+    const electron = (await import('electron')).default;
+    const calls = (electron.Menu.buildFromTemplate as any).mock.calls;
+    const items = calls[calls.length - 1][0];
+    const labels = items.filter((i: any) => i.type !== 'separator').map((i: any) => i.label);
+    expect(labels).not.toContain('지금 백업');
+    expect(labels).not.toContain('내보내기...');
+    expect(labels).not.toContain('Ollama 재확인');
+    expect(labels).not.toContain('Ollama 설정...');
+  });
+
+  it('"설정..." click invokes showSettings callback', async () => {
+    const cb = makeCallbacks();
+    createTray(cb);
+    const electron = (await import('electron')).default;
+    const calls = (electron.Menu.buildFromTemplate as any).mock.calls;
+    const items = calls[calls.length - 1][0];
+    const settingsItem = items.find((i: any) => i.label === '설정...');
+    settingsItem.click();
+    expect(cb.showSettings).toHaveBeenCalled();
+  });
+});

vitest.config.ts

@@ -1,11 +1,13 @@
 import { defineConfig } from 'vitest/config';
+import react from '@vitejs/plugin-react';
 import { resolve } from 'node:path';
 
 export default defineConfig({
+  plugins: [react()],
   test: {
     environment: 'node',
     globals: false,
-    include: ['tests/unit/**/*.test.ts'],
+    include: ['tests/unit/**/*.test.ts', 'tests/unit/**/*.test.tsx'],
     exclude: ['tests/integration/**', 'tests/e2e/**'],
     coverage: { reporter: ['text', 'html'] }
   },